Stocarea datelor în dezvoltarea mobilă — ce este, metode și cum funcționează

Ce este stocarea permanentă a datelor

Data Persistence — este capacitatea aplicației de a salva date în memoria nevolatilă a dispozitivului. În dezvoltarea mobilă, stocarea permanentă include baze de date, sistemul de fișiere, setări și cache. Fiecare mecanism are propriile caracteristici de performanță, securitate și volum de informații stocate.

Date temporare și permanente

Datele temporare există doar în memoria RAM și se pierd la terminarea procesului. Acestea includ starea ecranului, calcule temporare și cache de imagini. Datele permanente sunt scrise în sistemul de fișiere sau baza de date și rămân accesibile după repornirea aplicației. Acestea includ setările utilizatorului, token-uri de autorizare, istoricul operațiunilor și conținutul descărcat.

Criterii de selectare a mecanismului de stocare

La alegerea metodei de salvare, dezvoltatorul evaluează mai mulți factori. Tipul datelor determină structura de stocare: setări simple — SharedPreferences sau DataStore, înregistrări structurate — SQLite sau Room, fișiere — File Storage. Volumul datelor influențează performanța: bazele de date sunt optimizate pentru mii de înregistrări, iar fișierele — pentru obiecte binare mari. Securitatea necesită criptarea informațiilor sensibile prin EncryptedSharedPreferences sau SQLCipher.

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

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences și DataStore

SharedPreferences — metoda clasică de stocare a perechilor cheie-valoare pe Android. Această API există de la primele versiuni ale platformei și suportă tipuri primitive: șiruri de caractere, numere, valori booleene. Datele sunt stocate într-un fișier XML în directorul privat al aplicației și sunt accesibile doar procesului său.

DataStore ca alternativă

Jetpack DataStore — înlocuitorul modern pentru SharedPreferences, construit pe Kotlin Coroutines și Flow. DataStore oferă două variante: Preferences DataStore pentru valori simple și Proto DataStore pentru obiecte tipizate. Spre deosebire de SharedPreferences, DataStore garantează consistența datelor la acces concurent și suportă operații asincrone fără blocarea firului principal.

// SharedPreferences — mod tradițional
val prefs = context
    .getSharedPreferences("settings", Context.MODE_PRIVATE)
with (prefs.edit()) {
    putString("username", "john_doe")
    putInt("score", 1500)
    apply()
}

// DataStore — abordare asincronă
val settingsDataStore = context
    .createDataStore("settings.pb")

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

Pe iOS, echivalentul SharedPreferences este UserDefaults — un sistem de stocare a valorilor simple în format Property List. UserDefaults utilizează acces sincron și este potrivit pentru volume mici de date de configurare, dar nu este recomandat pentru stocarea informațiilor sensibile.

SQLite în aplicațiile mobile

SQLite — bază de date relațională încorporată care funcționează în cadrul procesului aplicației fără un server separat. Aceasta este cel mai răspândit DBMS în dezvoltarea mobilă: este utilizată implicit pe ambele platforme. Android include SQLite în SDK, iar iOS — în biblioteca libsqlite3. SQLite suportă SQL standard, tranzacții, indecși și declanșatoare.

Crearea tabelului și operații CRUD

Lucrul cu SQLite începe cu crearea schemei bazei de date. Dezvoltatorul definește tabelele, câmpurile și tipurile lor, după care execută operații de inserare, citire, actualizare și ștergere. SQLiteOpenHelper pe Android gestionează crearea și migrarea bazei de date, iar pe iOS se utilizează interfața C sau wrapper-ul FMDB.

// SQLiteOpenHelper pe 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 pentru Android

Room — bibliotecă din suita Jetpack, care oferă un strat ORM peste SQLite. Room elimină munca de rutină de scriere a interogărilor SQL și ContentValues, înlocuindu-le cu adnotări și funcții Kotlin. Compilatorul Room generează implementarea DAO (Data Access Object) în etapa de compilare, ceea ce exclude erorile în sintaxa SQL.

Configurarea Room în proiect

Pentru a conecta Room, trebuie adăugată dependența kapt și adnotată clasa entitate, interfața DAO și clasa bazei de date. RoomDatabase servește ca punct de intrare: prin el se obține DAO și se execută operații cu baza de date. Room suportă Flow pentru interogări reactive, migrări de schemă și verificarea interogărilor la compilare.

@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 — framework Apple pentru gestionarea grafului de obiecte și salvarea lor pe disc. Spre deosebire de Room, Core Data nu lucrează cu tabele, ci cu obiecte gestionate (NSManagedObject) care formează o ierarhie de relații. Core Data suportă încărcarea lentă, anularea modificărilor și interogări complexe prin NSFetchRequest.

Stiva Core Data

Baza Core Data o constituie stiva din trei componente: contextul gestionat (NSManagedObjectContext), stocarea persistentă (NSPersistentStoreCoordinator) și modelul de date (NSManagedObjectModel). NSPersistentContainer unește toate componentele într-un singur punct de intrare, simplificând configurarea pentru aplicațiile moderne în Swift.

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("Eroare salvare: \(error)")
        }
    }
}

Stocarea în fișiere (File Storage) este utilizată pentru salvarea imaginilor, videourilor și documentelor. Android oferă stocare internă (context.filesDir) — privată pentru aplicație, și externă (Environment.getExternalStorageDirectory) — accesibilă altor aplicații. Pe iOS, fișierele sunt salvate în directoarele Documents și Library, iar Library/Caches este destinată cache-ului care nu face obiectul backup-ului în iCloud. Pentru lucrul cu fișiere, ambele platforme oferă File API și operații de citire și scriere în flux. Bibliotecile moderne precum Coil și SDWebImage adaugă un strat de cache, combinând stocarea în fișiere cu memoria RAM pentru performanță optimă.

Pe Android, alternativa la Core Data ca complexitate și funcționalitate este Realm — o bază de date orientată pe obiecte care lucrează direct cu modelele fără un strat SQL. Realm este mai rapid decât SQLite în operațiile de citire și suportă obiecte live care actualizează automat UI la modificarea datelor.