Cómo guardar datos locales en una app Android

Introducción a la persistencia de datos en Android

En el desarrollo de aplicaciones Android, es fundamental poder almacenar datos locales de manera eficiente. Esto permite a los usuarios mantener su información incluso después de cerrar la aplicación. Existen diversas técnicas para lograr la persistencia de datos, cada una con sus ventajas y desventajas. A continuación, exploraremos las opciones más populares y cómo implementarlas.

Opciones de almacenamiento local

SharedPreferences

SharedPreferences es una de las formas más sencillas y útiles para almacenar datos en Android. Está diseñada para almacenar pares de clave-valor y es ideal para preferencias de usuario, configuraciones y otros datos simples.

Cómo usar SharedPreferences

1. Obtener una instancia de SharedPreferences:

SharedPreferences sharedPreferences = getSharedPreferences("mi_pref", Context.MODE_PRIVATE);

2. Escribir datos en SharedPreferences:

SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("clave_string", "valor");
editor.putInt("clave_int", 1);
editor.apply();

3. Leer datos de SharedPreferences:

String valorString = sharedPreferences.getString("clave_string", "valor_predeterminado");
int valorInt = sharedPreferences.getInt("clave_int", 0);

Archivos de almacenamiento interno

El almacenamiento interno permite guardar archivos directamente en el dispositivo. Estos archivos son accesibles solo por la aplicación que los creó, asegurando así la privacidad de los datos.

Cómo trabajar con archivos internos

1. Escribir en un archivo:

String filename = "mi_archivo.txt";
String fileContents = "Hola, mundo!";
FileOutputStream fos = openFileOutput(filename, Context.MODE_PRIVATE);
fos.write(fileContents.getBytes());
fos.close();

2. Leer de un archivo:

FileInputStream fis = openFileInput(filename);
InputStreamReader isr = new InputStreamReader(fis);
BufferedReader br = new BufferedReader(isr);
StringBuilder sb = new StringBuilder();
String linea;
while ((linea = br.readLine()) != null) {
    sb.append(linea);
}
String contenidoArchivo = sb.toString();
br.close();

Almacenamiento externo

El almacenamiento externo permite guardar archivos en el almacenamiento de la tarjeta SD o en la memoria externa del dispositivo. Este método tiene beneficios, pero también requiere manejar los permisos adecuadamente.

Cómo acceder al almacenamiento externo

1. Declarar permisos en el archivo AndroidManifest.xml:

2. Escribir un archivo en almacenamiento externo:

File dir = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_DOCUMENTS);
File file = new File(dir, "mi_archivo_externo.txt");
FileOutputStream fos = new FileOutputStream(file);
fos.write(fileContents.getBytes());
fos.close();

3. Leer un archivo de almacenamiento externo:

FileInputStream fis = new FileInputStream(file);
BufferedReader br = new BufferedReader(new InputStreamReader(fis));
StringBuilder sb = new StringBuilder();
String linea;
while ((linea = br.readLine()) != null) {
    sb.append(linea);
}
String contenidoArchivoExterno = sb.toString();
br.close();

Base de datos SQLite

SQLite es una opción robusta para aplicaciones que requieren una gestión compleja de datos. Este sistema de gestión de bases de datos permite crear tablas y realizar consultas SQL.

Configurar SQLite en tu aplicación

1. Crear una clase que extienda SQLiteOpenHelper:

public class MiBaseDeDatos extends SQLiteOpenHelper {
    public MiBaseDeDatos(Context context) {
        super(context, "mi_base_de_datos.db", null, 1);
    }
    
    @Override
    public void onCreate(SQLiteDatabase db) {
        db.execSQL("CREATE TABLE usuarios (id INTEGER PRIMARY KEY, nombre TEXT, edad INTEGER)");
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("DROP TABLE IF EXISTS usuarios");
        onCreate(db);
    }
}

2. Insertar datos en la base de datos:

ContentValues values = new ContentValues();
values.put("nombre", "Juan");
values.put("edad", 30);
SQLiteDatabase db = this.getWritableDatabase();
db.insert("usuarios", null, values);
db.close();

3. Leer datos de la base de datos:

SQLiteDatabase db = this.getReadableDatabase();
Cursor cursor = db.query("usuarios", new String[] { "id", "nombre", "edad" }, null, null, null, null, null);
while (cursor.moveToNext()) {
    int id = cursor.getInt(0);
    String nombre = cursor.getString(1);
    int edad = cursor.getInt(2);
}
cursor.close();
db.close();

Room Persistence Library

Room es una biblioteca de la arquitectura de Android que simplifica la gestión de datos en SQLite mediante un enfoque de objeto y la eliminación del código repetitivo.

Configuración de Room

1. Agregar dependencias en build.gradle:

implementation "androidx.room:room-runtime:2.4.1"
annotationProcessor "androidx.room:room-compiler:2.4.1"

2. Crear entidades:

@Entity(tableName = "usuarios")
public class Usuario {
    @PrimaryKey
    public int id;
    public String nombre;
    public int edad;
}

3. Crear un DAO (Data Access Object):

@Dao
public interface UsuarioDao {
    @Insert
    void insert(Usuario usuario);

    @Query("SELECT * FROM usuarios")
    List getAllUsuarios();
}

4. Crear la base de datos Room:

@Database(entities = {Usuario.class}, version = 1)
public abstract class MiBaseDeDatos extends RoomDatabase {
    public abstract UsuarioDao usuarioDao();
}

Comparativa de métodos de almacenamiento

Al seleccionar un método de almacenamiento local para una aplicación Android, es fundamental considerar varios factores:

Facilidad de uso

SharedPreferences y archivos internos son los métodos más fáciles de implementar, adecuados para aplicaciones simples o para el almacenamiento de preferencias del usuario.

Complejidad de los datos

Si los datos son complejos (como listas o estructuras jerárquicas), el uso de SQLite o Room es más apropiado, ya que permiten realizar consultas más avanzadas.

Seguridad y privacidad

El almacenamiento interno ofrece mayor seguridad, ya que los datos solo son accesibles para la aplicación que los creó. El almacenamiento externo, aunque sea accesible, puede ser más vulnerable a accesos no autorizados.

Rendimiento

SQLite y Room pueden manejar grandes volúmenes de datos de manera más eficiente que SharedPreferences o archivos simples. Esto los hace ideales para aplicaciones que manejan datos extensos.

Prácticas recomendadas

Al implementar el almacenamiento de datos locales en una aplicación Android, es importante seguir algunas prácticas recomendadas para asegurar que la Aplicación funcione de manera óptima y segura:

Evita realizar operaciones de entrada/salida (I/O) en el hilo principal. Utiliza hilos separados o bibliotecas como AsyncTask o ThreadPoolExecutor para realizar estas operaciones. Esto mejora la capacidad de respuesta de la aplicación.

Manejar excepciones

Siempre incluye manejo de excepciones al trabajar con almacenamiento. Esto ayuda a gestionar errores inesperados, como la falta de espacio en disco o problemas de permisos.

Proteger la información sensible

Siempre que trabajes con datos delicados, como información del usuario o credenciales, asegúrate de cifrar los datos antes de almacenarlos. Utiliza bibliotecas de cifrado como Android Keystore o javax.crypto.

Limpiar los datos obsoletos

Establece un mecanismo para limpiar o archivar datos antiguos que ya no sean necesarios. Esto no solo ayuda a liberar espacio de almacenamiento, sino que también mantiene la base de datos funcional y rápida.

Probar el rendimiento

Realiza pruebas de rendimiento frecuentes para asegurarte de que las operaciones de almacenamiento no afectan la usabilidad de tu aplicación. Usa herramientas como Android Profiler para identificar cuellos de botella.

la persistencia de datos en Android es una parte esencial del desarrollo de aplicaciones. Dependiendo de las necesidades específicas de tu aplicación, seleccionar el método adecuado (ya sea SharedPreferences, archivos internos, almacenamiento externo, SQLite o Room) te permitirá gestionar los datos de forma efectiva. Siguiendo las prácticas recomendadas, podrás asegurar que tu aplicación no solo almacene datos de manera eficiente, sino que también lo haga de forma segura y optimizada.

Con esta guía, estás listo para implementar la persistencia de datos locales en tu aplicación Android y mejorar la experiencia del usuario final.