Catalogue de versions Gradle sur Android

Les catalogues de versions Gradle nous permettent d’ajouter et de gérer des dépendances de manière simple et évolutive. Les applications grandissent, et la gestion de projets avec plusieurs équipes de développement augmente le temps de compilation.

Une solution potentielle pour résoudre ce problème consiste à segmenter le projet en plusieurs modules. Compiler ces modules en parallèle et ne recompiler que les parties modifiées réduit le temps de compilation global. Cependant, un dilemme se pose : comment pouvons-nous partager efficacement les dépendances de bibliothèques communes et leurs versions respectives tout en évitant les erreurs de compilation et la nécessité de scruter manuellement les fichiers Gradle de chaque module pour éviter les problèmes de synchronisation ?

Les catalogues de versions Gradle nous aident à centraliser toutes les dépendances dans un seul fichier avec une saisie sécurisée que vous pouvez appeler à partir de vos modules.

Créer le Fichier de Version

Tout d’abord, nous devons créer notre fichier dans le dossier Gradle. Par convention, nous utilisons le nom libs.version.toml recommandé dans les guides de développement Android.

Ce fichier aura trois sections:

[versions]

[libraries]

[plugins]

• Versions. Il définit les versions de vos dépendances et plugins utilisés dans les deux autres blocs
• Bibliothèques. Contient les dépendances.
• Plugins. Contient les plugins.

Définissons, par exemple, la version et les dépendances de la bibliothèque Koin pour l’injection de dépendances.

[versions]
koin = "3.4.0"

[libraries]
koin-core = { group = "io.insert-koin", name = "koin-core", version.ref = "koin" }
koin-android = { group = "io.insert-koin", name = "koin-android", version.ref = "koin" }
koin-androidx-compose = { group = "io.insert-koin", name = "koin-androidx-compose", version.ref = "koin" }
koin-androidx-workmanager = { group = "io.insert-koin", name = "koin-androidx-workmanager", version.ref = "koin" }
koin-test = { group = "io.insert-koin", name = "koin-test", version.ref = "koin" }
koin-test-junit4 = { group = "io.insert-koin", name = "koin-test-junit4", version.ref = "koin" }

Ensuite, pour appeler la dépendance à partir de n’importe quel module, nous n’aurions qu’à faire ce qui suit:

Dependencies {
    implementation(libs.koin.core)
    implementation(libs.koin.android)
}

Créez Vos Plugins, et Tous Vos Modules Seront Toujours Synchronisés

Lorsque nous avons déjà migré nos dépendances, nous constatons un problème. Tous nos modules qui ont besoin de Koin devront répéter les mêmes lignes. Ici, nous pouvons voir un exemple clair de DRY (Don’t Repeat Yourself), et nous allons créer un plugin Gradle pour nous épargner de répéter encore et encore l’inclusion de ces dépendances.

Dans notre fichier build.gradle.kts, nous pourrons enregistrer nos plugins Gradle.

gradlePlugin {
    plugins {
            register("koin") {
                    id = "example.android.koin"
                    implementationClass = "AndroidKoinConventionPlugin"
                }
}
}

Ensuite, nous créerons notre plugin, et nous ajouterons les dépendances de ce plugin avec GVC.

class AndroidKoinConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
            dependencies {
      "implementation"(libs.findLibrary("koin.core").get())
      "implementation"(libs.findLibrary("koin.android").get())
      "implementation"(libs.findLibrary("koin.androidx.compose").get())
      "implementation"(libs.findLibrary("koin.androidx.workmanager").get())
      "testImplementation"(libs.findLibrary("koin.test").get())
      "testImplementation"(libs.findLibrary("koin.test.junit4").get())
            }
        }
    }
}

La seule chose qui reste est d’appeler dans nos modules le plugin Koin, et si un jour nous devons mettre à jour la version, nous n’avons qu’à aller dans notre fichier de définitions, et toutes seront mises à jour lors de la synchronisation Gradle. Par exemple, le fichier du module de données avec toutes ses dépendances

plugins {
    id("example.android.library")
    id("example.android.koin")
}

android {
    namespace = "com.example.core.data"
}

dependencies {
    implementation(libs.kotlinx.coroutines.android)
}

Avec tout cela, nous pouvons créer des plugins qui regroupent les dépendances, par exemple:

• Bibliothèque
• Compose
• Goûts
• Fonctionnalité
• DI
• Base de données
• Test

Considérations

Les catalogues de versions Gradle sont encore en pleine métamorphose, et il est bon de suivre les bugs connus et les limitations que Android publie. Les exemples de cet article illustrent les avantages des catalogues de versions Gradle et comment ils peuvent simplifier nos existences. Si vous cherchez une application fonctionnelle, vous pouvez la découvrir sur GitHub dès maintenant pour Android.