Persistencia de datos en desarrollo móvil — qué es, métodos y cómo funciona

Qué es la persistencia de datos

Data Persistence es la capacidad de una aplicación de guardar datos en la memoria no volátil del dispositivo. En el desarrollo móvil, la persistencia abarca bases de datos, sistema de archivos, configuración y caché. Cada mecanismo tiene sus propias características de rendimiento, seguridad y capacidad de almacenamiento.

Datos volátiles y persistentes

Los datos volátiles existen solo en la RAM y se pierden al terminar el proceso. Incluyen el estado de la pantalla, cálculos temporales y caché de imágenes. Los datos persistentes se escriben en el sistema de archivos o en una base de datos y permanecen disponibles tras reiniciar la app. Incluyen configuraciones del usuario, tokens de autorización, historial de operaciones y contenido descargado.

Criterios para elegir un mecanismo de almacenamiento

Al seleccionar un método de almacenamiento, los desarrolladores evalúan varios factores. El tipo de datos determina la estructura: configuraciones simples — SharedPreferences o DataStore, registros estructurados — SQLite o Room, archivos — File Storage. El volumen de datos afecta el rendimiento: las bases de datos están optimizadas para miles de registros, mientras que los archivos son adecuados para objetos binarios grandes. La seguridad requiere cifrar la información sensible mediante EncryptedSharedPreferences o SQLCipher.

data class StorageOption(
    name: String,
    dataType: StorageType,
    capacity: Long,
    secure: Boolean
)

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences y DataStore

SharedPreferences es la forma clásica de almacenar pares clave-valor en Android. Esta API ha estado disponible desde las primeras versiones de la plataforma y admite tipos primitivos: cadenas, números y valores booleanos. Los datos se guardan en un archivo XML en el directorio privado de la app y solo son accesibles para su proceso.

DataStore como alternativa

Jetpack DataStore es un reemplazo moderno de SharedPreferences construido sobre Kotlin Coroutines y Flow. DataStore ofrece dos variantes: Preferences DataStore para valores simples y Proto DataStore para objetos tipados. A diferencia de SharedPreferences, DataStore garantiza la consistencia de los datos bajo acceso concurrente y admite operaciones asíncronas sin bloquear el hilo principal.

// SharedPreferences — el enfoque tradicional
val prefs = context
    .getSharedPreferences("settings", Context.MODE_PRIVATE)
with (prefs.edit()) {
    putString("username", "john_doe")
    putInt("score", 1500)
    apply()
}

// DataStore — enfoque asíncrono
val settingsDataStore = context
    .createDataStore("settings.pb")

val usernameFlow: Flow<String> = settingsDataStore
    .data
    .map { it[USERNAME_KEY] ?: "" }

En iOS, el equivalente de SharedPreferences es UserDefaults, un sistema de almacenamiento de valores simples en formato Property List. UserDefaults usa acceso síncrono y es adecuado para pequeños volúmenes de datos de configuración, pero no se recomienda para almacenar información sensible.

SQLite en aplicaciones móviles

SQLite es una base de datos relacional integrada que funciona dentro del proceso de la app sin un servidor separado. Es el DBMS más extendido en el desarrollo móvil: se usa por defecto en ambas plataformas. Android incluye SQLite en el SDK, e iOS lo incluye en la biblioteca libsqlite3. SQLite admite SQL estándar, transacciones, índices y disparadores.

Creación de tablas y operaciones CRUD

Trabajar con SQLite comienza definiendo el esquema de la base de datos. El desarrollador define tablas, sus campos y tipos, luego realiza operaciones de inserción, lectura, actualización y eliminación. SQLiteOpenHelper en Android gestiona la creación y migraciones de la base de datos, mientras que iOS usa la interfaz C o el envoltorio FMDB.

// SQLiteOpenHelper en Android
class DBHelper(context: Context) :
    SQLiteOpenHelper(context, "app.db", null, 1) {

    override fun onCreate(db: SQLiteDatabase) {
        db.execSQL("""
            CREATE TABLE users (
                id INTEGER PRIMARY KEY,
                name TEXT NOT NULL,
                email TEXT UNIQUE
            )
        """)
    }

    fun insertUser(name: String, email: String) {
        val db = writableDatabase
        val values = ContentValues().apply {
            put("name", name)
            put("email", email)
        }
        db.insert("users", null, values)
    }
}

Room — ORM para Android

Room es una biblioteca de Jetpack que proporciona una capa ORM sobre SQLite. Room elimina el trabajo repetitivo de escribir consultas SQL y ContentValues, reemplazándolos con anotaciones y funciones de Kotlin. El compilador de Room genera implementaciones de DAO (Data Access Object) en tiempo de compilación, eliminando errores de sintaxis SQL.

Configurar Room en un proyecto

Para integrar Room, debe agregar la dependencia kapt y anotar la clase de entidad, la interfaz DAO y la clase de base de datos. RoomDatabase sirve como punto de entrada: a través de ella se obtiene un DAO y se realizan operaciones de base de datos. Room admite Flow para consultas reactivas, migraciones de esquema y verificación de consultas en tiempo de compilación.

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    @ColumnInfo(name = "full_name") val name: String,
    @ColumnInfo val email: String
)

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAll(): Flow<List<User>>

    @Insert
    suspend fun insert(user: User)

    @Delete
    suspend fun delete(user: User)
}

@Database(
    entities = [User::class],
    version = 1
)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

Core Data — framework de iOS

Core Data es el framework de Apple para gestionar un grafo de objetos y persistirlo en disco. A diferencia de Room, Core Data no trabaja con tablas sino con objetos gestionados (NSManagedObject) que forman una jerarquía de relaciones. Core Data admite carga diferida, deshacer cambios y consultas complejas mediante NSFetchRequest.

Stack de Core Data

El núcleo de Core Data consta de tres componentes: un contexto de objetos gestionados (NSManagedObjectContext), un coordinador de almacenamiento persistente (NSPersistentStoreCoordinator) y un modelo de datos (NSManagedObjectModel). NSPersistentContainer unifica todos los componentes en un solo punto de entrada, simplificando la configuración para aplicaciones Swift modernas.

import CoreData

class PersistenceController {
    static let shared = PersistenceController()
    let container: NSPersistentContainer

    init() {
        container = NSPersistentContainer(name: "AppModel")
        container.loadPersistentStores { _, error in
            if let error = error {
                fatalError("Failed: \(error)")
            }
        }
    }

    func saveUser(name: String, email: String) {
        let context = container.viewContext
        let user = User(context: context)
        user.name = name
        user.email = email

        do {
            try context.save()
        } catch let error {
            print("Save error: \(error)")
        }
    }
}

El almacenamiento de archivos (File Storage) se usa para guardar imágenes, vídeos y documentos. Android proporciona almacenamiento interno (context.filesDir) — privado para la app, y almacenamiento externo (Environment.getExternalStorageDirectory) — accesible para otras apps. En iOS, los archivos se guardan en los directorios Documents y Library, donde Library/Caches está destinado a la caché que no se respalda en iCloud. Para operaciones con archivos, ambas plataformas proporcionan File API y operaciones de lectura/escritura en flujo. Bibliotecas modernas como Coil y SDWebImage añaden una capa de caché, combinando el almacenamiento de archivos con RAM para un rendimiento óptimo.

En Android, una alternativa a Core Data en complejidad y funcionalidad es Realm, una base de datos de objetos que trabaja directamente con modelos sin capa SQL. Realm es más rápido que SQLite en operaciones de lectura y admite objetos en vivo que actualizan automáticamente la UI cuando los datos cambian.