Le gradle sur Android

Le Gradle est l’outil de gestion de dépendance et d’automatisation officiel d’Android.

Il combine les atouts de Apache Maven ,et de Apache Ant, ajoute ces propres fonctionnalités et utilise le DSL( Domain Specific Language ) basé sur groovy (Un langage de la machine virtuel Java ) pour déclarer les configurations de votre projet. Contrairement à Apache Maven et Apache Ant qui utilise un fichier xml pour déclarer les configurations de projet .

Voici quelques avantages qui font du gradle l’outil de construction le plus utilisé.

Performance élevée : Le gradle évite les taches inutiles en n’exécutant que les taches dont les entrées ou les sorties ont changé.Vous pouvez également utiliser le build cache pour permettre la réutilisation des résultats des taches d’exécution précédente.Il existe bien d’autres optimisations implémentées par le gradle.

Fondé sur la JVM : Le gradle s’exécute sur la machine virtuel Java(JVM). Vous devez installer le JDK ( Java Development Kit ) pour l’utiliser.

Extensibilité :Vous pouvez facilement étendre le gradle et fournir vos propres types de tache pour construire des modèles.Il ajoute de nouveaux concepts de construction tel que les product flavors et les build types

Etc.

Table des matières

Le plugin Android du Gradle (Android plugin for Gradle)

Le plugin Android du gradle est un plugin du gradle qui ajoute plusieurs fonctionnalités spécifiques pour la construction de vos applications Android. Vous pouvez aussi créer votre propre plugin Android pour le gradle qui exécutera durant la construction de votre application.

.Android Studio utilise le gradle wrapper pour complètement intégrer le plugin Android du gradle. Le plugin Android du gradle peux s’exécuter indépendamment de Android Studio.Ce qui signifie que vous pouvez construire votre application depuis Android Studio ou en ligne de commande

Les configurations personnalisées de construction d’application(Cutsom Build Configuration)

La configuration du script de construction de votre application est défini dans le fichier build.gradle. Ce fichier est un ficher texte brut qui utilise la syntaxe et les options du gradle et du plugin Android pour configurer les aspects suivant du script de construction de votre application.

Build Types: Les Build Types définissent certaines propriétés du gradle utilisées durant la construction et la génération du package de votre application.

Ce sont des propriétés que vous configurez durant différents étapes du cycle de vie de votre application. Par défaut Android studio crée dans votre projet deux Build types tel que release et debug.

Par exemple le Build type debug permet d’activer les options de débogage et de signer l’APK avec une clé de débogage tandis que le build type release permet de réduire,masqué, signer votre APK avec une clé de version de distribution.

Dans chaque build type vous pouvez définir et activer plusieurs propriétés. Vous devez au moins définir dans votre fichier gradle un build type pour générer l’apk de votre application.Voir ci-dessous un exemple de configuration de build type

buildTypes {
        debug {
            applicationIdSuffix ".debug"
            debuggable true
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }

Vous pouvez constater que dans chaque build type : debug et release, plusieurs propriétés sont définis pour configurer chaque build type. Par exemple la propriété minifyEnabled permet d’activer ou non proguard pour réduire, masqué votre code etc.

Dès que vous activez l’option minifyEnabled , le gradle applique l’outil proguard pour réduire,masquer le code de votre application.

Product Flavors: Dans le fichier build.gradle de votre application, vous pouvez utiliser les product flavors pour représenter plusieurs versions de votre application que vous souhaiterai distribuer pour vos utilisateurs tel qu’une version gratuite, et une version payante ou même une version pour chaque pays.

Il n ya pas de limite sur comment vous souhaitez distribuer votre application avec les product flavors.

Vous pouvez aussi personnaliser chaque product flavors pour utiliser différents codes sources et ressources de votre application.Tous les product flavors partagent et utilisent le code et les ressource définis dans le répertoire du module d’application. Les product flavors sont optionnels et vous pouvez les créer manuellement.

Vous devez savoir que Android stuido ne crée pas automatiquement les différents répertoires de chaque product flavors généré

Vous devez donc créer un répertoire pour chaque product flavor. Et y insérer le code(les fonctionnalité) et les ressources qui seront disponible uniquement dans ces product flavors.

Voir ci-dessous un exemple de configuration de product flavors

  android {
    flavorDimensions "version"

    productFlavors {
        freeversion {
            //selectionne la dimension du flavor
            dimension "version"
           //configure la propriété applicationId pour que l'application soit publier sur le 
           //play store
            applicationId "com.exemple.flavors.free"
        }

        paidversion{
            dimension "version"
            applicationId "com.exemple.flavors.paid"
            resValue "string", "flavored_app_name", "Paid Great App"
        }
    }
}

Sur les périphériques des utilisateurs deux applications ne peuvent pas avoir un même identifiant. Ainsi pour la même application, j’ai défini deux valeurs différentes pour la propriété applicationId.

Ce qui permet à un utilisateur d’installer par exemple la version gratuite et la version payant de votre application.

Build variants: Build variant est le croisement du Build type et de Product Flavors. En utilisant les variantes de construction ou build variants, vous pourrai par exemple construire une version de débogage et une version de distribution(en production) signé de votre application.

En réalité vous ne configurez pas directement les variantes de construction( build variants), vous configurez juste le Build type et les product flavors et Android Studio génère automatiquement les variantes de votre application.Cela vous permet de générer plusieurs Apk.

Manifest Entries: Vous pouvez créez un fichier manifeste pour chaque variante de construction(build variants) et redéfinir certaines propriétés de manifeste tel que le nom de l’application, la version minimum du sdk ,la version de l’api à partir de laquelle vous créez l’apk(target SDK version) etc.

Dependencies: Le systeme de construction sur Android Studio vous facilite la tache en gérant les dépendance de votre projet à partir de votre système de fichier local ou des dépôts distant(remote repository) .

Il incluant dans la construction de votre application les librairies externes et d’autres librairies module comme dépendance. Cela vous préserve de rechercher, télécharger et de copier les fichiers binaires de package de vos dépendance de projet.

Signing: Le système de construction vous permet de spécifier les paramètres de signature dans les configurations de construction et pourra signer vos APK lors du processus de construction.

Proguard: Le système de construction vous permet de spécifier un fichier de règle proguard différent pour chaque variante de construction.Ainsi le système de construction pourra exécuter proguard pour réduire et masquer vos classe durant le processus de construction.

Multiple APK Support:Le système de construction vous permet de créer automatiquement différents APK contenant chacun le code sources et les ressource pour une densité d’écran donné, etc.

Paramètres de construction de projet et de modules(Projects and modules build settings)

Quand vous créez un nouveau projet, Android studio crée automatiquement certains fichiers comme indiqué dans la figure suivante et les remplies en fonctions de certaines valeurs par défaut que vous avez spécifié ou en fonction de certaines valeurs prédéfinies

Un projet représente le niveau supérieur dans la structure de développement Android et contient l’ensemble des fichiers de projet et un ou plusieurs modules application.

Un module est un composant que vous pouvez créez, tester et déboguer indépendamment. Les modules contiennent le code source et les ressources de vos applications générées.

Un projet Android Studio peut contenir plusieurs types de modules.

Modules de bibliothèque Android :Les modules de bibliothèque contiennent du code et les ressources réutilisable spécifique à android. Le système de construction Android génère un package AAR(Android Archive) pour les modules de bibliothèque.

Modules App Engine: Les modules App Engine contiennent du code et des ressource pour l’intégration d’App Engine

Modules de bibliothèque Java: Les modules de bibliothèque Java contiennent du code réutilisable. Le système de construction génère un package JAR(Java Archive) pour les modules de bibliothèque Java.

Fichier de configuration de construction(Build configuration files)

Pour créer des configurations de construction personnalisé, vous devez apporter des modifications à un ou plusieurs fichiers de configuration de construction ou a des fichiers build.gradle .

Ces fichiers de texte brute utilise le langage DSL(Domaine Spécifique Langauge) pour décrire et manipuler la logique de construction à l’aide de Groovy ( et à l’aide de Kotlin depuis la version 5.0 du gradle) .

Vous n’avez pas besoin de connaitre groovy pour commencer à configurer la logique de construction de votre application, car le plugin Android du gradle présente la plupart des éléments DSL dont vous avez besoin.Voir le lien suivant DSL reference documentation

DSL( Domain Specific Language )

Dans cette partie, nous allons aborder les DSL de manière bref. Vous pourriez alors vous sentir à l’aise dans la configuration de la logique de construction de votre application.

Un Domain Specifc Language(DSL) est un langage utilisé pour un domaine d’application spécifique (Vous utilisez par exemple les DSL dans Android studio pour configurer la logique de construction de votre application ) .

Contrairement aux langages plus généralistes tels que Java, Kotlin qui sont utilisés dans tout type de domaine d’application pour résoudre tous types de problème.

Il existe aussi d’autres DSL que vos connaissez probablement tel que le HTML pour écrire les pages web,le SQL pour interroger des bases de données, etc.

L’avantage d’utilisé les DSL pour configurer votre projet ou pour décrire la logique de construction de votre application est que vous n’écrivez que des déclarations au lieu d’écrire directement plusieurs ligne de code pour résoudre un problème.

Ce qui permet d’avoir un fichier de configuration courts,compréhensible, et facilement maintenable.

Voici un exemple de DSL écrit en Groovy qui initialise les paramètres d’envoie d’un email

EmailSender.init {
    from 'contact@androidtutos.com'
    to 'testegroovy@androiddev.com'
    subject 'Les dsl en groovy!'
    body 'Je suis un dsl'
}

Nous allons voir comment à été écrire ce simple DSL en Groovy. Vous pouvez aussi créer vos DSL en Kotlin.

Pour écrire un DSL en groovy, vous devez avoir des connaissances sur groovy et les closures en groovy.

Groovy vous permet d’omettre les parenthèse autour des arguments d’une méthode pour une expression de niveau supérieure.

def nb=2
print nb

A la ligne 2,j’ai omit les parenthèse de la méthode print.

Les closure

La définition d’une closure suit la syntaxe suivante

{ [closureParameters -> ] instruction}

ou [closureParameters -> ] est une liste facultative des paramètres délimités par des virgules et les instructions sont 0 ou plusieurs instructions groovy.

Lorsque la liste des paramètres est spécifiée, le caractère -> est requis et sert à séparer les arguments du corps de la closure.

{ item++ }                                          
//Ligne 1:Une closure faisant référence à une variable nommé item
{ -> item++ }                                       
/* Ligne 3:Il es possible de séparer explicitement les parametres du corps de la closure */
{ println it }                                      
/* Ligne 5: Une closure faisant référence à un parametre qui peut passé dans la closure lors de l'appelle de la closure */
                      
{ String x, int y ->                                
    println "hey ${x} the value is ${y}"
}
/* Ligne 8:  Une closure acceptant deux parametre typés */
{ reader ->                                         
    def line = reader.readLine()
    line.trim()
}
/* Ligne 13,14: Une closure peut contenir plusieurs instructions   */

En groovy une closure est une instance de la classe groovy.lang.Closure ce qui vous permet d’écrire l’expression suivante

Closure closure= { println 'Ma premiere closure' }

On peut donc créer une fonction qui prend en paramètre une closure et appelé la fonction comme dans l’exemple suivant

def read(Closure closure){
}

On peut appeler la fonction read en passant en paramètre à cette fonction, une closure comme dans l’exemple suivant

read({
println "Closure"
})
//Affichage: Closure

Puisque Groovy permet d’omettre les parametre d’une méthode.on peut aussi écrire

read{
println "Closure"
}
//Affichage: Closure

On appelle une closure par son son ou par sa méthode call. Voir l’examole suivant

def niveau={ print "Le niveau du joueur est 2"}

niveau()//Appelle de la closure par son nom ou
niveau.call() //Appelle de la closure par sa méthode call

Les closures possèdent un propriété essentiel à la création des DSL: la propriété delegate. Vous pouvez affecter une instance de classe à la propriété delegate de la closure.

Ainsi, si vous essayer d’exécuter une méthode à l’intérieur de la closure et qu’elle n’a pas été trouvée dans la closure, alors elle sera recherché dans les méthodes du délegué (L »instance de la classe déléguée).

Voir l’example suivant

Closure mclosure= {
    append("I'm inside a closure")
}
StringBuilder sb = new StringBuilder()
mclosure.delegate = sb
mclosure.call()

Dans l’exemple précédent, lors de l’exécution de la closure, la closure essaie d’exécuter la méthode append. Puisqu’elle ne la retrouve pas,elle recherche la méthode dans son délégué qui est l’instance de la classe StringBuilder.

Nous avons maintenant toutes les notions nécessaires pour écrire notre DSL d’initialisation des paramètres de l’envoi d’email. Voici notre DSL

EmailSender.init {
    from 'contact@androidtutos.com'
    to 'testegroovy@androiddev.com'
    subject 'Les dsl en groovy!'
    body 'Je suis un dsl'
}

Voici comment créer ce DSL en groovy

class EmailSender {  
   String from
   String to
   String subject
   String body 
   
   
   def static init(closure) { 
      EmailSender email = new EmailSender() 
      closure.delegate = email
      closure() 
   }
   
 
   def to(String to) { 
      this.toText = to 
   }
   
   def from(String from) { 
      this.fromText = from
   }
   def subject(String subject) { 
      this.subject= subject
   }
   def body(String body) { 
      this.body = body 
   } 
}

//Voici comment l'utiliser
EmailSender.init {
    from 'contact@androidtutos.com'
    to 'testegroovy@androiddev.com'
    subject 'Les dsl en groovy!'
    body 'Je suis un dsl'
}

A présent vous savez comment sont écris les DSL spécifique à Android qui configure la logique de construction de votre application. Vous pouvez maintenant facilement utiliser le fichier buid.gradle pour configurer la logique de construction de votre application.

Vous pouvez aussi consulter la référence des DSL Android sur ce lien et voir comment utiliser chaque bloc.

Le fichier de construction du projet

Ce fichier défini les configurations de construction qui s’applique à tous les modules de votre projet. Voici un exemple de ce fichier

buildscript {
    
    repositories {
        google()
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.3'
        

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        google()
        jcenter()
    }
}
ext {
   
    compileSdkVersion = 28
}
task clean(type: Delete) {
    delete rootProject.buildDir
}

buildscript: Ce bloc vous permet de configurer les dépôts, les dépendances du gradle et des plugins du gradle

repositories: Ce bloc configure les dépôts utilisés par le gradle pour rechercher et télécharger les dépendances de votre projet.
dependencies: ce bloc configure les dépendances que le gradle a besoin pour construire votre projet.
Allprojects: ce blog configure tous les dépôts et dépendances utilisé par tous les modules de votre projet

Si votre projet contient plusieurs modules, vous pouvez définir des propriétés dans le bloc ext dans le fichier gradle.build (Project).

Vous pouvez ensuite accéder à la propriété dans le fichier gradle.build de chaque module de votre projet comme dans l’exemple suivant avec la propriété rootProject.ext.property_name.

Voici comment utilisé cette propriété dans le fichier build.gradle(app) de votre projet

apply plugin: 'com.android.application'

android {
    compileSdkVersion rootProject.ext.compileSdkVersion
    defaultConfig {
        applicationId "premierprojet.com.premierprojet"
        minSdkVersion 16
        targetSdkVersion 27
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    
}

Le fichier de construction de module

Ce fichier permet de configurer les paramètres de construction d’un module spécifique.

Voici un exemple de fichier de construction du module

apply plugin: 'com.android.application'

android {
    compileSdkVersion 27
    defaultConfig {
        applicationId "premierprojet.com.premierprojet"
        minSdkVersion 16
        targetSdkVersion 27
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:27.1.1'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
}

Nous voici à la fin de ce tutoriel. J’espère que ce tutoriel vous permettra de facilement utiliser les fichiers de construction dans votre projet.

Merci à Florent Champigny du blog http://tutos-android-france.com/ pour la lecture de cet article et son retour.

Si vous avez aimé ce tutoriel, n’hésitez pas à écrire un commentaire.Je serai ravi de vous répondre.

Autres Ressources

https://developer.android.com/studio/build

https://developer.android.com/studio/build/dependencies

https://developer.android.com/studio/build/build-variants

https://groovy-lang.org/

Noé Joel VIGAN

Noe Joel Vigan, auteur de ce blog, est passionné par la programmation Android. Il a créé ce blog pour partager ses connaissances sur le développement d’application android. Il est Développeur Android Fullstack, ce qui lui permet de complètement mettre en place le Backend de ses applications sur Google Cloud à défaut d’utiliser FireBase.