bundletool
est l'outil sous-jacent utilisé par Android Studio, le plug-in Android Gradle et Google Play. bundletool
peut compiler un Android App Bundle (AAB) et convertir un app bundle en plusieurs APK déployés sur des 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 : 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 |
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 de SDK
Les appareils antérieurs à Android 13 ne sont pas compatibles avec l'installation de bibliothèques de SDK ni leur exécution
dans le 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 multiples ciblent des appareils ayant des fonctionnalités différentes:
- Il existe une variante pour les appareils plus récents, où le SDK est installé en tant que de l'application et que les APK de celle-ci n'incluent aucun contenu de SDK.
- Il existe une ou plusieurs variantes pour les anciens appareils, où les APK du SDK sont ajoutés à l'APK de l'application défini en tant que divisions d'APK supplémentaires. Les APK du SDK appartiennent à l'application d'un package. Dans ce cas, le SDK Runtime est émulé dans l'environnement d'exécution de l'application sur le appareil.
De la même manière que vous générez des APK pour des app bundles sans dépendances de SDK,
bundletool extract-apks
et bundletool install-apks
renvoient un ensemble filtré de
APK issus de la meilleure variante pour l'appareil connecté ou l'appareil fourni
configuration.
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 pour des appareils plus anciens, utilisez le
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 les
runtime_enabled_sdk_config.proto
. Voici à quoi ressemble l'élément app-properties
ressemble à ceci:
{
"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 de l'application
APK correspondant au contenu du SDK sous le nom du package de l'application. Vous pouvez
combiner ces APK avec d'autres APK incluant le contenu de l'application. Par exemple, si
vous les créez séparément et de manière incrémentielle, puis vous les installez ensemble sur un appareil
qui n'est pas compatible avec 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 fichierSdkBundleConfig.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 un préfixe à la valeur
avec 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 un préfixe à la valeur
avec 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.
![](https://developer.android.com/static/studio/images/command-line/asb-format.png?authuser=9&hl=fr)
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 fichiersdk_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 fichiersdk_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/
etassets/
: 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éthodeClass.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.
![](https://developer.android.com/static/studio/images/command-line/asar-format.png?authuser=9&hl=fr)
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 fichiersdk_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).