Diese Seite wurde von der Cloud Translation API übersetzt.

bundletool

bundletool ist das zugrunde liegende Tool, das Android Studio, das Android Gradle-Plug-in und Google Play zum Erstellen eines Android App Bundles verwenden. bundletool kann ein App Bundle in die verschiedenen APKs konvertieren, die auf den Geräten bereitgestellt werden.

Android SDK Bundles (ASBs) und die zugehörigen APKs wurden mit bundletool erstellt. Es ist auch als Befehlszeilentool verfügbar. So können Sie selbst App Bundles und SDK-Bundles erstellen und den serverseitigen Build von Google Play der APKs Ihrer App oder Ihrer laufzeitfähigen SDK-APKs neu erstellen.

`bundletool` herunterladen

Laden Sie bundletool aus dem GitHub-Repository herunter, falls noch nicht geschehen.

App Bundle erstellen und testen

Du kannst Android Studio oder das bundletool-Befehlszeilentool verwenden, um dein Android App Bundle zu erstellen und dann das Generieren von APKs aus diesem App Bundle zu testen.

App Bundle erstellen

Mit Android Studio und dem Android Gradle-Plug-in kannst du ein Android App Bundle erstellen und signieren. Wenn die Verwendung der IDE keine Option ist, z. B. weil Sie einen Continuous-Build-Server verwenden, können Sie Ihr App Bundle auch über die Befehlszeile erstellen und mit jarsigner signieren.

Weitere Informationen zum Erstellen von App Bundles mit bundletool findest du unter App Bundle mit Bundletool erstellen.

APKs aus deinem App Bundle generieren

Nachdem du dein Android App Bundle erstellt hast, solltest du testen, wie Google Play damit APKs generiert und wie sich diese APKs auf einem Gerät verhalten.

Es gibt zwei Möglichkeiten, Ihr App Bundle zu testen:

Verwenden Sie das bundletool-Befehlszeilentool lokal.
Lade dein Bundle über Google Play in die Play Console hoch. Verwende dazu einen Test-Track.

In diesem Abschnitt wird erläutert, wie du dein App Bundle mit bundletool lokal testen kannst.

Wenn bundletool APKs aus Ihrem App-Bundle generiert, werden die generierten APKs in einem Container namens APK Set Archive abgelegt, der die Dateierweiterung .apks verwendet. Verwenden Sie den Befehl bundletool build-apks wie hier gezeigt, um ein APK aus Ihrem App Bundle für alle Gerätekonfigurationen zu generieren, die Ihre App unterstützt:

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

Wenn Sie die APKs auf einem Gerät bereitstellen möchten, müssen Sie auch die Signaturinformationen Ihrer App angeben, wie im folgenden Befehl gezeigt. Wenn Sie keine Signaturinformationen angeben, versucht bundletool, Ihre APKs mit einem Schlüssel zur Fehlerbehebung zu signieren.

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

In der folgenden Tabelle werden die verschiedenen Flags und Optionen genauer beschrieben, die Sie mit dem Befehl bundletool build-apks festlegen können:

Tabelle 1 Optionen für den Befehl bundletool build-apks

Melden	Beschreibung
`--bundle=path`	(Erforderlich) Gibt den Pfad zum App Bundle an, das Sie mit Android Studio erstellt haben. Weitere Informationen finden Sie unter Projekt erstellen.
`--output=path`	(Erforderlich) Gibt den Namen der `.apks`-Ausgabedatei an, die alle APK-Artefakte für Ihre App enthält. Um die Artefakte in dieser Datei auf einem Gerät zu testen, folgen Sie den Schritten im Abschnitt zum Bereitstellen von APKs auf einem verbundenen Gerät.
`--overwrite`	Überschreibt alle vorhandenen Ausgabedateien mit dem Pfad, den Sie mit der Option `--output` angeben. Wenn Sie dieses Flag nicht angeben und die Ausgabedatei bereits vorhanden ist, wird ein Build-Fehler angezeigt.
`--aapt2=path`	Gibt einen benutzerdefinierten Pfad zu AAPT2 an. Standardmäßig enthält `bundletool` eine eigene Version von AAPT2.
`--ks=path`	(Optional) Gibt den Pfad zum Schlüsselspeicher für die Bereitstellung an, der zum Signieren der APKs verwendet wurde. Wenn Sie dieses Flag nicht angeben, versucht `bundletool`, Ihre APKs mit einem Signaturschlüssel zur Fehlerbehebung zu signieren.
`--ks-pass=pass:password` oder `--ks-pass=file:/path/to/file`	Gibt Ihr Schlüsselspeicherpasswort an. Wenn Sie ein Passwort im Nur-Text-Format angeben, qualifizieren Sie es mit `pass:`. Wenn Sie den Pfad zu einer Datei mit dem Passwort übergeben, qualifizieren Sie sie mit `file:`. Wenn Sie einen Schlüsselspeicher mit dem Flag `--ks` angeben, ohne `--ks-pass` anzugeben, fordert `bundletool` Sie in der Befehlszeile auf, ein Passwort einzugeben.
`--ks-key-alias=alias`	Gibt den Alias des Signaturschlüssels an, den Sie verwenden möchten.
`--key-pass=pass:password` oder `--key-pass=file:/path/to/file`	Gibt das Passwort für den Signaturschlüssel an. Wenn Sie ein Passwort im Nur-Text-Format angeben, qualifizieren Sie es mit `pass:`. Wenn Sie den Pfad zu einer Datei mit dem Passwort übergeben, qualifizieren Sie sie mit `file:`. Wenn dieses Passwort mit dem Passwort für den Schlüsselspeicher selbst identisch ist, können Sie dieses Flag weglassen.
`--connected-device`	Weist `bundletool` an, APKs zu erstellen, die auf die Konfiguration eines verbundenen Geräts ausgerichtet sind. Wenn du dieses Flag nicht angibst, generiert `bundletool` APKs für alle Gerätekonfigurationen, die deine App unterstützt.
`--device-id=serial-number`	Wenn Sie mehr als ein verbundenes Gerät haben, geben Sie mit diesem Flag die Seriennummer des Geräts an, auf dem Sie Ihre App bereitstellen möchten.
`--device-spec=spec_json`	Gibt einen Pfad zu einer `.json`-Datei an, die die Gerätekonfiguration angibt, die Sie als Ziel verwenden möchten. Weitere Informationen finden Sie im Abschnitt zum Generieren und Verwenden von JSON-Dateien mit Gerätespezifikationen.
`--mode=universal`	Legt den Modus auf `universal` fest. Verwende diese Option, wenn `bundletool` ein einzelnes APK erstellen soll, das den gesamten Code und die Ressourcen deiner App enthält, sodass das APK mit allen Gerätekonfigurationen kompatibel ist, die von deiner App unterstützt werden. Hinweis:`bundletool` enthält nur Funktionsmodule, die `<dist:fusing dist:include="true"/>` in ihrem Manifest in einem universellen APK angeben. Weitere Informationen finden Sie unter Manifest für Featuremodule. Hinweis: Diese APKs sind größer als die, die für eine bestimmte Gerätekonfiguration optimiert sind. Es ist jedoch einfacher, sie für interne Tester freizugeben, die beispielsweise deine App in mehreren Gerätekonfigurationen testen möchten.
`--local-testing`	Aktiviert Ihr App Bundle für lokale Tests. Lokale Tests ermöglichen schnelle, iterative Testzyklen, ohne dass sie auf Google Play-Server hochgeladen werden müssen. Ein Beispiel zum Testen der Modulinstallation mit dem Flag `--local-testing` finden Sie unter Modulinstallationen lokal testen.

APKs auf einem verbundenen Gerät bereitstellen

Nachdem du einen Satz APKs generiert hast, kann bundletool die richtige Kombination von APKs aus diesem Satz auf einem verbundenen Gerät bereitstellen.

Wenn du beispielsweise ein verbundenes Gerät mit Android 5.0 (API-Level 21) oder höher hast, überträgt bundletool das Basis-APK, die Featuremodul-APKs und die Konfigurations-APKs, die zum Ausführen deiner App auf diesem Gerät erforderlich sind. Wenn auf deinem verbundenen Gerät Android 4.4 (API-Level 20) oder niedriger ausgeführt wird, sucht bundletool alternativ nach einem kompatiblen Multi-APK, um es auf deinem Gerät bereitzustellen.

Verwenden Sie zum Bereitstellen Ihrer App aus einem APK-Satz den Befehl install-apks und geben Sie den Pfad des APK-Satzes mit dem Flag --apks=/path/to/apks an, wie im folgenden Befehl gezeigt. Wenn mehrere Geräte verbunden sind, geben Sie ein Zielgerät an, indem Sie das Flag --device-id=serial-id hinzufügen.

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

Gerätespezifische APKs generieren

Wenn Sie nicht für alle Gerätekonfigurationen, die Ihre App unterstützt, einen Satz APKs erstellen möchten, können Sie APKs erstellen, die nur auf die Konfiguration eines verbundenen Geräts abzielen. Verwenden Sie dazu die Option --connected-device, wie im folgenden Befehl gezeigt. Wenn mehrere Geräte verbunden sind, geben Sie mit dem Flag --device-id=serial-id ein Zielgerät an.

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

JSON-Dateien für Gerätespezifikationen generieren und verwenden

bundletool kann einen APK-Satz generieren, der auf eine durch eine JSON-Datei angegebene Gerätekonfiguration ausgerichtet ist. Führen Sie den folgenden Befehl aus, um zuerst eine JSON-Datei für ein verbundenes Gerät zu generieren:

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

bundletool erstellt im Verzeichnis des Tools eine JSON-Datei für dein Gerät. Anschließend kannst du die Datei an bundletool übergeben, um eine Reihe von APKs zu generieren, die nur auf die in dieser JSON-Datei beschriebene Konfiguration ausgerichtet sind:

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

JSON für Gerätespezifikation manuell erstellen

Wenn Sie keinen Zugriff auf das Gerät haben, für das Sie einen Ziel-APK-Satz erstellen möchten, z. B. wenn Sie Ihre App auf einem Gerät testen möchten, das Sie nicht zur Hand haben, können Sie manuell eine JSON-Datei im folgenden Format erstellen:

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

Sie können diese JSON-Datei dann wie im vorherigen Abschnitt beschrieben an den Befehl bundle extract-apks übergeben.

Gerätespezifische APKs aus einem vorhandenen APK-Set extrahieren

Wenn Sie ein bestehendes APK-Set haben und eine Teilmenge von APKs extrahieren möchten, die auf eine bestimmte Gerätekonfiguration ausgerichtet sind, können Sie den Befehl extract-apks verwenden und so eine Gerätespezifikations-JSON-Datei angeben:

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

Geschätzte Downloadgrößen von APKs in einer APK-Gruppe messen

Mit dem Befehl get-size total kannst du die geschätzten Downloadgrößen von APKs in einem APK-Set messen, wie sie über die Übertragung komprimiert bereitgestellt werden:

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

Mit den folgenden Flags können Sie das Verhalten des Befehls get-size total ändern:

Tabelle 2 Optionen für den Befehl get-size total

Melden	Beschreibung
`--apks=path`	(Erforderlich) Gibt den Pfad zur vorhandenen APK-Set-Datei an, deren Downloadgröße gemessen wird.
`--device-spec=path`	Gibt den Pfad zur Gerätespezifikationsdatei an (aus `get-device-spec` oder manuell erstellt), die für den Abgleich verwendet werden soll. Sie können einen Teilpfad angeben, um eine Reihe von Konfigurationen auszuwerten.
`--dimensions=dimensions`	Gibt die Abmessungen an, die bei der Berechnung der Größenschätzungen verwendet werden. Akzeptiert eine durch Kommas getrennte Liste von `SDK`, `ABI`, `SCREEN_DENSITY` und `LANGUAGE`. Wenn eine Messung über alle Dimensionen erfolgen soll, geben Sie `ALL` an.
`--instant`	Misst die Downloadgröße der APKs mit Instant-Version anstelle der installierbaren APKs. Standardmäßig misst `bundletool` die Downloadgröße des installierbaren APK.
`--modules=modules`	Gibt eine durch Kommas getrennte Liste von Modulen im APK an, die bei der Messung berücksichtigt werden sollen. Der Befehl `bundletool` schließt automatisch alle abhängigen Module für den angegebenen Satz ein. Standardmäßig misst der Befehl die Downloadgröße aller Module, die beim ersten Download installiert wurden.

App Bundle mit einer SDK-Bundle-Abhängigkeit erstellen (experimentell)

Sie können Ihr Android App Bundle mit einer ASB-Abhängigkeit (Android SDK Bundle) über die Befehlszeile erstellen und mit jarsigner signieren.

Jedes App-Bundle-Modul enthält eine Modulprotokollzwischenspeicher-Datei (.pb): runtime_enabled_sdk_config.pb. Diese Datei enthält die Liste der SDKs, von denen ein App Bundle-Modul abhängt. Die vollständige Definition dieser Datei finden Sie in der Datei runtime_enabled_sdk_config.proto.

Wenn Sie ein App Bundle mit einer SDK-Bundle-Abhängigkeit erstellen möchten, folgen Sie der Anleitung im Abschnitt App Bundle mit Bundletool erstellen und fügen Sie der ZIP-Datei jedes App-Moduls eine runtime_enabled_sdk_config.pb-Datei mit kompiliertem Code und Ressourcen hinzu.

Einige wichtige Felder in der Datei runtime_enabled_sdk_config.pb:

Zertifikat-Digest: Der SHA-256-Digest des Zertifikats für den Schlüssel, mit dem die APKs des SDK signiert werden. Es entspricht dem Zertifikat in der Datei SdkMetadata.pb im Android SDK Archive-Format.
Ressourcenpaket-ID:Die Paket-ID, der alle Ressourcen in diesem SDK neu zugeordnet werden, wenn APKs zum Einbetten des SDK in die App generiert werden. Dies ermöglicht die Abwärtskompatibilität.

Ein SDK kann nur in einem Modul verwendet werden. Wenn mehrere Module vom selben SDK abhängen, sollte diese Abhängigkeit dedupliziert und in das Basismodul verschoben werden. Verschiedene Module können nicht von verschiedenen SDK-Versionen abhängig sein.

APKs aus einem App-Bundle mit einer SDK-Bundle-Abhängigkeit generieren (experimentell)

Wenn Sie APKs aus Ihrem App Bundle generieren möchten, folgen Sie den Schritten im Abschnitt zum Generieren einer Gruppe von APKs aus Ihrem App Bundle oder zum Generieren eines gerätespezifischen Satzes von APKs und geben Sie den Befehl bundletool build-apks für die SDKs an, von denen die App abhängt. Diese SDKs können im SDK-Bundle-Format oder im SDK Archive-Format bereitgestellt werden.

Sie können die SDKs als SDK-Bundles bereitstellen. Fügen Sie dazu das Flag --sdk-bundles hinzu:

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

Sie können die SDKs als SDK-Archive bereitstellen, indem Sie das Flag --sdk-archives hinzufügen:

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

APKs aus einem App-Bundle mit einer SDK-Bundle-Abhängigkeit für Geräte ohne Unterstützung der SDK-Bibliothek generieren

Auf Geräten vor Android 13 können SDK-Bibliotheken nicht installiert oder in der SDK-Laufzeit ausgeführt werden. Bundletool blendet die Komplexität der Abwärtskompatibilität aus und generiert mehrere Varianten deines APK aus demselben App-Bundle, wenn du bundletool build-apks mit der Option --sdk-bundles oder --sdk-archives ausführst. Die verschiedenen Varianten sind auf Geräte mit unterschiedlichen Funktionen ausgerichtet:

Es gibt eine Variante für neuere Geräte, bei der das SDK als separates Paket von der App installiert wird und die App-APKs keine SDK-Inhalte enthalten.
Es gibt eine oder mehrere Varianten für ältere Geräte, bei denen die SDK-APKs dem App-APK hinzugefügt werden, das als zusätzliche APK-Unterteilungen festgelegt ist. Die SDK-APKs gehören zum App-Paket. In diesem Fall wird die SDK-Laufzeit in der App-Laufzeit auf dem Gerät emuliert.

Ähnlich wie bei der Erstellung von APKs für App-Bundles ohne SDK-Abhängigkeiten geben bundletool extract-apks und bundletool install-apks einen gefilterten Satz von APKs aus der besten Variante für das verbundene Gerät oder für die angegebene Gerätekonfiguration zurück.

Verwende für erweiterte Anwendungsfälle, in denen du nur APK-Splits aus einem SDK-Archiv für eine bestimmte App für ältere Geräte generieren möchtest, den Befehl bundletool build-sdk-apks-for-app so:

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

Die Datei app-properties sollte die in der Datei runtime_enabled_sdk_config.proto beschriebenen Felder enthalten. So sieht die Datei app-properties aus:

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

Der Befehl bundletool build-sdk-apks-for-app generiert die Teilmenge der App-APKs, die dem SDK-Inhalt unter dem App-Paketnamen entsprechen. Du kannst diese APKs mit anderen APKs mit den App-Inhalten kombinieren. Das ist beispielsweise der Fall, wenn Sie sie separat und inkrementell erstellen und zusammen auf einem Gerät installiert haben, das die SDK-Laufzeit nicht unterstützt.

SDK-Bundle erstellen und testen (experimentell)

Sie können bundletool verwenden, um ein ASB zu erstellen und die für die Installation und Verteilung erforderlichen Dateien zu testen.

SDK-Bundle erstellen

Sie können Ihren ASB über die Befehlszeile erstellen und mit jarsigner signieren.

So erstellen Sie ein SDK-Bundle:

Generieren Sie das Manifest und die Ressourcen des SDK-Bundles im .proto-Format. Führen Sie dazu die gleichen Schritte wie für ein App-Bundle aus.
Verpacken Sie den kompilierten Code Ihres SDK und die Ressourcen wie bei einem App-Modul in einer Basis-ZIP-Datei.
Generiere eine SdkModulesConfig.pb.json-Datei und eine SdkBundleConfig.pb.json-Datei in dem Format, das in der Android SDK-Bundle-Spezifikation beschrieben wird.
Erstellen Sie Ihr ASB so mit dem Befehl bundletool build-sdk-bundle:

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

In der folgenden Tabelle werden die verschiedenen Flags und Optionen, die Sie mit dem Befehl bundletool build-sdk-bundle festlegen können, ausführlicher beschrieben.

Tabelle 3 Optionen für den Befehl bundletool build-sdk-bundle

Melden	Beschreibung
`--modules`	(Erforderlich) Die Moduldatei, aus der Sie das endgültige ASB erstellen möchten.
`--output`	(Erforderlich) Der Pfad, zu dem das ASB erstellt werden soll.
`--sdk-modules-config`	(Erforderlich) Der Pfad zu einer JSON-Datei, in der die Konfiguration der SDK-Module beschrieben wird. Informationen zum Formatieren der JSON-Datei findest du im Abschnitt Android SDK-Bundle-Spezifikation.
`--sdk-bundle-config`	Der Pfad zu einer JSON-Datei, in der die Konfiguration des SDK-Bundles beschrieben wird. Informationen zum Formatieren der JSON-Datei findest du im Abschnitt Android SDK-Bundle-Spezifikation.
`--metadata-file`	Die Datei, in die Metadaten für das ASB aufgenommen werden sollen. Das Format des Flag-Werts ist `<bundle-path>:<physical-file>`, wobei `<bundle-path>` den Dateispeicherort im Metadatenverzeichnis des SDK-Bundles angibt und `<physical-file>` eine vorhandene Datei mit den zu speichernden Rohdaten ist. Das Flag kann wiederholt werden.
`--overwrite`	Wenn diese Option festgelegt ist, werden alle vorherigen vorhandenen Ausgaben überschrieben.

APKs aus einem SDK-Bundle generieren

Nachdem Sie Ihr ASB erstellt haben, können Sie ein SDK-Bundle lokal testen. Generieren Sie dazu die APKs mit dem Befehl bundletool build-sdk-apks, wie im folgenden Code gezeigt:

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

Wenn bundletool APKs aus deinem SDK-Bundle generiert, schließt das Tool die APKs in einen Container namens APK Set Archive ein, der die Dateierweiterung .apks verwendet. bundletool generiert aus dem SDK-Bundle ein eigenständiges APK, das auf alle Gerätekonfigurationen ausgerichtet ist.

Wenn Sie das ASB auf einem Gerät bereitstellen möchten, müssen Sie auch die Signaturinformationen Ihrer App angeben, wie im folgenden Befehl gezeigt:

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

In der folgenden Tabelle werden die verschiedenen Flags und Optionen, die Sie mit dem Befehl bundletool build-sdk-apks festlegen können, ausführlicher beschrieben.

Tabelle 4 Optionen für den Befehl bundletool build-sdk-apks

Melden	Beschreibung
`--sdk-bundle`	(Erforderlich) Der Pfad zum SDK-Bundle. Muss die Erweiterung `.asb` haben.
`--output`	(Erforderlich) Der Pfad, unter dem das APK-Set-Archiv erstellt werden soll. Wenn Sie `--output-format=DIRECTORY` verwenden, ist dies der Pfad zu dem Verzeichnis, in dem die generierten APKs gespeichert werden sollen.
`--ks`	Der Pfad zum Schlüsselspeicher, den Sie zum Signieren der generierten APKs verwenden möchten.
`--ks-key-alias`	Der Alias des Schlüssels, der im Schlüsselspeicher zum Signieren der generierten APKs verwendet werden soll.
`--key-pass`	Das Passwort des Schlüssels im Schlüsselspeicher, der zum Signieren der generierten APKs verwendet werden soll. Wenn Sie das Passwort im Klartext übergeben, müssen Sie dem Wert das Präfix `pass:` voranstellen. z. B. `pass:qwerty`. Wenn sich das Passwort in der ersten Zeile einer Datei befindet, müssen Sie dem Wert das Präfix `file:` voranstellen. Beispiel: `file:/tmp/myPassword.txt`. Wenn dieses Flag nicht festgelegt ist, wird versucht, das Schlüsselspeicherpasswort einzugeben. Wenn dies fehlschlägt, werden Sie vom Befehlszeilenterminal zur Eingabe eines Passworts aufgefordert.
`--ks-pass`	Das Passwort des Schlüsselspeichers, mit dem die generierten APKs signiert werden. Wenn Sie das Passwort im Klartext übergeben, müssen Sie dem Wert das Präfix `pass:` voranstellen. z. B. `pass:qwerty`. Wenn sich das Passwort in der ersten Zeile einer Datei befindet, müssen Sie dem Wert das Präfix `file:` voranstellen. Beispiel: `file:/tmp/myPassword.txt`. Wenn dieses Flag nicht festgelegt ist, werden Sie vom Befehlszeilenterminal zur Eingabe eines Passworts aufgefordert.
`--aapt2`	Der Pfad zur zu verwendenden AAPT2-Binärdatei.
`--output-format`	Das Ausgabeformat für generierte APKs. Standardmäßig ist diese Option auf `APK_SET` gesetzt, wodurch APKs an das erstellte APK-Set-Archiv ausgegeben werden. Wenn `DIRECTORY` festgelegt ist, werden APKs in das durch `--output` angegebene Verzeichnis ausgegeben.
`--verbose`	Wenn diese Option festgelegt ist, werden zusätzliche Informationen zur Befehlsausführung in der Standardausgabe ausgegeben.
`--version-code`	Der SDK-Versionscode. Dies ist der Versionscode, der von der Android-Plattform zur Installation des APKs verwendet wird, nicht die SDK-Version. Diese Option kann auf einen beliebigen Wert festgelegt werden. Wenn nichts festgelegt ist, wird standardmäßig 0 verwendet.
`--overwrite`	Wenn diese Option festgelegt ist, werden alle vorherigen vorhandenen Ausgaben überschrieben.

SDK-APKs bereitstellen, extrahieren und ihre Größe messen

Sie können dieselben Schritte wie für Apps ausführen, um APKs auf einem verbundenen Gerät bereitzustellen, gerätespezifische APKs aus einem vorhandenen APK-Set zu extrahieren und die geschätzten Downloadgrößen von APKs in einem APK-Satz zu messen.

SDK-Archiv aus einem SDK-Bundle generieren

Nachdem Sie Ihr ASB in Ihren Vertriebskanal (z. B. Google Play) hochgeladen haben, wird das ASB in ein Android SDK-Archiv (.asar) umgewandelt, das dann über Maven an App-Entwickler verteilt werden kann. Weitere Informationen zum Format finden Sie im Abschnitt zur SDK Archive-Formatspezifikation.

Nachdem Sie das ASB erstellt haben, können Sie die Generierung eines Android SDK-Archivs lokal mit dem Befehl bundletool build-sdk-asar testen, wie im folgenden Code gezeigt:

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

In der folgenden Tabelle werden die verschiedenen Flags und Optionen, die Sie mit dem Befehl bundletool build-sdk-asar festlegen können, ausführlicher beschrieben.

Tabelle 5 Optionen für den Befehl bundletool build-sdk-asar

Melden	Beschreibung
`--apk-signing-key-certificate`	(Erforderlich) Der Pfad zum SDK-APK-Signaturzertifikat. Dies ist das Zertifikat für den Schlüssel, mit dem Sie die APKs im Befehl `build-sdk-apks` signiert haben.
`--output`	(Erforderlich) Der Pfad, unter dem die Datei `.asar` erstellt werden soll.
`--sdk-bundle`	(Erforderlich) Der Pfad zum SDK-Bundle. Muss die Erweiterung `.asb` haben.
`--overwrite`	Wenn diese Option festgelegt ist, werden alle vorherigen vorhandenen Ausgaben überschrieben.

Laufzeitfähige SDK-Formate (experimentell)

Mit laufzeitfähigen SDKs werden zwei Android-Dateiformate eingeführt:

Das Android SDK Bundle (.asb), mit dem das laufzeitfähige SDK in App-Shops veröffentlicht wird
Das Android SDK Archive (.asar), mit dem das laufzeitfähige SDK auf Maven verteilt wird.

Das Android SDK-Bundle-Format

Ein SDK-Bundle ist ein Veröffentlichungsformat für laufzeitfähige SDKs. Es enthält den gesamten SDK-Code und die Ressourcen, einschließlich des Codes aller Bibliotheken, von denen das SDK abhängt. Der Code und die Ressourcen anderer laufzeitfähiger SDKs, von denen das SDK abhängt, sind nicht enthalten.

Ein Android SDK Bundle (ASB) ist eine signierte ZIP-Datei mit der Erweiterung .asb. Der SDK-Code und die Ressourcen sind darin ähnlich organisiert wie in einem APK. Ein ASB enthält auch mehrere Konfigurationsdateien zum Generieren der installierbaren APKs.

**Abbildung 1**: Der Inhalt eines Android SDK-Bundles.

In der folgenden Liste werden einige ASB-Dateien ausführlicher beschrieben:

SdkBundleConfig.pb: Eine Konfigurationsdatei im .proto-Format, die die Liste der laufzeitfähigen SDKs enthält, von denen Ihr SDK abhängt. Die vollständige Definition finden Sie in der Datei sdk_bundle_config.proto.
modules.resm: Eine ZIP-Datei mit allen Daten, die zum Generieren der APKs aus dem SDK erforderlich sind.
SdkModulesConfig.pb: Eine Konfigurationsdatei im .proto-Format. Diese Datei enthält den SDK-Namen, die Version und den Klassennamen des SDK-Einstiegspunkt für das Framework (SandboxedSdkProvider). Die vollständige Definition finden Sie in der Datei sdk_modules_config.proto.
base/: Das einzelne Modul, das den SDK-Code und die Ressourcen enthält.
- manifest/: Manifest des SDK im .proto-Format.
- dex/: Der kompilierte Code im DEX-Format. Es können mehrere DEX-Dateien bereitgestellt werden.
- res/, lib/, assets/: Diese Verzeichnisse sind mit denen in einem typischen APK identisch. Die Pfade in diesen Verzeichnissen bleiben beim Generieren der APKs des SDK erhalten.
- root/: In diesem Verzeichnis werden Dateien gespeichert, die später in das Stammverzeichnis der SDK-APKs verschoben werden. Es kann beispielsweise Java-basierte Ressourcen enthalten, die Ihr SDK mit der Methode Class.getResource() lädt. Die Pfade in diesem Verzeichnis werden ebenfalls beibehalten.
BUNDLE-METADATA: Dieses Verzeichnis enthält Metadatendateien mit Informationen, die für Tools oder Anwendungsspeicher nützlich sind. Solche Metadatendateien können ProGuard-Zuordnungen und die vollständige Liste der DEX-Dateien Ihres SDKs enthalten. Dateien in diesem Verzeichnis sind nicht in die APKs deines SDKs gepackt.

Das Format „Android SDK Archive“

Ein Android SDK Archive ist das Distributionsformat eines laufzeitfähigen SDKs auf Maven. Es handelt sich um eine ZIP-Datei mit der Dateiendung .asar. Die Datei enthält alle Informationen, die von den App-Build-Tools benötigt werden, um ein Android App Bundle zu generieren, das von Ihrem laufzeitfähigen SDK abhängt.

**Abbildung 2**: Der Inhalt eines Android SDK Archive Bundles.

In der folgenden Liste werden einige der Android SDK-Archivdateien ausführlicher beschrieben:

SdkMetadata.pb: Eine Konfigurationsdatei im .proto-Format, die den SDK-Namen, die Version und den Zertifikat-Digest für den Schlüssel enthält, der zum Signieren der für dieses SDK generierten APKs verwendet wird. Die vollständige Definition finden Sie in der Datei sdk_metadata.proto.
modules.resm: Eine ZIP-Datei mit allen Daten, die zum Generieren der APKs aus dem SDK erforderlich sind. Dies entspricht der Datei .resm im Android SDK-Bundle.
AndroidManifest.xml: Manifestdatei des SDK im Text-XML-Format.

Weitere Informationen

Weitere Informationen zur Verwendung von bundletool findest du in diesem Video: App Bundles: Bundles mit Bundletool und Play Console testen.