Ukládání dat v mobilním vývoji — co to je, způsoby a jak to funguje

Co je trvalé ukládání dat

Data Persistence — schopnost aplikace ukládat data do energeticky nezávislé paměti zařízení. V mobilním vývoji zahrnuje trvalé ukládání databáze, souborový systém, nastavení a mezipaměť. Každý mechanismus má své vlastnosti výkonu, zabezpečení a objemu uložených informací.

Dočasná a trvalá data

Dočasná data existují pouze v paměti RAM a při ukončení procesu se ztratí. Patří sem stav obrazovky, dočasné výpočty a mezipaměť obrázků. Trvalá data se zapisují do souborového systému nebo databáze a zůstávají přístupná po restartu aplikace. Patří sem uživatelská nastavení, autorizační tokeny, historie operací a stažený obsah.

Kritéria výběru mechanismu ukládání

Při výběru způsobu ukládání vývojář hodnotí několik faktorů. Typ dat určuje strukturu ukládání: jednoduchá nastavení — SharedPreferences nebo DataStore, strukturované záznamy — SQLite nebo Room, soubory — File Storage. Objem dat ovlivňuje výkon: databáze jsou optimalizovány pro tisíce záznamů, soubory pro velké binární objekty. Zabezpečení vyžaduje šifrování citlivých informací pomocí EncryptedSharedPreferences nebo SQLCipher.

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

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences a DataStore

SharedPreferences — klasický způsob ukládání párů klíč-hodnota na Androidu. Toto API existuje od prvních verzí platformy a podporuje primitivní typy: řetězce, čísla, booleovské hodnoty. Data jsou uložena v XML souboru v soukromém adresáři aplikace a jsou přístupná pouze jejímu procesu.

DataStore jako alternativa

Jetpack DataStore — moderní náhrada SharedPreferences, postavená na Kotlin Coroutines a Flow. DataStore nabízí dvě varianty: Preferences DataStore pro jednoduché hodnoty a Proto DataStore pro typované objekty. Na rozdíl od SharedPreferences, DataStore zaručuje konzistenci dat při souběžném přístupu a podporuje asynchronní operace bez blokování hlavního vlákna.

// SharedPreferences — tradiční způsob
val prefs = context
    .getSharedPreferences("settings", Context.MODE_PRIVATE)
with (prefs.edit()) {
    putString("username", "john_doe")
    putInt("score", 1500)
    apply()
}

// DataStore — asynchronní přístup
val settingsDataStore = context
    .createDataStore("settings.pb")

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

Na iOS je ekvivalentem SharedPreferences UserDefaults — systém ukládání jednoduchých hodnot ve formátu Property List. UserDefaults používá synchronní přístup a je vhodný pro malé objemy konfiguračních dat, ale nedoporučuje se pro ukládání citlivých informací.

SQLite v mobilních aplikacích

SQLite — vestavěná relační databáze, která pracuje uvnitř procesu aplikace bez samostatného serveru. Toto je nejrozšířenější DBMS v mobilním vývoji: standardně se používá na obou platformách. Android zahrnuje SQLite v SDK, iOS v knihovně libsqlite3. SQLite podporuje standardní SQL, transakce, indexy a triggery.

Vytvoření tabulky a CRUD operace

Práce s SQLite začíná vytvořením schématu databáze. Vývojář definuje tabulky, jejich pole a typy, poté provádí operace vkládání, čtení, aktualizace a mazání. SQLiteOpenHelper na Androidu spravuje vytváření a migrace databáze, na iOS se používá C rozhraní nebo FMDB obal.

// SQLiteOpenHelper na Androidu
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 pro Android

Room — knihovna ze sady Jetpack, která poskytuje ORM vrstvu nad SQLite. Room odstraňuje rutinní psaní SQL dotazů a ContentValues a nahrazuje je anotacemi a Kotlin funkcemi. Kompilátor Room generuje implementaci DAO (Data Access Object) při sestavování, což eliminuje chyby v syntaxi SQL.

Nastavení Room v projektu

Pro připojení Room je třeba přidat závislost kapt a anotovat třídu entity, rozhraní DAO a třídu databáze. RoomDatabase slouží jako vstupní bod: přes něj se získává DAO a provádějí se operace s databází. Room podporuje Flow pro reaktivní dotazy, migraci schématu a kontrolu dotazů při kompilaci.

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

Core Data — framework Apple pro správu objektového grafu a jeho ukládání na disk. Na rozdíl od Room, Core Data nepracuje s tabulkami, ale se spravovanými objekty (NSManagedObject), které tvoří hierarchii vztahů. Core Data podporuje líné načítání, vracení změn a složité dotazy prostřednictvím NSFetchRequest.

Zásobník Core Data

Základ Core Data tvoří zásobník tří komponent: spravovaný kontext (NSManagedObjectContext), trvalé úložiště (NSPersistentStoreCoordinator) a datový model (NSManagedObjectModel). NSPersistentContainer spojuje všechny komponenty do jediného vstupního bodu, což zjednodušuje konfiguraci pro moderní Swift aplikace.

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("Chyba ukládání: \(error)")
        }
    }
}

Souborové úložiště (File Storage) se používá k ukládání obrázků, videí a dokumentů. Android poskytuje interní úložiště (context.filesDir) — soukromé pro aplikaci, a externí (Environment.getExternalStorageDirectory) — přístupné jiným aplikacím. Na iOS se soubory ukládají do adresářů Documents a Library, přičemž Library/Caches je určena pro mezipaměť, která není zálohována do iCloudu. Pro práci se soubory obě platformy poskytují File API a operace streamovaného čtení a zápisu. Moderní knihovny jako Coil a SDWebImage přidávají vrstvu mezipaměti, kombinující souborové úložiště s RAM pro optimální výkon.

Na Androidu je alternativou Core Data z hlediska složitosti a funkcionality Realm — objektově orientovaná databáze pracující přímo s modely bez SQL vrstvy. Realm je rychlejší než SQLite při čtení a podporuje živé objekty, které automaticky aktualizují UI při změně dat.