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

Vous pouvez exécuter toutes les tâches de compilation disponibles pour votre projet Android à l'aide de l'outil de ligne de commande Gradle wrapper. Cet outil est disponible sous la forme d'un fichier par lot pour Windows (gradlew.bat) et d'un script shell pour Linux et Mac (gradlew.sh). Il est accessible à la racine de chaque projet que vous créez avec Android Studio.

Pour exécuter une tâche avec le wrapper, utilisez l'une des commandes suivantes depuis une fenêtre de terminal (depuis Android Studio, sélectionnez View > Tool Windows > Terminal (Affichage > Fenêtre de l'outil > Terminal) :

• Sous Windows:

  gradlew task-name

• Sous Mac ou Linux:

  ./gradlew task-name

Pour afficher la liste de toutes les tâches de compilation disponibles pour votre projet, exécutez tasks :

gradlew tasks

La suite de cet article page décrit les principes de base permettant de créer et d'exécuter votre application avec le wrapper Gradle. Pour en savoir plus sur la configuration de votre build Android, consultez Configurer votre build.

Si vous préférez utiliser les outils Android Studio au lieu des outils de ligne de commande, consultez Créer et exécuter votre application.

À propos des types de compilation

Par défaut, il existe deux types de compilation pour chaque application Android : un pour le débogage de votre application (le build debug) et un autre pour le déploiement de votre application auprès des utilisateurs (le build release). Le résultat de chaque compilation doit être signé avec un certificat pour que vous puissiez déployer votre application sur un appareil. La version de débogage est automatiquement signée avec une clé de débogage fournie par les outils SDK (elle n'est pas sécurisée et vous ne pouvez pas la publier sur le Google Play Store). Elle doit être signée avec votre propre clé privée.

Si vous souhaitez créer votre application en vue de sa publication, il est important de signer votre application avec la clé de signature appropriée. Toutefois, si vous débutez, vous pouvez rapidement exécuter vos applications sur un émulateur ou un appareil connecté en créant un APK de débogage.

Vous pouvez également définir un type de compilation personnalisé dans votre fichier build.gradle.kts et le configurer pour qu'il soit signé en tant que version de débogage en incluant debuggable true. Pour en savoir plus, consultez Configurer des variantes de compilation.

Créer et déployer un APK

Bien que la création d'un app bundle constitue le meilleur moyen de créer le package de votre application et de l'importer dans la Play Console, il est préférable de créer un APK si vous souhaitez tester rapidement une version de débogage ou partager votre application comme artefact déployable avec d'autres utilisateurs.

Créer un APK de débogage

Pour tester et déboguer l'application immédiatement, vous pouvez créer un APK de débogage. L'APK de débogage est signé avec une clé de débogage fournie par les outils 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 version de débogage, appelez la tâche assembleDebug :

gradlew assembleDebug

Un APK nommé module_name-debug.apk est ainsi créé 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 appareil.

Pour compiler l'APK et l'installer immédiatement sur un émulateur en cours d'exécution ou un appareil connecté, appelez plutôt installDebug :

gradlew installDebug

La partie "Débogage" dans les noms de tâches ci-dessus n'est qu'une version camel case du nom de la variante de compilation. Vous pouvez donc la remplacer par le type de compilation ou la variante que vous souhaitez assembler ou installer. Par exemple, si vous disposez d'un type de produit "demo", vous pouvez créer la version de débogage à l'aide de la tâche assembleDemoDebug.

Pour afficher toutes les tâches de compilation 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 expliquant comment exécuter votre application sur l'émulateur et exécuter votre application sur un appareil.

Créer un bundle ou APK de release

Lorsque vous êtes prêt à publier et distribuer votre application, vous devez créer un bundle ou APK de release signé avec votre clé privée. Pour en savoir plus, consultez la section expliquant comment signer votre application à partir de la ligne de commande.

Déployer votre application dans l'émulateur

Pour utiliser Android Emulator, vous devez créer un appareil virtuel Android (AVD) à l'aide d'Android Studio.

Une fois que vous disposez d'un AVD, lancez Android Emulator et installez votre application comme suit :

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

   emulator -avd avd_name

   Si vous avez un doute sur le nom du fichier AVD, exécutez emulator -list-avds.

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

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

   adb install path/to/your_app.apk
   

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

Pour en savoir plus, consultez Exécuter des applications sur Android Emulator.

Déployer votre application sur un appareil physique

Avant de pouvoir exécuter votre application sur un appareil, vous devez activer le débogage USB sur votre appareil. Vous trouverez l'option sous Paramètres > Options pour les développeurs.

Remarque : Sur Android 4.2 ou version ultérieure, les Options pour les développeurs sont masquées par défaut. Pour les afficher, accédez à Paramètres > À propos du téléphone, puis appuyez sept fois sur Numéro de build. Revenez à l'écran précédent et recherchez Options pour les développeurs.

Une fois votre appareil configuré et connecté via USB, vous pouvez installer votre application à l'aide des tâches d'installation Gradle mentionnées dans la section sur la création d'un fichier APK de débogage ou en utilisant l'outil adb :

adb -d install path/to/your_app.apk

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

Pour en savoir plus, consultez l'article Exécuter des applications sur un appareil.

Créer un app bundle

Les Android App Bundles incluent l'ensemble du code et des ressources compilés de votre application. Laissez toutefois Google Play générer l'APK et la signature. Contrairement à un APK, un app bundle ne peut pas être déployé directement sur un appareil. Par conséquent, si vous souhaitez tester ou partager rapidement un APK avec un autre utilisateur, vous devez plutôt créer un APK.

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

Créer un app bundle avec Gradle

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

./gradlew :base:bundleDebug

Si vous souhaitez créer un bundle signé pour l'importer dans la Play Console, vous devez d'abord configurer le fichier build.gradle.kts du module de base avec les informations de signature de votre application. Pour en savoir plus, consultez la section expliquant comment configurer Gradle pour signer votre application. Vous pouvez ensuite créer la version de votre application, par exemple. Gradle génère ensuite automatiquement un app bundle et le signe avec les informations de signature que vous fournissez dans le fichier build.gradle.kts.

Si vous souhaitez signer un app bundle dans une étape distincte, vous pouvez utiliser jarsigner pour signer votre app bundle à partir de la ligne de commande. La commande permettant de créer un app bundle est la suivante:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

Créer un app bundle à l'aide de bundletool

bundletool est un outil de ligne de commande utilisé par Android Studio, le plug-in Android Gradle et Google Play pour convertir le code et les ressources compilés de votre application en app bundles, et générer des APK déployables à partir de ces app bundles.

Bien qu'il soit utile de tester des app bundles avec bundletool et de recréer localement la manière dont Google Play génère des APK, vous n'aurez généralement pas à utiliser bundletool pour créer l'app bundle lui-même. Utilisez plutôt les tâches Android Studio ou Gradle, comme décrit dans les sections précédentes.

Toutefois, si vous ne souhaitez pas utiliser de tâches Android Studio ou Gradle pour créer des bundles (par exemple, si vous utilisez une chaîne d'outils de compilation personnalisée), vous pouvez utiliser bundletool à partir de la ligne de commande pour compiler un app bundle à partir du code et des ressources précompilés. Si ce n'est pas déjà fait, téléchargez bundletool à partir du dépôt GitHub.

Cette section explique comment créer le package du code et des ressources compilés de votre application, et comment utiliser bundletool à partir de la ligne de commande pour les convertir en Android App Bundle.

Générer le fichier manifeste et les ressources au format proto

bundletool nécessite certaines informations sur votre projet d'application, par exemple le fichier manifeste et les ressources de l'application, au format "Protocol Buffer" de Google, également appelé "protobuf" et utilise l'extension de fichier *.pb. Les protobufs fournissent un mécanisme indépendant du langage et de la plate-forme et extensible pour la sérialisation des données structurées. Ce mécanisme est semblable au langage XML, mais il est plus petit, plus rapide et plus simple.

Télécharger AAPT2

Vous pouvez générer le fichier manifeste et la table des ressources de votre application au format protobuf en utilisant la dernière version d'AAPT2 dans le dépôt Maven de Google.

Pour télécharger AAPT2 à partir du dépôt Maven de Google, procédez comme suit :

1. Accédez à com.android.tools.build > aapt2 dans l'index du dépôt.
2. Copiez le nom de la dernière version d'AAPT2.

3. Insérez le nom de la 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 la page suivante : 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 l'application AAPT2 devrait bientôt commencer.

5. Décompressez le fichier JAR que vous venez de télécharger.

Compiler et associer 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/

Au cours de la phase où AAPT2 associe vos différentes ressources compilées en un seul APK, demandez à AAPT2 de convertir le fichier manifeste et les ressources compilées de votre application au format protobuf en incluant l'option --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

Vous pouvez ensuite extraire du contenu du fichier APK de sortie, tel que les fichiers AndroidManifest.xml, resources.pb et d'autres fichiers de ressource de votre application (désormais au format protobuf). Vous avez besoin de ces fichiers lorsque vous préparez la source bundletool requise pour créer votre app bundle, comme décrit dans la section suivante.

Créer un package de code et ressources précompilés

Avant de générer un app bundle pour votre application à l'aide de bundletool, vous devez d'abord fournir des fichiers ZIP contenant chacun le code et les ressources compilés d'un module d'application donné. Le contenu et l'organisation du fichier ZIP de chaque module sont très similaires à ceux 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 :

Après avoir préparé le fichier ZIP pour chaque module de votre application, vous pouvez le transmettre à bundletool pour créer votre app bundle, comme décrit dans la section suivante.

Créer votre app bundle à l'aide de bundletool

Pour créer votre app bundle, utilisez la commande bundletool build-bundle, comme indiqué ci-dessous :

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

Le tableau suivant décrit les options de la commande build-bundle plus en détail :

Personnaliser la génération des APK en aval

Les app bundles incluent un fichier BundleConfig.pb qui fournit les métadonnées requises par les plates-formes de téléchargement d'applications, comme Google Play, lors de la génération des 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 le transmettre à la commande bundletool build-bundle. bundletool effectue ensuite une conversion et fusionne ce fichier avec la version protobuf incluse dans chaque app bundle.

Par exemple, vous pouvez contrôler les catégories d'APK de configuration à activer ou à désactiver. L'exemple de fichier BundleConfig.json suivant désactive les APK de configuration qui ciblent chacun un langage différent (c'est-à-dire que les ressources pour tous les langages sont incluses dans leurs fichiers APK de base ou de fonctionnalité) :

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

Dans votre fichier BundleConfig.json, vous pouvez également spécifier les types de fichiers à ne pas compresser lorsque vous créez les packages des APK à l'aide de modèles glob, comme suit :

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

Gardez à l'esprit que, par défaut, bundletool ne compresse pas les bibliothèques natives (sur Android 6.0 ou versions ultérieures) ni les tables de ressources (resources.arsc) de votre application. Pour obtenir une description complète des éléments configurables de votre BundleConfig.json, inspectez le fichier bundletoolconfig.proto , écrit à l'aide de la syntaxe Proto3.

Déployer votre application à partir d'un app bundle

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

Signer votre application depuis la ligne de commande

Vous n'avez pas besoin d'Android Studio pour signer votre application. Vous pouvez signer votre application à partir de la ligne de commande, en utilisant apksigner pour les APK ou jarsigner pour les app bundles, ou configurez Gradle pour le signer à votre place lors de la compilation. Dans tous les cas, vous devez d'abord générer une clé privée à l'aide de keytool, comme indiqué ci-dessous :

keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias

L'exemple ci-dessus vous invite à saisir des mots de passe pour le keystore et la clé, ainsi que pour les champs "Nom distinctif" de votre clé. Il génère ensuite le keystore sous la forme d'un fichier nommé my-release-key.jks, qui est enregistré dans le répertoire actuel (vous pouvez le déplacer où vous le souhaitez). Le keystore contient une seule clé, valide pendant 10 000 jours.

Vous pouvez désormais signer manuellement un APK ou un app bundle, ou configurer Gradle pour signer votre application au cours du processus de compilation, comme décrit dans les sections ci-dessous.

Signer votre application manuellement à partir de la ligne de commande

Si vous souhaitez signer un app bundle à partir de la ligne de commande, vous pouvez utiliser jarsigner. Si vous souhaitez signer un APK, vous devez utiliser zipalign et apksigner comme décrit ci-dessous.

1. Ouvrez une ligne de commande (depuis Android Studio, sélectionnez Afficher > Fenêtres d'outil > Terminal), puis accédez au répertoire de votre APK non signé.

2. Alignez l'APK non signé à l'aide de zipalign :

   zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
   

   zipalign garantit que toutes les données non compressées commencent par un alignement d'octets particulier en lien avec le début du fichier, ce qui peut réduire le volume de RAM utilisé par une application.

3. Signez votre APK avec votre clé privée à l'aide de apksigner :

   apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
   

   Cet exemple génère l'APK signé à l'adresse my-app-release.apk après l'avoir signé avec une clé privée et un certificat stockés dans un seul fichier keystore : my-release-key.jks.

   L'outil apksigner accepte d'autres options de signature, comme la signature d'un fichier APK à l'aide de fichiers de clé privée et de certificat distincts, et la signature d'un APK à l'aide de plusieurs signataires. Pour en savoir plus, consultez la documentation de référence sur apksigner.

   Remarque : Pour utiliser l'outil apksigner, vous devez disposer de la version 24.0.3 ou ultérieure des outils de compilation du SDK Android. Vous pouvez mettre à jour ce package à l'aide de SDK Manager.

4. Vérifiez que votre fichier APK est signé :

   apksigner verify my-app-release.apk
   

Configurer Gradle pour signer votre application

Ouvrez le fichier build.gradle.kts au niveau du module et ajoutez le bloc signingConfigs {} avec des entrées pour storeFile, storePassword, keyAlias et keyPassword. Transmettez ensuite cet objet à la propriété signingConfig dans votre type de compilation. Par exemple :

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        create("release") {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile = file("my-release-key.jks")
            storePassword = "password"
            keyAlias = "my-alias"
            keyPassword = "password"
        }
    }
    buildTypes {
        getByName("release") {
            signingConfig = signingConfigs.getByName("release")
            ...
        }
    }
}

android {
    ...
    defaultConfig { ... }
    signingConfigs {
        release {
            // You need to specify either an absolute path or include the
            // keystore file in the same directory as the build.gradle file.
            storeFile file("my-release-key.jks")
            storePassword "password"
            keyAlias "my-alias"
            keyPassword "password"
        }
    }
    buildTypes {
        release {
            signingConfig signingConfigs.release
            ...
        }
    }
}

Désormais, lorsque vous compilez votre application en appelant une tâche Gradle, Gradle signe votre application (et exécute zipalign) pour vous.

De plus, comme vous avez configuré le build avec votre clé de signature, la tâche d'installation est disponible pour ce type de compilation. Vous pouvez donc compiler, aligner, signer et installer l'APK de la version sur un émulateur ou un appareil à l'aide de la tâche installRelease.

Une application signée avec votre clé privée est prête à être distribuée, mais vous devez d'abord découvrir comment publier votre application et consulter la checklist pour le lancement Google Play.