Play Feature Delivery

Im App-Bereitstellungsmodell von Google Play werden Android App Bundles verwendet, um optimierte APKs für die Gerätekonfiguration der einzelnen Nutzer zu generieren und bereitzustellen. Nutzer laden dann nur den Code und die Ressourcen herunter, die sie zum Ausführen deiner App benötigen.

Play Feature Delivery nutzt erweiterte Funktionen von App Bundles, sodass bestimmte Funktionen Ihrer App unter bestimmten Bedingungen bereitgestellt oder on demand heruntergeladen werden können. Dazu müssen Sie diese Funktionen zuerst von Ihrer Basis-App in Funktionsmodule unterteilen.

Build-Konfiguration für Funktionsmodul

Wenn Sie mit Android Studio ein neues Funktionsmodul erstellen, wendet die IDE das folgende Gradle-Plug-in auf die Datei build.gradle des Moduls an.

// The following applies the dynamic-feature plugin to your feature module.
// The plugin includes the Gradle tasks and properties required to configure and build
// an app bundle that includes your feature module.

plugins {
  id 'com.android.dynamic-feature'
}

Viele der für das Standard-Anwendungs-Plug-in verfügbaren Attribute sind auch für Ihr Featuremodul verfügbar. In den folgenden Abschnitten werden die Attribute beschrieben, die Sie in die Build-Konfiguration Ihres Featuremoduls aufnehmen sollten und welche nicht.

Was nicht in der Build-Konfiguration des Feature-Moduls enthalten ist

Da jedes Featuremodul vom Basismodul abhängt, übernimmt es auch bestimmte Konfigurationen. Daher sollten Sie in der Datei build.gradle des Feature-Moduls Folgendes weglassen:

• Signierkonfigurationen:App Bundles werden mit Signaturkonfigurationen signiert, die Sie im Basismodul angeben.
• Attribut minifyEnabled:Sie können das Codekomprimieren für das gesamte Anwendungsprojekt nur über die Build-Konfiguration des Basismoduls aktivieren. Daher sollten Sie diese Eigenschaft bei den Funktionsmodulen weglassen. Sie können jedoch für jedes Featuremodul zusätzliche ProGuard-Regeln festlegen.
• versionCode und versionName: Beim Erstellen des App-Bundles verwendet Gradle die Informationen zur App-Version, die vom Basismodul bereitgestellt werden. Sie sollten diese Attribute in der Datei build.gradle Ihres Featuremoduls weglassen.

Beziehung zum Basismodul herstellen

Wenn Android Studio Ihr Feature-Modul erstellt, wird es für das Basismodul sichtbar, indem es der Datei build.gradle des Basismoduls das Attribut android.dynamicFeatures hinzufügt:

// In the base module’s build.gradle file.
android {
    ...
    // Specifies feature modules that have a dependency on
    // this base module.
    dynamicFeatures = [":dynamic_feature", ":dynamic_feature2"]
}

Darüber hinaus enthält Android Studio das Basismodul als Abhängigkeit des Funktionsmoduls, wie unten dargestellt:

// In the feature module’s build.gradle file:
...
dependencies {
    ...
    // Declares a dependency on the base module, ':app'.
    implementation project(':app')
}

Zusätzliche ProGuard-Regeln angeben

Obwohl nur die Build-Konfiguration des Basismoduls die Codeverkleinerung für Ihr App-Projekt ermöglicht, können Sie mit jedem Featuremodul über das Attribut proguardFiles benutzerdefinierte ProGuard-Regeln angeben, wie unten gezeigt.

android.buildTypes {
     release {
         // You must use the following property to specify additional ProGuard
         // rules for feature modules.
         proguardFiles 'proguard-rules-dynamic-features.pro'
     }
}

Beachten Sie, dass diese ProGuard-Regeln bei der Build-Erstellung mit denen aus anderen Modulen (einschließlich des Basismoduls) zusammengeführt werden. Obwohl für jedes Funktionsmodul ein neuer Satz von Regeln angegeben werden kann, gelten diese Regeln für alle Module im App-Projekt.

Anwendung bereitstellen

Während Sie Ihre Anwendung mit Unterstützung für Funktionsmodule entwickeln, können Sie sie wie gewohnt auf einem verbundenen Gerät bereitstellen. Wählen Sie dazu in der Menüleiste Ausführen > Ausführen aus oder klicken Sie in der Symbolleiste auf Ausführen .

Wenn Ihr App-Projekt ein oder mehrere Funktionsmodule enthält, können Sie auswählen, welche Features bei der Bereitstellung der App berücksichtigt werden sollen. Dazu ändern Sie die vorhandene Ausführungs-/Fehlerbehebungskonfiguration so:

1. Wählen Sie in der Menüleiste Run > Edit Configurations aus.
2. Wählen Sie im linken Bereich des Dialogfelds Run/Debug Configurations (Ausführungs-/Fehlerbehebungskonfigurationen) die gewünschte Konfiguration für die Android-App aus.
3. Klicken Sie unter Dynamische Features für die Bereitstellung auf dem Tab Allgemein das Kästchen neben jedem Featuremodul an, das Sie bei der Bereitstellung Ihrer Anwendung einbinden möchten.
4. Klicke auf OK.

Standardmäßig wird deine App von Android Studio nicht mit App Bundles bereitgestellt, um sie bereitzustellen. Stattdessen erstellt und installiert die IDE APKs auf deinem Gerät, die für die Bereitstellungsgeschwindigkeit und nicht für die APK-Größe optimiert sind. Wenn Sie Android Studio so konfigurieren möchten, dass APKs und Instant-Versionen stattdessen aus einem App Bundle erstellt und bereitgestellt werden, ändern Sie Ihre Ausführungs-/Fehlerbehebungskonfiguration.

Funktionsmodule für benutzerdefinierte Zustellung verwenden

Ein besonderer Vorteil von Funktionsmodulen besteht darin, dass du anpassen kannst, wie und wann verschiedene Funktionen deiner App auf Geräte mit Android 5.0 (API-Level 21) oder höher heruntergeladen werden. Wenn du beispielsweise die anfängliche Downloadgröße deiner App reduzieren möchtest, kannst du bestimmte Funktionen so konfigurieren, dass sie entweder bei Bedarf oder nur von Geräten heruntergeladen werden, die bestimmte Funktionen unterstützen, z. B. die Möglichkeit, Bilder aufzunehmen oder Augmented Reality-Funktionen zu unterstützen.

Auch wenn Sie Ihre App standardmäßig als App Bundle hochladen, sind die Downloads optimiert. Die erweiterten und anpassbaren Optionen für die Featurebereitstellung erfordern eine zusätzliche Konfiguration und Modularisierung der Funktionen Ihrer App mithilfe von Funktionsmodulen. Funktionsmodule stellen also die Bausteine zum Erstellen modularer Funktionen bereit, die Sie jeweils konfigurieren und nach Bedarf herunterladen können.

Stellen Sie sich eine App vor, mit der Nutzer Waren auf einem Onlinemarktplatz kaufen und verkaufen können. Du kannst jede der folgenden Funktionen der App in separate Funktionsmodule modularisieren:

• Kontoanmeldung und Kontoerstellung
• Marketplace durchsuchen
• Einen Artikel zum Verkauf anbieten
• Zahlungen werden verarbeitet

In der folgenden Tabelle werden die verschiedenen Auslieferungsoptionen beschrieben, die von Featuremodulen unterstützt werden, und wie sie verwendet werden können, um die anfängliche Downloadgröße der Beispiel-Marketplace-App zu optimieren.

URI für eine Ressource erstellen

Wenn Sie über einen URI auf eine Ressource zugreifen möchten, die in einem Featuremodul gespeichert ist, generieren Sie mit Uri.Builder() einen Ressourcen-URI für Featuremodule:

val uri = Uri.Builder()
                .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
                .authority(context.getPackageName()) // Look up the resources in the application with its splits loaded
                .appendPath(resources.getResourceTypeName(resId))
                .appendPath(String.format("%s:%s",
                  resources.getResourcePackageName(resId), // Look up the dynamic resource in the split namespace.
                  resources.getResourceEntryName(resId)
                  ))
                .build()

String uri = Uri.Builder()
                .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
                .authority(context.getPackageName()) // Look up the resources in the application with its splits loaded
                .appendPath(resources.getResourceTypeName(resId))
                .appendPath(String.format("%s:%s",
                  resources.getResourcePackageName(resId), // Look up the dynamic resource in the split namespace.
                  resources.getResourceEntryName(resId)
                  ))
                .build().toString();

Jeder Teil des Pfads zur Ressource wird während der Laufzeit erstellt, damit nach dem Laden der unterteilten APKs der richtige Namespace generiert wird.

Ein Beispiel für die Generierung des URI wird angenommen, wenn Sie eine App und Funktionsmodule mit den folgenden Namen haben:

• App-Paketname: com.example.my_app_package
• Paketname der Featureressourcen: com.example.my_app_package.my_dynamic_feature

Wenn sich resId im obigen Code-Snippet auf eine Rohdateiressource mit dem Namen „my_video“ in Ihrem Funktionsmodul bezieht, würde der obige Uri.Builder()-Code Folgendes ausgeben:

android.resource://com.example.my_app_package/raw/com.example.my_app_package.my_dynamic_feature:my_video

Mit diesem URI kann deine App dann auf die Ressource des Funktionsmoduls zugreifen.

Wenn Sie die Pfade in Ihrem URI prüfen möchten, können Sie mit dem APK Analyzer das APK Ihres Featuremoduls prüfen und den Paketnamen ermitteln:

Abbildung 2: Verwende das APK Analyzer, um den Paketnamen in einer kompilierten Ressourcendatei zu überprüfen.

Überlegungen zu Funktionsmodulen

Mit Funktionsmodulen können Sie die Build- und Entwicklungsgeschwindigkeit verbessern und die Bereitstellung der Funktionen Ihrer App umfassend anpassen, um die Größe Ihrer App zu reduzieren. Bei der Verwendung von Funktionsmodulen sind jedoch einige Einschränkungen und Grenzfälle zu beachten:

• Die Installation von 50 oder mehr Funktionsmodulen auf einem einzelnen Gerät über eine bedingte oder On-Demand-Bereitstellung kann zu Leistungsproblemen führen. Module bei der Installation, die nicht als entnehmbar konfiguriert sind, sind automatisch im Basismodul enthalten und zählen nur als ein Funktionsmodul auf jedem Gerät.
• Begrenzen Sie die Anzahl der Module, die Sie für die Bereitstellung bei der Installation als entfernbar konfigurieren, auf maximal zehn. Andernfalls kann sich die Download- und Installationszeit Ihrer App verlängern.
• Das Herunterladen und Installieren von Funktionen bei Bedarf wird nur auf Geräten mit Android 5.0 (API-Level 21) und höher unterstützt. Wenn Sie Ihr Feature für frühere Versionen von Android verfügbar machen möchten, aktivieren Sie beim Erstellen eines Funktionsmoduls Fusing.
• Aktivieren Sie SplitCompat, damit Ihre Anwendung auf heruntergeladene Funktionsmodule zugreifen kann, die bei Bedarf bereitgestellt werden.
• Featuremodule sollten in ihrem Manifest keine Aktivitäten angeben, wenn android:exported auf true gesetzt ist. Das liegt daran, dass es keine Garantie dafür gibt, dass das Gerät das Funktionsmodul heruntergeladen hat, wenn eine andere App versucht, die Aktivität zu starten. Außerdem sollte Ihre Anwendung prüfen, ob eine Funktion heruntergeladen wurde, bevor versucht wird, auf ihren Code und ihre Ressourcen zuzugreifen. Weitere Informationen finden Sie unter Installierte Module verwalten.
• Bei Play Feature Delivery musst du deine App mit einem App Bundle veröffentlichen. Achte deshalb darauf, dass du die bekannten Probleme mit App Bundle kennst.

Manifestreferenz für Funktionsmodul

Beim Erstellen eines neuen Funktionsmoduls mit Android Studio enthält die IDE die meisten Manifestattribute, die für das Verhalten des Moduls erforderlich sind. Außerdem werden einige Attribute bei der Kompilierung vom Build-System eingeschleust, sodass Sie sie nicht selbst angeben oder ändern müssen. In der folgenden Tabelle werden die Manifestattribute beschrieben, die für Featuremodule wichtig sind.

Zusätzliche Ressourcen

Weitere Informationen zur Verwendung von Funktionsmodulen finden Sie in den folgenden Ressourcen.

Blogposts

• Neue Funktionen für die Entwicklung, Veröffentlichung und den Ausbau deines Geschäfts bei Google Play
• Die neuesten Updates für Android App Bundle, einschließlich der Add-ons API
• Patchwork Plaid – Eine Geschichte zur Modularisierung

Videos

• Individuelle Bereitstellung mit dem App Bundle und einfaches Teilen von Test-Builds
• Neue Tools zur Optimierung der Größe deiner App und zur Steigerung der Installationen bei Google Play

Nutzungsbedingungen und Datensicherheit

Durch den Zugriff auf die Play Feature Delivery Library oder deren Verwendung stimmst du den Nutzungsbedingungen des Play Core Software Development Kit zu. Bitte lesen und verstehen Sie alle geltenden Nutzungsbedingungen und Richtlinien, bevor Sie auf die Bibliothek zugreifen.

Datensicherheit

Die Play Core-Bibliotheken sind die Schnittstelle zwischen Ihrer App und dem Google Play Store. Wenn Sie Play Core in Ihrer App verwenden, führt der Play Store daher eigene Prozesse aus. Dazu zählt die Verarbeitung von Daten gemäß den Google Play-Nutzungsbedingungen. Im Folgenden wird beschrieben, wie die Play Core-Bibliotheken Daten verarbeiten, um bestimmte Anfragen von deiner App zu verarbeiten.

API für zusätzliche Sprachen

Play Feature Delivery

Wir möchten so transparent wie möglich sein. Du bist aber allein dafür verantwortlich, das Formular für den Abschnitt zur Datensicherheit von Google Play in Bezug auf die Erhebung, Weitergabe und Sicherheit von Nutzerdaten in deiner App auszufüllen.