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

Warnung:Google Play Instant ist nicht mehr verfügbar. Ab Dezember 2025 können Instant Apps nicht mehr über Google Play veröffentlicht werden und alle Google Play-Dienste-Instant-APIs funktionieren nicht mehr. Nutzer erhalten keine Instant Apps mehr von Play.

Wir nehmen diese Änderung aufgrund von Entwicklerfeedback und unserer kontinuierlichen Investitionen zur Verbesserung des Ökosystems seit der Einführung von Google Play Instant vor.

Damit Sie Ihre App weiter optimieren und noch mehr Nutzer gewinnen können, empfehlen wir, Nutzer über Deeplinks zu Ihrer regulären App oder Ihrem regulären Spiel weiterzuleiten und so ihr Interesse für bestimmte Inhalte zu wecken.

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

Ab Android-Gradle-Plug-in 3.3.0 unterstützt das Base-App-Plug-in Instant-Funktionen. Wenn das Basis-App-Modul die Anforderungen für eine Sofort-App erfüllt, profitieren Sie automatisch von den Vorteilen. Anschließend können Sie zusätzliche Funktionen hinzufügen, die Nutzer bei Bedarf als Instant-Apps herunterladen können. Verwenden Sie dazu das Dynamic Feature-Plug-in. Diese Einrichtung erleichtert die Unterstützung sowohl einer installierten App als auch einer Instant-App in einem einzigen Projekt und ermöglicht es Ihnen, von der Veröffentlichung mit Android App Bundles zu profitieren.

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

Beschreibung des Moduls Altes Plug-in Aktuelles Plug-in
Das Modul, das den grundlegenden Code, die Ressourcen und die Funktionen 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 Manifest- und Signaturinformationen, 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 Ressourcen für eine Funktion, die nur für die installierte Version Ihrer App verfügbar ist. com.android.application com.android.dynamic-feature (mit dist:instant="false" und dist:onDemand="false" im Manifest des Moduls)

Auf dieser Seite erfahren Sie, wie Sie Ihr vorhandenes Instant-App-Projekt migrieren, um ein Android App Bundle mit Instant-App-Unterstützung zu erstellen. Außerdem wird beschrieben, wie Sie ein Android App Bundle mit Instant-Version erstellen, testen und veröffentlichen.

Wenn Sie neue Instant-Versionen für Ihre App erstellen, lesen Sie stattdessen den Abschnitt Feature-Modul mit Instant-Version erstellen.

Änderungen nachvollziehen

Wenn Sie Ihr Projekt migrieren, um stattdessen das Dynamic Feature-Plug-in zu verwenden, bieten Android App Bundles eine neue Möglichkeit, Ihre App zu erstellen und zu veröffentlichen. Dadurch wird die Verteilung optimierter APKs an Ihre Nutzer erheblich vereinfacht.

App Bundles vereinfachen den Vertrieb, da der gesamte kompilierte Code und alle Ressourcen Ihrer App für den Upload verpackt werden. Die APK-Generierung und -Signierung wird jedoch an Google Play übertragen. Das neue App-Auslieferungsmodell von Google Play verwendet dann Ihr App-Bundle, um optimierte APKs für die Gerätekonfigurationen der einzelnen Nutzer zu generieren und bereitzustellen. So laden Nutzer nur den Code und die Ressourcen herunter, 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. Außerdem erhalten Nutzer kleinere, optimierte Downloads.

Bei Verwendung des inzwischen eingestellten Feature-Plug-ins war zum Erstellen einer Instant-App ein Basis-Feature-Modul erforderlich, das den freigegebenen Code und die Ressourcen für alle Ihre Module, einschließlich Ihres Instant-App-Moduls, enthielt. Der Rest Ihres Codes war in mehreren Feature-Modulen enthalten, die keine Basismodule waren und Einstiegspunkte für Ihre Instant-Versionen enthielten. Für die installierte Version Ihrer App enthielt Ihr Projekt möglicherweise ein separates App-Modul mit dem Code und den Aktivitäten, die nur für Ihre installierte App erforderlich sind.

Wenn Sie Ihre App migrieren, um Android App Bundles zu unterstützen, übernimmt Ihr App-Modul wieder die Rolle des Basismoduls. Zusätzliche installierte oder Instant-Versionen werden als Funktionsmodule organisiert. Ihr Projekt ähnelt jetzt einem Standard-App-Projekt mit einem Instant-fähigen Basismodul und der Möglichkeit, zusätzliche modulare Instant-Funktionen einzubinden.

Wenn Sie Ihr vorhandenes Instant-App-Projekt migrieren und das optimierte Vertriebsmodell von Android App Bundles nutzen möchten, folgen Sie der Anleitung in den folgenden Abschnitten.

Basisfunktionsmodul in ein App-Modul umwandeln

Sie müssen zuerst die Datei build.gradle des Basismoduls bearbeiten, bevor Sie es in das Haupt-App-Modul umwandeln. Gehen Sie dazu so vor:

  1. Löschen Sie die Zeile baseFeature true.

  2. Entfernen Sie alle Abhängigkeiten, für die die Abhängigkeitskonfigurationen feature oder application verwendet werden.

    Groovy

    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-Script-Konfigurationen, die Sie im Basis-App-Modul erwarten, vom aktuellen com.android.application-Modul in das com.android.feature-Modul. Unten sehen Sie einige Beispiele. Je nach Ihrer spezifischen build.gradle-Einrichtung kann es einfacher sein, den android-Block der build.gradle aus dem vorherigen App-Modul in die build.gradle-Datei des neuen App-Moduls zu kopieren und einzufügen. Dabei ist jedoch Vorsicht geboten.

    Groovy

    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-App-fähig, indem Sie dem Manifest die entsprechenden Tags für die Bundle-Verteilung hinzufügen, wie unten gezeigt.

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

  5. Konvertieren Sie das Funktionsmodul in Ihr Basis-App-Modul, indem Sie den Plug-in-Typ in com.android.application ändern:

    Groovy

    // 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 Feature-Modul für die Installationszeit umwandeln

Wenn das alte App-Modul keinen Code oder keine Ressourcen enthält, können Sie es einfach löschen. Durch die Schritte im vorherigen Abschnitt wurde Ihr Funktionsmodul in das Basis-App-Modul Ihrer App umgewandelt.

Wenn Sie jedoch Code und Ressourcen im alten App-Modul haben, die Funktionen darstellen, die Nutzern bei der Installation Ihrer App zur Verfügung stehen sollen, folgen Sie der Anleitung in diesem Abschnitt, um das App-Modul in ein Funktionsmodul zu konvertieren.

Zum Erstellen eines Featuremoduls muss der Plug-in-Typ von com.android.application in com.android.dynamic-feature geändert werden. Außerdem sind einige andere build.gradle-Änderungen erforderlich:

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

    Groovy

    // 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. Wie im vorherigen Abschnitt beschrieben, müssen Sie alle Build-Konfigurationen, die für das com.android.application-Plug-in erforderlich sind, in das Basis-App-Modul verschieben, z. B. applicationId- oder proguardFiles-Regeln.

  3. Benennen Sie das Modul so um:

    1. Öffnen Sie den Bereich Project (Projekt), indem Sie in der Menüleiste View > Tool Windows > Project (Ansicht > Tool-Fenster > Projekt) auswählen.
    2. Klicken Sie mit der rechten Maustaste auf das Funktionsmodul und wählen Sie Refactor > Rename (Umgestalten > 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 das neue App-Modul, das Sie im vorherigen Abschnitt erstellt haben, ähnlich wie in Schritt 3 in „app“ um.

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

    Groovy

    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ügen Sie die Funktion der Datei build.gradle des neuen App-Moduls hinzu.

    Groovy

    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 das Funktionsmodul im Manifest des Funktionsmoduls als installierbares Modul, indem Sie dem Manifest die entsprechenden Tags für die Bundle-Verteilung hinzufügen.

    <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 Instant-fähige Funktionsmodule umwandeln

Wenn Sie zusätzliche Funktionen Ihrer App in mehrere Feature-Module unterteilt haben, müssen Sie die Schritte in diesem Abschnitt ausführen, um diese Module in Feature-Module mit Sofort-App-Unterstützung zu konvertieren.

Gehen Sie für jedes verbleibende Featuremodul in Ihrem Projekt so vor, um es in ein Instant-Feature zu konvertieren:

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

    Groovy

    // 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 Featuremodul als Instant-App-fähig, indem Sie dem Manifest Folgendes hinzufügen.

    <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 Featuremodul der build.gradle-Datei des neuen Anwendungsmoduls hinzu, in der Sie installed_feature der Liste der Featuremodule hinzugefügt haben.

    Groovy

    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 aktivierter Instant-Version erstellen, testen und veröffentlichen

Nachdem Sie die Schritte auf dieser Seite ausgeführt haben, kann Ihr Projekt ein einzelnes Artefakt, ein Android App Bundle, erstellen. Damit können Sie sowohl die installierte als auch die Instant-Version Ihrer App in der Google Play Console veröffentlichen und separat für die Instant- und die installierten Tracks bereitstellen. Außerdem können Sie mit App Bundles optimierte APKs für die Gerätekonfigurationen der einzelnen Nutzer bereitstellen. So laden Nutzer nur den Code und die Ressourcen herunter, die sie zum Ausführen Ihrer App benötigen. Das bedeutet, dass Sie nicht mehr mehrere APKs erstellen, signieren und verwalten müssen, um verschiedene Geräte zu unterstützen. Nutzer erhalten kleinere, optimierte Downloads.

Wenn Sie mit dem Erstellen und Testen Ihres App-Bundles mit Instant-Version beginnen möchten, gehen Sie zu App-Bundle erstellen.