Migrer votre appli instantanée pour qu'elle soit compatible avec le format Android App Bundle

Si vous utilisez toujours le plug-in Feature Android Gradle (com.android.feature) obsolète pour vos modules d'appli instantanée Android, vous devez migrer vers le plug-in d'application de base (com.android.application) et le plug-in Dynamic Feature (com.android.dynamic-feature).

Sur le plug-in Android Gradle 3.3.0 ou version ultérieure, le plug-in d'application de base est compatible avec les expériences instantanées. Autrement dit, si le module d'application de base répond aux exigences d'une expérience instantanée, vous en bénéficiez automatiquement. Vous pouvez ensuite inclure des fonctionnalités supplémentaires que les utilisateurs peuvent télécharger à la demande en tant qu'expériences instantanées à l'aide du plug-in Dynamic Feature. Cette configuration facilite la prise en charge à la fois d'une expérience d'application installée et instantanée à partir d'un seul projet, et vous permet de bénéficier des avantages offerts par la publication au format Android App Bundle.

Le tableau suivant décrit mieux les plug-ins vers lesquels vous allez migrer:

Description du module Ancien plug-in Plug-in actuel
Module qui inclut le code de base, les ressources et les fonctionnalités de votre expérience d'application installée ou instantanée. com.android.feature (avec baseFeature = true) com.android.application

Remarque:Ce module inclut toutes les informations de fichier manifeste et de signature requises pour compiler et empaqueter votre application en tant qu'Android App Bundle ou APK.

Fonctionnalités modulaires supplémentaires téléchargeables à la demande com.android.feature com.android.dynamic-feature (avec dist:instant="true" et dist:onDemand="false" dans le fichier manifeste du module)
Code et ressource d'une fonctionnalité disponible uniquement dans la version installée de votre application. com.android.application com.android.dynamic-feature (avec dist:instant="false" et dist:onDemand="false" dans le fichier manifeste du module)

Cette page explique comment migrer votre projet d'appli instantanée existant pour créer un Android App Bundle permettant une utilisation instantanée. Il explique également comment créer, tester et publier un Android App Bundle permettant une utilisation instantanée.

Si vous créez des expériences instantanées pour votre application, consultez plutôt la section Créer un module de fonctionnalité permettant une utilisation instantanée.

Comprendre les modifications

Lorsque vous migrez votre projet pour utiliser le plug-in Dynamic Feature à la place, les Android App Bundles offrent un nouveau moyen de créer et de publier votre application qui simplifie considérablement la distribution des APK optimisés aux utilisateurs.

Les app bundles simplifie la distribution en empaquetant l'ensemble du code et des ressources compilés de votre application en vue de leur importation, mais ils reportent la génération et la signature de l'APK à Google Play. Le nouveau modèle de diffusion d'applications de Google Play utilise ensuite votre app bundle pour générer et diffuser des APK optimisés pour la configuration de l'appareil de chaque utilisateur, afin qu'ils ne téléchargent que le code et les ressources nécessaires à l'exécution de votre application. Vous n'avez plus besoin de créer, de signer ni de gérer plusieurs APK pour prendre en charge différents appareils, et les utilisateurs bénéficient de téléchargements plus petits et plus optimisés.

Lorsque vous utilisez le plug-in de fonctionnalité désormais obsolète, la création d'une application instantanée nécessitait la création d'un module de fonctionnalité de base, qui contenait le code et les ressources partagés pour tous vos modules, y compris votre module d'appli instantanée. Le reste de votre code était inclus dans plusieurs modules de fonctionnalités non de base, qui contenaient des points d'entrée pour vos expériences instantanées. Votre projet comportait peut-être un module d'application distinct contenant le code et les activités uniquement requis pour la version installée de votre application.

Lorsque vous migrez votre application pour la rendre compatible avec le format Android App Bundle, votre module d'application récupère le rôle du module de base et vous organisez les expériences installées ou instantanées supplémentaires en tant que modules de fonctionnalité. En d'autres termes, votre projet ressemble désormais davantage à un projet d'application standard, avec un module de base permettant une utilisation instantanée et la possibilité d'inclure des expériences instantanées modulaires supplémentaires.

Pour migrer votre projet d'appli instantanée existant et adopter le modèle de distribution optimisé d'Android App Bundle, suivez les étapes décrites dans les sections ci-dessous.

Convertir le module de fonctionnalité de base en module d'application

Vous devez d'abord modifier le fichier build.gradle du module de fonctionnalité de base avant de le convertir en module d'application principal, comme suit:

  1. Supprimez la ligne baseFeature true.

  2. Supprimez toutes les dépendances qui utilisent les configurations de dépendance feature ou application.

    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. Déplacez applicationId, ainsi que toutes les autres configurations de script de compilation que vous vous attendez à voir dans votre module d'application de base, du module com.android.application actuel vers le module com.android.feature. Voici quelques exemples. Pour cette étape, en fonction de votre configuration build.gradle spécifique, il peut être plus facile de copier et coller le bloc android du build.gradle du module d'application précédent dans le fichier build.gradle du nouveau module d'application. Toutefois, vous devez être prudent si vous procédez ainsi.

    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. Marquez le module de fonctionnalité comme permettant une utilisation instantanée en ajoutant les balises de distribution de bundle appropriées au fichier manifeste, comme indiqué ci-dessous.

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

  5. Convertissez le module de fonctionnalité en module d'application de base en remplaçant son type de plug-in par com.android.application:

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

Convertir l'ancien module d'application en module de fonctionnalité au moment de l'installation

Si vous n'avez pas de code ni de ressources dans l'ancien module d'application, vous pouvez simplement le supprimer, car les étapes que vous avez suivies dans la section précédente ont permis de convertir votre module de fonctionnalité en module d'application de base de votre application.

Toutefois, si l'ancien module d'application contient du code et des ressources qui représentent des fonctionnalités que vous souhaitez mettre à la disposition des utilisateurs lorsqu'ils installent votre application, suivez les étapes de cette section pour convertir le module d'application en module de fonctionnalité.

La création d'un module de fonctionnalité implique de changer le type de plug-in de com.android.application à com.android.dynamic-feature, ainsi que d'autres modifications de build.gradle, comme suit:

  1. Remplacez le type de plug-in com.android.application par 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. Comme décrit dans la section précédente, assurez-vous d'avoir déplacé les configurations de compilation requises par le plug-in com.android.application vers le module d'application de base, telles que les règles applicationId ou proguardFiles.

  3. Renommez le module comme "installed_feature" :

    1. Ouvrez le volet Project (Projet) en sélectionnant View > Tool Windows > Project (Vue > Fenêtres d'outils > Projet) dans la barre de menu.
    2. Effectuez un clic droit sur le module de fonctionnalité, puis sélectionnez Refactor > Rename (Refactoriser > Renommer).
    3. Dans la boîte de dialogue qui s'affiche, sélectionnez Rename module (Renommer le module), puis cliquez sur OK.
    4. Saisissez le nouveau nom du module, puis cliquez sur OK.

  4. Comme à l'étape 3, renommez le nouveau module d'application que vous avez créé à la section précédente en un nom du type "app".

  5. Ajoutez une dépendance d'implémentation au module "app" dans le fichier build.gradle du module de fonctionnalité, comme indiqué ci-dessous.

    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. Ajoutez la fonctionnalité au fichier build.gradle du nouveau module d'application.

    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. Dans le fichier manifeste du module de fonctionnalité, marquez le module de fonctionnalité comme module installable en ajoutant les balises de distribution de bundle appropriées au fichier manifeste.

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

Convertir d'autres modules de fonctionnalités en modules de fonctionnalité permettant une utilisation instantanée

Si vous avez modularisé des fonctionnalités supplémentaires de votre application dans plusieurs modules de fonctionnalités, vous devez suivre les étapes de cette section pour les convertir en modules de fonctionnalité permettant une utilisation instantanée.

Pour chaque module de fonctionnalité restant de votre projet, procédez comme suit pour les convertir en fonctionnalités permettant une utilisation instantanée:

  1. Remplacez le type de plug-in dans le fichier build.gradle par com.android.dynamic-feature, comme indiqué ci-dessous:

    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. Marquez chaque module de fonctionnalité comme permettant une utilisation instantanée en ajoutant les éléments suivants au fichier manifeste.

    <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. Ajoutez le module de fonctionnalité au fichier build.gradle du nouveau module d'application, où vous avez ajouté installed_feature à la liste des modules de fonctionnalité.

    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
}

Créer, tester et publier un nouvel app bundle permettant une utilisation instantanée

Une fois les étapes de cette page terminées, votre projet peut générer un seul artefact, un Android App Bundle, que vous pouvez utiliser pour publier les versions installée et instantanée de votre application dans la Google Play Console, et pour les déployer séparément pour les canaux de l'appli instantanée et ceux installés. De plus, les app bundles vous permettent de diffuser des APK optimisés pour la configuration de l'appareil de chaque utilisateur. Ils ne téléchargent ainsi que le code et les ressources nécessaires à l'exécution de votre application. Autrement dit, vous n'avez plus besoin de compiler, de signer ni de gérer plusieurs APK pour prendre en charge différents appareils, et les utilisateurs bénéficient de téléchargements plus petits et plus optimisés.

Pour commencer à compiler et à tester votre app bundle permettant une utilisation instantanée, accédez à la section Créer l'app bundle.