Mit dem Gradle-Wrapper-Befehlszeilentool können Sie alle für Ihr Android-Projekt verfügbaren Build-Aufgaben ausführen. Sie ist als Batchdatei für Windows (gradlew.bat
) und als Shell-Skript für Linux und Mac (gradlew.sh
) verfügbar und kann vom Stammverzeichnis jedes mit Android Studio erstellten Projekts aus aufgerufen werden.
Um eine Aufgabe mit dem Wrapper auszuführen, verwenden Sie einen der folgenden Befehle in einem Terminal-Fenster. Wählen Sie in Android Studio Ansicht > Toolfenster > Terminal aus:
- Unter Windows:
gradlew task-name
- Mac oder Linux:
./gradlew task-name
Führen Sie tasks
aus, um eine Liste aller für Ihr Projekt verfügbaren Build-Aufgaben aufzurufen:
gradlew tasks
Auf dieser Seite werden die Grundlagen zum Erstellen und Ausführen Ihrer Anwendung mit dem Gradle-Wrapper beschrieben. Weitere Informationen zum Einrichten deines Android-Builds findest du unter Build konfigurieren.
Wenn Sie lieber die Android Studio-Tools anstelle der Befehlszeilentools verwenden möchten, lesen Sie App erstellen und ausführen.
Build-Typen
Standardmäßig sind zwei Build-Typen für jede Android-App verfügbar: einer für das Debugging Ihrer App – der Debug-Build – und der Release-Build für die Freigabe Ihrer App für Nutzer. Die Ausgabe jedes Builds muss mit einem Zertifikat signiert werden, bevor Sie die Anwendung auf einem Gerät bereitstellen können. Der Debug-Build wird automatisch mit einem von den SDK-Tools bereitgestellten Fehlerbehebungsschlüssel signiert. Er ist nicht sicher und kann nicht mit dem Build im Google Play Store veröffentlicht werden. Außerdem muss der Release-Build mit Ihrem eigenen privaten Schlüssel signiert sein.
Wenn Sie Ihre App für die Veröffentlichung erstellen möchten, ist es wichtig, dass Sie auch Ihre App mit dem entsprechenden Signaturschlüssel signieren. Wenn Sie jedoch gerade erst anfangen, können Sie Ihre Apps schnell auf einem Emulator oder einem verbundenen Gerät ausführen, indem Sie ein Debug-APK erstellen.
Sie können auch einen benutzerdefinierten Build-Typ in der Datei build.gradle.kts
definieren und ihn so konfigurieren, dass er als Debug-Build signiert wird, indem Sie debuggable true
einschließen. Weitere Informationen finden Sie unter Build-Varianten konfigurieren.
APK erstellen und bereitstellen
Obwohl das Erstellen eines App-Bundles die beste Möglichkeit ist, ein Paket für Ihre App zu erstellen und in die Play Console hochzuladen, eignet sich das Erstellen eines APKs besser, wenn Sie einen Debug-Build schnell testen oder Ihre App als bereitstellbares Artefakt mit anderen teilen möchten.
Debug-APK erstellen
Damit Sie Ihre Apps sofort testen und debuggen können, können Sie ein Debug-APK erstellen.
Das Debug-APK ist mit einem von den SDK-Tools bereitgestellten Schlüssel zur Fehlerbehebung signiert und ermöglicht das Debugging über adb
.
Öffnen Sie zum Erstellen eines Debug-APKs eine Befehlszeile und gehen Sie zum Stammverzeichnis Ihres Projektverzeichnisses. Um einen Debug-Build zu initiieren, rufen Sie die Aufgabe assembleDebug
auf:
gradlew assembleDebug
Dadurch wird in project_name/module_name/build/outputs/apk/
ein APK mit dem Namen module_name-debug.apk
erstellt.
Die Datei ist bereits mit dem Fehlerbehebungsschlüssel signiert und auf zipalign
ausgerichtet, sodass Sie sie sofort auf einem Gerät installieren können.
Wenn du das APK erstellen und sofort auf einem laufenden Emulator oder einem verbundenen Gerät installieren möchtest, rufe stattdessen installDebug
auf:
gradlew installDebug
Der Teil "Debug" in den obigen Aufgabennamen ist nur eine Kamel-Case-Version des Namens der Build-Variante. Sie kann also durch einen Build-Typ oder eine Build-Variante ersetzt werden, den Sie zusammenstellen oder installieren möchten. Wenn Sie beispielsweise eine „Demo“-Produktvariante haben, können Sie die Debug-Version mit der Aufgabe assembleDemoDebug
erstellen.
Führen Sie die Aufgabe tasks
aus, um alle für jede Variante verfügbaren Build- und Installationsaufgaben (einschließlich Deinstallationsaufgaben) zu sehen.
Lesen Sie auch den Abschnitt zum Ausführen Ihrer App im Emulator und zum Ausführen Ihrer App auf einem Gerät.
Release-Bundle oder APK erstellen
Wenn du bereit bist, deine App zu veröffentlichen und zu vertreiben, musst du ein Release-Bundle oder APK erstellen, das mit deinem privaten Schlüssel signiert ist. Weitere Informationen finden Sie im Abschnitt zum Signieren Ihrer Anwendung über die Befehlszeile.
Anwendung im Emulator bereitstellen
Wenn Sie den Android-Emulator verwenden möchten, müssen Sie mit Android Studio ein virtuelles Android-Gerät (AVD) erstellen.
Sobald Sie ein AVD haben, starten Sie den Android-Emulator und installieren Sie Ihre App so:
Rufen Sie in einer Befehlszeile
android_sdk/tools/
auf und starten Sie den Emulator, indem Sie Ihr AVD angeben:emulator -avd avd_name
Wenn Sie den AVD-Namen nicht kennen, führen Sie
emulator -list-avds
aus.- Jetzt können Sie die App mit einer der Gradle-Installationsaufgaben, die im Abschnitt zum Erstellen eines Debug-APKs beschrieben sind, oder mit dem
adb
-Tool installieren.Wenn das APK mit einem Entwicklervorschau-SDK erstellt wurde (wenn
targetSdkVersion
ein Buchstabe statt einer Zahl ist), musst du zum Installieren eines Test-APKs die Option-t
mit dem Befehlinstall
angeben.adb install path/to/your_app.apk
Alle APKs, die du erstellst, werden in
project_name/module_name/build/outputs/apk/
gespeichert.
Weitere Informationen finden Sie unter Apps im Android-Emulator ausführen.
App auf einem physischen Gerät bereitstellen
Bevor Sie die App auf einem Gerät ausführen können, müssen Sie das USB-Debugging auf dem Gerät aktivieren. Sie finden die Option unter Einstellungen > Entwickleroptionen.
Hinweis: Unter Android 4.2 und höher sind Entwickleroptionen standardmäßig ausgeblendet. Rufen Sie dazu Einstellungen > Über das Telefon auf und tippen Sie siebenmal auf Build-Nummer. Kehren Sie zum vorherigen Bildschirm zurück, um Entwickleroptionen zu sehen.
Sobald das Gerät eingerichtet und über USB verbunden ist, kannst du deine App entweder mit den Gradle-Installationsaufgaben, die im Abschnitt zum Erstellen eines Debug-APKs beschrieben sind, oder mit dem adb
-Tool installieren:
adb -d install path/to/your_app.apk
Alle APKs, die du erstellst, werden in project_name/module_name/build/outputs/apk/
gespeichert.
Weitere Informationen finden Sie unter Apps auf einem Hardwaregerät ausführen.
App Bundle erstellen
Android App Bundles enthalten den gesamten kompilierten Code und die Ressourcen deiner App. Du kannst jedoch die APK-Generierung und die Signatur bei Google Play verschieben. Im Gegensatz zu einem APK können Sie ein App Bundle nicht direkt auf einem Gerät bereitstellen. Wenn Sie also ein APK schnell testen oder für andere Personen freigeben möchten, sollten Sie stattdessen ein APK erstellen.
Am einfachsten lässt sich ein App-Bundle mit Android Studio erstellen. Wenn Sie jedoch ein App-Bundle über die Befehlszeile erstellen müssen, können Sie entweder Gradle oder bundletool
verwenden, wie in den folgenden Abschnitten beschrieben.
App-Bundle mit Gradle erstellen
Wenn Sie ein App-Bundle über die Befehlszeile generieren möchten, führen Sie die Gradle-Task bundleVariant
im Basismodul Ihrer App aus.
Mit dem folgenden Befehl wird beispielsweise ein App-Bundle für die Debug-Version des Basismoduls erstellt:
./gradlew :base:bundleDebug
Wenn Sie ein signiertes Bundle für den Upload in die Play Console erstellen möchten, müssen Sie zuerst die Datei build.gradle.kts
des Basismoduls mit den Signaturinformationen Ihrer App konfigurieren. Weitere Informationen finden Sie im Abschnitt Gradle zum Signieren Ihrer App konfigurieren. Wenn Sie dann beispielsweise die Release-Version Ihrer App erstellen, generiert Gradle automatisch ein App Bundle und signiert es mit den Signaturinformationen, die Sie in der Datei build.gradle.kts
angegeben haben.
Wenn Sie ein App-Bundle stattdessen als separaten Schritt signieren möchten, können Sie es mit jarsigner
über die Befehlszeile signieren. Der Befehl zum Erstellen eines App Bundles lautet:
jarsigner -keystore pathToKeystore app-release.aab keyAlias
App Bundle mit Bundletool erstellen
bundletool
ist ein Befehlszeilentool, mit dem Android Studio, das Android-Gradle-Plug-in und Google Play den kompilierten Code und die Ressourcen Ihrer App in App-Bundles konvertieren und aus diesen Bundles bereitstellbare APKs generieren.
Es ist zwar hilfreich, App Bundles mit bundletool
zu testen und lokal neu zu reproduzieren, wie Google Play APKs generiert, du musst bundletool
in der Regel aber nicht aufrufen, um das App Bundle selbst zu erstellen. Stattdessen solltest du Android Studio- oder Gradle-Aufgaben verwenden, wie in den vorherigen Abschnitten beschrieben.
Wenn Sie jedoch keine Android Studio- oder Gradle-Aufgaben zum Erstellen von Bundles verwenden möchten, z. B. wenn Sie eine benutzerdefinierte Build-Toolchain verwenden, können Sie bundletool
in der Befehlszeile verwenden, um ein App Bundle aus vorkompiliertem Code und Ressourcen zu erstellen. Falls noch nicht geschehen,
laden Sie bundletool
aus dem GitHub-Repository herunter.
In diesem Abschnitt wird beschrieben, wie du den kompilierten Code und die Ressourcen deiner App verpackst und wie du bundletool
über die Befehlszeile verwendest, um sie in ein Android App Bundle zu konvertieren.
Manifest und Ressourcen im .proto-Format generieren
bundletool
erfordert, dass bestimmte Informationen zu Ihrem App-Projekt, z. B. das Manifest und die Ressourcen der Anwendung, im Protokollzwischenspeicher-Format von Google vorliegen. Dieses Format wird auch als „protobuf“ bezeichnet und verwendet die Dateiendung *.pb
. Protobufs bieten einen sprachneutralen, plattformneutralen und erweiterbaren Mechanismus zur Serialisierung strukturierter Daten. Sie ähneln XML, aber kleiner, schneller und einfacher.
AAPT2 herunterladen
Sie können die Manifestdatei und die Ressourcentabelle Ihrer Anwendung im protobuf-Format mit der neuesten Version von AAPT2 aus dem Maven-Repository von Google generieren.
So laden Sie AAPT2 aus dem Maven-Repository von Google herunter:
- Rufen Sie im Repository-Index com.android.tools.build > aapt2 auf.
- Kopieren Sie den Namen der neuesten Version von AAPT2.
Fügen Sie den kopierten Versionsnamen in die folgende URL ein und geben Sie das Zielbetriebssystem an: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/aapt2-version/aapt2-aapt2-version-[windows | linux | osx].jar
Um beispielsweise Version 3.2.0-alpha18-4804415 für Windows herunterzuladen, verwenden Sie: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.4-018.jar-018-jar
Rufen Sie die URL in einem Browser auf. Der Download von AAPT2 sollte in Kürze beginnen.
Entpacken Sie die gerade heruntergeladene JAR-Datei.
App-Ressourcen kompilieren und verknüpfen
Verwenden Sie AAPT2, um die Ressourcen Ihrer App mit dem folgenden Befehl zu kompilieren:
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/
Während der Verknüpfungsphase, in der AAPT2 Ihre verschiedenen kompilierten Ressourcen in einem einzelnen APK verknüpft, weisen Sie AAPT2 an, das Manifest und die kompilierten Ressourcen Ihrer App in das protobuf-Format zu konvertieren. Dazu fügen Sie das Flag --proto-format
ein, wie unten gezeigt:
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
Anschließend können Sie Inhalte aus dem Ausgabe-APK extrahieren, z. B. AndroidManifest.xml
, resources.pb
und andere Ressourcendateien – jetzt im protobuf-Format. Sie benötigen diese Dateien, wenn Sie die Eingabe vorbereiten, die bundletool
zum Erstellen Ihres App-Bundles benötigt, wie im folgenden Abschnitt beschrieben.
Vorkompilierten Code und Ressourcen verpacken
Bevor Sie bundletool
zum Generieren eines Anwendungspakets für Ihre Anwendung verwenden, müssen Sie zuerst ZIP-Dateien bereitstellen, die jeweils den kompilierten Code und die Ressourcen für ein bestimmtes Anwendungsmodul enthalten. Inhalt und Organisation der ZIP-Datei jedes Moduls sind denen des Android App Bundle-Formats sehr ähnlich.
Sie sollten beispielsweise eine base.zip
-Datei für das Basismodul Ihrer Anwendung erstellen und ihren Inhalt so organisieren:
Datei oder Verzeichnis | Beschreibung |
---|---|
manifest/AndroidManifest.xml
|
Das Manifest des Moduls im protobuf-Format. |
dex/...
|
Ein Verzeichnis mit einer oder mehreren kompilierten DEX-Dateien Ihrer App. Diese Dateien sollten so benannt werden: classes.dex , classes2.dex , classes3.dex usw.
|
res/...
|
Enthält die Ressourcen des Moduls im protobuf-Format für alle Gerätekonfigurationen. Unterverzeichnisse und Dateien sollten ähnlich wie ein typisches APK organisiert sein. |
root/... , assets/... und lib/...
|
Diese Verzeichnisse sind mit den Verzeichnissen identisch, die im Abschnitt zum Android-App-Bundle-Format beschrieben werden. |
resources.pb
|
Die Ressourcentabelle Ihrer App im protobuf-Format. |
Nachdem Sie die ZIP-Datei für jedes Modul Ihrer Anwendung vorbereitet haben, können Sie sie wie im folgenden Abschnitt beschrieben an bundletool
übergeben, um Ihr App Bundle zu erstellen.
App Bundle mit Bundletool erstellen
Verwenden Sie zum Erstellen Ihres App-Bundles den Befehl bundletool build-bundle
, wie unten gezeigt:
bundletool build-bundle --modules=base.zip --output=mybundle.aab
In der folgenden Tabelle werden Flags für den Befehl build-bundle
ausführlicher beschrieben:
Melden | Beschreibung |
---|---|
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip
|
Gibt die Liste der Modul-ZIP-Dateien an, die bundletool zum Erstellen des App-Bundles verwenden soll.
|
--output=path-to-output.aab
|
Gibt den Pfad und den Dateinamen für die *.aab -Ausgabedatei an.
|
--config=path-to-BundleConfig.json
|
Gibt den Pfad zu einer optionalen Konfigurationsdatei an, mit der Sie den Build-Prozess anpassen können. Weitere Informationen finden Sie im Abschnitt zum Anpassen der nachgelagerten APK-Generierung. |
--metadata-file=target-bundle-path:local-file-path
|
Weist bundletool an, eine optionale Metadatendatei in Ihrem App-Bundle zu verpacken. Sie können diese Datei verwenden, um Daten wie ProGuard-Zuordnungen oder die vollständige Liste der DEX-Dateien Ihrer App einzubeziehen, die für andere Schritte in Ihrer Toolchain oder in einem App-Shop nützlich sein können.
target-bundle-path gibt einen Pfad relativ zum Stammverzeichnis des App Bundles an, in das die Metadatendatei gepackt werden soll, und local-file-path gibt den Pfad zur lokalen Metadatendatei selbst an. |
Nachgelagerte APK-Generierung anpassen
App Bundles enthalten eine BundleConfig.pb
-Datei mit Metadaten, die App-Shops wie Google Play benötigen, um APKs aus dem Bundle zu generieren.
Obwohl bundletool
diese Datei für Sie erstellt, können Sie einige Aspekte der Metadaten in einer BundleConfig.json
-Datei konfigurieren und an den bundletool build-bundle
-Befehl übergeben. bundletool
konvertiert diese Datei später und führt diese Datei mit der protobuf-Version zusammen, die in jedem App-Bundle enthalten ist.
Sie können beispielsweise festlegen, welche Kategorien von Konfigurations-APKs aktiviert oder deaktiviert werden sollen. Im folgenden Beispiel einer BundleConfig.json
-Datei werden Konfigurations-APKs deaktiviert, die jeweils auf eine andere Sprache ausgerichtet sind. Das heißt, Ressourcen für alle Sprachen sind in den jeweiligen Basis- oder Feature-APKs enthalten:
{
"optimizations": {
"splitsConfig": {
"splitDimension": [{
"value": "LANGUAGE",
"negate": true
}]
}
}
}
In der Datei BundleConfig.json
kannst du auch angeben, welche Dateitypen beim Packen von APKs mit
glob-Mustern unkomprimiert bleiben sollen:
{
"compression": {
"uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
}
}
Beachten Sie, dass bundletool
die nativen Bibliotheken Ihrer App (unter Android 6.0 oder höher) und die Ressourcentabelle (resources.arsc
) standardmäßig nicht komprimiert. Eine vollständige Beschreibung dessen, was Sie in BundleConfig.json
konfigurieren können, finden Sie in der Datei bundletool
config.proto
, die mit der Proto3-Syntax geschrieben wurde.
App aus einem App-Bundle bereitstellen
Wenn Sie ein App Bundle erstellt und signiert haben, verwenden Sie bundletool
, um APKs zu generieren und auf einem Gerät bereitzustellen.
App über die Befehlszeile signieren
Sie benötigen zum Signieren Ihrer App nicht Android Studio. Sie können Ihre App über die Befehlszeile signieren, mit apksigner
für APKs oder jarsigner
für App Bundles oder Gradle so konfigurieren, dass sie während des Builds für Sie signiert wird. In beiden Fällen müssen Sie zuerst einen privaten Schlüssel mit keytool
generieren, wie unten gezeigt:
keytool -genkey -v -keystore my-release-key.jks -keyalg RSA -keysize 2048 -validity 10000 -alias my-alias
Im obigen Beispiel werden Sie zur Eingabe von Passwörtern für den Schlüsselspeicher und den Schlüssel sowie für die Felder „Distinguished Name“ für Ihren Schlüssel aufgefordert. Anschließend wird der Schlüsselspeicher als Datei namens my-release-key.jks
generiert und im aktuellen Verzeichnis gespeichert. Sie können ihn beliebig verschieben. Der Schlüsselspeicher enthält einen einzelnen Schlüssel,der 10.000 Tage lang gültig ist.
Du kannst dein APK oder App-Bundle jetzt manuell signieren oder Gradle so konfigurieren, dass deine App während des Build-Prozesses signiert wird, wie in den folgenden Abschnitten beschrieben.
App manuell über die Befehlszeile signieren
Wenn Sie ein App-Bundle über die Befehlszeile signieren möchten, können Sie jarsigner
verwenden.
Wenn du stattdessen ein APK signieren möchtest, musst du zipalign
und apksigner
wie unten beschrieben verwenden.
- Öffnen Sie eine Befehlszeile. Wählen Sie in Android Studio View > Tool Windows > Terminal aus und wechseln Sie zu dem Verzeichnis, in dem sich Ihr nicht signiertes APK befindet.
-
Richte das nicht signierte APK anhand von
zipalign
aus:zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
zipalign
sorgt dafür, dass alle unkomprimierten Daten mit einer bestimmten Byte-Ausrichtung relativ zum Anfang der Datei beginnen. Dadurch kann der von einer Anwendung belegte RAM reduziert werden. -
Signieren Sie Ihr APK mit Ihrem privaten Schlüssel mit
apksigner
:apksigner sign --ks my-release-key.jks --out my-app-release.apk my-app-unsigned-aligned.apk
In diesem Beispiel wird das signierte APK unter
my-app-release.apk
ausgegeben, nachdem es mit einem privaten Schlüssel und Zertifikat signiert wurde, die in einer einzigen KeyStore-Datei gespeichert sind:my-release-key.jks
.Das
apksigner
-Tool unterstützt auch andere Signaturoptionen, darunter das Signieren einer APK-Datei mit separaten privaten Schlüssel- und Zertifikatsdateien sowie das Signieren eines APK mit mehreren Unterzeichnern. Weitere Informationen finden Sie in der Referenz zuapksigner
.Hinweis: Wenn Sie das
apksigner
-Tool verwenden möchten, muss Version 24.0.3 oder höher der Android SDK Build Tools installiert sein. Du kannst dieses Paket über den SDK-Manager aktualisieren. -
Prüfen Sie, ob Ihr APK signiert ist:
apksigner verify my-app-release.apk
Gradle zum Signieren Ihrer App konfigurieren
Öffnen Sie die Datei build.gradle.kts
auf Modulebene und fügen Sie den signingConfigs {}
-Block mit den Einträgen für storeFile
, storePassword
, keyAlias
und keyPassword
hinzu. Übergeben Sie dann das Objekt an das Attribut signingConfig
in Ihrem Build-Typ. Beispiele:
Kotlin
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") ... } } }
Groovig
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 ... } } }
Wenn Sie Ihre App jetzt durch Aufrufen einer Gradle-Aufgabe erstellen, signiert Gradle Ihre App (und führt zipalign aus) für Sie.
Da Sie den Release-Build mit Ihrem Signaturschlüssel konfiguriert haben, ist außerdem die Installationsaufgabe für diesen Build-Typ verfügbar. Mit der Aufgabe installRelease
kannst du also das Release-APK in einem Emulator oder auf einem Gerät erstellen, ausrichten, signieren und installieren.
Eine mit deinem privaten Schlüssel signierte App kann jetzt bereitgestellt werden. Wir empfehlen dir aber, dich zuerst über die Veröffentlichung deiner App und die Checkliste für die Einführung von Google Play zu informieren.