Instant App migrieren, um Android App Bundles zu unterstützen

Wenn Sie noch das eingestellte Android Gradle-Plug-in „Feature“ (com.android.feature) für Ihre Android Instant App-Module verwenden, müssen Sie zum Basis-App-Plug-in (com.android.application) und dem Plug-in für dynamische Funktionen (com.android.dynamic-feature) migrieren.

Unter Android Gradle-Plug-in 3.3.0 und höher unterstützt das Basis-App-Plug-in Instant-Funktionen. Wenn also das Basisanwendungsmodul die Anforderungen für eine Instant-Funktion erfüllt, erhalten Sie automatisch einen Vorteil. Anschließend können Sie zusätzliche Funktionen einbinden, die Nutzer mit dem Plug-in für dynamische Funktionen bei Bedarf als Instant-Funktionen herunterladen können. Mit dieser Konfiguration ist es einfacher, sowohl eine installierte als auch eine Instant App über ein einziges Projekt zu unterstützen, und Sie profitieren von der Veröffentlichung mit Android App Bundles.

In der folgenden Tabelle wird besser beschrieben, zu welchen Plug-ins Sie migrieren werden:

Beschreibung des Moduls Altes Plug-in Aktuelles Plug-in
Das Modul, das den grundlegenden Code, die Ressourcen und die Funktionalität für Ihre installierte App oder Instant-App enthält. com.android.feature (mit baseFeature = true) com.android.application

Hinweis:Dieses Modul enthält alle Informationen zum Manifest und zur Signatur, die zum Erstellen und Verpacken Ihrer App als Android App Bundle oder APK erforderlich sind.

Zusätzliche, modulare Funktionen, die Nutzer bei Bedarf herunterladen können com.android.feature com.android.dynamic-feature (mit dist:instant="true" und dist:onDemand="false" im Manifest des Moduls)
Code und Ressource für ein Feature, die nur für die installierte Version Ihrer App verfügbar sind. com.android.application com.android.dynamic-feature (mit dist:instant="false" und dist:onDemand="false" im Manifest des Moduls)

Auf dieser Seite wird beschrieben, wie Sie Ihr bestehendes Instant App-Projekt migrieren, um ein Android App Bundle mit Instant-Version zu erstellen. Außerdem wird beschrieben, wie ein Android App Bundle mit Instant-Version erstellt, getestet und veröffentlicht wird.

Wenn Sie neue Instant-Versionen für Ihre App erstellen, lesen Sie stattdessen den Artikel Funktionsmodul mit Instant-Version erstellen.

Änderungen verstehen

Wenn Sie Ihr Projekt stattdessen zur Verwendung des Plug-ins für dynamische Funktionen migrieren, bieten Android App Bundles eine neue Möglichkeit zum Erstellen und Veröffentlichen Ihrer App, um die Bereitstellung optimierter APKs an Ihre Nutzer erheblich zu vereinfachen.

App Bundles vereinfachen die Bereitstellung, da alle kompilierten Codes und Ressourcen der App für den Upload gepackt werden. Die APK-Erstellung und das Signieren werden jedoch bei Google Play verschoben. Das neue App-Bereitstellungsmodell von Google Play verwendet dann Ihr App-Bundle, um optimierte APKs für die Gerätekonfiguration der einzelnen Nutzer zu generieren und bereitzustellen, sodass nur der Code und die Ressourcen heruntergeladen werden, die sie zum Ausführen Ihrer App benötigen. Sie müssen nicht mehr mehrere APKs erstellen, signieren und verwalten, um verschiedene Geräte zu unterstützen, und Nutzer erhalten kleinere, optimierte Downloads.

Wenn Sie das mittlerweile verworfene Feature-Plug-in verwenden, musste zum Erstellen einer Instant-App ein Basis-Feature-Modul erstellt werden, das den freigegebenen Code und die Ressourcen für alle Module, einschließlich des Instant-App-Moduls, enthielt. Der Rest des Codes war in mehrere Nicht-Basisfunktionsmodule enthalten, die Einstiegspunkte für Ihre Instant-Funktionen enthielten. Für die installierte Version Ihrer Anwendung enthält Ihr Projekt möglicherweise ein separates Anwendungsmodul, das den Code und die Aktivitäten enthält, die nur für die installierte Anwendung erforderlich sind.

Wenn Sie Ihre App migrieren, um Android App Bundles zu unterstützen, übernimmt Ihr App-Modul die Rolle des Basismoduls und Sie organisieren zusätzliche installierte oder Instant-Funktionen als Featuremodule. Das heißt, Ihr Projekt ähnelt jetzt eher einem Standard-App-Projekt mit einem Basismodul mit Instant-Version und der Möglichkeit, zusätzliche, modulare Instant-Versionen einzubinden.

Wenn du dein bestehendes Instant App-Projekt migrieren und das optimierte Vertriebsmodell von Android App Bundle übernehmen möchtest, folge den Schritten in den folgenden Abschnitten.

Konvertiere das Basisfunktionsmodul in ein App-Modul

Sie müssen zuerst die Datei build.gradle des Basisfunktionsmoduls bearbeiten, bevor Sie sie in das Haupt-App-Modul konvertieren:

  1. Löschen Sie die Zeile baseFeature true.

  2. Entfernen Sie alle Abhängigkeiten, die die Abhängigkeitskonfigurationen feature oder application verwenden.

    Groovig

    dependencies {
    ...
    // delete any lines that look like
    // feature project(":foo")
    // feature project(":bar")
    // application project(":app")
}

    Kotlin

    dependencies {
    ...
    // delete any lines that look like
    // feature(project(":foo"))
    // feature(project(":bar"))
    // application(project(":app"))
}

  3. Verschieben Sie applicationId zusammen mit allen anderen Build-Skript-Konfigurationen, die sich im Basisanwendungsmodul befinden würden, vom aktuellen com.android.application-Modul in das com.android.feature-Modul. Einige Beispiele finden Sie unten. Abhängig von Ihrer spezifischen build.gradle-Einrichtung kann es für diesen Schritt einfacher sein, den android-Block des build.gradle-Elements aus dem vorherigen Anwendungsmodul aus dem vorherigen Anwendungsmodul in die Datei build.gradle des neuen Anwendungsmoduls einzufügen. Lassen Sie dabei jedoch Vorsicht walten.

    Groovig

    android {
    ...
    defaultConfig {
        // You need to move the application ID from the app module
        // to your feature module.
        applicationId "com.example.myapp"
        ...
    }
    // Some additional build configurations you might want to
    // copy from your current ‘app’ module may include ProGuard
    // rules and code shrinking settings.
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(
              'proguard-android-optimize.txt'),
              'proguard-rules.pro'
        }
    }
}

    Kotlin

    android {
    ...
    defaultConfig {
        // You need to move the application ID from the app module
        // to your feature module.
        applicationId = "com.example.myapp"
        ...
    }
    // Some additional build configurations you might want to
    // copy from your current ‘app’ module may include ProGuard
    // rules and code shrinking settings.
    buildTypes {
        getByName("release") {
            minifyEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

  4. Markieren Sie das Funktionsmodul als Instant-Version, indem Sie dem Manifest die entsprechenden Bundle-Distributions-Tags hinzufügen, wie unten gezeigt.

    <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="true" />
    ...
</manifest>

  5. Konvertieren Sie das Feature-Modul in das Basis-App-Modul. Ändern Sie dazu seinen Plug-in-Typ in com.android.application:

    Groovig

    // Replace  "plugins { id 'com.android.feature' }"
// with the following
plugins {
  id 'com.android.application'
}

    Kotlin

    // Replace  "plugins { id("com.android.feature") }"
// with the following
plugins {
    id("com.android.application")
}

Altes App-Modul in ein Funktionsmodul zur Installationszeit umwandeln

Wenn im alten Anwendungsmodul weder Code noch Ressourcen vorhanden sind, können Sie es einfach löschen. In den Schritten, die Sie im vorherigen Abschnitt ausgeführt haben, wurde Ihr Feature-Modul in das Basisanwendungsmodul Ihrer App umgewandelt.

Wenn Sie jedoch Code und Ressourcen im alten App-Modul haben, die Funktionen darstellen, die Sie Nutzern bei der Installation Ihrer App zur Verfügung stellen möchten, führen Sie die Schritte in diesem Abschnitt aus, um das App-Modul in ein Funktionsmodul zu konvertieren.

Zum Erstellen eines Funktionsmoduls müssen der Plug-in-Typ von com.android.application in com.android.dynamic-feature geändert werden sowie einige weitere build.gradle-Änderungen:

  1. Ändern Sie den Plug-in-Typ von com.android.application zu com.android.dynamic-feature.

    Groovig

    // Replace "plugins { id 'com.android.feature' }"
// with the following:
plugins {
  id 'com.android.dynamic-feature'
}

    Kotlin

    // Replace "plugins { id("com.android.application") }"
// with the following:
plugins {
    id("com.android.dynamic-feature")
}

  2. Achten Sie wie im vorherigen Abschnitt beschrieben darauf, dass Sie die für das com.android.application-Plug-in erforderlichen Build-Konfigurationen in das Basisanwendungsmodul verschoben haben, z. B. applicationId- oder proguardFiles-Regeln.

  3. Benennen Sie das Modul folgendermaßen um, z. B. in „installed_feature“:

    1. Öffnen Sie den Bereich Projekt, indem Sie in der Menüleiste Ansicht > Toolfenster > Projekt auswählen.
    2. Klicken Sie mit der rechten Maustaste auf das Funktionsmodul und wählen Sie Refaktorieren > Umbenennen aus.
    3. Wählen Sie im angezeigten Dialogfeld Modul umbenennen aus und klicken Sie auf OK.
    4. Geben Sie den neuen Namen für das Modul ein und klicken Sie auf OK.

  4. Benennen Sie ähnlich wie in Schritt 3 das neue App-Modul, das Sie im vorherigen Abschnitt erstellt haben, in etwa "app" um.

  5. Fügen Sie eine Implementierungsabhängigkeit für das Modul „App“ in der Datei build.gradle des Funktionsmoduls hinzu, wie unten dargestellt.

    Groovig

    dependencies {
    ...
    // In the feature module, add an implementation dependency
    // on the base app module.
    implementation project(":app")
}

    Kotlin

    dependencies {
    ...
    // In the feature module, add an implementation dependency
    // on the base app module.
    implementation(project(":app"))
}

  6. Füge die Funktion der Datei build.gradle des neuen App-Moduls hinzu.

    Groovig

    android {
    ...
    // In the base app module, specify each feature module.
    dynamicFeatures = [":installed_feature"]
}

    Kotlin

    android {
    ...
    // In the base app module, specify each feature module.
    dynamicFeatures.addAll(listOf(":installed_feature"))
}

  7. Markieren Sie im Manifest des Funktionsmoduls das Funktionsmodul als installierbares Modul. Fügen Sie dazu dem Manifest die entsprechenden Tags für die Bundle-Bereitstellung hinzu.

    <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="false" dist:onDemand="false"
            dist:title="@string/title_dynamic_feature">
        <dist:fusing dist:include="true" />
    </dist:module>
    ...
</manifest>

Andere Funktionsmodule in Funktionsmodule mit Instant-Version konvertieren

Wenn Sie zusätzliche Funktionen Ihrer App in mehrere Featuremodule modularisiert haben, müssen Sie die Schritte in diesem Abschnitt ausführen, um diese Module in Instant-fähige Featuremodule zu konvertieren.

Gehen Sie für jedes verbleibende Feature-Modul in Ihrem Projekt so vor, um sie in Instant-fähige Features zu konvertieren:

  1. Ändern Sie den Plug-in-Typ in der Datei build.gradle in com.android.dynamic-feature, wie unten gezeigt:

    Groovig

    // Replace 'com.android.feature' with 'com.android.dynamic-feature'
plugins {
  id 'com.android.dynamic-feature'
}

    Kotlin

    // Replace "com.android.feature" with "com.android.dynamic-feature"
plugins {
    id("com.android.dynamic-feature")
}

  2. Markieren Sie jedes Feature-Modul als für die Instant-Version aktiviert. Fügen Sie dazu dem Manifest Folgendes hinzu:

    <manifest ... xmlns:dist="http://schemas.android.com/apk/distribution">
    <dist:module dist:instant="true" dist:onDemand="false"
            dist:title="@string/title_dynamic_feature">
        <dist:fusing dist:include="true" />
    </dist:module>
    ...
</manifest>

  3. Fügen Sie das Feature-Modul der Datei build.gradle des neuen Anwendungsmoduls hinzu, in der Sie das installed_feature der Liste der Featuremodule hinzugefügt haben.

    Groovig

    android {
   ...
   dynamicFeatures = [":installed_feature", ":feature_1", ":feature_2"]
   // or whichever name exists for the instant enabled feature module
}

    Kotlin

    android {
   ...
   dynamicFeatures.addAll(listOf(":installed_feature", ":feature_1", ":feature_2"))
   // or whichever name exists for the instant enabled feature module
}

Neues App Bundle mit Instant-Version erstellen, testen und veröffentlichen

Nachdem Sie die Schritte auf dieser Seite ausgeführt haben, kann Ihr Projekt ein einzelnes Artefakt erstellen, ein Android App Bundle, mit dem Sie sowohl die installierte Version als auch die Instant-Version Ihrer App in der Google Play Console veröffentlichen und für den Instant- und den installierten Tracks separat einführen können. Mit App Bundles erhältst du außerdem den Vorteil, dass für die Gerätekonfiguration der einzelnen Nutzer optimierte APKs bereitgestellt werden. Diese laden dann nur den Code und die Ressourcen herunter, die sie zum Ausführen deiner App benötigen. Du musst also nicht mehr mehrere APKs erstellen, signieren und verwalten, um verschiedene Geräte zu unterstützen, und Nutzer erhalten kleinere, optimierte Downloads.

Informationen zum Erstellen und Testen des App Bundles mit Instant-Version finden Sie unter App Bundle erstellen.