Cette page a été traduite par l'API Cloud Translation.

bundletool

bundletool est l'outil sous-jacent utilisé par Android Studio, le plug-in Android Gradle et Google Play pour créer un Android App Bundle. bundletool peut convertir un app bundle en différents APK déployés sur les appareils.

Les fichiers Android SDK Bundle (ASB) et leurs APK sont compilés avec bundletool, qui est également disponible sous la forme d'un outil de ligne de commande. Vous pouvez ainsi compiler vous-même des app bundles et des SDK bundles, et recréer la build Google Play côté serveur des APK de votre application ou de votre SDK compatible avec l'environnement d'exécution.

Télécharger `bundletool`

Si vous ne l'avez pas déjà fait, téléchargez bundletool à partir du dépôt GitHub.

Compiler et tester un app bundle

Vous pouvez utiliser Android Studio ou l'outil de ligne de commande bundletool pour compiler votre Android App Bundle, puis tester la génération d'APK à partir de cet app bundle.

Compiler un app bundle

Utilisez Android Studio et le plug-in Android Gradle pour créer et signer un Android App Bundle. Cependant, si vous ne pouvez pas utiliser l'IDE (par exemple, parce que vous utilisez un serveur de compilation continue), vous pouvez également compiler votre app bundle à partir de la ligne de commande et le signer avec jarsigner.

Pour en savoir plus sur la compilation d'app bundles avec bundletool, consultez Compiler un app bundle à l'aide de bundletool.

Générer un ensemble d'APK à partir de votre app bundle

Après avoir créé votre Android App Bundle, testez la génération des APK sur Google Play à partir de ce package et leur comportement une fois qu'ils sont déployés sur un appareil.

Deux options sont disponibles pour tester votre app bundle :

Utilisez l'outil de ligne de commande bundletool en local.
Importez votre app bundle dans la Play Console via Google Play en utilisant un canal de test.

Cette section explique comment tester votre app bundle en local à l'aide de bundletool.

Lorsque bundletool génère des APK à partir de votre app bundle, il les inclut dans un conteneur appelé archive d'ensembles d'APK, qui utilise l'extension de fichier .apks. Pour générer un ensemble d'APK pour toutes les configurations d'appareil compatibles avec votre application à partir de votre app bundle, exécutez la commande bundletool build-apks, comme indiqué ci-dessous :

bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks

Si vous souhaitez déployer les APK sur un appareil, vous devez inclure les informations de signature de votre application, comme indiqué dans la commande suivante. Si vous ne spécifiez pas d'informations de signature, bundletool tente de signer vos APK pour vous à l'aide d'une clé de débogage.

bundletool build-apks --bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks
--ks=/MyApp/keystore.jks
--ks-pass=file:/MyApp/keystore.pwd
--ks-key-alias=MyKeyAlias
--key-pass=file:/MyApp/key.pwd

Le tableau suivant décrit de manière détaillée les différents indicateurs et options que vous pouvez définir lorsque vous utilisez la commande bundletool build-apks :

Tableau 1. Options pour la commande bundletool build-apks

Indicateur	Description
`--bundle=path`	(Obligatoire) Spécifie le chemin d'accès à l'app bundle que vous avez compilé à l'aide d'Android Studio. Pour en savoir plus, consultez Compiler votre projet.
`--output=path`	(Obligatoire) Spécifie le nom du fichier `.apks` de sortie qui contient tous les artefacts d'APK de votre application. Pour tester les artefacts de ce fichier sur un appareil, suivez la procédure décrite dans la section Déployer des APK sur un appareil connecté.
`--overwrite`	Remplace tous les fichiers de sortie existants par le chemin d'accès que vous spécifiez à l'aide de l'option `--output`. Si vous n'incluez pas cet indicateur et que le fichier de sortie existe déjà, une erreur de compilation est émise.
`--aapt2=path`	Spécifie un chemin d'accès personnalisé à AAPT2. Par défaut, `bundletool` inclut sa propre version d'AAPT2.
`--ks=path`	(Facultatif) Spécifie le chemin d'accès au keystore de déploiement utilisé pour signer les APK. Si vous n'incluez pas cet indicateur, `bundletool` tente de signer vos APK à l'aide d'une clé de débogage.
`--ks-pass=pass:password` ou `--ks-pass=file:/path/to/file`	Spécifie le mot de passe de votre keystore. Si vous spécifiez un mot de passe en texte brut, qualifiez-le avec `pass:`. Si vous transmettez le chemin d'accès à un fichier contenant le mot de passe, qualifiez-le avec `file:`. Si vous spécifiez un keystore à l'aide de l'indicateur `--ks` sans spécifier `--ks-pass`, `bundletool` vous invite à saisir un mot de passe à partir de la ligne de commande.
`--ks-key-alias=alias`	Spécifie l'alias de la clé de signature que vous souhaitez utiliser.
`--key-pass=pass:password` ou `--key-pass=file:/path/to/file`	Spécifie le mot de passe de la clé de signature. Si vous spécifiez un mot de passe en texte brut, qualifiez-le avec `pass:`. Si vous transmettez le chemin d'accès à un fichier contenant le mot de passe, qualifiez-le avec `file:`. Si ce mot de passe est identique à celui du keystore, vous pouvez omettre cet indicateur.
`--connected-device`	Indique à `bundletool` de créer des APK qui ciblent la configuration d'un appareil connecté. Si vous n'incluez pas cet indicateur, `bundletool` génère des APK pour toutes les configurations d'appareil prises en charge par votre application.
`--device-id=serial-number`	Si vous disposez de plusieurs appareils connectés, utilisez cet indicateur pour spécifier l'ID de série de l'appareil sur lequel vous souhaitez déployer votre application.
`--device-spec=spec_json`	Fournit un chemin d'accès à un fichier `.json` spécifiant la configuration d'appareil que vous souhaitez cibler. Pour en savoir plus, consultez la section Générer et utiliser des fichiers JSON de spécification d'appareil.
`--mode=universal`	Définit le mode sur `universal`. Utilisez cette option si vous souhaitez que `bundletool` ne compile qu'un seul APK comprenant l'ensemble du code et des ressources de votre application, de sorte que l'APK soit compatible avec toutes les configurations d'appareil prises en charge par votre application. Remarque : `bundletool` n'inclut que les modules de fonctionnalités qui spécifient `<dist:fusing dist:include="true"/>` dans leur fichier manifeste dans un APK universel. Pour en savoir plus, consultez la documentation de référence du fichier manifeste des modules de fonctionnalités. N'oubliez pas que ces APK sont plus volumineux que ceux qui sont optimisés pour une configuration d'appareil spécifique. Toutefois, ils sont plus faciles à partager avec les testeurs internes qui souhaitent, par exemple, tester votre application sur plusieurs configurations d'appareil.
`--local-testing`	Active votre app bundle pour les tests en local. Les tests en local permettent d'effectuer des cycles de test rapides et itératifs sans avoir à les importer sur les serveurs Google Play. Pour savoir comment tester une installation de modules à l'aide de l'indicateur `--local-testing`, consultez Tester localement les installations de modules.

Déployer des APK sur un appareil connecté

Une fois que vous avez généré un ensemble d'APK, bundletool peut déployer la bonne combinaison d'APK sur un appareil connecté à partir de cet ensemble.

Par exemple, si votre appareil connecté est équipé d'Android 5.0 (niveau d'API 21) ou version ultérieure, bundletool transmet l'APK de base, les APK du module de fonctionnalité et les APK de configuration requis pour exécuter votre application sur cet appareil. Si votre appareil connecté est équipé d'Android 4.4 (niveau d'API 20) ou version antérieure, bundletool recherche un APK multiple compatible à déployer sur votre appareil.

Pour déployer votre application à partir d'un ensemble d'APK, exécutez la commande install-apks et spécifiez le chemin d'accès de l'ensemble à l'aide de l'indicateur --apks=/path/to/apks, comme dans la commande suivante. Si plusieurs appareils sont connectés, spécifiez un appareil cible en ajoutant l'indicateur --device-id=serial-id.

bundletool install-apks --apks=/MyApp/my_app.apks

Générer un ensemble d'APK spécifique à un appareil

Si vous souhaitez ne pas créer un ensemble d'APK pour toutes les configurations d'appareil prises en charge par votre application, vous pouvez compiler des APK qui ne ciblent que la configuration d'un appareil connecté à l'aide de l'option --connected-device, comme indiqué dans la commande suivante. Si plusieurs appareils sont connectés, spécifiez un appareil cible en ajoutant l'indicateur --device-id=serial-id.

bundletool build-apks --connected-device
--bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks

Générer et utiliser des fichiers JSON de spécification d'appareil

bundletool peut générer un ensemble d'APK ciblant une configuration d'appareil spécifiée par un fichier JSON. Si vous voulez d'abord générer un fichier JSON pour un appareil connecté, exécutez la commande suivante :

bundletool get-device-spec --output=/tmp/device-spec.json

bundletool crée un fichier JSON pour votre appareil dans le répertoire de l'outil. Vous pouvez ensuite transmettre le fichier à bundletool afin de générer un ensemble d'APK ciblant uniquement la configuration décrite dans ce fichier JSON, comme ceci :

bundletool build-apks --device-spec=/MyApp/pixel2.json
--bundle=/MyApp/my_app.aab --output=/MyApp/my_app.apks

Créer manuellement un fichier JSON de spécification d'appareil

Si vous n'avez pas accès à l'appareil pour lequel vous souhaitez compiler un ensemble d'APK ciblé (par exemple, si vous voulez essayer votre application sur un appareil que vous ne possédez pas), vous pouvez créer manuellement un fichier JSON au format suivant :

{
  "supportedAbis": ["arm64-v8a", "armeabi-v7a"],
  "supportedLocales": ["en", "fr"],
  "screenDensity": 640,
  "sdkVersion": 27
}

Vous pouvez ensuite transmettre ce fichier JSON à la commande bundle extract-apks, comme indiqué dans la section précédente.

Extraire des APK spécifiques à l'appareil d'un ensemble d'APK existant

Supposons que vous ayez un ensemble d'APK et que vous souhaitiez en extraire un sous-ensemble d'APK ciblant une configuration d'appareil spécifique. Dans ce cas, vous pouvez utiliser la commande extract-apks et indiquer un fichier JSON de spécification d'appareil, comme suit :

bundletool extract-apks
--apks=/MyApp/my_existing_APK_set.apks
--output-dir=/MyApp/my_pixel2_APK_set.apks
--device-spec=/MyApp/bundletool/pixel2.json

Mesurer la taille de téléchargement estimée des APK d'un ensemble d'APK

Pour mesurer la taille de téléchargement estimée des APK d'un ensemble d'APK tels qu'ils seraient diffusés sous forme compressée sur le réseau, exécutez la commande get-size total :

bundletool get-size total --apks=/MyApp/my_app.apks

Vous pouvez modifier le comportement de la commande get-size total à l'aide des indicateurs suivants :

Tableau 2. Options pour la commande get-size total

Indicateur	Description
`--apks=path`	(Obligatoire) Spécifie le chemin d'accès au fichier d'ensemble d'APK dont la taille de téléchargement est mesurée.
`--device-spec=path`	Indique le chemin d'accès au fichier de spécification de l'appareil (à partir de `get-device-spec` ou construit manuellement) à utiliser pour la mise en correspondance. Vous pouvez spécifier un chemin d'accès partiel pour évaluer un ensemble de configurations.
`--dimensions=dimensions`	Spécifie les dimensions utilisées lors du calcul des estimations de taille. Accepte une liste d'éléments `SDK`, `ABI`, `SCREEN_DENSITY` et `LANGUAGE` séparés par une virgule. Pour effectuer des mesures dans toutes les dimensions, spécifiez `ALL`.
`--instant`	Mesure la taille de téléchargement des APK permettant une utilisation instantanée au lieu des APK installables. Par défaut, `bundletool` mesure la taille de téléchargement des APK installables.
`--modules=modules`	Spécifie une liste de modules séparés par une virgule dans l'ensemble d'APK à prendre en compte dans la mesure. La commande `bundletool` inclut automatiquement tous les modules dépendants de l'ensemble spécifié. Par défaut, la commande mesure la taille de téléchargement de tous les modules installés lors du premier téléchargement.

Compiler un app bundle avec une dépendance SDK bundle (expérimental)

Vous pouvez créer votre Android App Bundle avec une dépendance Android SDK Bundle (ASB) à partir de la ligne de commande et le signer à l'aide de jarsigner.

Chaque module d'app bundle comprend un fichier de tampon de protocole de module (.pb) : runtime_enabled_sdk_config.pb. Ce fichier contient la liste des SDK dont dépend un module d'app bundle. Pour connaître la définition complète de ce fichier, consultez le fichier runtime_enabled_sdk_config.proto.

Pour compiler un app bundle avec une dépendance SDK bundle, suivez les étapes de la section Compiler un app bundle à l'aide de bundletool et ajoutez un fichier runtime_enabled_sdk_config.pb au fichier ZIP de chaque module d'application avec le code et les ressources compilés.

Voici quelques champs importants du fichier runtime_enabled_sdk_config.pb :

Condensé du certificat : condensé SHA-256 du certificat de la clé utilisée pour signer les APK du SDK. Il correspond au certificat dans le fichier SdkMetadata.pb au format Android SDK Archive.
ID du package de ressources : ID du package sur lequel toutes les ressources de ce SDK sont remappées lors de la génération d'APK pour intégrer le SDK dans l'application. Cela assure la rétrocompatibilité.

Un SDK ne peut apparaître que dans un seul module. Si plusieurs modules dépendent du même SDK, cette dépendance doit être dédupliquée et déplacée vers le module de base. Les différents modules ne peuvent pas dépendre de versions différentes du SDK.

Générer des APK à partir d'un app bundle avec une dépendance SDK bundle (expérimental)

Pour générer des APK à partir d'un app bundle, suivez la procédure décrite dans la section Générer un ensemble d'APK à partir de votre app bundle ou Générer un ensemble d'APK spécifique à un appareil et fournissez à la commande bundletool build-apks les SDK dont dépend l'application. Ces SDK peuvent être fournis au format SDK bundle ou SDK Archive.

Vous pouvez fournir les SDK en tant que SDK bundles en ajoutant l'indicateur --sdk-bundles, comme suit :

bundletool build-apks --bundle=app.aab --sdk-bundles=sdk1.asb,sdk2.asb \
    --output=app.apks

Vous pouvez fournir les SDK en tant que SDK archives en ajoutant l'indicateur --sdk-archives, comme suit :

bundletool build-apks --bundle=app.aab --sdk-archives=sdk1.asar,sdk2.asar \
    --output=app.apks

Générer des APK à partir d'un app bundle avec une dépendance SDK bundle pour les appareils non compatibles avec la bibliothèque SDK

Les appareils antérieurs à Android 13 ne permettent pas d'installer des bibliothèques de SDK ni de les exécuter dans SDK Runtime. Bundletool masque la complexité de la rétrocompatibilité et génère plusieurs variantes de votre ensemble d'APK à partir du même app bundle lorsque vous exécutez bundletool build-apks avec l'option --sdk-bundles ou --sdk-archives. Les variantes ciblent des appareils aux fonctionnalités différentes:

Il existe une variante pour les appareils plus récents, où le SDK est installé en tant que package distinct de l'application et les APK de l'application n'incluent aucun contenu de SDK.
Il existe une ou plusieurs variantes pour les appareils plus anciens, où les APK du SDK sont ajoutés à l'ensemble d'APK de l'application en tant que divisions d'APK supplémentaires. Les APK du SDK appartiennent au package de l'application. Dans ce cas, le SDK Runtime est émulé dans l'environnement d'exécution de l'application sur l'appareil.

De la même manière que vous générez des APK pour les app bundles sans dépendances de SDK, bundletool extract-apks et bundletool install-apks renvoient un ensemble filtré d'APK à partir de la meilleure variante pour l'appareil connecté ou pour la configuration d'appareil fournie.

Pour les cas d'utilisation avancés où vous souhaitez uniquement générer des divisions d'APK à partir d'une archive SDK pour une application spécifique destinée aux appareils plus anciens, exécutez la commande bundletool build-sdk-apks-for-app comme suit:

bundletool build-sdk-apks-for-app --app-properties=app-properties.json \
    --sdk-archive=sdk.asar --output=sdk.apks

Le fichier app-properties doit contenir les champs décrits dans le fichier runtime_enabled_sdk_config.proto. Le fichier app-properties se présente comme suit:

{
  "package_name": "com.my.app",
  "version_code": 1234,
  "min_sdk_version": 21,
  "resources_package_id": 0x7e
}

La commande bundletool build-sdk-apks-for-app génère le sous-ensemble d'APK d'application correspondant au contenu du SDK sous le nom du package de l'application. Vous pouvez combiner ces APK avec d'autres APK contenant le contenu de l'application. Par exemple, si vous les compilez séparément et de manière incrémentielle, et si vous les installez ensemble sur un appareil non compatible avec le SDK Runtime.

Compiler et tester un SDK bundle (expérimental)

Vous pouvez utiliser bundletool pour compiler un ASB et tester la génération des fichiers nécessaires à l'installation et à la distribution.

Compiler un SDK bundle

Vous pouvez créer votre ASB à partir de la ligne de commande et le signer à l'aide de jarsigner.

Pour compiler un SDK bundle, procédez comme suit :

Générez le fichier manifeste et les ressources du SDK bundle au format proto en suivant la même procédure que pour un app bundle.
Empaquetez les ressources et le code compilés de votre SDK dans un fichier ZIP de base, comme vous le feriez avec un module d'application.
Générez un fichier SdkModulesConfig.pb.json et un fichier SdkBundleConfig.pb.json correspondant au format décrit dans la spécification d'Android SDK Bundle.
Créez votre ASB à l'aide de la commande bundletool build-sdk-bundle comme suit :

bundletool build-sdk-bundle --sdk-bundle-config=SdkBundleConfig.pb.json \
    --sdk-modules-config=SdkModulesConfig.pb.json \
    --modules=base.zip --output=sdk.asb

Le tableau suivant décrit de manière détaillée les différents indicateurs et options que vous pouvez définir lorsque vous utilisez la commande bundletool build-sdk-bundle.

Tableau 3. Options pour la commande bundletool build-sdk-bundle

Indicateur	Description
`--modules`	(Obligatoire) Fichier de module à partir duquel vous souhaitez compiler l'ASB final.
`--output`	(Obligatoire) Chemin d'accès au répertoire dans lequel vous souhaitez compiler l'ASB.
`--sdk-modules-config`	(Obligatoire) Chemin d'accès à un fichier JSON décrivant la configuration des modules SDK. Pour savoir comment mettre en forme le fichier JSON, consultez la section Spécification d'Android SDK Bundle.
`--sdk-bundle-config`	Chemin d'accès à un fichier JSON décrivant la configuration du SDK bundle. Pour savoir comment mettre en forme le fichier JSON, consultez la section Spécification d'Android SDK Bundle.
`--metadata-file`	Fichier dans lequel inclure des métadonnées pour l'ASB. Le format de la valeur de l'indicateur est `<bundle-path>:<physical-file>`, où `<bundle-path>` indique l'emplacement du fichier dans le répertoire de métadonnées du SDK bundle et `<physical-file>` est un fichier existant qui contient les données brutes à stocker. Cet indicateur peut être répété.
`--overwrite`	Si cette option est définie, toute sortie précédente est écrasée.

Générer des APK à partir d'un SDK bundle

Une fois que vous avez compilé votre ASB, vous pouvez le tester en local en générant ses APK à l'aide de la commande bundletool build-sdk-apks, comme indiqué dans le code suivant :

bundletool build-sdk-apks --sdk-bundle=sdk.asb --output=sdk.apks

Lorsque bundletool génère des APK à partir de votre SDK bundle, il les inclut dans un conteneur appelé archive d'ensembles d'APK, qui utilise l'extension de fichier .apks. bundletool génère un seul APK autonome à partir du SDK bundle, qui cible toutes les configurations d'appareil.

Si vous souhaitez déployer l'ASB sur un appareil, vous devez également inclure les informations de signature de votre application, comme indiqué dans la commande suivante :

bundletool build-sdk-apks --sdk-bundle=sdk.asb --output=sdk.apks \
    --ks=keystore.jks \
    --ks-pass=file:/keystore.pwd \
    --ks-key-alias=KeyAlias \
    --key-pass=file:/key.pwd

Le tableau suivant décrit de manière détaillée les différents indicateurs et options que vous pouvez définir lorsque vous utilisez la commande bundletool build-sdk-apks.

Tableau 4. Options pour la commande bundletool build-sdk-apks

Indicateur	Description
`--sdk-bundle`	(Obligatoire) Chemin d'accès au SDK bundle. Doit avoir l'extension `.asb`.
`--output`	(Obligatoire) Par défaut, il s'agit du chemin d'accès où vous allez créer l'archive d'ensembles d'APK. Si vous utilisez `--output-format=DIRECTORY`, il s'agit du chemin d'accès au répertoire dans lequel vous souhaitez que les APK générés soient stockés.
`--ks`	Chemin d'accès au keystore que vous voulez utiliser pour signer les APK générés.
`--ks-key-alias`	Alias de la clé à utiliser dans le keystore pour signer les APK générés.
`--key-pass`	Mot de passe de la clé dans le keystore à utiliser pour signer les APK générés. Si vous transmettez le mot de passe en texte clair, vous devez ajouter le préfixe `pass:` à la valeur. Par exemple, `pass:qwerty`. Si le mot de passe est la première ligne d'un fichier, vous devez ajouter le préfixe `file:` à la valeur. Exemple : `file:/tmp/myPassword.txt`. Si cet indicateur n'est pas défini, le mot de passe du keystore est utilisé. En cas d'échec, le terminal de ligne de commande vous invite à saisir un mot de passe.
`--ks-pass`	Mot de passe du keystore à utiliser pour signer les APK générés. Si vous transmettez le mot de passe en texte clair, vous devez ajouter le préfixe `pass:` à la valeur. Par exemple, `pass:qwerty`. Si le mot de passe est la première ligne d'un fichier, vous devez ajouter le préfixe `file:` à la valeur. Exemple : `file:/tmp/myPassword.txt`. Si cet indicateur n'est pas défini, le terminal de ligne de commande vous invite à saisir un mot de passe.
`--aapt2`	Chemin d'accès au binaire AAPT2 à utiliser.
`--output-format`	Format de sortie des APK générés. Par défaut, cette option est définie sur `APK_SET`, ce qui génère des APK dans l'archive d'ensembles d'APK qui est créée. Si elle est définie sur `DIRECTORY`, les APK sont générés dans le répertoire spécifié par `--output`.
`--verbose`	Si cette option est spécifiée, elle affiche des informations supplémentaires sur l'exécution de la commande dans la sortie standard.
`--version-code`	Code de version du SDK. Il s'agit du code de version utilisé par la plate-forme Android pour installer l'APK, et non de la version du SDK. Cette option peut être définie sur une valeur arbitraire. Si elle n'est pas spécifiée, elle est définie par défaut sur 0.
`--overwrite`	Si cette option est définie, toute sortie précédente est écrasée.

Déployer et extraire les APK du SDK, et mesurer leur taille

Vous pouvez suivre la même procédure que celle utilisée pour permettre aux applications de déployer des APK sur un appareil connecté, d'extraire des APK spécifiques à l'appareil d'un ensemble d'APK existant et de mesurer la taille de téléchargement estimée des APK d'un ensemble d'APK.

Générer une SDK Archive à partir d'un SDK bundle

Une fois que vous avez importé votre ASB dans votre canal de distribution (dans Google Play, par exemple), il est transformé au format Android SDK Archive (.asar) pour être distribué aux développeurs d'applications via Maven. Pour en savoir plus sur ce format, consultez la section Spécification du format d'archive du SDK.

Une fois que vous avez compilé votre ASB, vous pouvez tester la génération d'un fichier Android SDK Archive en local à l'aide de la commande bundletool build-sdk-asar, comme indiqué dans le code ci-dessous :

bundletool build-sdk-asar --sdk-bundle=sdk.asb --output=sdk.asar \
    --apk-signing-key-certificate=keycert.txt

Le tableau suivant décrit de manière détaillée les différents indicateurs et options que vous pouvez définir lorsque vous utilisez la commande bundletool build-sdk-asar.

Tableau 5. Options pour la commande bundletool build-sdk-asar

Indicateur	Description
`--apk-signing-key-certificate`	(Obligatoire) Chemin d'accès au certificat de signature de l'APK du SDK. Il s'agit du certificat correspondant à la clé que vous avez utilisée pour signer les APK dans la commande `build-sdk-apks`.
`--output`	(Obligatoire) Chemin d'accès au répertoire dans lequel vous souhaitez que le fichier `.asar` soit créé.
`--sdk-bundle`	(Obligatoire) Chemin d'accès au SDK bundle. Doit avoir l'extension `.asb`.
`--overwrite`	Si cette option est définie, toute sortie précédente est écrasée.

Formats SDK compatibles avec l'environnement d'exécution (expérimental)

Les SDK compatibles avec l'environnement d'exécution introduisent deux formats de fichiers Android :

Android SDK Bundle (.asb), utilisé pour publier le SDK compatible avec l'environnement d'exécution sur les plates-formes de téléchargement d'applications.
SDK Android Archive (.asar), utilisé pour distribuer le SDK compatible avec l'environnement d'exécution sur Maven.

Format Android SDK Bundle (ASB)

SDK Bundle est un format de publication destiné aux SDK compatibles avec l'environnement d'exécution. Il contient l'ensemble du code et des ressources du SDK, y compris le code des bibliothèques dont dépend le SDK. Il ne comporte pas le code ni les ressources des autres SDK compatibles avec l'environnement d'exécution dont dépend le SDK.

Un Android SDK Bundle (ASB) est un fichier ZIP signé avec l'extension .asb. Le code et les ressources du SDK y sont organisés de la même manière que dans un APK. Un ASB contient également plusieurs fichiers de configuration qui aident à générer les APK installables.

**Figure 1**. Contenu d'un fichier Android SDK Bundle

La liste suivante décrit de manière détaillée certains fichiers ASB :

SdkBundleConfig.pb : fichier de configuration au format proto contenant la liste des SDK compatibles avec l'environnement d'exécution dont dépend votre SDK. Pour une définition complète, consultez le fichier sdk_bundle_config.proto.
modules.resm : fichier ZIP contenant toutes les données nécessaires pour générer les APK à partir du SDK.
SdkModulesConfig.pb : fichier de configuration au format proto. Ce fichier contient le nom et la version du SDK, ainsi que le nom de classe du point d'entrée du SDK pour le framework (SandboxedSdkProvider). Pour obtenir la définition complète, consultez le fichier sdk_modules_config.proto.
base/ : module unique contenant le code et les ressources du SDK.
- manifest/ : fichier manifeste du SDK au format proto.
- dex/ : code compilé au format DEX. Plusieurs fichiers DEX peuvent être fournis.
- res/, lib/ et assets/ : ces répertoires sont identiques à ceux d'un APK standard. Les chemins d'accès de ces répertoires sont conservés lors de la génération des APK du SDK.
- root/ : ce répertoire stocke les fichiers qui sont déplacés par la suite à la racine des APK du SDK. Par exemple, il peut inclure des ressources Java que votre SDK charge à l'aide de la méthode Class.getResource(). Les chemins d'accès de ce répertoire sont également conservés.
BUNDLE-METADATA : ce répertoire inclut des fichiers de métadonnées contenant des informations utiles pour les outils ou les plates-formes de téléchargement d'applications. Ces fichiers de métadonnées peuvent inclure des mappages ProGuard et la liste complète des fichiers DEX de votre SDK. Les fichiers de ce répertoire ne sont pas empaquetés dans les APK de votre SDK.

Format Android SDK Archive

Android SDK Archive est le format de distribution d'un SDK compatible avec l'environnement d'exécution sur Maven. Il s'agit d'un fichier ZIP avec l'extension .asar. Il contient toutes les informations dont les outils de compilation d'applications ont besoin pour générer un Android App Bundle qui dépend de votre SDK compatible avec l'environnement d'exécution.

**Figure 2**. Contenu d'un fichier Android SDK Archive.

La liste suivante décrit de manière détaillée certains fichiers Android SDK Archive :

SdkMetadata.pb : fichier de configuration au format proto contenant le nom du SDK, la version et le condensé du certificat correspondant à la clé utilisée pour signer les APK générés pour ce SDK. Pour une définition complète, consultez le fichier sdk_metadata.proto.
modules.resm : fichier ZIP contenant toutes les données nécessaires pour générer les APK à partir du SDK. Identique au fichier .resm de l'Android SDK Bundle.
AndroidManifest.xml : fichier manifeste du SDK au format texte XML.

Ressources supplémentaires

Pour en savoir plus sur l'utilisation de bundletool, regardez la vidéo App Bundles: Testing bundles with bundletool and the Play Console (App bundles : tests avec Bundletool et la Play Console).