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

Si vous utilisez toujours le plug-in de fonctionnalité Android Gradle obsolète (com.android.feature) pour vos modules d'appli instantanée Android : migrer vers le plug-in d'application de base (com.android.application) ; Plug-in de fonctionnalités dynamiques (com.android.dynamic-feature).

Sur le plug-in Android Gradle 3.3.0 et versions ultérieures, le plug-in d'application de base est compatible avec pour des expériences instantanées. Autrement dit, si le module de base de l'application répond aux exigences pour bénéficier d'une expérience instantanée, vous en bénéficiez automatiquement. Vous pouvez ensuite inclure des fonctionnalités supplémentaires téléchargeables à la demande, grâce au plug-in de fonctionnalités dynamiques. Cette configuration permet plus facile de prendre en charge à la fois une expérience d'appli installée et une expérience d'appli instantanée à partir d'une seule et vous permet de publier des contenus via 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 comprend le code de base, les ressources et les fonctionnalités pour votre expérience d'appli installée ou instantanée. com.android.feature (avec baseFeature = true) com.android.application

Remarque:Ce module inclut tous les fichiers manifestes les informations de signature requises pour compiler et empaqueter votre application en tant qu'application 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 ressource d'une fonctionnalité disponibles uniquement pour 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'appli instantanée existant pour créer un Android App Bundle activé pour une appli instantanée. Il décrit é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 Créez un module de fonctionnalité permettant une utilisation instantanée.

Comprendre les modifications

Lorsque vous migrez votre projet pour utiliser le plug-in de fonctionnalités dynamiques, Le format Android App Bundle offre une nouvelle façon de créer et de publier votre application qui simplifie considérablement la distribution d'APK optimisés à vos utilisateurs.

Les app bundles simplifient la distribution en empaquetant tout le code compilé de votre application et ressources pour l'importation, mais reporte la génération de l'APK et sa signature sur Google Play. Le nouveau modèle de diffusion d'applications de Google Play App bundle pour générer et diffuser des APK optimisés pour l'appareil de chaque utilisateur de sorte qu'ils ne téléchargent que le code et les ressources nécessaires votre application. 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 obtiennent des téléchargements plus petits et plus optimisés.

Lors de l'utilisation du plug-in de fonctionnalité désormais obsolète, la création d'une appli instantanée était requise 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 a été inclus dans plusieurs modules de fonctionnalités non standards, qui contenaient des points d'entrée pour vos expériences instantanées. Pour la version installée de votre application, votre projet comportait peut-être un module d'application distinct, qui contenait le code et activités requises uniquement pour votre application installée.

Lorsque vous migrez votre application pour qu'elle soit 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 ressources supplémentaires des expériences instantanées sous forme de modules de fonctionnalité. C'est-à-dire que votre projet est maintenant plus ressemble beaucoup à 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 supplémentaires modulaires.

Pour migrer votre projet d'appli instantanée existant et adopter le format Android App Bundle plus optimisé, 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 en le convertissant en module d'application principal, comme suit:

  1. Supprimez la ligne baseFeature true.

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

    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 toute autre configuration de script de compilation que vous doit se trouver dans votre module d'application de base, à partir de la version actuelle com.android.application au module com.android.feature. Un peu exemples sont présentés ci-dessous. Pour cette étape, en fonction de votre build.gradle, il peut être plus simple de copier et coller le android le bloc build.gradle du module d'application précédent dans la nouvelle application le fichier build.gradle du module. Toutefois, vous devez faire preuve de prudence lorsque vous faites donc.

    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. Marquer le module de fonctionnalité comme permettant une utilisation instantanée en ajoutant le bundle approprié de distribution dans le 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 modifiant son plug-in saisissez 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 les supprimer, car les étapes que vous avez suivies dans la section précédente ont converti dans le module de base de votre application.

Toutefois, si l'ancien module d'application contient du code et des ressources des fonctionnalités que vous souhaitez proposer aux 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 modifier le type de plug-in De com.android.application à com.android.dynamic-feature, ainsi que quelques 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é la compilation requises par le plug-in com.android.application pour module d'application de base, comme les règles applicationId ou proguardFiles.

  3. Renommez le module "installed_feature" par exemple. comme suit:

    1. Ouvrez le volet Project (Projet) en sélectionnant View > Fenêtres d'outil > Projet dans la barre de menu.
    2. Effectuez un clic droit sur le module de fonctionnalité, puis sélectionnez Refactor > Refactor > 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 et cliquez sur OK.

  4. Comme à l'étape 3, renommez le nouveau module d'application que vous avez créé à l'étape par exemple "application".

  5. Ajoutez une dépendance d'implémentation au module "app" de la fonctionnalité. le fichier build.gradle du module, 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 comme un module installable en ajoutant les tags de distribution de bundle appropriés au fichier 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 en plusieurs modules, vous devez suivre les étapes de cette section pour les convertir en modules de fonctionnalités permettant une utilisation instantanée.

Pour chaque module de fonctionnalité restant dans votre projet, procédez comme suit pour 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és.

    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 est en mesure de générer une un artefact unique, un Android App Bundle, que vous pouvez utiliser pour publier à la fois installée et instantanée de votre application dans la Google Play Console, puis lancez séparément pour les canaux instantanés et installés. De plus, avec l'application vous avez la possibilité de diffuser des APK optimisés pour la configuration de l'appareil de chaque utilisateur, de sorte qu'il ne télécharge que le code et dont elles ont besoin pour exécuter votre application. Autrement dit, vous n'avez plus à construire, signer, et gérer plusieurs APK pour prendre en charge différents appareils, et les utilisateurs deviennent plus petits, des téléchargements optimisés.

Pour commencer à créer et à tester votre app bundle activé pour une appli instantanée, accédez à Créez l'app bundle.