ALMACENAMIENTO EN ANDROID:

Cuando tenemos necesidad de almacenar y posteriormente recuperar información en

nuestras aplicaciones Android, contamos con diversas opciones de almacenamiento
que varían en cuanto al tipo y complejidad de la información guardada.

1. Preferencias Compartidas (Shared Preferences):

Mecanismo simple y ligero para almacenar datos en base a esquema de pares clave-
valor. Habitualmente se usa para guardar y recuperar preferencias u opciones de la
aplicación. También se puede usar para compartir información entre componentes de
nuestra misma aplicación.
Se utiliza la clase SharedPreferences, que permite guardar datos en formato:
enteros, booleanos, fotantes y cadenas de texto.

1.1. Guardar Preferencias Compartidas:

Para crear un SharedPreferences se llama al método getSharedPreferences(),

pasando como parámetros el nombre asignado al archivo de preferencias y el modo
de apertura del mismo. La opciones de acceso al archivo de preferencias compartidas
son las siguientes: MODE_PRIVATE, MODE_WORLD_READABLE,
MODE_WORLD_WRITEABLE. El primero caso es de acceso solo para la propia
aplicación, mientras que los 2 siguientes permiten el acceso desde otras aplicaciones
en el dispositivo Android.
Para realizar la modifcación de uno o mas valores de preferencias compartidas, se
debe usar la clase SharedPreferences.Editor y obtenemos una instancia de la misma
mediante el método edit() del objeto SharedPreference sobre el que estamos
trabajando.
Para realizar los cambios en el estado de las preferencias, desde el objeto “editor” se
hace uso de métodos según el tipo de dato (entero, boolean, cadena o fotante), por
ejemplo putString() para cadenas o putInt() para valores enteros.
Para fnalizar y aplicar los cambios se llama al método commit(), del objeto editor.

public static final String PREFS_NAME = “ArchivoPref”;

SharedPreferences pref = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
String email = edtNombre.getText();
editor.putString("emailUsuario", email);
// aplicar cambios
editor.commit();

Página 1
1.2. Leer Preferencias Compartidas:

Para leer preferencias compartidas, solo tenemos que usar el método

getSharedPreferences(), indicando como parámetros el nombre del archivo y el
modo de apertura del mismo, siendo las opciones disponibles: privado, publico de
lectura y publico de escritura.

public static final String PREFS_NAME = “ArchivoPref”;

// Restaurar preferencias
SharedPreferences pref = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
boolean recordar = settings.getBoolean("recordar", false);
setRecordar(recordar);

2. Almacenamiento Interno:

Es posible guardar archivos directamente en el almacenamiento interno del

dispositivo. Los modos de apertura y acceso disponibles son MODE_PRIVATE y
MODE_APPEND.
En caso de indicar el modo MODE_APPEND, estamos agregando contenido al archivo
en lugar de reemplazarlo en cada escritura como ocurre con MODE_PRIVATE.

String FILENAME = "hola_file.txt";

String cadena = "Hola Mundo!";
FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE);
fos.write(cadena.getBytes());
fos.close();

Para fnalizar correctamente el el proceso de lectura debemos proceder a llamar los

métodos write() y fnalmente close().
En caso de querer leer el contenido de un archivo se deberá utilizar el metodo read()
de openFileInput() que obtiene un fleInputStream.

String FILENAME = "hola_file.txt";

String ret = "";
InputStream inputStream = context.openFileInput(FILENAME);

if ( inputStream != null ) {
InputStreamReader inputStreamReader = new InputStreamReader(inputStream);
int largo = inputStream.available();
char[] buffer = new char[largo];
inputStreamReader.read(buffer);
inputStream.close();
ret = new String(buffer);
}

Es necesario implementar manejo de errores con try/catch para controlar posibles

fallos en el acceso a los archivos.

Página 2
3. Almacenamiento Externo:

Para poder escribir archivos según las indicaciones expuestas en el punto anterior,
pero sobre el almacenamiento “externo” del dispositivo (SDCard), en primer termino
se deben establecer los permisos correspondientes (lectura/escritura) en el archivo
manifest de nuestra aplicacion:

<manifest ...>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
</manifest ...>

Luego se deben implementar métodos propios para verifcar que este disponible la
unidad externa de almacenamiento y si esta en modo solo lectura:

//verificar si almacenamiento es disponible

public boolean isExternalStorageWritable() {
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {
return true;
}
return false;
}
// verificar si almacenamiento es disponible y solo lectura
public boolean isExternalStorageReadable() {
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state) ||
Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
return true;
}
return false;
}

Accedemos a la ubicación del almacenamiento externo:

File ruta = new File(Environment.getExternalStorageDirectory().getAbsolutePath()

+ File.separator);
File file = new File(ruta, "score.txt");

4. SQLite:

SQLite es un sistema de base de datos relacional contenida en una biblioteca

desarrollada en C, que se integra en la aplicación como un proceso integrado de
motor de base de datos SQL con soporte para transacciones de base de datos
atómicas (ACID), sin servidor y sin confguración. Su código es de dominio público y de
libre uso. Se guarda toda la base en un único archivo junto con nuestra aplicación.

Android ofrece compatibilidad total con la base de datos SQLite (versión 3), sin
necesidad de incluir librerías adicionales. Es la opción recomendada cuando debemos
almacenar datos estructurados y con cierta complejidad, recordando siempre la

Página 3
necesidad de estar atentos a las posibilidades y espacio de almacenamiento de los
dispositivos móviles.

4.1. SQLiteOpenHelper:

Para crear y acceder a una nueva base de datos SQLite en nuestra aplicación, en
primer lugar debemos crear una nueva clase en nuestro proyecto que herede de la
clase abstracta SQLiteOpenHelper e implementar sus métodos y constructor:

public class ContactoOpenHelper extends SQLiteOpenHelper {

private static final int DATABASE_VERSION = 2;
private static final String CONTACTO_TABLE_NAME = "contactos";

//consulta sql para crear la tabla contacto

private String sql = "CREATE TABLE ” + this.CONTACTO_TABLE_NAME + “ (id
INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
telefono INT, nombre TEXT, email TEXT, domicilio
TEXT)";

public ContactoSQLiteHelper(Context context) {

super(context, BDConstantes.DATABASE_NAME, null,
BDConstantes.DATABASE_VERSION);
}

@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(sqlCrear);
}

@Override
public void onUpgrade(SQLiteDatabase db, int anterior, int nueva) {
//se elimina version anterior de tabla
db.execSQL("DROP TABLE IF EXISTS "+BDConstantes.TABLE_CONTACTO);
//se crea nueva version de tabla
db.execSQL(sql);
}

En dicha clase nos ocupados de las instrucciones necesarios para la creación inicial de
la base de datos en nuestra aplicación (onCreate), con la estructura y modelo de
datos que hayamos previamente estipulado. También tenemos un método para el
caso d actualización de la estructura de datos (onUpgrade).

Ademas necesitaremos hace uso de las clases SQLiteDatabase y Content Values. La

primera nos brinda todas las operaciones disponibles sobre la base de datos, desde la
apertura de la base de datos, métodos CRUD (insert, detele, update, select) e incluso
transacciones.

//abrimos db en modo escritura

ContactoSQLiteHelper contactoSQLiteHelper = new ContactoSQLiteHelper(context);
SQLiteDatabase db = contactoSQLiteHelper.getWritableDatabase();

Página 4
//seleccionamos todos los registros
Cursor cursor = db.rawQuery("SELECT * FROM contactos",null);

Nos apoyamos en los Content Values, cuando debemos alimentar con datos los
métodos CRUD

ContentValues nuevoRegistro = new ContentValues();

nuevoRegistro.put("telefono",445566);
nuevoRegistro.put("nombre","Luis Andres Fernandez");
nuevoRegistro.put("email","lafernandez88@gmail.com");
nuevoRegistro.put("domicilio","Avenida Las Heras 334");

//insertamos registro
db.insert("contactos", null, nuevoRegistro);

Un objeto Cursor, nos permiten obtener un arreglo de datos en memoria como

resultado de una consulta SQL sobre nuestra base de datos. Ademas disponemos de
métodos para recorrer y acceder a dichos datos en forma individual.
La clase Cursor incluye, entre otras, las siguientes funciones de navegación entre
resultados:

• moveToFirst: desplaza el cursor a la primera fla de los resultados de la

consulta.
• moveToNext: desplaza el cursor a la siguiente fla.
• isAfterLast: nos indica si se alcanzó la ultima fla del cursor.
• getCount: devuelve el número de flas del conjunto de resultados de la
consulta.
• getColumnName: devuelve el nombre de la columna especifcada mediante
un índiceque se pasa como parámetro.
• getColumnNames: devuelve un array de cadenas conteniendo el nombre de
todas las columnas en el cursor.
• moveToPosition: mueve el cursor a la fla especifcada.
• getPosition: devuelve el índice de la posición apuntada actualmente por el
cursor.

Cursor cursor = db.rawQuery("SELECT * FROM contactos",null);

List<Contacto> lista = new ArrayList<>();

//nos posicionamos al inicio del curso

if(cursor.moveToFirst()){
//iteramos todos los registros del cursor y llenamos array con registros
while (cursor.isAfterLast()==false){
//recorremos hasta llegar al ultimo registro
int telefono = cursor.getInt(cursor.getColumnIndex("telefono"));
String nombre = cursor.getString(cursor.getColumnIndex("nombre"));
String email = cursor.getString(cursor.getColumnIndex("email"));
String domicilio = cursor.getString(cursor.getColumnIndex("domicilio"));
lista.add(new Contacto(telefono,nombre,email,domicilio));
//nos movemos a la proxima fila del cursos
cursor.moveToNext();

Página 5
 }
}
return lista;

El primer paso para obtener resultados de un cursor será desplazarnos a la posición a

partir de la cual queremos obtener los datos, usando cualquiera de los métodos
especifcados anteriormente (como por ejemplo moveToFirst o moveToPosition).

Unavez hecho esto hacemos uso de métodos get[TIPO DATO] pasando como
parámetro el índice la columna. Esto tendrá como resultado la devolución del valor
para dicha columna de la fla actualmente apuntada por el cursor:

String valor = cursor.getString(indiceColumna);

5. Comentarios Finales:

Se debe tener en cuenta que al eliminar una aplicación del dispositivo android se
borran también cualquier archivo de persistencia (preferencias compartidas, bases
sqlite, archivos de texto, etc) que utilice la misma, perdiéndose en dicho proceso la
información contenido en los mismos.

Desde Android Studio podemos utilizar la herramienta Android Device Monitor para
conectarnos a nuestro dispositivo físico o virtual y desde la solapa File Explorer
navegar el sistema de archivos para acceder a descargarnos cualquier archivo que
hayamos generado desde nuestra aplicación. Desde la misma herramienta podemos
subir archivos a dispositivos conectados en Android Studio.

Documentación Adicional:
https://developer.android.com/guide/topics/data/data-storage.html
http://www.sqlite.org/

Proyectos Demo en GitHub:

https://github.com/federicotrani/SharedPreferences
https://github.com/federicotrani/SQLiteDemo

Página 6