El tutor de nuestro curso online de Desarrollo de Aplicaciones para Android, Víctor Ramírez Las,…
Gestionar preferencias de usuario en App Android
En nuestro curso de programación de Apps con Android Studio dedicamos un módulo al almacenamiento y gestión de datos. Vamos a publicar en Academia Android algunos de sus apartados empezando por la gestión de preferencias de usuario en una aplicación.
En este apartado explicamos la clase SharedPreferences y cómo utilizarla para acceder, añadir o recuperar datos. También el cómo crear una interfaz para que el usuario pueda introducir dichos datos, usando la PreferenceActivity, un tipo de activity específica para este caso.
Clase SharedPreferences
La forma más sencilla de almacenar datos en nuestras aplicaciones es recurrir a la clase SharedPreferences, ésta nos permite guardar y consultar posteriormente datos en forma de clave-valor, de modo que la clave será el nombre que demos al dato que queremos almacenar y el valor estará representado por alguno de los tipos de datos básicos: boolean, float, int, long y string.
Las preferencias se almacenan en uno o varios ficheros que pueden ser privados o públicos para que otras aplicaciones puedan acceder a nuestras preferencias de usuario.
Acceder a las preferencias de usuario
Podemos crear y acceder a nuestros ficheros de preferencias de dos formas:
Usando el método getSharedPreferences()
Éste se usa si necesitamos diferentes ficheros de preferencias identificados por un nombre, que pasaremos como primer parámetro.
Como segundo parámetro pasaremos el modo de acceso, que indicará si el fichero de preferencias es privado a nuestra aplicación, o si por el contrario otras aplicaciones podrán acceder a él.
Tendremos varias posibilidades distintas para especificar el modo:
- MODE_PRIVATE. Privado a nuestra aplicación. En la mayoria de los casos será el único modo que necesitemos.
- MODE_WORLD_READABLE. Cualquier aplicación puede acceder al fichero de preferencias pero sólo en modo lectura. (Obsoleto desde la API 17).
- MODE_WORLD_WRITABLE. Cualquier aplicación puede acceder al fichero en modo lectura y escritura. (Obsoleto desde la API 17).
- MODE_MULTIPROCESS. Permite comprobar si se han producido cambios en el fichero de preferencias, incluso aunque éste este abierto.
- MODE_APPEND. Permite añadir nuevas preferencias en un fichero existente.
- MODE_ENABLE_WRITE_AHEAD_LOGGING. Se utiliza para labores de depuración.
Usando el método getPreferences()
Éste se usa si sólo necesitamos un fichero de preferencias para una Activity. Únicamente recibe un parámetro, que será el modo de acceso a este fichero, el nombre vendrá implícito y será el nombre de la Activity.
Añadir datos
Para escribir datos usando la clase SharedPreferences lo haríamos de la siguiente manera:
Obtenemos las preferencias usando por ejemplo el método getSharedPreferences() , a continuación obtenemos el objeto Editor mediante el método edit() , este objeto será el que nos permita modificarlas.
|
1 2 3 |
SharedPreferences propiedades = getPreferences(Context.MODE_PRIVATE); SharedPreferences.Editor editor = propiedades.edit(); |
En este caso hemos utilizado el método para un único fichero de preferencias y el modo de acceso privado a la aplicación.
Para añadir datos, podemos usar métodos tales como putBoolean() para almacenar un valor booleano, putString() para almacenar un String, putInt() para almacenar un entero, etc. Veamos cómo almacenar por ejemplo una cadena de texto y un entero:
|
1 2 3 |
editor.putString("name", "Digital Learning"); editor.putInt("idCurso", 3); |
Para guardar los datos debemos hacer un commit del siguiente modo:
|
1 2 |
editor.commit(); |
Recuperar datos
Para recuperar los datos almacenados obtenemos de nuevo las preferencias del mismo modo que vimos antes.
|
1 2 |
SharedPreferences propiedades = getPreferences(Context.MODE_PRIVATE); |
Sobre este objeto ya podremos obtener los valores directamente así:
|
1 2 3 |
String name= preferences.getString("name", ""); int id = preferences.getInt("idCurso", -1); |
Vemos que los métodos getString y getInt reciben dos parámetros, uno es la clave del dato almacenado, y otro es un valor por defecto por si no se encuentra el dato representado por la clave dada.
Crear una PreferenceActivity
Normalmente necesitaremos que sea el usuario quien introduzca los valores de las preferencias de la aplicación, para ello podemos crear una interfaz en la que recoger los datos.
Existe un tipo de Activity especial para este fin llamada PreferenceActivity, que nos permitirá crear de forma sencilla una interfaz en la que podremos añadir preferencias de distintos tipos para que el usuario defina sus valores.
Para crear nuestra PreferenceActivity seguiremos los siguientes pasos:
En primer lugar crearemos un fichero preferences.xml dentro de la carpeta res/xml con el siguiente contenido
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
<?xml version="1.0" encoding="utf-8"?> <PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"> <EditTextPreference android:title="Nombre" android:key="username" android:summary="Introduce tu nombre de usuario"></EditTextPreference> <CheckBoxPreference android:title="Buscar actualizaciones" android:defaultValue="false" android:summary="Marca si quieres que se busquen actualizaciones automáticamente" android:key="applicationUpdates" /> <ListPreference android:title="Interfaz" android:summary="Selecciona el tipo de interfaz de la aplicación" android:key="interfaz" android:defaultValue="1" android:entries="@array/listKeys" android:entryValues="@array/listValues" /> </PreferenceScreen> |
Podemos observar como se definen los 3 principales tipos de preferencias:
- EditTextPreference
- CheckBoxPreference
- ListPreference
Las dos primeras nos permiten crear campos de entrada de texto y CheckBox respectivamente, mientras que la tercera nos mostrara una lista desplegable cuyos valores seleccionables deben ser definidos en dos arrays: listKeys para el texto mostrado y listValues para el valor que se asignara a la variable.
Para definir los dos arrays mencionados en el apartado anterior crearemos un fichero llamado array.xml dentro de la carpeta res/values con el siguiente contenido
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<?xml version="1.0" encoding="utf-8"?> <resources> <string-array name="listKeys"> <item>Por defecto</item> <item>Clara</item> <item>Oscura</item> </string-array> <string-array name="listValues"> <item>1</item> <item>2</item> <item>3</item> </string-array> </resources> |
Este fichero tiene la misma utilidad que los mencionados en los primeros temas (strings, styles, etc) pero en esta ocasión servirá para almacenar listados de elementos que puedan ser consultados en cualquier parte de la aplicación.
Ahora necesitamos crear la Activity que mostrará los datos. Para ello, creamos una nueva clase vacía en la misma carpeta de nuestra actividad principal que contendrá el siguiente código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
package com.academiaandroid.demopreferences; import android.os.Bundle; import android.preference.PreferenceActivity; import android.preference.PreferenceFragment; public class PrefActivity extends PreferenceActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); getFragmentManager().beginTransaction().replace(android.R.id.content, new MyPreferenceFragment()).commit(); } public static class MyPreferenceFragment extends PreferenceFragment { @Override public void onCreate(final Bundle savedInstanceState) { super.onCreate(savedInstanceState); addPreferencesFromResource(R.xml.preferences); } } } |
En la última línea de código vemos cómo el método addPreferencesFromResource() carga el contenido del XML creado en el primer paso.
Por último modificaremos el código de nuestra actividad principal para que lance la ventana de preferencias al iniciar la aplicación:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package com.academiaandroid.demopreferences; import android.content.Intent; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; public class MainActivity extends AppCompatActivity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); //Lanzamos la ventana de Preferencias Intent i = new Intent(this, PrefActivity.class); startActivity(i); } } |
Si ejecutamos la aplicación nos aparecerá una venta como esta:
Para consultar los valores de las preferencias en cualquier parte la aplicación utilizaremos el siguiente código:
|
1 2 3 4 5 |
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getBaseContext()); String username = prefs.getString("username", "NA"); boolean applicationUpdates = prefs.getBoolean("applicationUpdates",false); String interfaz = prefs.getString("interfaz","1"); |
Muy similar al que vimos al principio de este apartado con la diferencia del método necesario para obtener el fichero de preferencias, que podemos ver en la primera linea de código.
Entradas relacionadas
