Aller au contenu

Créer l'application RoomWordsSample

Remarque

Dans ce TP, vous êtes censé créer des propriétés, importer des classes et extraire des valeurs selon les besoins. Le code que vous êtes censé connaître est fourni mais pas expliqué.

Un TP 100 % Kotlin

Tout le code de ce TP est écrit en Kotlin, et les scripts Gradle en Kotlin DSL (fichiers .gradle.kts). Lors de la création du projet, vérifiez bien ces deux choix (étape 3 ci-dessous).

1.1 Créer une application avec une seule activité

  1. Ouvrez Android Studio et cliquez sur New Project.
  2. Dans la fenêtre New Project, choisissez Basic Views Activity et cliquez sur Next. New Project window

  3. Sur l'écran suivant, configurez votre application, puis cliquez sur Finish :

    • Name : RoomWordSample
    • Package name : com.example.enetcom.roomwordsample
    • Save location : le dossier de votre dépôt cloné (voir la Tâche 0)
    • Language : Kotlin
    • Build configuration language : Kotlin DSL (build.gradle.kts)

  4. Ouvrez themes.xml, changez le parent du thème Base.Theme.RoomWordSample de l'application par Theme.Material3.Light.NoActionBar et supprimez le fichier themes.xml (night).

    Info

    Ceci permet d'avoir une interface utilisateur cohérente, car le mode sombre peut être activé sur vos émulateurs ou téléphones.

  5. Supprimez le répertoire navigation sous les ressources (res).

  6. Supprimez toutes les mises en page et classes Kotlin des fragments :

    • FirstFragment.kt et SecondFragment.kt
    • fragment_first.xml et fragment_second.xml

  7. Supprimez la balise fragment de content_main.xml.

  8. Supprimez les dépendances de la bibliothèque de navigation dans le fichier build.gradle.kts (Module: app) et synchronisez le projet :

    build.gradle.kts (Module: app)
    1
2
    implementation(libs.androidx.navigation.fragment.ktx)
implementation(libs.androidx.navigation.ui.ktx)

    Noms des dépendances

    Les noms exacts (libs.androidx.navigation.fragment.ktx, …) peuvent varier légèrement selon la version d'Android Studio. Supprimez simplement les deux lignes qui contiennent navigation.

  9. Nettoyez MainActivity.kt :

    Supprimez les imports inutilisés, la fonction de navigation onSupportNavigateUp() et toutes les variables en rouge liées à la bibliothèque de navigation (appBarConfiguration, navHostFragment, navController et l'appel à setupActionBarWithNavController()).

    Résultat attendu

    Après le nettoyage, MainActivity ressemble à ceci (le code généré peut varier légèrement selon la version d'Android Studio) :

    MainActivity.kt
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
    class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        enableEdgeToEdge()

        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        ViewCompat.setOnApplyWindowInsetsListener(binding.root) { v, insets ->
            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom)
            insets
        }
        setSupportActionBar(binding.toolbar)

        binding.fab.setOnClickListener { view ->
            Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                .setAction("Action", null)
                .setAnchorView(R.id.fab).show()
        }
    }

    override fun onCreateOptionsMenu(menu: Menu): Boolean {
        // Inflate the menu; this adds items to the action bar if it is present.
        menuInflater.inflate(R.menu.menu_main, menu)
        return true
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        return when (item.itemId) {
            R.id.action_settings -> true
            else -> super.onOptionsItemSelected(item)
        }
    }
}

  10. Exécutez votre application pour vérifier que tout fonctionne correctement.

1.2 Mettre à jour les fichiers Gradle

Ensuite, vous devez ajouter les bibliothèques de composants à vos fichiers Gradle.

Le fichier libs.versions.toml (le catalogue de versions) centralise les versions et les coordonnées des bibliothèques du projet. Chaque entrée de la section [libraries] devient une propriété de l'objet libs, utilisable dans les scripts Gradle : les tirets de l'alias deviennent des points (room-runtime → libs.room.runtime).

build.gradle.kts (Module: app)
1
implementation("androidx.room:room-runtime:2.8.4") // (1)!
  1. La coordonnée de la bibliothèque est écrite directement dans le script, sous la forme groupe:nom:version.
libs.versions.toml
1
2
3
4
5
[versions]
room = "2.8.4" # (1)!

[libraries]
room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" } # (2)!
  1. Le numéro de version est déclaré une seule fois, sous le nom room.
  2. L'alias room-runtime regroupe le group, le name et la version (version.ref renvoie à la variable room).
build.gradle.kts (Module: app)
1
implementation(libs.room.runtime) // (1)!
  1. Le script utilise l'alias du catalogue : plus aucun numéro de version dans le script.

Le plugin KSP (Kotlin Symbol Processing) est également déclaré dans le catalogue : c'est lui qui permet au compilateur de Room de générer le code de la base de données à partir de vos annotations Kotlin.

  1. Dans Android Studio, cliquez sur l'onglet Project et développez le dossier Gradle Scripts.
  2. Ouvrez le fichier libs.versions.toml.

  3. À la fin de la section [versions], ajoutez les trois variables suivantes qui définissent les versions des bibliothèques "room" et "lifecycle" ainsi que celle du plugin "ksp" :

    libs.versions.toml
    1
2
3
4
5
    # Versions des bibliothèques de composants d'architecture
room = "2.8.4"
lifecycle = "2.10.0"
# Version du plugin KSP (traitement des annotations de Room)
ksp = "2.3.12"

  4. À la fin de la section [libraries], ajoutez la définition des packages des deux bibliothèques ainsi que leurs versions respectives :

    libs.versions.toml
    1
2
3
4
5
6
7
    # Composant de base de données Room
room-runtime = { group = "androidx.room", name = "room-runtime", version.ref = "room" }
room-compiler = { group = "androidx.room", name = "room-compiler", version.ref = "room" }
room-testing = { group = "androidx.room", name = "room-testing", version.ref = "room" }
# Composants de cycle de vie
lifecycle-viewmodel = { group = "androidx.lifecycle", name = "lifecycle-viewmodel", version.ref = "lifecycle" }
lifecycle-livedata = { group = "androidx.lifecycle", name = "lifecycle-livedata", version.ref = "lifecycle" }

  5. À la fin de la section [plugins], ajoutez la définition du plugin KSP :

    libs.versions.toml
    1
    ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

  6. Ouvrez le fichier build.gradle.kts (Project: RoomWordSample) et déclarez le plugin KSP dans le bloc plugins (sans l'appliquer à la racine du projet) :

    build.gradle.kts (Project: RoomWordSample)
    1
2
3
4
    plugins {
    alias(libs.plugins.android.application) apply false
    alias(libs.plugins.ksp) apply false // (1)!
}
    1. Ligne à ajouter. Les autres lignes déjà présentes dans votre fichier restent inchangées.

  7. Ouvrez le fichier build.gradle.kts (Module: app) et appliquez le plugin KSP au module de l'application :

    build.gradle.kts (Module: app)
    1
2
3
4
    plugins {
    alias(libs.plugins.android.application)
    alias(libs.plugins.ksp) // (1)!
}
    1. Ligne à ajouter. Les autres lignes déjà présentes dans votre fichier restent inchangées.

  8. Dans le même fichier, ajoutez le code suivant en bas du bloc des dépendances dependencies (mais toujours à l'intérieur du bloc) :

    build.gradle.kts (Module: app)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    // Dépendances pour travailler avec les composants d'architecture
// Vous devrez probablement mettre à jour les numéros de version dans libs.versions.toml

// Composant de base de données Room
implementation(libs.room.runtime)
ksp(libs.room.compiler)
testImplementation(libs.room.testing)

// Composants de cycle de vie
implementation(libs.lifecycle.viewmodel)
implementation(libs.lifecycle.livedata)

    ksp et non annotationProcessor

    Le compilateur de Room doit être déclaré avec ksp(...). La configuration annotationProcessor, réservée aux sources Java, ne traiterait aucune de vos classes Kotlin.

  9. Cliquez sur Sync Now pour synchroniser votre projet avec les nouveaux fichiers Gradle.