Gérez vos données localement pour une application Android 100 % hors-ligne

Vous connaissez maintenant les différentes solutions de stockage local proposées par le système Android. Dans le cadre du projet fil rouge PETiSoin, la base de données Room est la solution qui répond le mieux à vos besoins.

Créez un projet Android Studio

Focalisons-nous sur les options et paramètres à sélectionner pour la création de votre projet Android Studio. Que vous utilisez le langage de programmation Java ou Kotlin, vous pouvez utiliser le template Empty Views Activity.

1. Dans le champ Name, saisissez le nom de l'application : "PETiSoin".

2. Dans le champ Package name, vous êtes libre de préciser le nom de paquetage de votre choix, de mon côté j’ai fait le choix d’utiliser "com.openclassRooms.petisoin".

3. Utilisez Java ou Kotlin comme langage de programmation en fonction de vos préférences. 

4. Choisissez la version minimale d’Android supportée par l’application. L’API 24, qui permet de cibler plus de 95% des terminaux Android est une bonne option.

5. Sélectionnez Kotlin DSL pour la section Build configuration language.

Déclarez les dépendances Room dans le catalogue Gradle

Maintenant que le projet Android Studio a été créé, vous pouvez déclarer la dépendance Room.

Dans un premier temps, il est nécessaire de référencer Room au sein du catalogue Gradle du projet.

1. Pour ce faire, rendez-vous dans le dossier "gradle" du projet.

2. Ouvrez dans Android Studio le fichier "libs.versions.toml". Par défaut, le contenu du fichier ressemble à ça :

[versions]
agp = "8.4.0"
kotlin = "1.9.0"
coreKtx = "1.10.1"
junit = "4.13.2"
junitVersion = "1.1.5"
espressoCore = "3.5.1"
appcompat = "1.6.1"
material = "1.10.0"
activity = "1.8.0"
constraintlayout = "2.1.4"

[libraries]
androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
junit = { group = "junit", name = "junit", version.ref = "junit" }
androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
material = { group = "com.google.android.material", name = "material", version.ref = "material" }
androidx-activity = { group = "androidx.activity", name = "activity", version.ref = "activity" }
androidx-constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintlayout" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
jetbrains-kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }

Ce fichier est composé de trois sections :

• la sectionversions qui permet de déclarer l’ensemble des variables qui stockent les versions des dépendances et des plugins ;

• la sectionlibrairies qui permet de définir vos dépendances ;

• la sectionplugins qui permet de définir vos plugins.

Vous pouvez donc créer une variableRoom dans la sectionversions en lui donnant pour valeur le numéro de la dernière version stable de Room. Au moment où j’écris ces lignes, la dernière version stable est la version 2.6.1.

[versions]
Room = "2.6.1"

Maintenant que la version de Room est déclarée, vous pouvez l’utiliser pour déclarer les dépendances Room à placer dans la section "variables" du fichier libs.versions.toml.

Ici, nous allons utiliser les deux dépendances obligatoires :

• Room-runtime fournit l’ensemble des classes et des ressources nécessaires à l’implémentation et l’exécution de Room dans votre application mobile ;

• Room-compilerfournit l’ensemble des outils nécessaires à la génération de code. 

Room, comme d’autres dépendances (comme Hilt par exemple) s’implémente en partie à l’aide d’annotations qui permettent de générer automatiquement du code. Les objectifs sont multiples :

• réduction du code à écrire pour les développeurs ;

• amélioration de la lisibilité du code et donc amélioration de la maintenabilité ;

• détection précoce des erreurs au moment de la génération du code et donc de la compilation.

Voici les dépendances à ajouter.

[libraries]
Room-runtime = { group = "androidx.Room", name = "Room-runtime", version.ref = "Room" }
Room-compiler = { group = "androidx.Room", name = "Room-compiler", version.ref = "Room" }
# Si le projet est en Kotlin
Room-ktx = { group = "androidx.Room", name = "Room-ktx", version.ref = "Room" }

Déclarez les dépendances Room dans le projet

Maintenant que les différentes dépendances de Room sont déclarées dans le catalogue Gradle, vous pouvez les utiliser dans votre projet. Commençons par la dépendance Room-runtime . 

Dans le fichier "build.gradle.kts" qui se trouve dans le dossier "app" de votre projet Android, repérez la section  dependencies et ajoutez-y la dépendance :

dependencies {
  //…
  implementation(libs.Room.runtime)
  // Si le projet est en Kotlin
  implementation(libs.Room.ktx)
}

Comprenez la génération de code

Avant de passer à la suite, il est encore nécessaire de déclarer l’usage de la dépendance  Room-compiler qui, comme mentionné précédemment, fournit l’ensemble des outils nécessaires à la génération de code. L’utilisation et la déclaration de cette dépendance varient en fonction du langage de programmation utilisé pour votre projet.

Utilisez Java et APT

Avec Java, le traitement des annotations et la génération de code nécessaire à l’utilisation de Room sont possibles grâce au processeur d’annotations APT (Annotation Processing Tool). APT est donc un processeur d'annotations qui vous permet, en tant que développeur, d'utiliser des annotations sur vos classes et interfaces Java, puis de générer automatiquement du code Java à partir de ces annotations.

Pour indiquer que le traitement des annotations et la génération de code sont faits à l’aide d’APT au sein de votre projet, vous devez référencer la dépendance  Room-compiler à l’aide de la configuration GradleannotationProcessor. Dans le fichier "build.gradle.kts" qui se trouve dans le dossier "app" de votre projet Android, vous pouvez alors compléter la section dependencies:

dependencies {
  //…
  annotationProcessor(libs.Room.compiler)
}

Utilisez Kotlin et KSP

Avec Kotlin, le traitement des annotations et la génération de code nécessaire à l’utilisation de Room sont possibles grâce à KSP (Kotlin Symbol Processing). Pour utiliser KSP, la première étape est d’ajouter le plugin à votre projet Android dans le catalogue Gradle et dans les différents fichiers "build.gradle.kts" de votre projet.

1. Déclarez le plugin et sa version dans le catalogue Gradle. Le choix de la version du plugin nécessite une petite réflexion car la version de KSP utilisée doit être alignée avec la version de Kotlin du projet. Le versionnage de KSP suit le modèle suivant :{version.de.kotlin}-{version.de.ksp}.

Si comme moi, vous utilisez la version 1.9.23 de Kotlin, vous devez donc choisir une version de KSP qui débute par ces chiffres-là.

La déclaration du plugin dans le catalogue Gradle devrait alors ressembler à ça.

[versions]
ksp = "1.9.23-1.0.20"
[plugins]
ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }

2. Maintenant que le plugin est déclaré dans le catalogue Gradle, déclarez l’usage du plugin KSP dans le fichier "build.gradle.kts" qui se trouve à la racine du projet Android Studio en l’ajoutant dans la section  plugins .

// Top-level build file where you can add configuration options common to all sub-projects/modules.
plugins {
  //…
  alias(libs.plugins.ksp) apply false
}

3. Activez l’utilisation du plugin KSP au sein du module "app" du projet Android. Pour ce faire, rendez-vous dans le fichier "build.gradle.kts" qui se trouve, cette fois-ci, dans le dossier app de votre projet Android. Cherchez la section  plugins et ajoutez-y une référence au plugin KSP.

plugins {
  //…
  alias(libs.plugins.ksp)
}

4. Déclarez l’usage de la dépendance  Room-compiler à l’aide de la configuration Gradle  ksp dans la sectiondependencies du fichier "build.gradle.kts" qui se trouve dans le dossier "app" de votre projet Android.

dependencies {
  //…
  ksp(libs.Room.compiler)
}

Voici une vidéo qui récapitule les principales étapes pour déclarer les dépendances Room en Kotlin.

À vous de jouer !

Contexte

Pour implémenter techniquement la rubrique “Santé” de l’application PETiSoin, il convient de créer la base de données Room qui permettra de stocker localement les données.

Votre mission est d'ajouter l'ensemble des dépendances Room permettant d’utiliser la bibliothèque dans les bases de l’application PETiSoin Java ou Kotlin . 

Consignes

1. Dans la sectionlibraries du catalogue Gradle, référencez les dépendances suivantes

   • Room-runtime  ;

   • Room-compiler  ;

   • Room-ktx si vous utilisez Kotlin.

2. Dans la sectionplugins du catalogue Gradle, référencez les plugins Gradle suivants :

   • KSP si vous utilisez Kotlin ;

   • APT si vous utilisez Java.

3. Appliquez l'ensemble des dépendances au projet.

Livrables

Vous pouvez dupliquer le projet GitHub pour modifier le code source du projet.

En résumé

• L'utilisation de Room dans un projet Android nécessite l’ajout de dépendances.

• Room-runtimeest la dépendance qui met à disposition l’ensemble des classes et des annotations permettant d’utiliser Room.

• Room-compiler est le processeur d'annotations qui analyse vos annotations Room et génère le code nécessaire pour interagir avec votre base de données SQLite.

• Room-ktxest la dépendance qui fournit des extensions Kotlin.

• APT (Annotation Processing Tool) est un outil de traitement d'annotations qui permet d'automatiser la génération de code en Java.

• KSP (Kotlin Annotation Processing Tool) est un outil de traitement d'annotations qui permet d'automatiser la génération de code en Kotlin.

Vous avez importé avec succès Room au sein de votre projet. Nous devons maintenant configurer certaines options qui vont permettre de personnaliser son usage et compiler notre projet correctement.