App über Befehlszeile erstellen

Mit dem Befehlszeilentool Gradle Wrapper können Sie alle Build-Aufgaben ausführen, die für Ihr Android-Projekt verfügbar sind. Es ist als Batchdatei für Windows (gradlew.bat) und als Shell-Script für Linux und Mac (gradlew.sh) verfügbar und kann über das Stammverzeichnis jedes Projekts aufgerufen werden, das Sie mit Android Studio erstellen.

Wenn Sie eine Aufgabe mit dem Wrapper ausführen möchten, verwenden Sie einen der folgenden Befehle in einem Terminalfenster. Wählen Sie dazu in Android Studio Ansicht > Toolfenster > Terminal aus:

  • In der Windows-Befehlsshell:

    gradlew task-name

  • Auf Mac, Linux oder Windows PowerShell:

    ./gradlew task-name

Führen Sie tasks aus, um eine Liste aller verfügbaren Build-Aufgaben für Ihr Projekt aufzurufen:

gradlew tasks

Auf dieser Seite werden die Grundlagen zum Erstellen und Ausführen Ihrer App mit dem Gradle-Wrapper beschrieben. Weitere Informationen zum Einrichten Ihres Android-Builds finden Sie unter Build konfigurieren.

Wenn Sie lieber die Android Studio-Tools anstelle der Befehlszeilentools verwenden möchten, lesen Sie den Hilfeartikel App erstellen und ausführen.

Build-Typen

Standardmäßig sind für jede Android-App zwei Build-Typen verfügbar: einer zum Debuggen der App (Debug-Build) und einer zum Veröffentlichen der App für Nutzer (Release-Build). Die Ausgabe jedes Builds muss mit einem Zertifikat signiert werden, bevor Sie Ihre App auf einem Gerät bereitstellen können. Der Debug-Build wird automatisch mit einem Debug-Schlüssel signiert, der von den SDK-Tools bereitgestellt wird. Er ist unsicher und Sie können damit nicht im Google Play Store veröffentlichen. Der Release-Build muss mit Ihrem eigenen privaten Schlüssel signiert werden.

Wenn Sie Ihre App für den Release erstellen möchten, müssen Sie sie auch mit dem entsprechenden Signaturschlüssel signieren. Wenn Sie 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 einfügen. Weitere Informationen finden Sie unter Build-Varianten konfigurieren.

APK erstellen und bereitstellen

Das Erstellen eines App-Bundles ist zwar die beste Methode, um deine App zu verpacken und in die Play Console hochzuladen, aber das Erstellen eines APKs ist besser geeignet, wenn du schnell einen Debug-Build testen oder deine App als bereitstellbares Artefakt mit anderen teilen möchtest.

Debugging-APK erstellen

Wenn Sie Ihre App sofort testen und Fehler beheben möchten, können Sie ein Debug-APK erstellen. Das Debug-APK wird mit einem Debug-Schlüssel signiert, der von den SDK-Tools bereitgestellt wird, und ermöglicht das Debugging über adb.

Öffnen Sie eine Befehlszeile und rufen Sie das Stammverzeichnis Ihres Projektverzeichnisses auf, um ein Debug-APK zu erstellen. Rufen Sie die Aufgabe assembleDebug auf, um einen Debug-Build zu initiieren:

gradlew assembleDebug

Dadurch wird ein APK mit dem Namen module_name-debug.apk in project_name/module_name/build/outputs/apk/ erstellt. Die Datei ist bereits mit dem Debug-Schlüssel signiert und mit zipalign ausgerichtet, sodass Sie sie sofort auf einem Gerät installieren können.

Wenn Sie das APK erstellen und sofort auf einem laufenden Emulator oder verbundenen Gerät installieren möchten, rufen Sie stattdessen installDebug auf:

gradlew installDebug

Der Teil „Debug“ in den Aufgabennamen ist nur eine Camel-Case-Version des Namens der Build-Variante. Er kann also durch den Build-Typ oder die Variante ersetzt werden, die Sie zusammenstellen oder installieren möchten. Wenn Sie beispielsweise eine Produktvariante „Demo“ haben, können Sie die Debug-Version mit der Aufgabe assembleDemoDebug erstellen.

Führen Sie die Aufgabe tasks aus, um alle Build- und Installationsaufgaben für jede Variante (einschließlich Deinstallationsaufgaben) aufzurufen.

Weitere Informationen findest du in den Abschnitten App im Emulator ausführen und App auf einem Gerät ausführen.

Release-Bundle oder APK erstellen

Wenn du deine App veröffentlichen und vertreiben möchtest, musst du ein Release-Bundle oder ein APK erstellen, das mit deinem privaten Schlüssel signiert ist. Weitere Informationen finden Sie im Abschnitt App über die Befehlszeile signieren.

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.

Wenn Sie ein AVD haben, starten Sie den Android-Emulator und installieren Sie Ihre App so:

  1. Rufen Sie in einer Befehlszeile android_sdk/tools/ auf und starten Sie den Emulator, indem Sie Ihr AVD angeben:

    emulator -avd <var>avd_name</var>

    Wenn Sie sich beim AVD-Namen nicht sicher sind, führen Sie emulator -list-avds aus.

  2. Sie können Ihre App jetzt mit einer der Gradle-Installationsaufgaben installieren, die im Abschnitt zum Erstellen eines Debug-APKs oder zum adb-Tool erwähnt werden.

    Wenn das APK mit einem Entwicklervorschau-SDK erstellt wurde (wenn targetSdkVersion ein Buchstabe statt einer Zahl ist), musst du die Option -t mit dem Befehl install angeben, um ein Test-APK zu installieren.

    adb install <var>path/to/your_app</var>.apk

    Alle von Ihnen erstellten APKs werden in project_name/module_name/build/outputs/apk/ gespeichert.

Weitere Informationen finden Sie unter Apps im Android-Emulator ausführen.

Anwendung auf einem physischen Gerät bereitstellen

Bevor Sie Ihre App auf einem Gerät ausführen können, müssen Sie das USB-Debugging auf Ihrem Gerät aktivieren. Du findest die Option unter Einstellungen > Entwickleroptionen.

Sobald Ihr Gerät eingerichtet und über USB verbunden ist, können Sie Ihre App entweder mit den Gradle-Installationsaufgaben installieren, die im Abschnitt zum Erstellen eines Debug-APKs erwähnt werden, oder mit dem adb-Tool:

adb -d install path/to/your_app.apk

Alle von Ihnen erstellten APKs 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 alle Ressourcen Ihrer App, die APK-Generierung und -Signierung wird jedoch an Google Play übertragen. Im Gegensatz zu einem APK können Sie ein App-Bundle nicht direkt auf einem Gerät bereitstellen. Wenn Sie ein APK schnell testen oder mit jemandem teilen 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 dazu entweder Gradle oder bundletool verwenden, wie in den folgenden Abschnitten beschrieben.

App-Bundle mit Gradle erstellen

Wenn Sie ein App Bundle lieber über die Befehlszeile generieren möchten, führen Sie die Gradle-Aufgabe bundleVariant für das 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 du ein signiertes Bundle zum Hochladen in die Play Console erstellen möchtest, musst du zuerst die Datei build.gradle.kts des Basismoduls mit den Signaturinformationen deiner App konfigurieren. Weitere Informationen finden Sie im Abschnitt Gradle zum Signieren Ihrer App konfigurieren. Sie können dann beispielsweise die Release-Version Ihrer App erstellen. Gradle generiert dann automatisch ein App-Bundle und signiert es mit den Signaturinformationen, die Sie in der Datei build.gradle.kts angeben.

Wenn Sie ein App-Bundle stattdessen in einem separaten Schritt signieren möchten, können Sie jarsigner verwenden, um Ihr App-Bundle über die Befehlszeile zu 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 nützlich, App-Bundles mit bundletool zu testen und lokal nachzuvollziehen, wie Google Play APKs generiert, aber normalerweise musst du bundletool nicht aufrufen, um das App-Bundle selbst zu erstellen. Verwende stattdessen Android Studio- oder Gradle-Tasks, wie in den vorherigen Abschnitten beschrieben.

Wenn Sie jedoch keine Android Studio- oder Gradle-Aufgaben zum Erstellen von Bundles verwenden möchten, z. B. weil Sie eine benutzerdefinierte Build-Toolchain verwenden, können Sie bundletool über die 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 Sie den kompilierten Code und die Ressourcen Ihrer App verpacken und wie Sie sie über die Befehlszeile mit bundletool in ein Android App Bundle konvertieren.

Manifest und Ressourcen im Proto-Format generieren

Für bundletool müssen bestimmte Informationen zu Ihrem App-Projekt, z. B. das Manifest und die Ressourcen der App, im Protocol Buffer-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, sind aber kleiner, schneller und einfacher.

AAPT2 herunterladen

Sie können die Manifestdatei und die Ressourcentabelle Ihrer App im Protobuf-Format mit der neuesten Version von AAPT2 aus dem Google Maven-Repository generieren.

So laden Sie AAPT2 aus dem Maven-Repository von Google herunter:

  1. Rufe im Repository-Index com.android.tools.build > aapt2 auf.
  2. Kopieren Sie den Namen der neuesten Version von AAPT2.

  3. Fügen Sie den kopierten Versionsnamen in die folgende URL ein und geben Sie Ihr Zielbetriebssystem an: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/ aapt2-version/aapt2-aapt2-version- [windows | linux | osx].jar

    Wenn Sie beispielsweise die Version 3.2.0-alpha18-4804415 für Windows herunterladen möchten, verwenden Sie: https://dl.google.com/dl/android/maven2/com/android/tools/build/aapt2/3.2.0-alpha18-4804415/aapt2-3.2.0-alpha18-4804415-windows.jar

  4. Rufen Sie die URL in einem Browser auf. Der Download von AAPT2 sollte in Kürze beginnen.

  5. Entpacken Sie die gerade heruntergeladene JAR-Datei.

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/

In der Verknüpfungsphase, in der AAPT2 die verschiedenen kompilierten Ressourcen zu einem einzigen APK verknüpft, weisen Sie AAPT2 an, das Manifest und die kompilierten Ressourcen Ihrer App in das Protobuf-Format zu konvertieren. Fügen Sie dazu das Flag --proto-format ein, wie im folgenden Beispiel 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 der Ausgabe-APK extrahieren, z. B. die AndroidManifest.xml, resources.pb und andere Ressourcendateien Ihrer App, die jetzt im Protobuf-Format vorliegen. 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 mit bundletool ein App-Bundle für Ihre App generieren, müssen Sie zuerst ZIP-Dateien bereitstellen, die jeweils den kompilierten Code und die Ressourcen für ein bestimmtes App-Modul enthalten. Der Inhalt und die Struktur der ZIP-Datei jedes Moduls sind dem Android App Bundle-Format sehr ähnlich. Sie sollten beispielsweise eine base.zip-Datei für das Basismodul Ihrer App erstellen und den 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 bei einem typischen APK organisiert sein.
root/..., assets/... und lib/... Diese Verzeichnisse sind mit denen im Abschnitt Android App Bundle-Format identisch.
resources.pb Die Ressourcentabelle Ihrer App im Protobuf-Format.

Nachdem Sie die ZIP-Datei für jedes Modul Ihrer App vorbereitet haben, können Sie sie an bundletool übergeben, um Ihr App-Bundle zu erstellen, wie im folgenden Abschnitt beschrieben.

App-Bundle mit bundletool erstellen

Verwenden Sie den Befehl bundletool build-bundle, um Ihr App-Bundle zu erstellen, wie im folgenden Beispiel gezeigt:

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

In der folgenden Tabelle werden die Flags für den Befehl build-bundle ausführlicher beschrieben:

Flag Beschreibung
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip Gibt die Liste der ZIP-Dateien für Module 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 Generierung von Downstream-APKs anpassen.
--metadata-file=target-bundle-path:local-file-path Weist bundletool an, eine optionale Metadatendatei in Ihr App-Bundle zu packen. Sie können diese Datei verwenden, um Daten wie ProGuard-Zuordnungen oder die vollständige Liste der DEX-Dateien Ihrer App einzufügen, die für andere Schritte in Ihrer Toolchain oder einen App-Shop nützlich sein können.

target-bundle-path gibt einen Pfad relativ zum Stammverzeichnis des App-Bundles an, in dem die Metadatendatei verpackt werden soll, und local-file-path gibt den Pfad zur lokalen Metadatendatei selbst an.

Downstream-APK-Generierung anpassen

App-Bundles enthalten eine BundleConfig.pb-Datei mit Metadaten, die App-Shops wie Google Play benötigen, wenn sie APKs aus dem Bundle generieren. bundletool erstellt diese Datei zwar für Sie, Sie können jedoch einige Aspekte der Metadaten in einer BundleConfig.json-Datei konfigurieren und an den Befehl bundletool build-bundle übergeben. bundletool konvertiert diese Datei später und führt sie mit der Protobuf-Version zusammen, die in jedem App Bundle enthalten ist.

Du kannst 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 bedeutet, dass Ressourcen für alle Sprachen in den jeweiligen Basis- oder Feature-APKs enthalten sind:

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

In der Datei BundleConfig.json können Sie 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 der Konfigurationsmöglichkeiten in Ihrer BundleConfig.json finden Sie in der bundletool-config.proto-Datei, die mit der Proto3-Syntax geschrieben wurde.

Anwendung 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 Android Studio nicht, um Ihre App zu signieren. Sie können Ihre App über die Befehlszeile signieren, indem Sie apksigner für APKs oder jarsigner für App-Bundles verwenden, oder Gradle so konfigurieren, dass die App während des Builds signiert wird. In beiden Fällen müssen Sie zuerst mit keytool einen privaten Schlüssel generieren, wie im folgenden Beispiel gezeigt:

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

In diesem 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 mit dem Namen my-release-key.jks generiert und im aktuellen Verzeichnis gespeichert. Sie können die Datei an einen beliebigen Ort verschieben. Der Schlüsselspeicher enthält einen einzelnen Schlüssel,der 10.000 Tage lang gültig ist.

Jetzt kannst du dein APK oder App Bundle 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 Sie stattdessen ein APK signieren möchten, müssen Sie zipalign und apksigner verwenden:

  1. Öffnen Sie eine Befehlszeile. Wählen Sie dazu in Android Studio Ansicht > Toolfenster > Terminal aus und rufen Sie das Verzeichnis auf, in dem sich Ihre unsignierte APK befindet.

  2. Richten Sie das nicht signierte APK mit 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, wodurch die von einer App verbrauchte RAM-Menge reduziert werden kann.

  3. 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 einem Zertifikat signiert wurde, die in einer einzelnen Schlüsselspeicherdatei gespeichert sind: my-release-key.jks.

    Das apksigner-Tool unterstützt weitere Signaturoptionen, darunter das Signieren einer APK-Datei mit separaten privaten Schlüssel- und Zertifikatsdateien sowie das Signieren eines APK mit mehreren Signierern. Weitere Informationen finden Sie in der Referenz zu apksigner.

  4. 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 Block signingConfigs {} mit Einträgen für storeFile, storePassword, keyAlias und keyPassword hinzu. Übergeben Sie dieses Objekt dann an die Property signingConfig in Ihrem Build-Typ. Beispiel:

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")
            ...
        }
    }
}

Groovy

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, wird sie von Gradle signiert und „zipalign“ wird ausgeführt.

Da Sie den Release-Build mit Ihrem Signaturschlüssel konfiguriert haben, ist außerdem die Aufgabe „install“ für diesen Build-Typ verfügbar. Mit der Aufgabe installRelease können Sie das Release-APK auf einem Emulator oder Gerät erstellen, ausrichten, signieren und installieren.

Eine mit deinem privaten Schlüssel signierte App ist bereit für die Veröffentlichung. Du solltest jedoch zuerst mehr über die App-Signatur lesen und die Checkliste für die Einführung bei Google Play durchgehen.