Créer votre application Android à partir de la ligne de commande

Vous pouvez exécuter toutes les tâches de création disponibles pour votre projet Android à l’aide de l’outil de ligne de commande de Gradle wrapper.

Disponible sous forme de fichier de commandes pour Windows (gradlew.bat) et de script shell pour Linux et Mac (gradlew.sh), il est accessible à la racine de chaque projet créé avec Android Studio.

Pour exécuter une tâche avec le wrapper, utilisez l’une des commandes suivantes à partir d’une fenêtre de terminal (à partir d’Android Studio, sélectionnez Affichage> Fenêtres d’outils> Terminal) :

Sous Windows :

gradlew task-name

Sur Mac ou Linux :

./gradlew task-name

Pour voir une liste de toutes les tâches de création disponibles pour votre projet, exécutez tasks :

gradlew tasks

Le reste de cette page décrit les bases pour créer et exécuter votre application avec le Gradle wrapper.

A propos des types de créations

Par défaut, il existe deux types de créations disponibles pour chaque application Android : un pour le débogage de votre application, la version de débogage, et un autre pour la publication de votre application aux utilisateurs, la version finale. La sortie résultant de chaque build doit être signée avec un certificat avant de pouvoir déployer votre application sur un périphérique. La version de débogage est automatiquement signée avec une clé de débogage fournie par les outils du SDK (elle n’est pas sécurisée et vous ne pouvez pas publier sur Google Play Store), et la version build doit être signée avec votre propre clé privée.

Si vous souhaitez créer votre application pour publication, il est important de savoir signer votre application. Il y a une procédure à suivre pour générer une clé privée, puis l’utiliser pour signer votre application. Si vous ne faites que commencer, vous pouvez rapidement exécuter vos applications sur un émulateur ou un appareil connecté en créant un fichier APK de débogage.

Vous pouvez également définir un type de build personnalisé dans votre fichier build.gradle et le configurer pour qu’il soit signé en tant que build de débogage en incluant debuggable true.

Créer et déployer un APK

Bien que la création d’un ensemble d’applications constitue le meilleur moyen de regrouper votre application et de la télécharger sur Play Console, la création d’un fichier APK convient mieux lorsque vous souhaitez tester rapidement une version de débogage ou partager votre application sous la forme d’un artefact déployable.

Créer un APK de débogage

Pour tester et déboguer les applications immédiatement, vous pouvez créer un APK de débogage. L’API de débogage est signé avec une clé de débogage fournie par les outils du SDK et permet le débogage via adb.

Pour créer un APK de débogage, ouvrez une ligne de commande et accédez à la racine du répertoire de votre projet. Pour lancer une création de débogage, appelez la tâche assembleDebug :

gradlew assembleDebug

Cela crée un fichier APK nommé module_name-debug.apk dans project_name/module_name/build/outputs/apk/. Le fichier est déjà signé avec la clé de débogage et aligné sur zipalign. Vous pouvez donc l’installer immédiatement sur un périphérique.

Ou pour créer l’APK et l’installer immédiatement sur un émulateur en cours d’exécution ou un périphérique connecté, appelez plutôt installDebug :

gradlew installDebug

La partie « Debug » dans les noms de tâches ci-dessus est simplement une version camelCase (casse-chameau) du nom de la variante de build. Vous pouvez donc la remplacer par le type de build ou la variante à assembler ou à installer. Par exemple, si vous avez une version de produit « démo », vous pouvez créer la version de débogage avec la tâche assembleDemoDebug.

Pour afficher toutes les tâches de création et d’installation disponibles pour chaque variante (y compris les tâches de désinstallation), exécutez la tâche tasks.

Consultez également la section sur Exécuter votre application sur l’émulateur et Exécuter votre application sur votre appareil.

Créer une version finale APK

Lorsque vous êtes prêt à publier et à distribuer votre application, vous devez créer une version APK signé avec votre clé privée.

Déployez votre application sur l’émulateur

Pour utiliser Android Emulator, vous devez créer un périphérique virtuel Android (AVD) à l’aide d’Android Studio.

Une fois que vous avez un fichier AVD, démarrez l’émulateur Android et installez votre application comme suit :

1. Dans une ligne de commande, accédez à android_sdk/tools/ et démarrez l’émulateur en spécifiant votre AVD :

emulator -avd avd_name

Si vous n’êtes pas sûr du nom AVD, exécutez emulator -list-avds.

2. Vous pouvez maintenant installer votre application en utilisant l’une des tâches d’installation de Gradle mentionnées dans la section sur Créer un APK de débogage ou l’outil adb.

Si l’APK est créé à l’aide d’un SDK d’aperçu pour développeur (si targetSdkVersion est une lettre au lieu d’un nombre), vous devez inclure -t option avec la commande install pour installer un APK de test.

adb install path/to/your_appapk

Tous les fichiers APK que vous construisez sont enregistrés dans project_name/module_name/build/outputs/apk/.

Déployez votre application sur un périphérique physique

Avant de pouvoir exécuter votre application sur un appareil, vous devez activer le débogage USB sur votre appareil. Vous pouvez trouver l’option sous Paramètres> Options pour développeur.

Remarque : sur Android 4.2 et les versions plus récentes, les options pour développeur sont masquées par défaut. Pour le rendre disponible, allez à Paramètres> À propos du téléphone et appuyez sept fois sur Numéro de build. Retournez à l’écran précédent pour trouver les options pour développeur.

Une fois votre appareil configuré et connecté via USB, vous pouvez installer votre application à l’aide des tâches d’installation de Gradle mentionnées dans la section Créer un APK de débogage ou de l’outil adb :

adb -d install path/to/your_appapk

Tous les fichiers APK que vous construisez sont enregistrés dans project_name/module_name/build/outputs/apk/.

Créer un bundle d’application

Les Bundles d’applications Android (Android App Bundle) incluent tout le code et toutes les ressources compilés de votre application, mais diffèrent la génération d’APK et la signature sur Google Play. Contrairement à un APK, vous ne pouvez pas déployer un bundle d’applications directement sur un appareil. Donc, si vous voulez tester rapidement ou partager un APK avec quelqu’un d’autre, vous devriez plutôt créer un APK.

Le moyen le plus simple de créer un bundle d’applications consiste à utiliser Android Studio. Toutefois, si vous devez créer un bundle d’applications à partir de la ligne de commande, vous pouvez le faire en utilisant Gradle ou bundletool, comme décrit dans les sections ci-dessous.

Créer un bundle d’applications avec Gradle

Si vous préférez générer un bundle d’applications à partir de la ligne de commande, exécutez la tâche bundleVariant Gradle sur le module de base de votre application. Par exemple, la commande suivante crée un bundle d’applications pour la version de débogage du module de base :

./gradlew :base:bundleDebug

Si vous souhaitez créer un bundle signé à télécharger sur la Play Console, vous devez d’abord configurer le fichier build.gradle du module de base avec les informations de signature de votre application. Vous pouvez ensuite, par exemple, créer la version finale de votre application et Gradle génère automatiquement un bundle d’applications et le signe avec les informations de signature fournies dans le fichier build.gradle.

Si vous souhaitez plutôt signer un bundle d’applications séparément, vous pouvez utiliser jarsigner pour signer votre bundle d’applications à partir de la ligne de commande.

Remarque : vous ne pouvez pas utiliser apksigner pour signer votre bundle d’applications.

Créer un bundle d’applications à l’aide de bundletool

Bundletool est un outil de ligne de commande utilisé par Android Studio, le plugin Android Gradle et Google Play utilise pour convertir le code et les ressources compilés de votre application en bundles d’applications et générer des fichiers APK déployables à partir de ces bundles.

Ainsi, bien qu’il soit utile de tester les bundles d’applications avec bundletool et de recréer localement la manière dont Google Play génère les fichiers APK, vous n’avez généralement pas besoin d’appeler bundletoolpour créer lui-même le bundle d’applications. Vous devez plutôt utiliser les tâches Android Studio ou Gradle, comme décrit dans la section précédente.

Toutefois, si vous ne souhaitez pas utiliser les tâches Android Studio ou Gradle pour créer des bundles (par exemple, si vous utilisez une chaîne d’outils de création personnalisée), vous pouvez utiliser bundletool à partir de la ligne de commande pour créer un bundle d’applications à partir de code et de ressources précompilés. Si vous ne l’avez pas déjà fait, téléchargez bundletool à partir du référentiel GitHub.

Cette section explique comment conditionner le code et les ressources compilés de votre application et comment utiliser à partir de la ligne de commande pour les convertir en un bundle d’applications Android.

Générez le manifeste et les ressources au format proto

bundletool exige que certaines informations sur votre projet d’application, telles que le manifeste et les ressources de l’application, soient au format Protocol Buffer de Google, également appelé « protobuf » et utilise l’extension de fichier *.pb. Les protobufs fournissent un langage neutre, une plate-forme neutre et un mécanisme extensible pour la sérialisation des données structurées. Il est similaire à XML, mais plus petit, plus rapide et plus simple.

Télécharger AAPT2

Vous pouvez générer le fichier manifeste et la table de ressources de votre application au format protobuf à l’aide de la dernière version de AAPT2 à partir du référentiel Google Maven.

Attention : N’utilisez pas la version d’AAPT2 incluse dans le package d’outils de build Android, cette version d’AAPT2 ne prend pas en charge bundletool.

Pour télécharger AAPT2 à partir du référentiel Maven de Google, procédez comme suit :

1. Accédez à android.tools.build > aapt2 dans l’index du référentiel.
2. Copiez le nom de la dernière version de AAPT2.
3. Insérez le nom de version que vous avez copié dans l’URL suivante et spécifiez votre système d’exploitation cible : https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/aapt2-version/aapt2-aapt2-version–[windows | linux | osx].jar

Par exemple, pour télécharger la version 3.2.0-alpha18-4804415 pour Windows, vous devez utiliser : https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.0-alpha18-4804415–windows.jar

4. Accédez à l’URL dans un navigateur. Le téléchargement de AAPT2 devrait commencer sous peu.
5. Décompressez le fichier JAR que vous venez de télécharger.

Compiler et lier les ressources de votre application

Utilisez AAPT2 pour compiler les ressources de votre application à l’aide de la commande suivante :

aapt2 compile \
project_root/module_root/src/main/res/drawable/Image1.png \
project_root/module_root/src/main/res/drawable/Image2.png \
-o compiled_resources/

Remarque : Bien que vous puissiez transmettre les répertoires de ressources à AAPT2 à l’aide de l’indicateur –dir, cela recompile tous les fichiers du répertoire, quel que soit le nombre de fichiers réellement modifiés.

Au cours de la phase de liaison, où AAPT2 relie vos différentes ressources compilées à un seul APK, indiquez à AAPT2 de convertir le manifeste et les ressources compilées de votre application au format protobuf en incluant le drapeau –proto-format, comme indiqué ci-dessous :

aapt2 link --proto-format -o output.apk \
-I android_sdk/platforms/android_version/android.jar \
--manifest project_root/module_root/src/main/AndroidManifest.xml \
-R compiled_resources/*.flat \
--auto-add-overlay

Remarque : lorsque vous spécifiez des ressources compilées avec le drapeau -R, vous pouvez également spécifier un fichier texte incluant le chemin absolu de chacune de vos ressources compilées, chaque chemin étant séparé par un seul espace. Vous pouvez ensuite transmettre ce fichier texte à AAPT2 comme suit aapt2 link … -R @compiled_resources.txt.

Vous pouvez ensuite extraire le contenu depuis le fichier APK de sortie, tel que le fichier AndroidManifest.xml, resources.pb et d’autres fichiers de ressources de votre application, désormais au format protobuf. Vous avez besoin de ces fichiers lors de la préparation du bundletool d’entrée qui est nécessaire à la création de votre bundle d’applications, comme décrit dans la section suivante.

Package de code et de ressources pré-compilés

Avant d’utiliser bundletool pour générer un bundle d’applications pour votre application, vous devez d’abord fournir des fichiers ZIP contenant chacun le code et les ressources compilés pour un module d’application donné. Le contenu et l’organisation du fichier ZIP de chaque module est très similaire à celui du format Android App Bundle. Par exemple, vous devez créer un fichier base.zip pour le module de base de votre application et organiser son contenu comme suit :

Une fois que vous avez préparé le fichier ZIP pour chaque module de votre application, vous pouvez le transmettre à bundletool pour créer votre bundle d’applications, comme décrit dans la section suivante.

Créer votre bundle d’applications en utilisant bundletool

Pour créer votre bundle d’applications, vous utilisez la commande bundletool build-bundle, comme indiqué ci-dessous :

bundletool build-bundle --modules=base.zip --output=mybundle.aab

Remarque : Si vous prévoyez de publier le bundle d’applications, vous devez le signer à l’aide de jarsigner. Vous ne pouvez pas utiliser apksigner pour signer votre bundle d’applications.

Le tableau suivant décrit les indicateurs de la commande build-bundle de manière plus détaillée :

Personnaliser la génération APK en aval

Les bundles d’applications comprennent un fichier BundleConfig.pb qui fournit les métadonnées que les magasins d’applications, tels que Google Play, ont besoin pour générer des fichiers APK à partir du bundle. Bien que bundletool crée ce fichier pour vous, vous pouvez configurer certains aspects des métadonnées dans un fichier BundleConfig.json et les transmettre à la commande bundletool build-bundle. bundletool convertit et fusionne ensuite ce fichier avec la version de protobuf incluse dans chaque bundle d’applications.

Remarque : pour en savoir plus sur la façon dont le protocole JSON est mappé sur le format protobuf, lisez le mappage JSON. Cependant, ces informations sont plus avancées que celles requises pour cette page.

Par exemple, vous pouvez définir les catégories des configurations APK à activer ou à désactiver. L’exemple suivant d’un fichier BundleConfig.json désactive les configurations APK qui ciblent un langage différent (c’est-à-dire que les ressources de tous les langages sont incluses dans leurs APK de base ou de fonctionnalité dynamique respectifs) :

{"optimizations": {
    "splitsConfig": {
      "splitDimension": [{
        "value": "LANGUAGE",
        "negate": true
      }]
    }}
}

Vous pouvez également utiliser BundleConfig.json pour définir les types de fichiers à laisser non compressés lors de la compression des fichiers APK. Par défaut, tous les fichiers sauf les suivants sont compressés :

• La table de ressources de votre application (resources.arsc).
• Les fichiers avec les extensions suivantes : 3g2, 3gp, 3gpp, 3gpp2, aac, amr, awb, gif, imy, jet, jpeg, jpg, m4a, m4v, mid, midi, mkv, mp2, mp3, mp4, mpeg, mpg, ogg, png, rtttl, smf, wav, webm, wma, wmv, et xmf.
• Sur Android 6.0 (API niveau 23) et version ultérieure : les bibliothèques natives pour les applications qui spécifient extractNativeLibraries=false dans leur manifeste.

Si vous souhaitez que d’autres fichiers restent non compressés, spécifiez-les dans votre fichier BundleConfig.json personnalisé à l’aide de modèles globaux, comme suit :

{"compression": {
    "uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]}
}

Pour une description complète de ce que vous pouvez configurer dans votre fichier BundleConfig.json, consultez le fichier bundletool config.proto, écrit à partir de la syntaxe Proto3.

Déployer votre application à partir d’un bundle d’applications

Si vous avez créé et signé un bundle d’applications, utilisez bundletool pour générer des fichiers APK et les déployer sur un appareil.

L’article Créer votre application Android à partir de la ligne de commande est apparu en premier sur Webmaster Blog.