App über Befehlszeile erstellen

Mit dem Befehlszeilentool Gradle-Wrapper können Sie alle für Ihr Android-Projekt verfügbaren Build-Aufgaben ausführen. Es ist als Batchdatei für Windows (gradlew.bat) und als Shell-Script für Linux und Mac (gradlew.sh) verfügbar. Sie können es im Stammverzeichnis jedes Projekts aufrufen, 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 in Android Studio Ansicht > Toolfenster > Terminal aus.

• In der Windows-Befehlsshell:

  gradlew task-name

• Unter 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

Im restlichen Teil 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 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 Buildtypen verfügbar: einer zum Debuggen Ihrer App (Debug-Build) und einer zum Veröffentlichen Ihrer App für Nutzer (Release-Build). Die resultierende 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 kann nicht für die Veröffentlichung im Google Play Store verwendet werden. Der Release-Build muss mit Ihrem eigenen privaten Schlüssel signiert werden.

Wenn Sie Ihre App für die Veröffentlichung erstellen möchten, müssen Sie sie auch mit dem entsprechenden Signaturschlüssel signieren. Wenn Sie gerade erst mit der Entwicklung beginnen, können Sie Ihre Apps jedoch schnell auf einem Emulator oder einem verbundenen Gerät ausführen, indem Sie ein Debug-APK erstellen.

Sie können auch einen benutzerdefinierten Buildtyp in Ihrer build.gradle.kts-Datei definieren und ihn so konfigurieren, dass er als Debug-Build signiert wird. Fügen Sie dazu debuggable true ein. Weitere Informationen finden Sie unter Buildvarianten konfigurieren.

APK erstellen und bereitstellen

Das Erstellen eines App-Bundles ist die beste Möglichkeit, Ihre App zu verpacken und in die Play Console hochzuladen. Das Erstellen eines APKs eignet sich jedoch besser, wenn Sie schnell einen Debug-Build testen oder Ihre App als ausführbares Artefakt für andere freigeben möchten.

Debug-APK erstellen

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

Wenn Sie ein Debug-APK erstellen möchten, öffnen Sie eine Befehlszeile und wechseln Sie zum Stammverzeichnis Ihres Projektverzeichnisses. Rufen Sie die Aufgabe assembleDebug auf, um einen Debug-Build zu starten:

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. Sie kann also sofort auf einem Gerät installiert werden.

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

gradlew installDebug

Der Teil „Debug“ in den obigen Aufgabennamen ist nur eine CamelCase-Version des Namens der Buildvariante. Er kann also durch den Buildtyp oder die Buildvariante ersetzt werden, die Sie kompilieren oder installieren möchten. Wenn Sie beispielsweise eine „Demo“-Produktvariante haben, können Sie die Debugversion mit der Aufgabe assembleDemoDebug erstellen.

Wenn Sie alle Build- und Installationsaufgaben sehen möchten, die für jede Variante verfügbar sind (einschließlich Deinstallationsaufgaben), führen Sie die Aufgabe tasks aus.

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

Release-Bundle oder APK erstellen

Wenn Sie Ihre App veröffentlichen und verteilen möchten, müssen Sie ein Release-Bundle oder APK erstellen, das mit Ihrem privaten Schlüssel signiert ist. Weitere Informationen finden Sie im Abschnitt zum Signieren Ihrer App ü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.

Nachdem Sie eine AVD erstellt 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 Ihre AVD angeben:

   emulator -avd avd_name

   Wenn Sie sich nicht sicher sind, welchen AVD-Namen Sie verwenden sollen, 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 erwähnt wurden, oder mit dem adb-Tool.

   Wenn das APK mit einem SDK für die Entwicklervorschau erstellt wurde (targetSdkVersion ist ein Buchstabe anstelle einer Zahl), müssen Sie die Option -t mit dem Befehl install angeben, um ein Test-APK zu installieren.

   adb 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 im Android-Emulator ausführen.

App 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. Sie finden die Option unter Einstellungen > Entwickleroptionen.

Hinweis:Unter Android 4.2 und höher sind die Entwickleroptionen standardmäßig ausgeblendet. Wenn Sie die Option aktivieren möchten, gehen Sie zu Einstellungen > Über das Telefon und tippen Sie siebenmal auf Build-Nummer. Kehren Sie zum vorherigen Bildschirm zurück, um die Entwickleroptionen zu finden.

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 wurden, 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 Generierung und Signatur des APK wird jedoch an Google Play weitergeleitet. Im Gegensatz zu einem APK können Sie ein App-Bundle nicht direkt auf einem Gerät bereitstellen. Wenn Sie ein APK also schnell testen oder mit anderen teilen möchten, sollten Sie stattdessen ein APK erstellen.

Am einfachsten erstellen Sie ein App-Bundle mit Android Studio. Wenn Sie ein App-Bundle jedoch über die Befehlszeile erstellen möchten, 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 bundleVariant-Gradle-Aufgabe für das Basismodul Ihrer App aus. Mit dem folgenden Befehl wird beispielsweise ein App-Bundle für die Debugversion des Basismoduls erstellt:

./gradlew :base:bundleDebug

Wenn Sie ein signiertes Bundle zum Hochladen in die Play Console erstellen möchten, müssen Sie zuerst die build.gradle.kts-Datei des Basismoduls mit den Signaturinformationen Ihrer 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 nachzubilden, wie Google Play APKs generiert, aber in der Regel müssen Sie bundletool nicht aufrufen, um das App-Bundle selbst zu erstellen. Verwenden Sie stattdessen Android Studio oder Gradle-Aufgaben, 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 über die Befehlszeile verwenden, um ein App-Bundle aus vorkompiliertem Code und Ressourcen zu erstellen. Falls noch nicht geschehen, downloaden Sie bundletool aus dem GitHub-Repository.

In diesem Abschnitt wird beschrieben, wie Sie den kompilierten Code und die Ressourcen Ihrer App verpacken und wie Sie sie mit bundletool über die Befehlszeile 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 hat die Dateiendung *.pb. Protobufs bieten einen sprach- und plattformneutralen, 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. Gehen Sie im Repository-Index zu com.android.tools.build > aapt2.
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 Version 3.2.0-alpha18-4804415 für Windows herunterladen möchten, verwenden Sie Folgendes: 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 bald beginnen.

5. Entpacken Sie die JAR-Datei, die Sie gerade heruntergeladen haben.

Ressourcen Ihrer App 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 zu einem einzelnen APK verknüpft, weisen Sie AAPT2 an, das Manifest und die kompilierten Ressourcen Ihrer App in das Protobuf-Format umzuwandeln. Fügen Sie dazu das Flag --proto-format hinzu, 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

Sie können dann Inhalte aus dem Ausgabe-APK extrahieren, z. B. die AndroidManifest.xml-, resources.pb- und andere Ressourcendateien Ihrer App – 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 mit bundletool ein App-Bundle für Ihre App generieren können, 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 Organisation der ZIP-Datei jedes Moduls ähneln dem Android App Bundle-Format. Erstellen Sie beispielsweise eine base.zip-Datei für das Basismodul Ihrer App und strukturieren Sie den Inhalt so:

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

App-Bundle mit bundletool erstellen

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

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

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

Generierung von Downstream-APKs anpassen

App-Bundles enthalten eine BundleConfig.pb-Datei mit Metadaten, die App-Shops wie Google Play zum Generieren von APKs aus dem Bundle benötigen. Diese Datei wird zwar von bundletool erstellt, Sie können aber einige Aspekte der Metadaten in einer BundleConfig.json-Datei konfigurieren und an den bundletool build-bundle-Befehl übergeben. bundletool konvertiert und zusammenführt diese Datei später mit der protobuf-Version, 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 bedeutet, dass Ressourcen für alle Sprachen in den jeweiligen Basis- oder Feature-APKs enthalten sind:

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

In Ihrer BundleConfig.json-Datei können Sie auch angeben, welche Dateitypen beim Verpacken von APKs mit Glob-Mustern unverpackt bleiben sollen. Gehen Sie dazu so vor:

{
  "compression": {
    "uncompressedGlob": ["res/raw/**", "assets/**.uncompressed"]
  }
}

Standardmäßig werden mit bundletool die nativen Bibliotheken Ihrer App (unter Android 6.0 oder höher) und die Ressourcentabelle (resources.arsc) nicht komprimiert. Eine vollständige Beschreibung der Konfigurationsoptionen für BundleConfig.json finden Sie in der bundletool-config.proto-Datei, die in Proto3-Syntax geschrieben ist.

App aus einem App-Bundle bereitstellen

Wenn Sie ein App-Bundle erstellt und signiert haben, können Sie mit bundletool APKs generieren und auf einem Gerät bereitstellen.

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 Signatur während des Builds automatisch erfolgt. 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 Beispiel oben werden Sie aufgefordert, Passwörter für den Schlüsselspeicher und den Schlüssel sowie für die Felder „Distinguished Name“ für den Schlüssel einzugeben. Anschließend wird der Keystore als Datei namens my-release-key.jks generiert und im aktuellen Verzeichnis gespeichert. Sie können ihn an eine beliebige Stelle verschieben. Der Schlüsselspeicher enthält einen einzelnen Schlüssel,der 10.000 Tage lang gültig ist.

Sie können Ihr APK oder App-Bundle jetzt manuell signieren oder Gradle so konfigurieren, dass Ihre 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 wie unten beschrieben verwenden.

1. Öffnen Sie eine Befehlszeile. Wählen Sie in Android Studio Ansicht > Toolfenster > Terminal aus und wechseln Sie zum Verzeichnis, in dem sich die signaturlose APK befindet.

2. Richten Sie das signaturlose APK mit zipalign aus:

   zipalign -v -p 4 my-app-unsigned.apk my-app-unsigned-aligned.apk
   

   zipalign sorgt dafür, dass alle nicht komprimierten Daten mit einer bestimmten Byte-Ausrichtung relativ zum Anfang der Datei beginnen. Dadurch kann der von einer App belegte RAM-Speicher reduziert werden.

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 einzigen Keystore-Datei gespeichert sind: my-release-key.jks.

   Das apksigner-Tool unterstützt auch andere Signaturoptionen, z. B. die Signatur einer APK-Datei mit separaten privaten Schlüssel- und Zertifikatdateien sowie die Signatur eines APK mit mehreren Unterzeichnern. Weitere Informationen finden Sie in der Referenz zu apksigner.

   Hinweis:Wenn Sie das apksigner-Tool verwenden möchten, muss Version 24.0.3 oder höher der Android SDK Build Tools installiert sein. Sie können dieses Paket mit dem SDK Manager aktualisieren.

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 das Attribut signingConfig in Ihrem Build-Typ. Beispiel:

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

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 erstellen, indem Sie eine Gradle-Aufgabe aufrufen, signiert Gradle Ihre App und führt zipalign für Sie aus.

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

Eine mit Ihrem privaten Schlüssel signierte App ist bereit für den Vertrieb. Lesen Sie sich aber zuerst die Informationen zum Veröffentlichen Ihrer App durch und sehen Sie sich die Checkliste für die Einführung bei Google Play an.