App über Befehlszeile erstellen

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:

1. 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.

2. 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 Befehl install 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:

1. Rufen Sie 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 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

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.

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/

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

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

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

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

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

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