Persistência de dados no desenvolvimento móvel — o que é, métodos e como funciona

O que é persistência de dados

Data Persistence é a capacidade de um aplicativo salvar dados na memória não volátil do dispositivo. No desenvolvimento móvel, a persistência abrange bancos de dados, sistema de arquivos, configurações e cache. Cada mecanismo tem suas próprias características de desempenho, segurança e capacidade de armazenamento.

Dados voláteis e persistentes

Dados voláteis existem apenas na RAM e são perdidos quando o processo termina. Isso inclui estado da tela, cálculos temporários e cache de imagens. Os dados persistentes são gravados no sistema de arquivos ou banco de dados e permanecem disponíveis após a reinicialização do aplicativo. Isso inclui configurações do usuário, tokens de autorização, histórico de operações e conteúdo baixado.

Critérios para escolher um mecanismo de armazenamento

Ao selecionar um método de armazenamento, os desenvolvedores avaliam vários fatores. O tipo de dados determina a estrutura: configurações simples — SharedPreferences ou DataStore, registros estruturados — SQLite ou Room, arquivos — File Storage. O volume de dados afeta o desempenho: bancos de dados são otimizados para milhares de registros, enquanto arquivos são adequados para grandes objetos binários. A segurança exige criptografia de informações confidenciais via EncryptedSharedPreferences ou SQLCipher.

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

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences e DataStore

SharedPreferences é a forma clássica de armazenar pares chave-valor no Android. Esta API está disponível desde as primeiras versões da plataforma e suporta tipos primitivos: strings, números e valores booleanos. Os dados são armazenados em um arquivo XML no diretório privado do aplicativo e são acessíveis apenas ao seu processo.

DataStore como alternativa

Jetpack DataStore é uma substituição moderna para SharedPreferences construída sobre Kotlin Coroutines e Flow. DataStore oferece duas variantes: Preferences DataStore para valores simples e Proto DataStore para objetos tipados. Ao contrário do SharedPreferences, o DataStore garante consistência dos dados sob acesso concorrente e suporta operações assíncronas sem bloquear a thread principal.

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

// DataStore — abordagem assíncrona
val settingsDataStore = context
    .createDataStore("settings.pb")

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

No iOS, o equivalente ao SharedPreferences é o UserDefaults, um sistema de armazenamento de valores simples no formato Property List. O UserDefaults usa acesso síncrono e é adequado para pequenos volumes de dados de configuração, mas não é recomendado para armazenar informações confidenciais.

SQLite em aplicativos móveis

SQLite é um banco de dados relacional incorporado que funciona dentro do processo do aplicativo sem um servidor separado. É o SGBD mais difundido no desenvolvimento móvel: é usado por padrão em ambas as plataformas. O Android inclui SQLite no SDK, e o iOS o inclui na biblioteca libsqlite3. SQLite suporta SQL padrão, transações, índices e gatilhos.

Criação de tabelas e operações CRUD

Trabalhar com SQLite começa definindo o esquema do banco de dados. O desenvolvedor define tabelas, seus campos e tipos, depois realiza operações de inserção, leitura, atualização e exclusão. O SQLiteOpenHelper no Android gerencia a criação e migrações do banco de dados, enquanto o iOS usa a interface C ou o wrapper FMDB.

// SQLiteOpenHelper no 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 é uma biblioteca do Jetpack que fornece uma camada ORM sobre o SQLite. O Room elimina o trabalho repetitivo de escrever consultas SQL e ContentValues, substituindo-os por anotações e funções Kotlin. O compilador do Room gera implementações de DAO (Data Access Object) em tempo de compilação, eliminando erros de sintaxe SQL.

Configurar Room em um projeto

Para integrar o Room, você precisa adicionar a dependência kapt e anotar a classe de entidade, a interface DAO e a classe do banco de dados. RoomDatabase serve como ponto de entrada: através dela você obtém um DAO e realiza operações no banco de dados. O Room suporta Flow para consultas reativas, migrações de esquema e verificação de consultas em tempo de compilação.

@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 iOS

Core Data é o framework da Apple para gerenciar um grafo de objetos e persisti-lo em disco. Ao contrário do Room, o Core Data não trabalha com tabelas, mas com objetos gerenciados (NSManagedObject) que formam uma hierarquia de relacionamentos. O Core Data suporta carregamento preguiçoso, desfazer alterações e consultas complexas via NSFetchRequest.

Stack do Core Data

O núcleo do Core Data consiste em três componentes: um contexto de objetos gerenciados (NSManagedObjectContext), um coordenador de armazenamento persistente (NSPersistentStoreCoordinator) e um modelo de dados (NSManagedObjectModel). O NSPersistentContainer unifica todos os componentes em um único ponto de entrada, simplificando a configuração para aplicativos Swift modernos.

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)")
        }
    }
}

O armazenamento de arquivos (File Storage) é usado para salvar imagens, vídeos e documentos. O Android fornece armazenamento interno (context.filesDir) — privado para o aplicativo, e armazenamento externo (Environment.getExternalStorageDirectory) — acessível a outros aplicativos. No iOS, os arquivos são salvos nos diretórios Documents e Library, onde Library/Caches é destinado ao cache que não faz backup no iCloud. Para operações com arquivos, ambas as plataformas fornecem File API e operações de leitura/gravação em streaming. Bibliotecas modernas como Coil e SDWebImage adicionam uma camada de cache, combinando armazenamento de arquivos com RAM para desempenho ótimo.

No Android, uma alternativa ao Core Data em termos de complexidade e funcionalidade é o Realm, um banco de dados de objetos que trabalha diretamente com modelos sem camada SQL. O Realm é mais rápido que o SQLite em operações de leitura e suporta objetos ao vivo que atualizam automaticamente a UI quando os dados mudam.