App über Befehlszeile erstellen

Sie können alle für Ihr Android-Projekt verfügbaren Build-Aufgaben mit des Gradle-Wrappers des Befehlszeilentools Es ist als Batchdatei für Windows (gradlew.bat) und Shell verfügbar für Linux und Mac (gradlew.sh) und es ist ein Sie können über das Stammverzeichnis jedes mit Android Studio erstellten Projekts aufgerufen werden.

Um eine Aufgabe mit dem Wrapper auszuführen, verwenden Sie einen der folgenden Befehle aus einem Terminalfenster (wählen Sie in Android Studio View > Tool Windows > Terminal:

• In der Windows-Befehlsshell:

  gradlew task-name

• Unter Mac, Linux oder Windows PowerShell:

  ./gradlew task-name

So rufen Sie eine Liste aller verfügbaren Build-Aufgaben für Ihrem Projekt den Befehl tasks aus:

gradlew tasks

Im Folgenden werden die Grundlagen zum Erstellen und Ausführen Ihrer App beschrieben. mit dem Gradle-Wrapper. Weitere Informationen zum Einrichten Ihres Android-Build, siehe Konfigurieren Ihres Builds.

Wenn Sie lieber die Android Studio-Tools anstelle der Befehlszeile verwenden möchten finden Sie unter Anwendung erstellen und ausführen.

Build-Typen

Standardmäßig sind für jede Android-App zwei Build-Typen verfügbar: zur Fehlerbehebung deiner App – dem Debug-Build, und einem für die Veröffentlichung deiner App für Nutzer – den Release-Build. Die resultierende Ausgabe der einzelnen der Build mit einem Zertifikat signiert werden muss, bevor Sie Ihre App auf einem . Der Debug-Build wird automatisch mit einem Debug-Schlüssel signiert, der vom SDK-Tools (sind unsicher und können nicht damit im Google Play Store veröffentlicht werden) gespeichert) und der Release-Build muss mit Ihrem eigenen privaten Schlüssel signiert sein.

Wenn Sie Ihre App für die Veröffentlichung erstellen möchten, ist es wichtig, signieren Sie Ihre App mit dem entsprechenden Signaturschlüssel. Wenn Sie gerade erst anfangen, können Sie Ihre Apps schnell auf einem Emulators oder ein verbundenes Gerät Erstellen eines Fehlerbehebungs-APKs

Sie können auch einen benutzerdefinierten Build-Typ in Ihrem build.gradle.kts definieren und konfigurieren Sie sie so, dass sie als Debug-Build signiert wird. Fügen Sie dazu debuggable true. Weitere Informationen Siehe Build-Varianten konfigurieren.

APK erstellen und bereitstellen

Obwohl das Erstellen eines App Bundles die beste Möglichkeit ist, verpacken Sie Ihre App und laden Sie sie in die Play Console hoch. Geeignet, wenn du schnell einen Debug-Build testen oder deine App teilen möchtest als bereitstellbares Artefakt mit anderen.

Fehlerbehebungs-APK erstellen

Wenn Sie die App sofort testen und debuggen 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 Debugging über adb.

Um ein Debug-APK zu erstellen, öffnen Sie eine Befehlszeile und navigieren Sie zum Stammverzeichnis Ihres Projektverzeichnis. Um einen Debug-Build zu starten, rufen Sie den Aufgabe assembleDebug:

gradlew assembleDebug

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

Oder Sie erstellen das APK und installieren es sofort in einem laufenden Emulator oder verbundenes Gerät. Rufen Sie stattdessen installDebug auf:

gradlew installDebug

Die Funktion „Fehlerbehebung“ in den oben genannten Aufgabennamen nur Camel-Case-Version des Namens der Build-Variante, sodass er durch einen beliebigen Build-Typ oder Variante, die Sie zusammenbauen oder installieren möchten. Wenn Sie z. B. eine „Demo“ haben, Produkt-Flavor erstellt, können Sie die Debug-Version assembleDemoDebug Aufgabe.

Um alle Build- und Installationsaufgaben anzuzeigen, 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 vertreiben möchten, müssen Sie eine Release-Bundle oder APK, das mit deinem privaten Schlüssel signiert ist. Weitere Informationen finden Sie im Abschnitt zum Signieren Ihrer App über die Befehlszeile auf.

Anwendung im Emulator bereitstellen

Um den Android-Emulator verwenden zu können, müssen Sie eine virtuelle Android-App Gerät (AVD) über Android Studio.

Sobald Sie über ein AVD verfügen, starten Sie den Android-Emulator und installieren Sie die wie folgt aussehen:

1. Gehen Sie in einer Befehlszeile zu android_sdk/tools/ und starten Sie den Emulator, indem Sie unter Angabe der AVD:

   emulator -avd avd_name

   Wenn Sie sich bezüglich des AVD-Namens nicht sicher sind, emulator -list-avds

2. Du kannst deine App jetzt mit einer der Gradle-Installationsaufgaben installieren. wie im Abschnitt zum Erstellen eines Debug-APKs erwähnt, oder die adb-Tool.

   Wenn das APK mit einem SDK für die Entwicklervorschau erstellt wurde (wenn die targetSdkVersion ein einen Buchstaben statt einer Zahl, müssen Sie den -t Option mit dem Befehl install, um ein Test-APK zu installieren.

   adb install path/to/your_app.apk
   

   Alle von dir erstellten APKs sind gespeichert in project_name/module_name/build/outputs/apk/

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 USB- Fehlerbehebung auf Ihrem Gerät. Die Option finden Sie unter Einstellungen > Entwickleroptionen.

Hinweis: Unter Android 4.2 und höher Entwickleroptionen sind standardmäßig ausgeblendet. Um sie verfügbar zu machen, Öffnen Sie Einstellungen > Über das Telefon und tippe auf Erstellen Nummer siebenmal. Kehre zum vorherigen Bildschirm zurück, Entwickleroptionen.

Sobald dein Gerät eingerichtet und über USB verbunden ist, kannst du deine App installieren entweder mit den oben erwähnten Gradle-Installationsaufgaben im Abschnitt zum Erstellen eines Debug-APKs oder im adb-Tool:

adb -d install path/to/your_app.apk

Alle von dir erstellten APKs sind gespeichert in project_name/module_name/build/outputs/apk/

Weitere Informationen finden Sie unter Apps auf einem Hardwaregerät ausführen

App Bundle erstellen

Android App Bundles enthalten alle kompilierten Code und Ressourcen kompiliert, aber die APK-Erstellung und -Anmeldung bei Google aussetzen Spielen. 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, erstellen Sie stattdessen ein APK.

Am einfachsten erstellen Sie ein App Bundle, mit Android Studio. Wenn Sie jedoch eine App Bundle können Sie entweder Gradle oder bundletool, 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 den Befehl bundleVariant Gradle-Task im Basismodul deiner App. Mit dem folgenden Befehl wird beispielsweise ein App-Bundle für die Debug-Version erstellt. des Basismoduls:

./gradlew :base:bundleDebug

Wenn Sie ein signiertes Bundle für den Upload in die Play Console erstellen möchten, müssen Sie konfigurieren Sie zuerst die Datei build.gradle.kts des Basismoduls mit dem Informationen unterschreiben. Weitere Informationen finden Sie im Abschnitt zur Gradle zum Signieren Ihrer App konfigurieren Anschließend können Sie zum Beispiel die Release-Version Ihrer App erstellen generiert automatisch ein App Bundle und signiert es mit der Informationen, die Sie in der Datei build.gradle.kts angeben.

Wenn Sie ein App Bundle in einem separaten Schritt signieren möchten, können Sie jarsigner um Ihr App Bundle über die Befehlszeile zu signieren. Befehl zum Erstellen einer Anwendung Set ist:

jarsigner -keystore pathToKeystore app-release.aab keyAlias

Hinweis: Du kannst apksigner nicht zum Signieren deines App Bundles verwenden.

App Bundle mit Bundletool erstellen

bundletool ist ein Befehlszeilentool, das von Android Studio, dem Android-Gradle-Plug-in, und Google Play verwenden, um den kompilierten Code Ihrer App zu konvertieren und in App Bundles umwandeln und bereitstellbare APKs aus diesen Bundles generieren.

Es ist zwar nützlich, App Bundles mit bundletool testen und lokal neu erstellen wie Google Play APKs generiert, brauchen Sie Rufe bundletool auf, um das App Bundle selbst zu erstellen. Du solltest stattdessen Android Studio- oder Gradle-Aufgaben verwenden, wie in den vorherigen Abschnitten beschrieben.

Wenn Sie Android Studio- oder Gradle-Aufgaben zum Erstellen Bundles – wenn Sie beispielsweise eine benutzerdefinierte Build-Toolchain verwenden – können Sie bundletool verwenden. über die Befehlszeile ein App Bundle aus vorkompiliertem Code erstellen und Ressourcen. Falls noch nicht geschehen, <ph type="x-smartling-placeholder"></ph> 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 bundletool über die Befehlszeile in ein Android App Bundle

Manifest und Ressourcen im .proto-Format generieren

bundletool benötigt bestimmte Informationen zu Ihrem App-Projekt, z. B. die das Manifest und die Ressourcen der App. das Protokollzwischenspeicher-Format von Google, das wird auch als „protobuf“ bezeichnet. und hat die Dateiendung *.pb. Protobufs Bereitstellung eines sprach-, plattformneutralen und erweiterbaren Mechanismus zum Serialisieren strukturierter Daten. Es ähnelt XML, ist aber kleiner, schneller und einfacher zu machen.

AAPT2 herunterladen

Die Manifestdatei und die Ressourcentabelle Ihrer App können Sie in protobuf-Format mit der neuesten Version von AAPT2 vom Google Maven-Repository.

Achtung :Verwende nicht die im Android-Build enthaltene Version von AAPT2. Tools-Paket enthalten – diese Version von AAPT2 unterstützt bundletool nicht.

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

1. Gehen Sie zu com.android.tools.build > aapt2 im Feld Repository-Index.
2. Kopiere den Namen der neuesten Version von AAPT2.

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

   Um beispielsweise die Version 3.2.0-alpha18-4804415 für Windows herunterzuladen, würde Folgendes verwenden: 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. Rufe die URL in einem Browser auf. Der Download von APT2 wird in Kürze beginnen.

5. 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/

Hinweis: Sie können Ressourcenverzeichnisse mit dem Flag --dir zwar an AAPT2 übergeben, Dabei werden alle Dateien im Verzeichnis neu kompiliert, unabhängig davon, wie viele Dateien die sich tatsächlich geändert haben.

Während der Verknüpfungsphase verknüpft AAPT2 Ihre verschiedenen kompilierten Ressourcen mit einem ein einzelnes APK haben, weisen Sie AAPT2 an, das Manifest deiner App und die kompilierten Ressourcen zu konvertieren. in das protobuf-Format umwandeln, indem Sie das Flag --proto-format wie unten gezeigt einfügen:

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

Hinweis: Wenn Sie kompilierte Ressourcen mit dem Flag -R angeben, können Sie alternativ kann eine Textdatei angegeben werden, die den absoluten Pfad für jede der Ihre kompilierten Ressourcen, wobei jeder Pfad durch ein einzelnes Leerzeichen getrennt ist. Sie können Übergib diese Textdatei dann wie folgt an AAPT2: aapt2 link ... -R @compiled_resources.txt

Anschließend können Sie Inhalte aus dem Ausgabe-APK extrahieren, z. B. das AndroidManifest.xml, resources.pb und andere Ressourcendateien – jetzt im protobuf-Format. Sie benötigen diese Dateien zum Vorbereiten der Eingabe bundletool muss dein App Bundle erstellen, wie im Folgenden beschrieben .

Vorkompilierten Code und Ressourcen verpacken

Bevor du mit bundletool ein App Bundle für deine App generierst, musst du stellen zunächst ZIP-Dateien bereit, die jeweils den kompilierten Code und die Ressourcen für ein eines bestimmten App-Moduls. Inhalt und Struktur der ZIP-Datei für jedes Modul sind sehr ähnlich wie beim Android App Bundle-Format. Sie sollten beispielsweise eine base.zip-Datei für das Basismodul Ihrer App erstellen und So organisieren Sie den Inhalt:

Datei oder Verzeichnis	Beschreibung
manifest/AndroidManifest.xml	Das Manifest des Moduls im protobuf-Format.
dex/...	Ein Verzeichnis mit einer oder mehreren der kompilierten DEX-Dateien Ihrer Anwendung. Diese Dateien sollte folgendermaßen benannt werden: classes.dex, classes2.dex, classes3.dex usw.
res/...	Enthält die Modulressourcen im protobuf-Format für alle Geräte Konfigurationen. Unterverzeichnisse und Dateien sollten ähnlich organisiert sein wie wie bei einem typischen APK.
root/..., assets/... und lib/...	Diese Verzeichnisse sind identisch mit den im Abschnitt über Android App Bundle-Format.
resources.pb	Die Ressourcentabelle Ihrer App im protobuf-Format.

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

App Bundle mit Bundletool erstellen

Um Ihr App Bundle zu erstellen, verwenden Sie den Befehl bundletool build-bundle wie folgt: (siehe unten):

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

Hinweis: Wenn du das App Bundle veröffentlichen möchtest, musst du es mit signieren. jarsigner Du kannst dein App Bundle nicht mit apksigner signieren.

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

Melden	Beschreibung
--modules=path-to-base.zip, path-to-module2.zip,path-to-module3.zip	Gibt die Liste der ZIP-Dateien des Moduls an, die bundletool enthalten soll mit denen Sie Ihr App Bundle erstellen können.
--output=path-to-output.aab	Gibt den Pfad und Dateinamen für die *.aab-Ausgabedatei an.
--config=path-to-BundleConfig.json	Gibt den Pfad zu einer optionalen Konfigurationsdatei an, die Sie für Folgendes verwenden können: Anpassung des Build-Prozesses. Weitere Informationen finden Sie im Abschnitt Anpassung der nachgelagerten APK-Generierung.
--metadata-file=target-bundle-path:local-file-path	Weist bundletool an, eine optionale Metadatendatei zu verpacken in deinem App Bundle. Sie können diese Datei verwenden, um Daten wie die ProGuard-Zuordnungen oder die vollständige Liste der DEX-Dateien Ihrer App, die möglicherweise für andere Schritte in Ihrer Toolchain oder einem App-Shop nützlich sein. target-bundle-path gibt einen Pfad relativ zum Stamm von das App Bundle, in das die Metadatendatei gepackt werden soll, und local-file-path den Pfad zu den lokalen Metadaten angibt. -Datei selbst.

Downstream-APK-Generierung anpassen

App Bundles enthalten eine BundleConfig.pb-Datei mit Metadaten, die von der App wie Google Play, erfordern, wenn APKs aus dem Paket generiert werden. Obwohl bundletool diese Datei für Sie erstellt, können Sie einige Aspekte konfigurieren. der Metadaten in einer BundleConfig.json-Datei und übergeben sie an den bundletool build-bundle-Befehl: bundletool konvertiert ihn später und führt ihn zusammen. -Datei mit der im jeweiligen App-Bundle enthaltenen protobuf-Version.

Hinweis: Weitere Informationen zur Zuordnung von JSON zum protobuf-Format finden Sie unter JSON-Zuordnung. Diese Informationen sind jedoch komplexer als für diese Seite erforderlich.

Sie können beispielsweise festlegen, welche Kategorien von Konfigurations-APKs aktiviert werden, deaktivieren. Im folgenden Beispiel einer BundleConfig.json-Datei werden Konfigurations-APKs, die jeweils auf eine andere Sprache ausgerichtet sind (d. h. Ressourcen für alle Sprachen sind in der jeweiligen Basis oder Feature-APKs):

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

In der Datei BundleConfig.json kannst du auch angeben, welche Dateitypen beibehalten werden sollen beim Verpacken von APKs mit <ph type="x-smartling-placeholder"></ph> glob-Muster wie folgt:

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

Beachten Sie, dass bundletool standardmäßig nicht die nativen Bibliotheken (unter Android 6.0 oder höher) und Ressourcen Tabelle (resources.arsc). Eine vollständige Beschreibung dessen, was Sie dort konfigurieren können Ihr BundleConfig.json, prüfen Sie die bundletool config.proto Datei der mit Proto3 geschrieben wurde Syntax.

App aus einem App Bundle bereitstellen

Wenn Sie ein App Bundle erstellt und signiert haben, Verwende bundletool, um APKs zu generieren und auf auf einem Gerät.

App über die Befehlszeile signieren

Du benötigst zum Signieren deiner App kein Android Studio. Du kannst deine App über über die Befehlszeile mit apksigner für APKs oder jarsigner für App Bundles oder Gradle so konfigurieren, dass es während des Builds für Sie signiert wird. In jedem Fall müssen Sie Generieren Sie zunächst einen privaten Schlüssel mit keytool, wie unten dargestellt:

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

Im obigen Beispiel werden Sie aufgefordert, Passwörter für den Schlüsselspeicher und Schlüssel sowie für den „Distinguished Name“ für Ihren Schlüssel. Dann generiert es die Keystore als Datei namens my-release-key.jks gespeichert und im Verzeichnis des aktuellen Verzeichnisses. Sie können es an einen beliebigen Ort verschieben. 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, 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 Wenn du stattdessen ein APK signieren möchtest, musst du zipalign und apksigner verwenden. wie unten beschrieben.

1. Öffnen Sie eine Befehlszeile. Wählen Sie in Android Studio Ansicht > Toolfenster &gt; Terminal: Rufen Sie das Verzeichnis auf, in dem sich Ihr nicht signiertes APK befindet. befindet.

2. Richte 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 einem Byte-Ausrichtung relativ zum Anfang der Datei, Reduzieren des von einer App verbrauchten Arbeitsspeichers.

3. Signieren Sie Ihr APK mit Ihrem privaten Schlüssel über 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 einem Einzelne KeyStore-Datei: my-release-key.jks.

   Das apksigner-Tool unterstützt andere Signaturoptionen, darunter Signieren einer APK-Datei mit separatem privaten Schlüssel und separaten Zertifikatsdateien und Signieren eines APK mit mehreren Unterzeichnern Weitere Informationen finden Sie in der apksigner. Referenz.

   Hinweis:Wenn Sie das apksigner-Tool verwenden möchten, müssen Sie auf denen Version 24.0.3 oder höher der Android SDK Build Tools installiert ist. 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 Parameter Block signingConfigs {} mit Einträgen für storeFile, storePassword, keyAlias und keyPassword und übergeben Sie dieses Objekt an den signingConfig im Build-Typ fest. 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")
            ...
        }
    }
}

Cool

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

Hinweis: In diesem Fall sind der Schlüsselspeicher und das Schlüsselpasswort sichtbar. direkt in der Datei build.gradle. Zur Verbesserung der Sicherheit sollten Sie Entfernen die Signaturinformationen aus der Build-Datei.

Wenn Sie Ihre App jetzt Beim Aufrufen einer Gradle-Aufgabe signiert Gradle Ihre App und führt zipalign aus.

Da Sie den Release-Build mit Ihrem Signaturschlüssel konfiguriert haben, „Installation“ Task ist für diesen Build-Typ verfügbar. Sie können also das Release-APK zu signieren und auf einem Emulator oder Gerät zu installieren – alles mit der installRelease Aufgabe.

Eine mit Ihrem privaten Schlüssel signierte App ist bereit für die Bereitstellung. Sie sollten jedoch lesen Sie zuerst mehr zum Thema Veröffentlichung Ihre App und gehen Sie die Checkliste für die Einführung von Google Play durch.