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

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

Ab Android-Gradle-Plug-in 3.3.0 unterstützt das Basis-App-Plug-in für Instant-Apps. Das heißt, wenn das Basis-App-Modul die Anforderungen für eine Instant-Version bieten, erhältst du den Vorteil automatisch. Anschließend können Sie zusätzliche Funktionen hinzufügen, die Nutzer bei Bedarf als Instant-Funktionen mit dem Plug-in für dynamische Funktionen. Mit dieser Einrichtung können Sie ist es einfacher, eine installierte App und eine Instant App zu unterstützen. und profitieren von der Veröffentlichung mit Android App Bundles

In der folgenden Tabelle wird besser 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 enthält für deine installierte App oder Instant App. com.android.feature (mit baseFeature = true) com.android.application

Hinweis: Dieses Modul enthält das gesamte Manifest und Signaturinformationen, die zum Erstellen und Verpacken deiner App als Android-Gerät erforderlich sind App Bundle oder APK

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, das nur für die installierte Version verfügbar ist Ihrer App. 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 du dein bestehendes Instant App-Projekt migrierst, um ein Instant-fähiges Android App Bundle. Außerdem wird beschrieben, wie Sie ein Android App Bundle mit Instant-Version veröffentlichen.

Wenn Sie neue Instant-Versionen für Ihre App erstellen, lesen Sie stattdessen Erstellen Sie ein Instant-fähiges Funktionsmodul.

Informationen zu den Änderungen

Wenn Sie Ihr Projekt migrieren, um stattdessen das Plug-in für dynamische Funktionen zu verwenden, Android App Bundles bieten eine neue Möglichkeit, Inhalte zu erstellen und zu veröffentlichen. die die Verteilung optimierter APKs an deine App Nutzenden.

App Bundles vereinfacht die Bereitstellung, da der gesamte kompilierte Code deiner App gepackt wird und Ressourcen für den Upload, verschiebt aber die APK-Erstellung und -Signatur bei Google Play. Im neuen App-Bereitstellungsmodell von Google Play werden dann App Bundle, um optimierte APKs für die Geräte der einzelnen Nutzer zu generieren und bereitzustellen Konfiguration, sodass sie nur den Code und die Ressourcen herunterladen, die sie zur Ausführung benötigen. für Ihre App. Sie müssen für den Support nicht mehr mehrere APKs erstellen, signieren und verwalten. und Nutzer erzielen kleinere, optimierte Downloads.

Bei Verwendung des inzwischen verworfenen Funktions-Plug-ins ist das Erstellen einer Instant-App erforderlich Erstellen eines Basisfunktionsmoduls, das den gemeinsamen Code und die Ressourcen enthielt für alle Module, einschließlich des Instant-App-Moduls. Der Rest Ihres Codes war in mehreren Nicht-Basis-Funktionsmodulen enthalten, die Einstiegspunkte enthielten, für Ihre Instant-App. Für die installierte Version Ihrer App könnte ein separates Anwendungsmodul mit dem Code und Aktivitäten, die nur für die installierte App erforderlich sind.

Wenn du deine App migrierst, damit Android App Bundles unterstützt werden, nimmt die Rolle des Basismoduls zurück und Sie organisieren zusätzliche installierte oder Instant-Versionen als Funktionsmodule. Das heißt, Ihr Projekt Es ähnelt einem Standard-App-Projekt mit einem Basismodul mit Instant-Version. und die Möglichkeit, zusätzliche, modulare Instant-Versionen einzubinden.

Um dein bestehendes Instant App-Projekt zu migrieren und das Android App Bundle zu übernehmen für ein optimiertes Vertriebsmodell, führen Sie die in den Abschnitten beschriebenen Schritte aus. unten.

Basisfunktionsmodul in ein App-Modul konvertieren

Du musst zuerst die Datei build.gradle des Basisfunktionsmoduls bearbeiten, bevor wie folgt in das App-Hauptmodul umgewandelt:

  1. Löschen Sie die Zeile baseFeature true.

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

    Cool

    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 in eurem Basis-App-Modul aus dem aktuellen com.android.application-Moduls zum com.android.feature-Modul. Einige Beispiele finden Sie unten. Für diesen Schritt benötigen Sie build.gradle einrichten, ist es möglicherweise einfacher, die android zu kopieren und einzufügen Block von build.gradle aus dem vorherigen App-Modul in die neue App der Datei build.gradle des Moduls. Sie sollten jedoch vorsichtig sein, also.

    Cool

    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-fähig, indem Sie das entsprechende Bundle hinzufügen. Distribution-Tags an das Manifest übergeben, wie unten gezeigt.

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

  5. Konvertiere das Funktionsmodul in dein Basis-App-Modul, indem du sein Plug-in änderst in com.android.application eingeben:

    Cool

    // 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")
}

Konvertiere das alte App-Modul in ein Funktionsmodul bei der Installation

Wenn im alten App-Modul weder Code noch Ressourcen vorhanden sind, da die Schritte, die Sie im vorherigen Abschnitt ausgeführt haben, Ihr Funktionsmodul in das Basismodul deiner App einfügen.

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

Zum Erstellen eines Funktionsmoduls muss der Plug-in-Typ von com.android.application bis com.android.dynamic-feature, zusammen mit einigen weitere build.gradle-Änderungen:

  1. Plug-in-Typ von com.android.application zu ändern com.android.dynamic-feature.

    Cool

    // 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 darauf, dass Sie den Build verschoben haben, wie im vorherigen Abschnitt beschrieben. Konfigurationen, die vom com.android.application-Plug-in für die Basis-App-Modul, z. B. applicationId- oder proguardFiles-Regeln

  3. Benennen Sie das Modul um, z. B. in „installed_feature“. wie folgt:

    1. Öffnen Sie den Bereich Projekt, indem Sie View > Tool-Fenster > Projekt aus.
    2. Klicken Sie mit der rechten Maustaste auf das Funktionsmodul und wählen Sie Refaktorieren > Umbenennen:
    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. Ähnlich wie in Schritt 3 benennen Sie das neue App-Modul, das Sie im vorherigen Schritt erstellt haben, um. z. B. in „App“.

  5. Fügen Sie eine Implementierungsabhängigkeit vom App-Modul der Funktion hinzu. des Moduls build.gradle (siehe unten).

    Cool

    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.

    Cool

    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. Markiere im Manifest des Funktionsmoduls das Funktionsmodul als ein installierbares Modul durch Hinzufügen der entsprechenden Bundle-Verteilungs-Tags zum Manifests.

    <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-Funktionsmodule umwandeln

Wenn Sie zusätzliche Funktionen Ihrer App in mehrere Module, müssen Sie die Schritte in diesem Abschnitt ausführen, um diese Module in Featuremodule mit Instant-Version.

Führen Sie für jedes verbleibende Funktionsmodul in Ihrem Projekt die folgenden Schritte aus, um die Konvertierung in Instant-Funktionen umwandeln:

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

    Cool

    // 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 Funktionsmodul als Instant-fähig, indem Sie Folgendes hinzufügen: zum Manifest 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. Funktionsmodul zur Datei build.gradle des neuen Anwendungsmoduls hinzufügen Dabei hast du installed_feature der Liste der Funktionsmodule hinzugefügt.

    Cool

    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

Nach Abschluss der Schritte auf dieser Seite kann Ihr Projekt ein ein einzelnes Artefakt, ein Android App Bundle, mit dem Sie sowohl die Instant-Version deiner App in der Google Play Console für die Instant-Version und die installierten Tracks getrennt. Zusätzlich mit der App Bundles profitieren Sie von optimierten APKs, für die Gerätekonfiguration der einzelnen Nutzer, sodass sie nur den Code und Ressourcen, die sie zum Ausführen Ihrer Anwendung benötigen. Das heißt, Sie müssen nicht mehr und mehrere APKs zur Unterstützung unterschiedlicher Geräte verwalten. Dabei werden die Nutzer kleiner, Downloads optimieren.

Um mit dem Erstellen und Testen Ihres Instant-fähigen App-Bundles zu beginnen, gehen Sie zu Erstellen Sie das App Bundle.