Publié par

Il y a 3 semaines -

Temps de lecture 4 minutes

Pépite #20- Centralisez vos dépendances avec Gradle Kotlin DSL

Je vous propose, dans cette pépite, de vous montrer comment migrer vers Gradle Kotlin DSL afin de gérer vos dépendances Gradle proprement et sainement.

Pourquoi migrer vers cette nouvelle syntaxe ?

Si vous avez commencé à développer en Kotlin, il vous est également possible d’avoir vos scripts de configuration de build en Kotlin plutôt qu’en Groovy qui peut être pénible à gérer.

En plus du langage, l’un des intérêts principaux de cette nouvelle syntaxe est l’auto-complétion car Kotlin est statiquement typé. Contrairement à Groovy qui est dynamique, Android Studio peine à vous mettre en place les méthodes, les paramètres et à remonter les erreurs de saisie.

Afin de tirer les avantages des nouvelles améliorations apportées depuis la version 3 du plugin Android pour Gradle, Google nous conseille de découper nos projets en modules lorsque notre périmètre fonctionnel est assez fourni. Ce qui veut dire qu’il faut gérer les configurations Gradle dans chaque module et garder le contrôle des versions des dépendances.

Comment gériez-vous vos dépendances dans votre configuration ?

Vous aviez sûrement commencé par ajouter les dépendances manuellement ce qui nécessitera beaucoup de changement manuels pour mettre à jour les librairies.

Prenons l’exemple de deux modules feature_a et feature_b ayant quelques dépendances communes.

 

feature_a/build.gradle
dependencies {   
	implementation "androidx.appcompat:appcompat:1.1.0"
	implementation "androidx.constraintlayout:constraintlayout:1.1.3"
	implementation "androidx.recyclerview:recyclerview:1.0.0"
    implementation "com.airbnb.android:lottie:3.0.7"
}

 

feature_b/build.gradle

dependencies {   
	implementation "androidx.appcompat:appcompat:1.1.0"
    implementation "androidx.fragment:fragment-ktx:1.1.0"
  	implementation "androidx.transition:transition:1.1.0"
    implementation "com.airbnb.android:lottie:3.0.7"
}
Comment s’assurer que les dépendances communes aient les mêmes versions ?

Google recommande les extra properties à configurer dans build.gradle à la racine du projet.

Mais nous allons plus loin et passons par la configuration Kotlin pour Gradle qui est bien plus claire.

Tout d’abord, nous allons créer un nouveau module buildSrc.

Pourquoi nommer ainsi ? buildSrc est une fonctionnalité de Gradle qui permet de définir des tâches (tasks) et outils à disposition des scripts de build.

Comme tout module, nous devons y ajouter un script de configuration du build. Cependant, ce script sera en Kotlin (avec l’extension .kts pour Kotlin Script) et nous y appliquerons le plugin Kotlin DSL.

 

buildSrc/build.gradle.kts
plugins {
    `kotlin-dsl`
}

repositories {
    jcenter()
}

 

Ensuite, nous allons créer nos propriétés Kotlin dans un fichier que l’on nommera Dependencies.kt pour déclarer nos dépendances et nos versions. Ce nommage n’est pas imposé, à vous la liberté du nom de fichier mais priorité à la cohérence et la compréhension.

 

buildSrc/src/main/kotlin/Dependencies.kt
object Versions {
	const val appCompat = "1.1.0"
	const val constraintLayout = "1.1.3"
	const val recyclerView = "1.0.0"
	const val transition = "1.1.0"
	const val lottie = "3.0.7"
}

object Libraries {   
	val androidx = AndroidX
	const val lottie = "com.airbnb.android:lottie:${Versions.lottie}"
}

object AndroidX {
	const val appCompat = "androidx.appcompat:appcompat:${Versions.appCompat}"
	const val constraintLayout = "androidx.constraintlayout:constraintlayout:${Versions.constraintLayout}"
	const val recyclerView = "androidx.recyclerview:recyclerview:${Versions.recyclerView}"
  	const val transition = "androidx.transition:transition:${Versions.transition}"
}

 

Les dépendances, organisées ainsi, sont plus lisibles et cela permet de les maitriser de manière centralisée.

Enfin, une synchronisation Gradle et nous pouvons maintenant accéder et appliquer nos dépendances aux scripts de configuration de nos deux modules précédents.

Nous allons également transformer nos scripts Groovy en Kotlin.

feature_b/build.gradle.kts
dependencies {   
	implementation(Libraries.androidX.appCompat)
    implementation(Libraries.androidX.fragment)
	implementation(Libraries.androidX.transition)
 	implementation(Libraries.lottie)
}
feature_a/build.gradle.kts
dependencies {   
	implementation(Libraries.androidX.appCompat)
	implementation(Libraries.androidX.constraintLayout)
	implementation(Libraries.androidX.recyclerView)
 	implementation(Libraries.lottie)
}

 

À noter que la transformation de vos scripts de configuration n’est pas forcément requise. Vous pouvez continuer à utiliser Groovy.

En conclusion, cette manipulation vous permettra de maitriser vos dépendances et d’avoir une gestion de manière centralisée lorsque votre projet prendra une plus grande envergure.

Publié par

Commentaire

1 réponses pour " Pépite #20- Centralisez vos dépendances avec Gradle Kotlin DSL "

  1. Publié par , Il y a 2 semaines

    Très bon article mais pas besoin de kotlin gradle dsl, la même chose est possible avec le dsl groovy ;)

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Nous recrutons

Être un Xebian, c'est faire partie d'un groupe de passionnés ; C'est l'opportunité de travailler et de partager avec des pairs parmi les plus talentueux.