Compiler et exécuter votre application

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Pour voir comment votre application se présente et se comporte sur un appareil, vous devez la compiler et l'exécuter. Android Studio configure de nouveaux projets pour vous permettre de déployer votre application sur un appareil virtuel ou physique en quelques clics.

Cette présentation explique comment utiliser Android Studio pour compiler et exécuter votre application à des fins de test et de débogage. Pour plus d'informations sur la manière d'utiliser Android Studio pour créer votre application et la proposer aux utilisateurs, consultez Créer votre application pour la proposer aux utilisateurs. Pour des informations détaillées sur la manière de gérer et de personnaliser votre build, avec ou sans Android Studio, consultez Configurer votre build.

Compiler et exécuter une application

Pour compiler et exécuter votre application, procédez comme suit :

  1. Dans la barre d'outils, sélectionnez votre application dans le menu "Run configurations" (Configurations d'exécution).
  2. Dans le menu des appareils cibles, sélectionnez l'appareil sur lequel vous souhaitez exécuter l'application.

    Menu des appareils cibles

    Si vous n'avez configuré aucun appareil, vous devez créer un appareil virtuel Android pour utiliser Android Emulator ou vous connecter un appareil physique.

  3. Cliquez sur Run (Exécuter) .

Android Studio vous avertit si vous tentez de lancer votre projet sur un appareil auquel une erreur ou un avertissement est associé. L'iconographie et les changements stylistiques font la différence entre les erreurs (sélections d'appareils qui entraînent une configuration défectueuse) et les avertissements (sélections d'appareils pouvant entraîner un comportement inattendu, mais qui sont toujours exécutables).

Surveiller le processus de compilation

Pour consulter les détails du processus de compilation, sélectionnez (View > Tool Windows > Build (Vue > Fenêtres d'outils > Compilation) ou cliquez sur Build (Compilation) dans la barre des fenêtres d'outils. La fenêtre d'outils Build (Compilation) affiche les tâches que Gradle exécute pour compiler votre application, comme l'illustre la figure 1.

Figure 1. Fenêtre d'outil Build (Compilation) dans Android Studio
  1. Onglet "Sync" (Synchronisation) : affiche les tâches exécutées par Gradle à des fins de synchronisation avec les fichiers de votre projet. Comme pour l'onglet Build Output (Sortie de compilation), si vous rencontrez une erreur de synchronisation, sélectionnez un élément de l'arborescence pour en savoir plus.
  2. Onglet "Build Output" (Compilation de sortie) : affiche les tâches que Gradle exécute en tant qu'arborescence, où chaque nœud représente une phase de compilation ou un groupe de dépendances de tâches. Si vous recevez des erreurs liées à la durée ou au temps de la compilation, inspectez l'arborescence et sélectionnez un élément pour lire la sortie de l'erreur, comme illustré dans la figure 2.
    Figure 2. Inspecter la fenêtre Build Output (Sortie de compilation) pour détecter les messages d'erreur
  3. Onglet "Build Analyzer" : fournit des informations d'analyse des performances concernant votre compilation. Pour en savoir plus, consultez la section Résoudre les problèmes de performances de compilation avec Build Analyzer.
  4. Restart (Redémarrer) : effectue la même action que lorsque vous sélectionnez Build > Make Project (Compilation > Créer un projet) en générant des fichiers de compilation intermédiaires pour tous les modules de votre projet.
  5. Filters (Filtres) : filtre les avertissements, les tâches ou les avertissements et les tâches qui ont abouti. Ils contribuent à faciliter la recherche de problèmes dans la sortie.

Si vos variantes de compilation utilisent des types de produit, Gradle appelle également des tâches pour créer ces types. Pour afficher la liste de toutes les tâches de compilation disponibles, cliquez sur View > Tool Windows > Gradle (Vue > Fenêtres d'outils > Gradle) ou sur Gradle dans la barre des fenêtres d'outils.

Si une erreur se produit pendant le processus de compilation, Gradle peut vous recommander des options de ligne de commande, telles que --stacktrace ou --debug, pour vous aider à y remédier. Pour utiliser les options de ligne de commande avec votre processus de compilation, procédez comme suit :

  1. Ouvrez la boîte de dialogue Settings (Paramètres) ou Preferences (Préférences) :
    • Sous Windows ou Linux, sélectionnez File > Settings (Fichier > Paramètres) dans la barre de menu.
    • Sous macOS, sélectionnez Android Studio (Android Studio) > Preferences (Préférences) dans la barre de menu.
  2. Accédez à Build, Execution, Deployment (Compilation, exécution, déploiement) > Compiler (Compilateur).
  3. Dans le champ de texte situé à côté d'Command-line Options (Options de ligne de commande), saisissez vos options de ligne de commande.
  4. Cliquez sur OK pour enregistrer et quitter.

Gradle applique ces options de ligne de commande la prochaine fois que vous essayez de créer votre application.

Fonctionnalités de compilation et d'exécution avancées

La méthode par défaut pour compiler et exécuter votre application dans Android Studio est suffisante pour tester une application simple. Toutefois, vous pouvez utiliser ces fonctionnalités de compilation et d'exécution pour des cas d'utilisation plus avancés :

  • Pour déployer votre application en mode débogage, cliquez sur Debug (Déboguer) . L'exécution de votre application en mode débogage vous permet de définir des points d'arrêt dans votre code, d'examiner les variables et d'évaluer les expressions au moment de l'exécution, ainsi que d'exécuter des outils de débogage. Pour en savoir plus, consultez Déboguer votre application.

  • Si vous disposez d'une application plus volumineuse et plus complexe, utilisez "Apply Changes" (Appliquer les modifications) au lieu de cliquer sur Run (Exécuter) . Vous éviterez ainsi d'avoir à redémarrer votre application chaque fois que vous souhaitez déployer une modification. Pour en savoir plus sur la fonctionnalité "Apply Changes" (Appliquer les modifications), consultez la section Déployer progressivement avec la fonctionnalité "Apply Changes" (Appliquer les modifications)".

  • Si vous utilisez Jetpack Compose, la fonctionnalité expérimentale de modification en temps réel vous permet de mettre à jour des composables en temps réel sans avoir à cliquer à nouveau sur Run (Exécuter) . Vous pouvez ainsi vous concentrer sur l'écriture du code de l'interface utilisateur avec un minimum de perturbations. Pour en savoir plus, consultez la section Modification en temps réel (fonctionnalité expérimentale).

  • Si votre application compte plusieurs variantes de compilation ou versions, vous pouvez choisir la variante à déployer à l'aide de la fenêtre d'outils Build Variants (Variantes de compilation). Pour en savoir plus sur l'exécution d'une variante de compilation spécifique, consultez la section Modifier la variante de compilation.

  • Pour affiner les options d'installation, de lancement et de test de l'application, vous pouvez modifier la configuration d'exécution/de débogage. Pour en savoir plus sur la création de configurations d'exécution/de débogage personnalisées, consultez la section Créer des configurations d'exécution/de débogage.

  • Nous vous recommandons d'utiliser Android Studio pour vos besoins de développement, mais vous pouvez également déployer votre application sur un appareil virtuel ou physique à partir de la ligne de commande. Pour en savoir plus, consultez la section Créer une application à partir de la ligne de commande.

Déployer progressivement avec la fonctionnalité "Apply Changes" (Appliquer les modification)

Dans Android Studio 3.5 et versions ultérieures, "Apply Changes" vous permet de transférer des modifications de code et de ressources vers votre application en cours d'exécution, sans devoir la redémarrer (et, dans certains cas, sans redémarrer l'activité en cours). Cette flexibilité vous aide à contrôler les redémarrages de votre application lorsque vous souhaitez déployer et tester de petites modifications incrémentielles tout en préservant l'état actuel de votre appareil.

La fonctionnalité "Apply Changes" (Appliquer les modifications) utilise les fonctionnalités de l'implémentation JVMTI Android prises en charge avec les appareils exécutant Android 8.0 (niveau d'API 26) ou version ultérieure. Pour en savoir plus sur le fonctionnement de la fonctionnalité "Apply Changes" (Appliquer les modifications), consultez Projet Marble Android Studio : Apply Changes (Appliquer les modifications).

Conditions requises

Les actions de la fonctionnalité "Apply Changes" ne sont disponibles que si vous remplissez les conditions suivantes :

  • Vous compilez l'APK de votre application à l'aide d'une variante de débogage de compilation.
  • Vous déployez votre application sur un appareil ou un émulateur cible exécutant Android 8.0 (niveau d'API 26) ou version ultérieure.

Utiliser "Apply Changes" (Appliquer les modification)

Utilisez les options suivantes lorsque vous souhaitez déployer vos modifications sur un appareil compatible :

Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité) Icône Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité) : tente d'appliquer les modifications apportées à la ressource et au code en redémarrant votre activité, sans redémarrer votre application. En règle générale, vous pouvez utiliser cette option lorsque vous modifiez du code dans le corps d'une méthode ou modifiez une ressource existante.

Vous pouvez également effectuer cette action en appuyant sur Ctrl+Alt+F10 (Ctrl+Cmd+Maj+R sous macOS).

Apply Code Changes (Appliquer les modifications du code) Icône Apply Code Changes (Appliquer les modifications du code) : tente uniquement d'appliquer les modifications apportées au code sans redémarrer aucun élément. En règle générale, vous pouvez utiliser cette option si vous modifiez du code dans le corps d'une méthode, sans modifier aucune ressource. Si vous modifiez du code et des ressources, utilisez plutôt Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité).

Vous pouvez également effectuer cette action en appuyant sur Ctrl+F10 (Ctrl+Commande+R sous macOS).

Run (Exécuter)  : déploie toutes les modifications et redémarre l'application. Utilisez cette option lorsque les modifications que vous avez effectuées ne peuvent pas être appliquées à l'aide de l'une des options "Apply Changes" (Appliquer les modifications). Pour en savoir plus sur les types de modifications nécessitant le redémarrage d'une application, consultez Limites de la fonctionnalité "Apply Changes" (Appliquer les modifications).

Activer l'exécution de l'action de remplacement pour "Apply Changes" (Appliquer les modifications)

Lorsque vous cliquez sur Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité) ou sur Apply Code Changes (Appliquer les modifications de code), Android Studio génère un nouvel APK et détermine si les modifications peuvent être appliquées. Si les modifications ne peuvent pas être appliquées et que l'application des modifications échoue, Android Studio vous invite à réexécuter votre application. Pour ce faire, utilisez l'icône Run (Exécuter) Icône Run (Exécuter).

Si vous ne souhaitez éviter cette étape vous pouvez configurer Android Studio afin qu'il réexécute automatiquement votre application lorsque les modifications ne peuvent pas être appliquées. Pour activer ce comportement, procédez comme suit :

  1. Ouvrez la boîte de dialogue Settings (Paramètres) ou Preferences (Preferences) :

    • Sous Windows ou Linux, sélectionnez File > Settings (Fichier > Paramètres) dans le menu.
    • Sous macOS, sélectionnez Android Studio > Preferences (Android Studio > Préférences) dans le menu.
  2. Accédez à Build, Execution, Deployment > Deployment (Compilation, exécution, déploiement > Déploiement).

  3. Cochez les cases permettant d'activer l'exécution automatique de l'action de remplacement pour l'une des actions "Apply Changes" (Appliquer les modifications) ou les deux.

  4. Cliquez sur OK.

Modifications dépendant de la plate-forme

Certaines fonctionnalités de l'option "Apply Changes" dépendent de versions spécifiques de la plate-forme Android. Pour appliquer ce type de modifications, votre application doit être déployée sur un appareil exécutant cette version d'Android (ou une version ultérieure). Par exemple, Android 11 ou une version ultérieure est nécessaire pour pouvoir ajouter une méthode.

Limites de la fonctionnalité "Apply Changes" (Appliquer les modification)

La fonctionnalité "Apply Changes" (Appliquer les modification) est conçue pour accélérer le processus de déploiement des applications. Cela étant, son utilisation est soumise à certaines limites.

Modifications de code nécessitant le redémarrage de l'application

Certaines modifications de code et de ressources ne peuvent pas être appliquées tant que l'application n'a pas été redémarrée, par exemple :

  • Ajout ou suppression d'un champ
  • Suppression d'une méthode
  • Modification des signatures de méthodes
  • Modification des modificateurs des méthodes ou des classes
  • Modification de l'héritage de classe
  • Modification des valeurs dans les énumérations
  • Ajout ou suppression d'une ressource
  • Modification du fichier manifeste de l'application
  • Modification des bibliothèques natives (fichiers SO)
Bibliothèques et plug-ins

Plusieurs bibliothèques et plug-ins modifient automatiquement les fichiers manifestes de votre application ou les ressources référencées dans le fichier manifeste. Ces mises à jour automatiques peuvent interférer avec la fonctionnalité "Apply Changes" (Appliquer les modifications) de différentes manières :

  • Si une bibliothèque ou un plug-in modifie le fichier manifeste de votre application, vous ne pouvez pas utiliser "Apply Changes" (Appliquer les modifications). Vous devrez redémarrer votre application pour voir les modifications.
  • Si une bibliothèque ou un plug-in modifie les fichiers de ressources de votre application, vous ne pouvez pas utiliser Apply Code Changes (Appliquer les modifications du code) Icône Apply Code Changes (Appliquer les modifications du code). Vous devez utiliser Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité) Icône Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité) (ou redémarrer l'application) pour voir les modifications.

Pour contourner ces limites, désactivez toutes les mises à jour automatiques pour vos variantes de compilation de débogage.

Par exemple, Firebase Crashlytics met à jour les ressources de l'application avec un ID de compilation unique à chaque compilation, ce qui vous empêche d'utiliser l'option Apply Code Changes (Appliquer les modifications de code) Icône Apply Code Changes (Appliquer les modifications du code) et implique de redémarrer l'activité de votre application pour voir vos modifications. Désactivez ce comportement pour utiliser Apply Code Changes (Appliquer les modifications de code) avec Crashlytics avec vos versions de débogage.

Code faisant directement référence au contenu d'un APK installé

Si votre code fait directement référence à du contenu de l'APK de votre application installé sur l'appareil, ce code peut entraîner des plantages ou un dysfonctionnement après avoir cliqué sur Apply Code Changes (Appliquer les modifications de code) Icône Apply Code Changes (Appliquer les modifications du code). Ce comportement est dû au fait que lorsque vous cliquez sur Apply Code Changes (Appliquer les modifications de code), l'APK sous-jacent de l'appareil est remplacé lors de l'installation. Dans ce cas, vous pouvez cliquer sur Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité) Icône Apply Changes and Restart Activity (Appliquer les modifications et redémarrer l'activité) ou Run (Exécuter) Icône Run (Exécuter).

En cas de problème lors de l'utilisation de la fonctionnalité "Apply Changes" (Appliquer les modifications), signalez un bug.

Modification en temps réel (fonctionnalité expérimentale)

La modification en temps réel est une fonctionnalité expérimentale dans les versions Canary d'Android Studio Flamingo qui vous permet de mettre à jour en temps réel des composables dans des émulateurs et des appareils physiques. Cette fonctionnalité limite les changements de contexte entre l'écriture et la compilation de votre application pour vous permettre de mieux vous concentrer sur l'écriture du code et ce, sans interruption.

La modification en temps réel comprend deux modes :

  • Manual (manuel) : les modifications apportées au code sont appliquées lorsqu'elles sont enregistrées manuellement à l'aide des touches Ctrl + S (Commande + S sur macOS).
  • Automatic (Automatique) : les modifications sont appliquées sur votre appareil ou votre émulateur lorsque vous mettez à jour une fonction modulable.

La modification en temps réel se concentre sur les modifications de code liées à l'UI et à l'expérience utilisateur. Cette fonctionnalité ne prend pas en charge les modifications telles que les mises à jour de signature de méthode, l'ajout de nouvelles méthodes ou les modifications de hiérarchie des classes. Pour en savoir plus, consultez la liste des limites de la fonctionnalité de modification en temps réel.

Cette fonctionnalité ne remplace pas la création et l'exécution de votre application, ni l'option Apply Changes (Appliquer les modifications). Elle est conçue pour optimiser votre workflow lorsque vous compilez, déployez et itérez une application afin de développer l'UI Compose.

Le workflow recommandé est le suivant :

  1. Configurez votre application pour qu'elle puisse être exécutée.
  2. Utilisez la fonctionnalité de modification en temps réel autant que possible, jusqu'à ce que vous ayez besoin d'apporter une modification non prise en charge par cette fonctionnalité, comme l'ajout de nouvelles méthodes, lorsque l'application est en cours d'exécution.
  3. Après avoir effectué une modification non compatible, cliquez sur Run (Exécuter) Icône Run (Exécuter) pour redémarrer votre application et reprendre la modification en temps réel.

GIF montrant comment utiliser la fonctionnalité de modification en temps réel avec un appareil

Figure 3. En mode automatique, chaque fois que vous apportez une modification compatible avec la fonctionnalité de modification en temps réel, l'application en cours d'exécution sur votre appareil ou dans l'émulateur est mise à jour en temps réel.

Premiers pas avec la fonctionnalité de modification en temps réel

Pour faire vos premiers pas, procédez comme suit afin de créer une activité Compose vide, d'activer la fonctionnalité de modification en temps réel pour votre projet et d'utiliser cette fonctionnalité pour y apporter des modifications.

Configurer votre nouveau projet
  1. Avant de commencer, assurez-vous que la dernière version Canary d'Android Studio Flamingo est installée et que vous utilisez au moins le niveau d'API 30 sur votre appareil physique ou dans l'émulateur.

  2. Ouvrez Android Studio et sélectionnez New Project (Nouveau projet) dans la boîte de dialogue Welcome to Android Studio (Bienvenue dans Android Studio). Si vous avez déjà ouvert un projet, vous pouvez en créer un nouveau en accédant à File > New > New Project (Fichier > Nouveau > Nouveau projet).

  3. Choisissez le modèle Empty Compose Activity (Activité Compose vide) pour Phone and Tablet (Téléphone et tablette), puis cliquez sur Next (Suivant).

    Sélection d'un modèle dans Android Studio Figure 4. Modèles disponibles Pour "Live Edit" (Modification en temps réel), sélectionnez Empty Compose Activity (Activité Compose vide).

  4. Dans la boîte de dialogue New Project (Nouveau projet), saisissez les informations requises : nom, nom du package, emplacement d'enregistrement, langage (défini sur Kotlin) et SDK minimal.

    Exemples de paramètres de projet définis à l'étape 4 dans AS Figure 5. Exemples de paramètres de projet

  5. Cliquez sur Finish (Terminer).

Activer la fonctionnalité "Live Edit" (Modification en temps réel)
  1. Accédez aux paramètres pour activer la modification en temps réel.

    • Sous Windows ou Linux, accédez à File > Settings > Editor > Live Edit (Fichier > Paramètres > Éditeur > Modification en temps réel).
    • Sous macOS, accédez à Android Studio > Preferences > Editor > Live Edit (Préférences > Éditeur > Modification en temps réel).
  2. Sélectionnez l'option Live Edit (Modification en temps réel), puis choisissez le mode que vous souhaitez exécuter dans les paramètres.

    En mode manuel, les modifications de code sont appliquées à chaque enregistrement manuel, à l'aide des combinaisons de touches Ctrl + S (Commande + S sur macOS). En mode automatique, les modifications de code sont appliquées sur votre appareil ou votre émulateur lorsque vous effectuez des modifications.

    UI de la case à cocher "Live Edit" (Modification en temps réel) dans les paramètres d'Android Studio Figure 6. Paramètres Live Edit (Modification en temps réel)

  3. Dans l'éditeur, ouvrez le fichier MainActivity correspondant au point d'entrée de votre application.

  4. Cliquez sur Run (Exécuter) Bouton d'UI pour déployer votre application, puis sur Split (Partager) en haut à droite de l'éditeur pour ouvrir l'aperçu.

  5. Une fois la fonctionnalité "Live Edit" (Modification en temps réel) activée, la coche verte Live Edit s'affiche en haut à droite de l'éditeur :

    Coche verte "Live Edit" (UI)

Apporter des modifications et les examiner

Lorsque vous apportez des modifications compatibles dans l'éditeur, l'aperçu est automatiquement mis à jour.

Par exemple, remplacez la méthode Greeting existante dans MainActivity par ce qui suit :

@Composable
fun Greeting(name: String) {
    Text(text = "Hello $name!",
        Modifier.padding(80.dp) // Outer padding; outside background
            .background(color = Color.Cyan) // Solid element background color
            .padding(16.dp) // Inner padding; inside background, around text)
    )
}

Les modifications apparaissent instantanément dans l'aperçu, comme l'illustre la figure 7.

Modifications apportées à la méthode d'accueil d'un appareil

Figure 7. Aperçu affichant les modifications en temps réel apportées à la méthode Greeting

Résoudre les problèmes liés à la modification en temps réel

Si vos modifications ne s'affichent pas dans le volet d'aperçu, il est possible qu'Android Studio ne soit pas parvenu à les mettre à jour. Vérifiez si l'indicateur d'interface utilisateur Live Edit (Modification en temps réel) affiche une icône en veille, comme illustré à la figure 8, qui indique une erreur de compilation. Pour en savoir plus sur l'erreur et obtenir des suggestions sur sa résolution, cliquez sur l'indicateur d'erreur.

UI de l'état "Live Edit" (Modification en temps réel)

Figure 8. Indicateur d'état de la modification en temps réel

Limites de la fonctionnalité de modification en temps réel

Voici la liste des limites actuelles.

  • La fonctionnalité de modification en temps réel peut ne pas être compatible avec la gestion des erreurs et la création de rapports avec Compose 1.2.0 ou une version antérieure. Utilisez Compose 1.3.0 ou une version ultérieure pour une expérience optimale.
  • La fonctionnalité "Live Edit" (Modification en temps réel) nécessite un appareil physique ou un émulateur exécutant le niveau d'API 30 ou supérieur.
  • La fonctionnalité "Live Edit" prend uniquement en charge la modification d'un corps de fonction Vous ne pouvez donc pas modifier le nom ou la signature de la fonction, ajouter ou supprimer une fonction, ni modifier des champs non fonctionnels.
  • Les classes modifiées par "Live Edit" (Modification en temps réel) peuvent altérer les performances. Exécutez votre application et utilisez un build "propre" si vous évaluez ses performances.
  • Vous devez effectuer une exécution complète pour permettre le bon fonctionnement du débogueur sur les classes que vous avez modifiées avec "Live Edit" (Modification en temps réel).
  • Une application en cours d'exécution peut planter lorsque vous la modifiez à l'aide de la fonctionnalité "Live Edit". Dans ce cas, vous pouvez redéployer l'application à l'aide du bouton Run (Exécuter) Bouton d'UI.
  • La fonctionnalité "Live Edit" (Modification en temps réel) n'effectue aucune manipulation du bytecode défini dans le fichier de compilation de votre projet, par exemple, une manipulation du bytecode qui serait appliquée lors de la compilation du projet en utilisant les options du menu Build (Compilation) ou en cliquant sur le bouton Build (Compilation) ou Run (Exécuter).
  • Les fonctions non modulables sont mises à jour en temps réel sur l'appareil ou l'émulateur, et une recomposition complète est déclenchée. Cette recomposition complète n'appelle pas systématiquement la fonction mise à jour. Pour les fonctions non modulables, vous devez déclencher les fonctions récemment mises à jour ou exécuter à nouveau l'application.
  • La fonctionnalité "Live Edit" (Modification en temps réel) n'est pas réactivée au redémarrage de l'application. Vous devez exécuter à nouveau l'application.
  • Si votre projet utilise la version 1.2 ou une version ultérieure de Compose, seule la première modification de code effectuée sur un fichier donné réinitialise la composition. Les modifications apportées ultérieurement à ce fichier ne la réinitialisent pas.

Questions fréquentes sur la fonctionnalité de modification en temps réel

  • Quel est l'état actuel de la fonctionnalité de modification en temps réel ?
    • La fonctionnalité expérimentale de modification en temps réel est disponible sur la version Canary d'Android Studio Flamingo. Pour l'activer ou la désactiver, accédez à File (Fichier) > Settings (Paramètres) > Editor (Éditeur) > Live Edit (Modification en temps réel) ou àAndroid Studio > Preferences (Préférences) > Editor (Éditeur) > Live Edit (Modification en temps réel) sous macOS.
  • Quand dois-je utiliser la fonctionnalité de modification en temps réel ?
    • Utilisez la fonctionnalité de modification en temps réel si vous souhaitez voir rapidement les effets des mises à jour des éléments de l'expérience utilisateur (mises à jour de modificateurs ou animations, par exemple) sur l'expérience globale de l'application.
  • Quand dois-je éviter d'utiliser la fonctionnalité de modification en temps réel ?
    • Actuellement, la fonctionnalité de modification en temps réel permet de modifier le code associé à l'UI et à l'expérience utilisateur. Elle n'est pas compatible avec les modifications telles que les mises à jour des signatures de méthodes, l'ajout de méthodes ou les modifications de la hiérarchie de classes. Pour en savoir plus, consultez la section Limites de la fonctionnalité de modification en temps réel.
  • Quand dois-je utiliser l'aperçu de Compose ?
    • Utilisez l'aperçu de Compose lorsque vous développez des composables individuels. L'aperçu permet de visualiser les éléments de Compose et s'actualise automatiquement pour afficher l'effet des modifications apportées au code. L'aperçu prend également en charge l'affichage des éléments d'UI dans différentes configurations et états, tels que le mode sombre, les paramètres régionaux et l'échelle de police.

Modifier la variante de compilation

Par défaut, Android Studio crée la version de débogage de votre application, à utiliser pendant le développement, lorsque vous cliquez sur Run (Exécuter) Bouton d'UI.

Pour modifier la variante de compilation utilisée par Android Studio, effectuez l'une des opérations suivantes :

  • Dans le menu, sélectionnez Build > Select Build Variant (Compilation > Sélectionner une variante de compilation).
  • Sélectionnez View > Tool Windows > Build Variants (Vue> Fenêtres d'outils > Variantes de compilation) dans le menu.
  • Cliquez sur l'onglet Build Variants (Variantes de compilation) dans la barre des fenêtres d'outils.

Pour les projets sans code natif/C++, le panneau Build Variants (Variantes de compilation) présente deux colonnes : Module et Active Build Variant (Variante de compilation active). La valeur Active Build Variant (Variante de compilation active) du module détermine la variante de compilation déployée par l'IDE sur votre appareil connecté et est visible dans l'éditeur.

Figure 9. Le volet Build Variants (Variantes de compilation) comporte deux colonnes pour les projets sans code natif/C++

Pour passer d'une variante à l'autre, cliquez sur la cellule Active Build Variant (Variante de compilation active) d'un module et sélectionnez la variante souhaitée dans le champ de liste.

Pour les projets avec du code natif/C++, le panneau Build Variants (Variantes de compilation) comporte trois colonnes :

  • Module
  • Active Build Variant (Variante de compilation active)
  • Active ABI (ABI active)

La valeur Active Build Variant (Variante de compilation active) du module détermine la variante de compilation déployée par l'IDE sur votre appareil et visible dans l'éditeur. Pour les modules natifs, la valeur Active ABI (ABI active) détermine l'ABI qui sera utilisée par l'éditeur, mais n'a aucune incidence sur ce qui est déployé.

Figure 10. Le panneau Build Variants (Variantes de compilation) ajoute la colonne Active ABI (ABI active) pour les projets avec du code natif/C++

Pour modifier la variante de compilation ou l'ABI, cliquez sur la cellule correspondant à la colonne Active Build Variant (Variante de compilation active) ou Active ABI (ABI active), puis sélectionnez la variante ou l'ABI souhaitée dans la liste. Une fois la sélection modifiée, l'IDE synchronise automatiquement votre projet. Si vous modifiez l'une des colonnes d'un module d'application ou de bibliothèque, la modification est appliquée à toutes les lignes dépendantes.

Par défaut, les nouveaux projets sont configurés avec deux variantes de compilation : une variante de débogage et une variante de version. Vous devez créer la variante de version pour préparer votre application à des fins de publication. Pour définir d'autres variantes de votre application avec différentes fonctionnalités ou exigences d'appareil, vous pouvez définir des variantes de compilation supplémentaires.

Conflits dans la boîte de dialogue "Build Variants" (Variantes de compilation) d'Android Studio

Dans la boîte de dialogue Build Variants (Variantes de compilation) d'Android Studio, vous pouvez voir des messages d'erreur indiquant des conflits entre les variantes de compilation, par exemple :

Fenêtre "Build Variants" (Variantes de compilation) affichant les erreurs de conflit de variantes

Cette erreur n'indique pas un problème de compilation avec Gradle. Elle indique que l'IDE Android Studio ne peut pas résoudre les symboles entre les variantes des modules sélectionnés.

Par exemple, si vous avez un module M1 qui dépend de la variante v1 du module M2, mais que M2 présente une variante v2 sélectionnée dans l'IDE, vous constaterez des symboles non résolus dans l'IDE. Supposons que M1 dépende d'une classe qui n'est disponible que dans v1. Lorsque v2 est sélectionné, cette classe n'est pas connue par l'IDE. Par conséquent, il ne parvient pas à résoudre le nom de la classe et affiche des erreurs dans le code du module M1.

Ces messages d'erreur s'affichent, car l'IDE n'est pas en mesure de charger simultanément le code de plusieurs variantes. La variante sélectionnée dans cette boîte de dialogue n'a aucune incidence sur la compilation de votre application, car Gradle compile votre application avec le code source spécifié dans vos combinaisons de compilation Gradle, et non en fonction des éléments actuellement chargés dans l'IDE.

Modifier la configuration d'exécution/de débogage

Lorsque vous exécutez votre application pour la première fois, Android Studio utilise une configuration d'exécution par défaut. La configuration d'exécution/de débogage spécifie si votre application doit être déployée à partir d'un fichier APK ou d'un fichier Android App Bundle, le module à exécuter, le package à déployer, l'activité à démarrer, l'appareil cible, les paramètres de l'émulateur, les options Logcat, etc.

La configuration d'exécution/de débogage par défaut génère un APK, lance l'activité de projet par défaut et utilise la boîte de dialogue Select Deployment Target (Sélectionner une cible de déploiement) à des fins de sélection des appareils cibles. Si les paramètres par défaut ne conviennent pas à votre projet ou module, vous pouvez personnaliser la configuration d'exécution/de débogage ou en créer une au niveau du projet, par défaut ou au niveau du module.

Pour modifier une configuration d'exécution/de débogage, sélectionnez Run > Edit Configurations (Exécuter > Modifier les configurations). Pour en savoir plus, consultez Créer et modifier des configurations d'exécution/de débogage.