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

Avertissement : Google Play Instant ne sera plus disponible. À partir de décembre 2025, les Applis instantanées ne pourront plus être publiées sur Google Play, et toutes les API Instant des services Google Play ne fonctionneront plus. Play ne proposera plus d'applis instantanées aux utilisateurs, quel que soit le mécanisme utilisé.

Nous apportons cette modification en fonction des commentaires des développeurs et de nos investissements continus pour améliorer l'écosystème depuis l'introduction de Google Play Instantané.

Pour continuer à optimiser la croissance du nombre d'utilisateurs, nous encourageons les développeurs à rediriger les utilisateurs vers leur application ou leur jeu habituels à l'aide de liens profonds pour les rediriger vers des parcours ou des fonctionnalités spécifiques, le cas échéant.

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

Sur le plug-in Android Gradle 3.3.0 et versions ultérieures, le plug-in d'application de base inclut la prise en charge des expériences instantanées. En d'autres termes, si le module d'application de base répond aux exigences pour être 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 d'une expérience d'application installée et instantanée à partir d'un seul projet, et vous permet de bénéficier de la publication avec les Android App Bundles.

Le tableau suivant décrit plus précisément les plug-ins vers lesquels vous migrerez :

Description du module Ancien plug-in Plug-in actuel
Module qui inclut le code, les ressources et les fonctionnalités de base pour l'expérience de votre 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 nécessaires pour compiler et empaqueter votre application en tant qu'Android App Bundle ou APK.

Fonctionnalités modulaires supplémentaires que les utilisateurs peuvent télécharger à 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 ressources 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 vous explique comment migrer votre projet d'application instantanée existant pour créer un Android App Bundle compatible avec les applications instantanées. Il explique également comment créer, tester et publier un Android App Bundle activé pour une appli instantanée.

Si vous créez des expériences instantanées pour votre application, consultez plutôt 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, les Android App Bundles vous offrent une nouvelle façon de compiler et de publier votre application, ce qui simplifie considérablement la distribution d'APK optimisés à vos utilisateurs.

Les app bundles simplifient la distribution en regroupant l'ensemble du code et des ressources compilés de votre application pour l'importation, mais en déléguant la génération et la signature des 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. Les utilisateurs téléchargent ainsi uniquement le code et les ressources nécessaires à l'exécution de votre application. Vous n'avez plus besoin de créer, de signer et de gérer plusieurs APK pour prendre en charge différents appareils. Les utilisateurs bénéficient de téléchargements plus petits et plus optimisés.

Lorsque vous utilisiez 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'application instantanée. Le reste de votre code était inclus dans plusieurs modules de fonctionnalité non de base, qui contenaient des points d'entrée pour vos expériences instantanées. Pour la version installée de votre application, votre projet peut avoir inclus un module d'application distinct, qui contenait le code et les activités requis uniquement pour votre application installée.

Lorsque vous migrez votre application pour qu'elle soit compatible avec les Android App Bundles, le module d'application reprend le rôle de module de base. Vous organisez les expériences instantanées ou installées supplémentaires en tant que modules de fonctionnalités. 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 plus 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épendances 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 attendez dans votre module d'application de base, du module com.android.application actuel vers le module com.android.feature. Vous trouverez quelques exemples ci-dessous. Pour cette étape, en fonction de la configuration spécifique de votre build.gradle, il peut être plus facile de copier et coller le bloc android du build.gradle de l'ancien module d'application dans le fichier build.gradle du nouveau module d'application. Toutefois, vous devez faire preuve de prudence lorsque vous le faites.

    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 compatible avec les applications instantanées en ajoutant les tags de distribution de bundle appropriés 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é à l'installation

Si l'ancien module d'application ne contient aucun code ni aucune ressource, vous pouvez simplement le supprimer, car les étapes que vous avez suivies dans la section précédente ont converti votre module de fonctionnalité en module d'application de base.

Toutefois, si l'ancien module d'application contient du code et des ressources qui représentent une fonctionnalité 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é.

Pour créer un module de fonctionnalité, vous devez remplacer le type de plug-in de com.android.application par com.android.dynamic-feature, ainsi que quelques autres modifications 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, par exemple "installed_feature", comme suit :

    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 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éé dans la section précédente, par exemple "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 installable en ajoutant les tags de distribution de bundle appropriés 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és permettant une utilisation instantanée

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

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

  1. Modifiez le type de plug-in dans le fichier build.gradle en 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 étant compatible avec l'application instantanée en ajoutant ce qui suit 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 compatible avec les applications instantanées

Après avoir suivi les étapes de cette page, votre projet pourra produire un seul artefact, un Android App Bundle, que vous pourrez utiliser pour publier la version installée et la version instantanée de votre application sur la Google Play Console, et les déployer séparément pour les pistes instantanée et installée. De plus, avec les app bundles, vous pouvez distribuer des APK optimisés pour la configuration d'appareil de chaque utilisateur. Ils ne téléchargent ainsi que le code et les ressources dont ils ont besoin pour exécuter votre application. Autrement dit, vous n'avez plus besoin de créer, signer et gérer plusieurs APK pour prendre en charge différents appareils. Les utilisateurs bénéficient ainsi de téléchargements plus petits et plus optimisés.

Pour commencer à créer et à tester votre app bundle comportant une expérience instantanée, accédez à Créer l'app bundle.