Jetpack Compose - Bases de Données : Room et les Requêtes Réactives

Bonjour et bienvenue dans mon article numéro 5 dans cet article, on va voir comment utiliser Room, une bibliothèque pour gérer les données locales sur Android, avec Jetpack Compose. On va aussi apprendre à utiliser des requêtes réactives pour rendre l’application plus fluide.

Pourquoi utiliser Room avec Jetpack Compose ?

Room est une bibliothèque qui permet de travailler facilement avec une base de données SQLite dans Android. Elle est simple et aide à bien gérer les données locales. En utilisant Jetpack Compose avec Room, on peut créer des applications qui gèrent bien les données tout en mettant à jour l’interface utilisateur rapidement. Jetpack Compose et Room fonctionnent bien ensemble et permettent de créer des applications modernes et faciles à maintenir.

Étape 1 : Ajouter les Dépendances Room

La première étape est d’ajouter les dépendances pour Room dans le fichier build.gradle :

dependencies {
    implementation "androidx.room:room-runtime:2.4.3"
    kapt "androidx.room:room-compiler:2.4.3"

    implementation "androidx.compose.ui:ui:1.1.1"
    implementation "androidx.compose.material:material:1.1.1"
    implementation "androidx.compose.ui:ui-tooling-preview:1.1.1"
}

N’oublie pas d’ajouter KAPT pour générer le code nécessaire pour Room.

Étape 2 : Créer les Entités Room Ensuite, tu dois créer les entités. Ce sont les classes qui représentent les données stockées dans la base. Par exemple, voici une entité représentant un utilisateur :

@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int = 0,
    val name: String,
    val email: String
)

Ici, chaque utilisateur a un id, un name et un email.

Étape 3 : Créer la DAO (Data Access Object) La DAO définit les méthodes pour accéder aux données. Par exemple, voici une interface DAO pour ajouter, modifier, supprimer et lire des utilisateurs :

@Dao
interface UserDao {
    @Insert
    suspend fun insert(user: User)

    @Update
    suspend fun update(user: User)

    @Delete
    suspend fun delete(user: User)

    @Query("SELECT * FROM users")
    fun getAllUsers(): Flow<List<User>>
}

En utilisant Flow dans getAllUsers(), on crée une méthode réactive. Cela veut dire que l’interface utilisateur sera mise à jour automatiquement quand les données changent.

Étape 4 : Créer la Base de Données Room Maintenant, il faut créer la base de données qui va gérer les entités et DAO. Voici comment définir la base de données :

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

Étape 5 : Utiliser Room dans un ViewModel avec Jetpack Compose Dans Android, il est conseillé d’utiliser un ViewModel pour gérer les données et la logique de l’application. Le ViewModel récupère les données de Room et les envoie à l’interface utilisateur. Voici un exemple avec Jetpack Compose :

class UserViewModel(application: Application) : AndroidViewModel(application) {
    private val userDao = Room.databaseBuilder(application, AppDatabase::class.java, "app_database")
        .build()
        .userDao()

    val users: StateFlow<List<User>> = userDao.getAllUsers().stateIn(viewModelScope, SharingStarted.Lazily, emptyList())

    fun addUser(user: User) {
        viewModelScope.launch {
            userDao.insert(user)
        }
    }
}

Ici, on utilise StateFlow pour collecter les utilisateurs de la base de données et les envoyer à l’interface utilisateur. Quand les données changent, l’interface se met à jour automatiquement.

Étape 6 : Afficher les Données dans Jetpack Compose Maintenant que nous avons les données dans le ViewModel, il est temps de les afficher avec Jetpack Compose. Voici comment afficher la liste des utilisateurs :

@Composable
fun UserListScreen(viewModel: UserViewModel) {
    val users by viewModel.users.collectAsState()

    LazyColumn {
        items(users) { user ->
            Text(text = "${user.name} - ${user.email}")
        }
    }
}

Ici, on utilise LazyColumn pour afficher les utilisateurs. Quand la liste des utilisateurs change dans la base de données, l’interface se met à jour grâce à collectAsState().

Conclusion

En utilisant Jetpack Compose avec Room, tu peux créer des applications Android modernes et réactives. Grâce à Flow et StateFlow, tu peux gérer facilement les données réactives et offrir une expérience utilisateur fluide. Avec ces étapes simples, tu peux commencer à gérer des données locales dans tes applications Jetpack Compose.

Sources

• Philipp Lackner(youtubeur), "How to Setup a Room DB for Kotlin Multiplatform Compose" [vidéo], YouTube, 2024, 20 min 26 sec, YouTube, https://www.youtube.com/watch?v=IHs0yPa2Nv4
• GOOGLE. « Room Database », dans GOOGLE, dir., Android Developers, 2025/01/30, https://developer.android.com/training/data-storage/room