Compiler et exécuter votre application

Remarque :Android Studio Meerkat a mis à jour les libellés et l'ordre de certaines actions de compilation. En savoir plus

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.

   

   Si vous n'avez configuré aucun appareil, vous devez créer un appareil virtuel Android pour utiliser Android Emulator ou 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).

Remarque :Android Studio inclut des optimisations de déploiement pour les modifications incrémentielles sur Android 11 ou version ultérieure. Si vous effacez manuellement les données de l'application entre les modifications incrémentielles, certaines modifications peuvent être supprimées sans avertissement. Votre application risque alors d'exécuter du code obsolète. Si vous devez effacer les données de l'application entre les déploiements, cochez l'option "Always install with package manager" (Toujours installer avec le gestionnaire de paquets) dans la configuration d'exécution/de débogage. Cela contournera ces optimisations de déploiement et garantira que la dernière version du code de l'application est déployée chaque fois que l'application est exécutée.

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'outils 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. Cela affiche également un résumé de l'impact des téléchargements pour déterminer si les téléchargements de dépendances affectent votre build de manière négative.
2. Onglet "Build Output" (Sortie de compilation) : 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 l'onglet 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 à nouveau la dernière action de compilation. Si vous avez exécuté Build > Make Selected Module (Compilation > Créer le module sélectionné) en dernier, il compile le module actuel. Si vous avez exécuté Build > Make Project (Compilation > Créer le projet), cela génère des fichiers de build intermédiaires pour tous les modules du 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é de 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 modifications)

Dans Android Studio 3.5 et versions ultérieures, "Apply Changes" (Appliquer les modifications) 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 cette fonctionnalité, consultez Projet Marble Android Studio : "Apply Changes" (Appliquer les modifications).

Conditions requises

Les actions de la fonctionnalité "Apply Changes" (Appliquer les modifications) 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 modifications)

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é)  : 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)  : 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) .

Si vous ne souhaitez pas y être invité chaque fois que cela se produit, 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.

Remarque : Certains types de modifications n'entraînent pas l'échec de l'option "Apply Changes" (Appliquer les modifications), mais nécessitent que vous redémarriez manuellement votre application pour voir ces modifications. Par exemple, si vous modifiez la méthode onCreate() d'une activité, ces modifications ne prennent effet qu'après le redémarrage de l'activité. Vous devez donc redémarrer votre application pour les voir.

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

Certains plug-ins et bibliothèques 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) . Vous devez utiliser 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) 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) . 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é) ou 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

La fonctionnalité de modification en temps réel est une fonctionnalité expérimentale d'Android Studio qui vous permet de mettre à jour des composables en temps réel 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.

En savoir plus sur la fonctionnalité de modification en temps réel

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

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 :

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.