Persistance des données en développement mobile — définition, méthodes et fonctionnement

Qu’est-ce que la persistance des données

Data Persistence est la capacité d’une application à sauvegarder des données dans la mémoire non volatile de l’appareil. Dans le développement mobile, la persistance englobe les bases de données, le système de fichiers, les paramètres et le cache. Chaque mécanisme a ses propres caractéristiques en termes de performances, de sécurité et de capacité de stockage.

Données volatiles et persistantes

Les données volatiles existent uniquement dans la RAM et sont perdues à la fin du processus. Cela inclut l’état de l’écran, les calculs temporaires et le cache d’images. Les données persistantes sont écrites dans le système de fichiers ou une base de données et restent disponibles après le redémarrage de l’application. Cela inclut les paramètres utilisateur, les jetons d’autorisation, l’historique des opérations et le contenu téléchargé.

Critères de choix d’un mécanisme de stockage

Lors du choix d’une méthode de stockage, les développeurs évaluent plusieurs facteurs. Le type de données détermine la structure : paramètres simples — SharedPreferences ou DataStore, enregistrements structurés — SQLite ou Room, fichiers — File Storage. Le volume de données affecte les performances : les bases de données sont optimisées pour des milliers d’enregistrements, tandis que les fichiers conviennent aux grands objets binaires. La sécurité nécessite le chiffrement des informations sensibles via EncryptedSharedPreferences ou SQLCipher.

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

enum class StorageType {
    KEY_VALUE,
    RELATIONAL,
    FILE
}

SharedPreferences et DataStore

SharedPreferences est la méthode classique pour stocker des paires clé-valeur sur Android. Cette API est disponible depuis les premières versions de la plateforme et prend en charge les types primitifs : chaînes, nombres, valeurs booléennes. Les données sont stockées dans un fichier XML dans le répertoire privé de l’application et ne sont accessibles qu’à son processus.

DataStore comme alternative

Jetpack DataStore est un remplacement moderne de SharedPreferences construit sur Kotlin Coroutines et Flow. DataStore propose deux variantes : Preferences DataStore pour les valeurs simples et Proto DataStore pour les objets typés. Contrairement à SharedPreferences, DataStore garantit la cohérence des données en cas d’accès concurrent et prend en charge les opérations asynchrones sans bloquer le thread principal.

// SharedPreferences — l’approche traditionnelle
val prefs = context
    .getSharedPreferences("settings", Context.MODE_PRIVATE)
with (prefs.edit()) {
    putString("username", "john_doe")
    putInt("score", 1500)
    apply()
}

// DataStore — l’approche asynchrone
val settingsDataStore = context
    .createDataStore("settings.pb")

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

Sous iOS, l’équivalent de SharedPreferences est UserDefaults, un système de stockage de valeurs simples au format Property List. UserDefaults utilise un accès synchrone et convient aux petits volumes de données de configuration, mais n’est pas recommandé pour le stockage d’informations sensibles.

SQLite dans les apps mobiles

SQLite est une base de données relationnelle intégrée qui fonctionne dans le processus de l’application sans serveur séparé. C’est le SGBD le plus répandu dans le développement mobile : il est utilisé par défaut sur les deux plateformes. Android inclut SQLite dans le SDK, et iOS l’inclut dans la bibliothèque libsqlite3. SQLite prend en charge le SQL standard, les transactions, les index et les déclencheurs.

Création de tables et opérations CRUD

Le travail avec SQLite commence par la définition du schéma de la base de données. Le développeur définit les tables, leurs champs et types, puis effectue des opérations d’insertion, de lecture, de mise à jour et de suppression. SQLiteOpenHelper sur Android gère la création et les migrations de la base de données, tandis qu’iOS utilise l’interface C ou le wrapper FMDB.

// SQLiteOpenHelper sous 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 pour Android

Room est une bibliothèque de Jetpack qui fournit une couche ORM au-dessus de SQLite. Room élimine le travail répétitif d’écriture de requêtes SQL et de ContentValues, en les remplaçant par des annotations et des fonctions Kotlin. Le compilateur de Room génère des implémentations de DAO (Data Access Object) à la compilation, éliminant ainsi les erreurs de syntaxe SQL.

Configurer Room dans un projet

Pour intégrer Room, vous devez ajouter la dépendance kapt et annoter la classe d’entité, l’interface DAO et la classe de base de données. RoomDatabase sert de point d’entrée : vous obtenez un DAO via celle-ci et effectuez des opérations sur la base de données. Room prend en charge Flow pour les requêtes réactives, les migrations de schéma et la vérification des requêtes à la compilation.

@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 est le framework d’Apple pour gérer un graphe d’objets et le persister sur le disque. Contrairement à Room, Core Data ne travaille pas avec des tables mais avec des objets gérés (NSManagedObject) qui forment une hiérarchie de relations. Core Data prend en charge le chargement paresseux, l’annulation des modifications et les requêtes complexes via NSFetchRequest.

Stack Core Data

Le cœur de Core Data se compose de trois composants : un contexte d’objets gérés (NSManagedObjectContext), un coordinateur de stockage persistant (NSPersistentStoreCoordinator) et un modèle de données (NSManagedObjectModel). NSPersistentContainer unifie tous les composants en un seul point d’entrée, simplifiant ainsi la configuration pour les applications Swift modernes.

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

Le stockage de fichiers (File Storage) est utilisé pour sauvegarder les images, vidéos et documents. Android fournit un stockage interne (context.filesDir) — privé à l’application, et un stockage externe (Environment.getExternalStorageDirectory) — accessible aux autres applications. Sous iOS, les fichiers sont enregistrés dans les répertoires Documents et Library, Library/Caches étant destiné au cache qui n’est pas sauvegardé dans iCloud. Pour les opérations sur les fichiers, les deux plateformes fournissent une File API et des opérations de lecture/écriture en flux. Les bibliothèques modernes comme Coil et SDWebImage ajoutent une couche de cache, combinant le stockage de fichiers avec la RAM pour des performances optimales.

Sur Android, une alternative à Core Data en termes de complexité et de fonctionnalités est Realm, une base de données orientée objet qui travaille directement avec les modèles sans couche SQL. Realm est plus rapide que SQLite pour les opérations de lecture et prend en charge les objets live qui mettent automatiquement à jour l’interface lors des modifications de données.