Contenu

• Explorer les fichiers de construction de Gradle
• 1. paramètres.gradle
• 2. build.gradle (niveau du projet)
• 3. build.gradle (niveau du module)
• Déclarer les dépendances de votre projet: Bibliothèques locales
• Ajout d'une dépendance de construction: référentiels distants
• Connexion à un référentiel distant
• Déclarer une dépendance à distance
• Générer plusieurs fichiers APK: comment créer des variantes de construction
• Création d'une tâche Gradle personnalisée
• Construire votre projet avec le wrapper Gradle
• Quelles autres tâches Gradle sont disponibles?
• Obtenir plus de Gradle: Ajouter des plugins
• Le Gradle Kotlin DSL
• Emballer

Au lieu de Java, XML ou Kotlin, ces fichiers de construction Gradle utilisent le langage DSL (Domain-Specific Language) basé sur Groovy. Si vous ne connaissez pas bien Groovy, nous examinerons chacun de ces fichiers de construction Gradle ligne par ligne. Ainsi, à la fin de cet article, vous serez à l'aise avec la lecture et l'écriture de code Groovy simple.

Gradle vise à vous simplifier la vie en fournissant un ensemble de paramètres par défaut que vous pouvez souvent utiliser avec une configuration manuelle minimale. Lorsque vous êtes prêt à construire votre projet, il vous suffit d'appuyer sur le bouton «Exécuter» d'Android Studio pour que Gradle lance le processus de construction. pour toi.

Malgré l’approche «convention sur la configuration» de Gradle, si ses paramètres par défaut ne répondent pas tout à fait à vos besoins, vous pouvez personnaliser, configurer et étendre le processus de construction, et même ajuster les paramètres de Gradle pour effectuer des tâches très spécifiques.

Les scripts Gradle étant contenus dans leurs propres fichiers, vous pouvez modifier le processus de construction de votre application à tout moment, sans avoir à toucher au code source de votre application. Dans ce didacticiel, nous allons modifier le processus de construction à l’aide de saveurs, de variantes de construction et d’une tâche Gradle personnalisée - le tout sans modification préalable. déjà touchant notre code d'application.

Explorer les fichiers de construction de Gradle

Chaque fois que vous créez un projet, Android Studio génère la même collection de fichiers de construction Gradle. Même si vous importez un projet existant dans Android Studio, il sera encore créez ces mêmes fichiers Gradle et ajoutez-les à votre projet.

Pour commencer à mieux comprendre Gradle et la syntaxe Groovy, examinons ligne par ligne chacun des fichiers de construction Gradle d’Android.

1. paramètres.gradle

Le fichier settings.gradle vous permet de définir tous les modules de votre application par leur nom, à l’aide du mot-clé «include». Par exemple, si vous avez un projet composé d'une "application" et d'un "secondModule", votre fichier settings.gradle ressemblera à ceci:

include: app,: secondmodule rootProject.name = MyProject

Selon la taille de votre projet, ce fichier peut être considérablement plus long.

Au cours du processus de construction, Gradle examinera le contenu du fichier settings.gradle de votre projet et identifiera tous les modules qu’il doit inclure dans le processus de construction.

2. build.gradle (niveau du projet)

Le fichier build.gradle au niveau du projet se trouve dans le répertoire racine de votre projet et contient les paramètres qui seront appliqués à tout vos modules (également appelés «projets» par Gradle).

Vous devez utiliser ce fichier pour définir les plug-ins, les référentiels, les dépendances et les options de configuration qui s'appliquent à chaque module de votre projet Android. Notez que si vous définissez des tâches Gradle dans le fichier build.gradle au niveau du projet, il est toujours possible de remplacer ou d’étendre ces tâches pour des modules individuels, en modifiant leurs tâches correspondantes. niveau module fichier build.gradle.

Un fichier build.gradle typique au niveau du projet ressemblera à ceci:

buildscript {repositories {google () jcenter ()} dépendances {classpath com.android.tools.build:gradle:3.5.0-alpha06 // NOTE: ne placez pas les dépendances de votre application ici; ils appartiennent // dans le module individuel fichiers build.gradle}} allprojects {référentiels {google () jcenter ()}} tâche propre (type: Supprimer) {delete rootProject.buildDir}

Ce fichier build.gradle au niveau du projet est divisé en blocs suivants:

• Buildscript. Cela contient les paramètres requis pour effectuer la construction.
• Dépôts. Gradle est chargé de localiser les dépendances de votre projet et de les rendre disponibles dans votre construction. Cependant, toutes les dépendances ne proviennent pas du même référentiel. Vous devez donc définir tous les référentiels que Gradle doit rechercher pour pouvoir récupérer les dépendances de votre projet.
• Les dépendances. Cette section contient les dépendances de votre plugin, qui sont téléchargées et stockées dans votre cache local. Vous devriez ne pas Définissez les dépendances de module dans ce bloc.
• Tous les projets. C’est là que vous définissez les référentiels devant être disponibles pour tout des modules de votre projet.

3. build.gradle (niveau du module)

Il s'agit du fichier build.gradle au niveau du module, présent dans chaque module de votre projet. Si votre projet Android comprend plusieurs modules, il comprendra également plusieurs fichiers build.gradle au niveau du module.

Chaque fichier build.gradle au niveau du module contient le nom du package, le nom de version et le code de version de votre projet, ainsi que le SDK minimum et cible pour ce module particulier.

Un fichier build.gradle au niveau du module peut également avoir son propre ensemble unique d'instructions de construction et de dépendances. Par exemple, si vous créez une application avec un composant Wear OS, votre projet Android Studio sera composé d'un module smartphone / tablette séparé et d'un module Wear. En effet, étant donné qu'ils ciblent des périphériques totalement différents, ces modules ont des caractéristiques radicalement différentes. dépendances!

Un fichier de base build.gradle au niveau module ressemblera généralement à ceci:

apply plugin: com.android.application android {compileSdkVersion 28 defaultConfig {applicationId "com.jessicathornsby.speechtotext" minSdkVersion 23 targetSdkVersion 28 versionCode 1 versionName "1.0" testInstrumentationRunner "etroid.test.test.runner getDefaultProguardFile (proguard-android-optim.txt), proguard-rules.pro}}} dépendances {implementation fileTree (dir: libs, include:) implémentation androidx.appcompat: appcompat: implémentation 1.0.2 androidx.constraintlayout: constraintlayout: 1.1. 3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: junit: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1}

Examinons de plus près chacune de ces sections:

• appliquer le plugin. Ceci est une liste des plugins nécessaires pour construire ce module. Le plug-in com.android.application est nécessaire pour configurer le processus de construction spécifique à Android. Il est donc ajouté automatiquement.
• Android. C’est là que vous devez placer toutes les options spécifiques à la plate-forme du module.
• compileSdkVersion. C'est le niveau de l'API avec lequel ce module est compilé. Vous ne pouvez pas utiliser les fonctionnalités d'une API supérieure à cette valeur.
• buildToolsVersion. Cela indique la version du compilateur. Dans Gradle 3.0.0 et supérieur, buildToolsVersion est facultatif; Si vous ne spécifiez pas de valeur buildToolsVersion, Android Studio utilisera par défaut la version la plus récente de Build Tools.
• defaultConfig. Cela contient des options qui seront appliquées à toutes les versions de votre application, telles que vos versions de débogage et de publication.
• ID d'application. C'est l'identifiant unique de votre application.
• minSdkVersion. Ce paramètre définit le niveau d'API le plus bas pris en charge par ce module.
• targetSdkVersion. Il s'agit du niveau maximal de l'API pour lequel votre application a été testée. Idéalement, vous devez tester votre application à l'aide de la dernière API, ce qui signifie que la valeur targetSdkVersion sera toujours égale à la valeur compileSdkVersion.
• versionCode. Ceci est une valeur numérique pour la version de votre application.
• versionName. Il s'agit d'une chaîne conviviale, qui représente la version de votre application.
• buildTypes. Par défaut, Android prend en charge deux types de construction: debug et release. Vous pouvez utiliser les blocs «debug» et «release» pour spécifier les paramètres spécifiques au type de votre application.
• dépendances. C’est là que vous définissez les bibliothèques dont dépend ce module.

Déclarer les dépendances de votre projet: Bibliothèques locales

Vous pouvez rendre des fonctionnalités supplémentaires disponibles pour vos projets Android, en ajoutant une ou plusieurs dépendances du projet. Ces dépendances peuvent être locales ou stockées dans un référentiel distant.

Pour déclarer une dépendance sur un fichier JAR local, vous devez ajouter ce fichier JAR au répertoire "libs" de votre projet.

Vous pouvez ensuite modifier le fichier build.gradle au niveau du module pour déclarer une dépendance à ce fichier. Par exemple, nous déclarons ici une dépendance à un fichier JAR «mylibrary».

fichiers d'implémentation (libs / mylibrary.jar)

Si votre dossier «libs» contient plusieurs fichiers JAR, il peut être plus simple d'indiquer simplement que votre projet dépend de tous les fichiers situés dans le dossier «libs», par exemple:

implémentation fileTree (dir: libs, include:)

Ajout d'une dépendance de construction: référentiels distants

Si une bibliothèque est située dans un référentiel distant, vous devrez procéder comme suit:

• Définissez le référentiel où se trouve cette dépendance.
• Déclarez la dépendance individuelle.

Connexion à un référentiel distant

La première étape consiste à indiquer à Gradle le ou les référentiels qu’il doit vérifier afin de récupérer toutes les dépendances de votre projet. Par exemple:

référentiels {google () jcenter ()}}

Ici, la ligne «jcenter ()» garantit que Gradle vérifiera le référentiel JCenter, qui est un référentiel public gratuit hébergé sur bintray.

Si vous ou votre organisation maintenez un référentiel personnel, vous devez également ajouter l’URL de ce référentiel à votre déclaration de dépendance. Si le référentiel est protégé par un mot de passe, vous devez également fournir vos informations de connexion, par exemple:

référentiels {mavenCentral () maven {// Configurez l'URL cible // // url "http://repo.mycompany.com/myprivaterepo"} maven {informations d'identification {nom d'utilisateur myUsername mot de passe myPassword} url "http://repo.mycompany.com / myprivaterepo "}

Si une dépendance est présente dans plusieurs référentiels, Gradle sélectionne alors la «meilleure» version de cette dépendance, en fonction de facteurs tels que l'âge de chaque référentiel et la version statique.

Déclarer une dépendance à distance

L'étape suivante consiste à déclarer la dépendance dans votre fichier build.gradle au niveau du module. Vous ajoutez ces informations au bloc «dépendances», en utilisant l’un des éléments suivants:

• La mise en oeuvre. C'est une dépendance normale dont vous avez besoin chaque fois que vous construisez votre projet. Une dépendance «mise en œuvre» sera présente à travers tout vos constructions.
• Testimplementation. Il s’agit d’une dépendance nécessaire pour compiler la source de test de votre application et exécuter des tests basés sur JVM. Lorsque vous marquez une dépendance comme «Testimplementation», Gradle saura qu'il n'est pas nécessaire d'exécuter de tâches pour cette dépendance lors d'une construction normale, ce qui peut aider à réduire le temps de génération.
• Androidtestimplementation. Il s’agit d’une dépendance nécessaire lors de l'exécution de tests sur un périphérique. Par exemple, le framework Espresso est un «test d'implémentation Android» commun.

Nous définissons une dépendance à distance en utilisant l’un des mots-clés ci-dessus, suivi des attributs groupe, nom et version de la dépendance, par exemple:

dependencies {implementation fileTree (dir: libs, include:) implémentation androidx.appcompat: appcompat: 1.0.2 implémentation androidx.constraintlayout: constraintlayout: 1.1.3 testImplementation junit: junit: 4.12 androidTestImplementation androidx.test.ext: 1.1.0 androidTestImplementation androidx.test.espresso: espresso-core: 3.1.1}

Générer plusieurs fichiers APK: comment créer des variantes de construction

Parfois, vous devrez peut-être créer plusieurs versions de votre application. Par exemple, vous souhaiterez peut-être publier une version gratuite et une version payante, qui comprend des fonctionnalités supplémentaires.

C'est une tâche de construction que Gradle peut vous aider. Voyons comment modifier le processus de construction pour créer plusieurs fichiers APK à partir d'un même projet:

• Ouvrez votre fichier strings.xml et supprimez la chaîne du nom de votre application d'origine.
• Ensuite, définissez les noms de chaque saveur de produit que vous souhaitez créer. dans ce cas, j'utilise:

Mon application gratuite Mon application payante

• Ouvrez votre fichier AndroidManifest.xml et remplacez android: label = "@ string / app_name" par:

android: label = "$ {appName}"

• Ouvrez votre fichier build.gradle au niveau du module et ajoutez les éléments suivants au bloc «Android»:

saveurDimensions "mode" productFlavors {libre {dimension "mode" applicationIdSuffix ".free" manifestPlaceholders =} payé {dimension "mode" applicationIdSuffix ".payé" manifestPlaceholders =}}}

Décrivons ce qui se passe ici:

• saveurDimensions. Le plugin Android crée des variantes de construction en combinant des saveurs de différentes dimensions. Nous créons ici une dimension de saveur composée de versions «gratuites» et «payantes» de notre application. En se basant sur le code ci-dessus, Gradle générera quatre variantes de construction: paidDebug, paidRelease, freeDebug et freeRelease.
• productFlavors. Ceci spécifie une liste de saveurs et leurs réglages, qui dans le code ci-dessus sont «payés» et «gratuits».
• Gratuit / payant. Ce sont les noms de nos deux saveurs de produits.
• Dimension. Nous devons spécifier une valeur de paramètre «dimension»; dans ce cas, j’utilise le «mode».
• applicationIdSuffix. Puisque nous voulons créer plusieurs versions de notre application, nous devons attribuer à chaque APK un identifiant d'application unique.
• manifestPlaceholders. Chaque projet contient un fichier manifeste unique contenant des informations importantes sur la configuration de votre projet. Lors de la création de plusieurs variantes de construction, vous souhaiterez généralement modifier certaines de ces propriétés Manifest au moment de la construction. Vous pouvez utiliser les fichiers de génération Gradle pour spécifier des entrées de manifeste uniques pour chaque variante de construction, qui seront ensuite insérées dans votre manifeste au moment de la génération. Dans le code ci-dessus, nous modifions la valeur «appName» selon que Gradle est en train de créer la version gratuite ou payante de notre application.

Création d'une tâche Gradle personnalisée

Parfois, vous devrez peut-être personnaliser le processus de construction à l’aide de Gradle. les tâches.

Une tâche est un ensemble nommé d'actions que Gradle exécutera lors de la construction, par exemple en générant un Javadoc. Gradle prend en charge de nombreuses tâches par défaut, mais vous pouvez également créer des tâches personnalisées, ce qui peut s'avérer utile si vous avez un ensemble très spécifique d'instructions de construction en tête.

Dans cette section, nous allons créer une tâche Gradle personnalisée qui effectuera une itération de toutes les variantes de construction de notre projet (payéDebug, payéRelease, freeDebug et freeRelease), créera un tampon de date et d’heure, puis ajoutera ces informations à chaque fichier APK généré.

Ouvrez votre fichier build.gradle au niveau du module et ajoutez les éléments suivants:

tâche addDateAndTime () {// Itérer dans toutes les variantes de construction en sortie // android.applicationVariants.all {variant -> // Itérer dans tous les fichiers APK // variant.outputs.all {output -> // Créer une instance de date et heure actuelles, au format spécifié // def dateAndTime = new Date () format ("aaaa-MM-jj: HH-mm") // Ajoute cette information au nom de fichier de l'APK // def fileName = variant. name + "_" + dateAndTime + ".apk" output.outputFileName = nom_fichier}}}

Ensuite, nous devons dire à Gradle quand il devrait exécuter cette tâche. Lors d'une construction, Gradle identifie tout ce dont il a besoin pour télécharger et toutes les tâches qu'il doit exécuter, et les organise dans un graphe acyclique dirigé (DAG). Gradle exécutera alors toutes ces tâches, selon l'ordre défini dans son DAG.

Pour mon application, je vais utiliser la méthode «whenReady», qui garantit que notre tâche sera appelée une fois le DAG rempli et que Gradle est prêt à commencer à exécuter ses tâches.

Ajoutez les éléments suivants à votre fichier build.gradle au niveau du module:

// Exécuter cette tâche // gradle.taskGraph.whenReady {addDateAndTime}

Mettons notre tâche personnalisée et notre code de variante de construction à l’essai, en construisant ce projet à l’aide d’une commande Gradle.

Construire votre projet avec le wrapper Gradle

Vous émettez des commandes Gradle à l'aide de l'encapsuleur Gradle («gradlew»). Ce script est le moyen privilégié pour démarrer une construction Gradle, car il rend son exécution indépendante de votre version de Gradle. Cette séparation peut être utile si vous collaborez avec d’autres utilisateurs ne disposant pas nécessairement de la même version de Gradle.

Lors de l'exécution de vos commandes d'emballage Gradle, vous utiliserez «gradlew» pour les systèmes d'exploitation de type Unix, y compris macOS, et «gradlew.bat» pour Windows. J'ai un Mac, donc j'utiliserai les commandes «gradlew».

Vous pouvez émettre des commandes Gradle depuis Android Studio:

• Dans la barre d’outils Android Studio, sélectionnez «Affichage> Outils Windows> Terminal». Ceci ouvre un panneau de terminal dans la partie inférieure de la fenêtre de l’EDI.
• Entrez la commande suivante dans le terminal:

./gradlew build

Android Studio devrait ressembler à quelque chose comme ça:

• Appuyez sur la touche "Entrée" de votre clavier. Gradle va maintenant construire votre projet.

Gradle stocke tous les fichiers APK générés dans le répertoire app / build / output / apk de votre projet. Vous devez donc naviguer dans ce répertoire. Le dossier «APK» doit contenir plusieurs dossiers et sous-dossiers. Assurez-vous que Gradle a généré un APK pour chacune de vos variantes de construction et que les informations de date et heure correctes ont été ajoutées à chaque fichier.

Quelles autres tâches Gradle sont disponibles?

En plus des tâches personnalisées que vous pourriez créer, Gradle prend en charge une liste de tâches prédéfinies prêtes à l'emploi. Si vous êtes curieux de voir exactement quelles tâches sont disponibles, alors:

• Ouvrez la fenêtre Terminal d’Android Studio, si elle n’est pas déjà ouverte (en sélectionnant «Affichage> Outils Windows> Terminal» dans la barre d’outils Android Studio).
• Tapez ce qui suit dans le terminal:

./gradlew -q tâches

• Appuyez sur la touche "Entrée" de votre clavier.

Cette tâche «tâches» va maintenant être exécutée et, au bout de quelques instants, le terminal affichera une liste de toutes les tâches disponibles pour ce projet, avec une brève description de chaque tâche.

Obtenir plus de Gradle: Ajouter des plugins

Gradle est livré avec un certain nombre de plugins pré-installés, mais vous pouvez étendre Gradle en ajoutant de nouveaux plugins. Ces plugins rendent de nouvelles tâches disponibles pour vos projets Android. Par exemple, le plugin Java comprend des tâches qui vous permettent de compiler le code source Java, d'exécuter des tests unitaires et de créer un fichier JAR, tel que «compileJava», «compileText», «jar». «Javadoc» et «propre».

Pour appliquer un plugin, ajoutez la déclaration «apply plugin» à votre fichier build.gradle au niveau du module, suivi du nom du plugin. Par exemple, nous appliquons ici le plugin Java:

appliquer le plugin: java

Si vous êtes curieux de savoir quels plugins sont disponibles, consultez la recherche Gradle Plugin, qui fournit un registre complet des plugins Gradle.

Le Gradle Kotlin DSL

Par défaut, vous écrivez vos scripts de génération Gradle à l’aide de Groovy DSL, mais si vous êtes l’un des nombreux développeurs qui ont adopté Kotlin pour le développement Android, vous préférerez peut-être écrire vos scripts de génération dans Kotlin.

Contrairement à Groovy, Kotlin est un langage de programmation typé de manière statique. Ainsi, si vous faites le changement, vos fichiers de construction seront compatibles avec les fonctionnalités de complétion automatique et de navigation du code source d’Android Studio. De plus, passer de Groovy à Kotlin signifie que vous utiliserez le même langage de programmation dans votre projet, ce qui simplifiera le développement, en particulier si vous n’êtes pas trop familiarisé avec Groovy!

Si vous souhaitez commencer à écrire votre logique de construction dans Kotlin, vous devez configurer le Gradle Kotlin DSL et suivre les instructions du guide de migration.

Emballer

Dans cet article, nous avons exploré l’automatisation de la construction et l’outil de gestion des dépendances d’Android Studio. Nous avons examiné comment Gradle automatisait le processus de construction tel quel, et comment vous pouvez le modifier en modifiant les fichiers de construction Gradle de votre projet, notamment en créant des tâches Gradle personnalisées et en générant plusieurs variantes de construction à partir d'un même projet.

Avez-vous étendu Gradle à l'automatisation d'autres parties du processus de construction d'Android? Faites-nous savoir dans les commentaires ci-dessous!