Comment créeriez-vous une base de données pour une…

Pour créer une base de données locale sur Android, j’utiliserais Room Persistence Library.

C’est une abstraction sur SQLite qui simplifie la gestion de la base de données, en fournissant une API annotée pour créer des schémas, des requêtes et gérer les migrations.

Étapes principales :

Ajouter les dépendances :

// Dans build.gradle (niveau app)
dependencies {
    implementation("androidx.room:room-runtime:2.6.1")
    annotationProcessor("androidx.room:room-compiler:2.6.1") // Pour Java
    kapt("androidx.room:room-compiler:2.6.1") // Pour Kotlin
    implementation("androidx.room:room-ktx:2.6.1") // Pour les coroutines
}

Créer des entités (Entities) : POJO (Plain Old Java Object) ou classes de données représentant les tables. Les annotations @Entity, @PrimaryKey, @ColumnInfo sont utilisées pour définir la structure.

@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    @ColumnInfo(name = "first_name") val firstName: String?,
    @ColumnInfo(name = "last_name") val lastName: String?
)

Créer le DAO (Data Access Object) : Interfaces définissant les méthodes d’accès aux données (insertion, suppression, mise à jour, requêtes). Les annotations @Dao, @Insert, @Delete, @Update, @Query sont utilisées.

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

    @Insert
    fun insertAll(vararg users: User)

    @Delete
    fun delete(user: User)
}

Créer la classe Database : Classe abstraite héritant de RoomDatabase, qui donne accès au DAO et définit le schéma. L’annotation @Database indique les entités et la version.

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

    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null

        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database"
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

Travailler avec la base de données : Obtenir l’instance et effectuer des opérations via le DAO.

val db = AppDatabase.getDatabase(applicationContext)
val userDao = db.userDao()

// Insertion de données (habituellement dans un thread en arrière-plan)
GlobalScope.launch {
    userDao.insertAll(User(firstName = "John", lastName = "Doe"))
}

// Récupération de données
GlobalScope.launch {
    val users = userDao.getAll()
}

Avantages de Room :

Vérification des requêtes à la compilation : Les requêtes SQL sont vérifiées lors de la compilation, ce qui réduit les erreurs à l’exécution.
Facilité de gestion des threads : L’intégration avec les coroutines ou LiveData facilite le travail avec des données en arrière-plan.
Migration plus simple : Fournit des outils pour gérer les changements de schéma.
Moins de code boilerplate comparé à SQLite natif.

Si les exigences sont très spécifiques ou petites, on peut envisager d’utiliser Shared Preferences pour des paires clé-valeur simples, mais pour des données structurées et des requêtes, Room est préféré. Pour des scénarios plus complexes nécessitant synchronisation ou accès depuis différentes sources (par exemple, web), on peut envisager l’utilisation de bases de données cloud comme Firebase Realtime Database ou Firestore, mais pour le stockage local, Room est la solution standard et recommandée.

Comment créeriez-vous une base de données pour une application mobile?