Créer différentes versions de votre application à l'aide de variantes de compilation

1. Introduction

Dernière mise à jour : 14 avril 2022

Les variantes de compilation permettent de créer différentes versions de votre application. Par exemple, vous pouvez créer une version gratuite, avec un ensemble limité de contenus, et une version payante avec davantage de fonctionnalités. Vous pouvez également créer différentes versions de votre application pour cibler divers appareils, en fonction du niveau d'API ou d'autres paramètres.

Dans cet atelier de programmation, vous allez modifier l'application de lancer de dé Dice Roller que vous avez créée dans le module 1 sur les fondamentaux de Kotlin afin d'obtenir deux versions : une version de démo "demo" et une version complète "full". La version "full" comporte une zone de texte supplémentaire qui affiche le résultat du lancer de dé en toutes lettres, ce qui évite à l'utilisateur d'avoir à lire le résultat sur l'image.

Ce que vous devez déjà savoir

Prérequis :

Points abordés

  • Présentation des variantes de compilation
  • Présentation des ensembles de sources
  • Comment créer différentes versions de votre application à l'aide de variantes de compilation et d'ensembles de sources
  • Comment attribuer des ID d'application uniques à vos variantes d'application

Objectifs de l'atelier

Dans cet atelier de programmation, vous allez reprendre l'application DiceRoller que vous avez créée dans le module 1 sur les fondamentaux de Kotlin. L'application DiceRoller contient une image d'un dé avec un bouton ROLL (Lancer) en dessous. Lorsque l'utilisateur clique sur ROLL, le dé est lancé et l'image change en fonction du résultat obtenu.

Vous allez créer des fichiers de projet supplémentaires et ajouter du code pour :

  • créer un type de produit "demo" et un type de produit "full" correspondant aux deux versions (démo et complète) de votre application ;
  • créer des ensembles de sources "demo" et "full" pour ces types de produit ;
  • ajouter une zone de texte dans la version "full" de votre application ;
  • programmer cette zone de texte pour qu'elle affiche le résultat du lancer de dé lorsque l'utilisateur clique sur ROLL ;
  • personnaliser le titre de l'application selon qu'il s'agit de la version de démo ou de la version complète ;
  • attribuer des ID d'application uniques à la version de démo et à la version complète.

La version complète de votre application ressemblera à ceci :

Application DiceRoller avec zone de texte dynamique

Ce dont vous aurez besoin

2. Configurer votre environnement

Obtenir le code

Si vous ne disposez pas de l'application DiceRoller créée dans le module 1 sur les fondamentaux de Kotlin, téléchargez le code de cette application depuis GitHub.

Pour télécharger et ouvrir le code d'application dans Android Studio, procédez comme suit :

  1. Sur la page d'accueil du dépôt GitHub android-basics-kotlin-dice-roller-with-images-app-solution, cliquez sur Code > Download ZIP (Code > Télécharger le ZIP).
  2. Une fois le fichier ZIP téléchargé, ouvrez le projet dans Android Studio, puis cliquez sur File > Open (Fichier > Ouvrir). Vous pouvez démarrer une activité vide ou ouvrir un projet précédent, si vous y êtes invité. Peu importe, puisque nous allons ouvrir le projet téléchargé.
  3. Accédez à l'emplacement de téléchargement de votre fichier ZIP (probablement dans votre dossier Downloads), sélectionnez-le, puis cliquez sur Open (Ouvrir).

Utiliser la vue Projet

Lorsque vous utilisez des variantes de compilation, vous devez utiliser vos fichiers de projet dans la vue Projet pour afficher tous les répertoires des différentes variantes. Pour ce faire, ouvrez le volet Project (Projet) dans Android Studio, cliquez sur le menu "View Type" (Type de vue) (défini sur Android par défaut), puis sélectionnez Project (Projet).

3. Comprendre les variantes de compilation

Les variantes de compilation sont le résultat de différentes combinaisons de types de produit et de types de compilation. Vous pouvez considérer les types de produit comme des attributs côté utilisateur, et les types de compilation comme des attributs côté développeur. Vous n'allez pas configurer les variantes de compilation directement : vous allez définir un ensemble de types de produit et un ensemble de types de compilation, ce qui déterminera les variantes de compilation.

Les variantes de compilation représentent les différentes combinaisons "type de produit/type de compilation" possibles. Elles sont donc nommées selon le schéma <product-flavor><build-type>. Par exemple, avec les types de compilation debug et release, et les types de produit demo et full, vous obtiendrez les variantes de compilation suivantes :

  • demoDebug
  • demoRelease
  • fullDebug
  • fullRelease

Configurons à présent les types de produit et les types de compilation pour l'application DiceRoller.

4. Configurer les types de produit

Les types de produit correspondent aux attributs de votre application côté utilisateur, dans la mesure où ils représentent généralement les versions de l'application disponibles. Pour créer la version de démo et la version complète de votre application, vous devez ajouter les deux types de produit correspondants et les attribuer à un groupe de types. Pour ajouter les types de produit, ouvrez le fichier build.gradle au niveau de l'application (app > build.gradle dans la vue Project) et collez ce code dans le bloc android {}.

flavorDimensions "app_type"
productFlavors {
   demo {
       dimension "app_type"
         }
   full {
       dimension "app_type"
   }
}

Ce code effectue les opérations suivantes :

  • Il crée un groupe de types appelé app_type.
  • Il crée deux types de produit, représentés par les blocs demo {} et full {}.
  • Il attribue les deux types de produit au groupe app_type (facultatif, s'il n'y a qu'un seul groupe de types).

Il s'agit du code de base nécessaire pour définir les types de produit. Vous utiliserez d'autres options dans la suite de cet atelier de programmation.

5. Configurer les types de compilation

Les types de compilation sont des attributs côté développeur, dans le sens où ils représentent généralement des étapes de développement (débogage, version bêta et version de production, par exemple). Android Studio configure automatiquement deux types de compilation pour vous : debug et release. Le type de compilation debug est destiné au débogage, tandis que le type de compilation release est destiné à la distribution.

Vous pouvez créer des types de compilation et modifier leurs configurations en modifiant le bloc buildTypes {} dans le fichier build.gradle au niveau de l'application. Le bloc buildTypes {} par défaut se présente comme suit :

buildTypes {
   release {
       minifyEnabled false
       proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
   }
}

Vous pouvez voir la configuration par défaut pour le type de compilation release (nous n'aborderons pas les propriétés minifyEnabled ni proguardFiles dans cet atelier de programmation). Le type de compilation debug n'apparaît pas par défaut dans le fichier de configuration de compilation, mais vous pouvez ajouter un bloc debug {} pour ajouter ou modifier certains paramètres. La configuration par défaut fonctionne pour nos besoins. Vous pouvez donc la laisser telle quelle.

6. Utiliser l'outil Build Variants

Maintenant que vous disposez de deux types de produit et de deux types de compilation, voyons quelles variantes de compilation ils permettent de créer. Pour afficher vos nouvelles variantes de compilation dans Android Studio, procédez comme suit :

  1. Dans la barre d'outils, cliquez sur Sync Project with Gradle Files 4e7fbf18152549d8.png (Synchroniser le projet avec les fichiers Gradle). Chaque fois que vous apportez des modifications pour créer des fichiers de configuration de compilation, Studio vous invite à synchroniser vos fichiers afin d'enregistrer la nouvelle configuration de compilation et de rechercher les erreurs de compilation.
  2. Cliquez sur Build > Select Build Variant (Compilation > Sélectionner une variante de compilation) ou sur View > Tool Windows > Build Variants (Vue > Fenêtres d'outil > Variantes de compilation) pour afficher la fenêtre Build Variants (Variantes de compilation).
  3. Cliquez sur demoDebug dans la colonne Active Build Variant (Variante de compilation active) pour ouvrir un menu contenant toutes les variantes de compilation : demoDebug, demoRelease, fullDebug, et fullRelease. Ce menu vous permet de sélectionner différentes variantes de compilation à exécuter et tester.

Fenêtre de l'outil Build Variants avec le menu "Active Build Variant" affiché

Exécutez les variantes demoDebug et fullDebug (les variantes basées sur le type de compilation release nécessitent une configuration supplémentaire pour être exécutées ; nous ne les utiliserons donc pas dans cet atelier de programmation). Pour l'instant, les variantes demoDebug et fullDebug ne sont pas différenciables du point de vue de l'utilisateur.

7. Créer des fonctionnalités différentes pour les différentes variantes

Maintenant que vous disposez de la version de démonstration et de la version complète de l'application, vous allez ajouter des fonctionnalités dans la version complète.

Ajouter une fonctionnalité premium à l'aide d'ensembles de sources

Pour le type de produit full, ajoutons une zone qui montre le résultat du lancer de dé, pour que les utilisateurs n'aient pas besoin de se fier uniquement à l'image du dé pour savoir combien ils ont fait. Pour ajouter cette fonctionnalité premium, vous devez utiliser des ensembles de sources. Un ensemble de sources est un répertoire qui affiche du contenu pour des types de compilation, des types de produit et des variantes de compilation spécifiques. L'ensemble de sources main par défaut (app > src > main) contient du contenu commun à toutes les variantes de compilation. Ce contenu par défaut peut être remplacé par le contenu d'autres ensembles de sources.

Le choix de ces ensembles de sources et la manière dont vous remplacerez le contenu de l'ensemble de sources main dépendent de ce que vous souhaitez modifier.

Pour modifier une ressource, telle qu'une mise en page ou une image (dans un fichier main > res), procédez comme suit :

  1. Créez un ensemble de sources, ou répertoire, pour le type de produit que vous souhaitez modifier (nous verrons où et comment créer cet ensemble de sources dans la section suivante).
  2. Collez le fichier de ressources à modifier dans ce nouvel ensemble de sources, puis modifiez-le. Lorsque le plug-in Android Gradle crée une variante de compilation qui dépend du nouvel ensemble de sources, il ignore le code de ressource dans main et applique de force le code de ressource du nouvel ensemble de sources.

Pour ignorer un comportement dans une classe Java ou Kotlin (dans un fichier main > java) et appliquer de force un autre comportement, procédez comme suit :

  1. Créez des ensembles de sources, ou répertoires, pour le type de produit que vous souhaitez modifier et pour tous les autres types de produit du même groupe de types.
  2. Collez le fichier à modifier dans tous les ensembles de sources ainsi créés, puis modifiez le ou les exemplaires voulus.
  3. Supprimez le fichier d'origine de l'ensemble de sources main.

Pour ajouter une zone dynamique à la version complète de votre application, vous pouvez décomposer la fonctionnalité premium en deux parties :

  • Personnaliser la mise en page : ajoutez une zone en modifiant le fichier activity_main.xml.
  • Personnaliser le comportement de l'application : modifiez ce qui s'affiche dans la zone en fonction du lancer de dé en modifiant le fichier MainActivity.kt.

Dans la section suivante, vous allez apprendre où et comment créer des ensembles de sources.

Déterminer où créer des ensembles de sources

Le plug-in Android Gradle vous montre comment organiser vos fichiers pour vos types de compilation, types de produit et variantes de compilation. Pour ajouter une fonctionnalité premium au type de produit full incluant une modification du fichier MainActivity.kt, vous devez créer des ensembles de sources pour les types full et demo. Pour savoir où créer ces ensembles de sources, procédez comme suit dans Android Studio :

  1. Dans la fenêtre de l'IDE, cliquez sur Gradle.
  2. Accédez à MyApplication > Tasks > android (Mon application > Tâches > Android) et double-cliquez sur sourceSets (Ensembles de sources). Si vous ne voyez pas le dossier Tasks (Tâches), laissez Gradle créer la liste de tâches pendant la synchronisation en cliquant sur File > Settings > Experimental (Fichier > Paramètres > Expérimental), puis en décochant Do not build Gradle task list during Gradle sync (Ne pas créer la liste de tâches Gradle pendant la synchronisation Gradle). Vous trouverez cette option sous Android Studio > Preferences > Expérimental (Android Studio > Préférences > Expérimental) sur macOS. Une fois que Gradle a exécuté la tâche, la fenêtre Run (Exécuter) doit afficher le résultat.
  3. Si l'écran n'est pas en mode Texte, comme illustré ici, cliquez sur Activer/Désactiver l'affichage 82487fd4e011f105.png dans la fenêtre Run.

Dans la fenêtre Run (Exécuter), vous devriez obtenir le résultat suivant :

------------------------------------------------------------
Project ':app'
------------------------------------------------------------

...

debug
-----
Compile configuration: debugCompile
build.gradle name: android.sourceSets.debug
Java sources: [app/src/debug/java]
Kotlin sources: [app/src/debug/kotlin, app/src/debug/java]
Manifest file: app/src/debug/AndroidManifest.xml
Android resources: [app/src/debug/res]
Assets: [app/src/debug/assets]
AIDL sources: [app/src/debug/aidl]
RenderScript sources: [app/src/debug/rs]
JNI sources: [app/src/debug/jni]
JNI libraries: [app/src/debug/jniLibs]
Java-style resources: [app/src/debug/resources]

...

full
----
Compile configuration: fullCompile
build.gradle name: android.sourceSets.full
Java sources: [app/src/full/java]
Kotlin sources: [app/src/full/kotlin, app/src/full/java]
Manifest file: app/src/full/AndroidManifest.xml
Android resources: [app/src/full/res]
Assets: [app/src/full/assets]
AIDL sources: [app/src/full/aidl]
RenderScript sources: [app/src/full/rs]
JNI sources: [app/src/full/jni]
JNI libraries: [app/src/full/jniLibs]
Java-style resources: [app/src/full/resources]

La liste des chemins d'accès aux fichiers sous "debug" décrit où le plug-in Android Gradle recherche le code d'application et les ressources pour le type de produit "debug", par défaut. De la même manière, la liste des chemins d'accès aux fichiers sous "full" indique où le plug-in Android Gradle recherche du contenu pour le type de produit "full", par défaut.

Prenez note des chemins d'accès "Java sources" (pour les fichiers tels que les classes Java et Kotlin) et "Android resources" (pour les fichiers tels que les mises en page et les images). Maintenant que vous savez où créer des ensembles de sources, créez-les et ajoutez du code pour la fonctionnalité premium.

Personnaliser la mise en page de la version complète

Pour ajouter une zone de texte à la version complète de votre application, procédez comme suit :

Commencez par créer l'ensemble de sources full et le répertoire de ressources Java :

  1. Ouvrez le volet Project (Projet) et sélectionnez la vue Project (Projet).
  2. Accédez au répertoire DiceRoller/app/src/.
  3. Faites un clic droit sur le répertoire src, puis sélectionnez New > Directory (Nouveau > Répertoire).
  4. Dans le menu situé sous Gradle Source Sets (Ensembles de sources Gradle), sélectionnez full/resources, puis appuyez sur Enter.

Ensuite, collez le fichier activity_main.xml de l'ensemble de sources main dans l'ensemble de sources full.

  1. Accédez à DiceRoller/app/src/main/res/.
  2. Faites un clic droit sur le fichier activity_main.xml, puis cliquez sur Copy (Copier).
  3. Accédez à DiceRoller/app/src/full/res/.
  4. Faites un clic droit sur le répertoire res, puis cliquez sur Paste (Coller).

Ensuite, pour ajouter une zone de texte au type de produit full de votre application, ajoutez ce code au fichier activity_main.xml de l'ensemble de sources full :

<TextView
    android:id="@+id/resultTextView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:textSize="16sp"
    android:text="Result"
    app:layout_constraintBottom_toTopOf="@+id/button"
    app:layout_constraintEnd_toEndOf="parent"
    app:layout_constraintStart_toStartOf="parent"
    app:layout_constraintTop_toBottomOf="@id/imageView" />

Exécutez les variantes de compilation fullDebug et demoDebug de votre application : sélectionnez la variante que vous souhaitez exécuter via la fenêtre de l'outil Build Variants, puis cliquez sur Run (Exécuter). La nouvelle zone ne doit s'afficher que pour la variante fullDebug. Elle ne fait rien pour le moment. Vous allez donc la programmer pour que le texte change en fonction du lancer.

Application DiceRoller avec un espace réservé intitulé "Result" (Résultat)

Personnaliser le comportement de la version complète

Pour la version complète de l'application, le résultat du lancer de dé doit s'afficher dans la zone de texte, en toutes lettres. Pour programmer ce comportement, procédez comme suit :

Commencez par créer le répertoire de ressources Java de l'ensemble de sources full.

  1. Dans le volet Project (Projet) de la vue Project (Projet), accédez au répertoire DiceRoller/app/src/full.
  2. Faites un clic droit sur le répertoire full, puis sélectionnez New > Directory (Nouveau > Répertoire).
  3. Dans le menu Gradle Source Sets (Ensembles de sources Gradle), sélectionnez java, puis appuyez sur Enter.

Ensuite, créez l'ensemble de sources debug et le répertoire de ressources Java.

  1. Dans le volet Project (Projet) de la vue Project (Projet), accédez au répertoire DiceRoller/app/src.
  2. Faites un clic droit sur le répertoire src, puis sélectionnez New > Directory (Nouveau > Répertoire).
  3. Dans le menu Gradle Source Sets (Ensembles de sources Gradle), sélectionnez debug/java, puis appuyez sur Enter.

Ensuite, accédez au répertoire DiceRoller/app/src/main/java.

  1. Collez le fichier MainActivity.kt dans les répertoires full/java et debug/java.
  2. Supprimez le répertoire java, y compris le fichier MainActivity.kt, de l'ensemble de sources principal. (Faites un clic droit sur le répertoire java, puis cliquez sur Delete (Supprimer)).
  3. Dans le fichier MainActivity.kt de l'ensemble de sources "full", ajoutez le code suivant à la méthode rollDice() :
// Update the result text view
val resultTextView: TextView = findViewById(R.id.resultTextView)
resultTextView.text = when (diceRoll) {
    1 -> "One"
    2 -> "Two"
    3 -> "Three"
    4 -> "Four"
    5 -> "Five"
    else -> "Six"
}

Exécutez à nouveau les variantes de compilation fullDebug et demoDebug. Le résultat du lancer de dé doit s'afficher en toutes lettres dans la version complète de l'application.

Application DiceRoller avec zone de texte dynamique

Modifier le titre des différentes versions de l'application

Par souci de clarté, vous allez spécifier la version de l'application utilisée dans le titre de celle-ci. Ce type de modification peut être effectué sans les ensembles de sources. Le titre de l'application est défini par la propriété label dans le fichier AndroidManifest.xml (app > manifests > AndroidManifest.xml). Pour obtenir la valeur label qui change en fonction de la variante en cours d'exécution, ouvrez le fichier AndroidManifest.xml et modifiez la ligne de libellé comme suit :

android:label="${appLabel}"

Cette action attribue une variable, appLabel, au titre de l'application.

Ensuite, pour définir la valeur de appLabel ou modifier le titre de la version de démo de l'application, ajoutez la ligne manifestPlaceholders au bloc demo {} que vous avez créé précédemment :

demo {
   dimension "version"
   manifestPlaceholders = [appLabel: "Dice Roller - Demo"]
   applicationIdSuffix ".demo"
}

De même, pour modifier le titre du type de produit full, ajoutez une autre ligne manifestPlaceholders au bloc full {} :

full {
   dimension "version"
   manifestPlaceholders = [appLabel: "Dice Roller - Full"]
   applicationIdSuffix ".full"
}

Exécutez à nouveau les variantes demoDebug et fullDebug. Les titres des différentes versions doivent s'afficher.

Application DiceRoller terminée avec la zone dynamique

8. Attribuer des ID d'application uniques à vos variantes de compilation

Lorsque vous compilez un APK ou AAB pour votre application, les outils de compilation attribuent à l'application l'ID d'application défini dans le bloc defaultConfig {} à partir du fichier build.gradle au niveau de l'application (comme illustré ci-dessous). Toutefois, si vous souhaitez créer différentes versions de votre application sous forme de fiches distinctes sur le Google Play Store, comme une version "démo" ou "complète", vous devez attribuer un ID d'application différent à chaque version. Pour chaque type de produit du bloc productFlavors {}, vous pouvez redéfinir la propriété applicationId ou ajouter un segment à l'ID d'application par défaut à l'aide de applicationIdSuffix, comme indiqué ci-dessous :

defaultConfig {
   applicationId "com.example.diceroller"
   ...
}

flavorDimensions "version"
productFlavors {
   demo {
 dimension "version"
       manifestPlaceholders = [appLabel: "Dice Roller - Demo"]
         applicationIdSuffix ".demo"
   }
   full {
       dimension "version"
       manifestPlaceholders = [appLabel: "Dice Roller - Full"]
         applicationIdSuffix ".full"
   }
}

9. Félicitations

Félicitations, vous avez réussi à créer deux versions de l'application DiceRoller à l'aide des variantes de compilation !

Vous avez configuré des types de produit et des types de compilation afin de créer des variantes de compilation. Vous avez ajouté une fonctionnalité premium à la version complète de l'application à l'aide d'ensembles de sources. Vous avez appris à attribuer un ID d'application unique aux différentes variantes de compilation afin qu'elles soient considérées comme des applications distinctes sur le Play Store.

Vous connaissez maintenant les étapes de base nécessaires pour créer plusieurs versions d'une application afin de mieux répondre aux besoins de différents groupes d'utilisateurs.

Et ensuite ?

Documents de référence