Déboguer votre application

Stay organized with collections Save and categorize content based on your preferences.

Android Studio fournit un débogueur permettant d'effectuer les opérations suivantes, entre autres :

  • Sélectionnez un appareil sur lequel déboguer votre application.
  • Définissez des points d'arrêt dans votre code Java, Kotlin et C/C++.
  • Examinez les variables et évaluez les expressions lors de l'exécution.

Cette page explique comment effectuer les opérations de débogage de base. Pour en savoir plus, consultez également la documentation sur le débogage avec IntelliJ IDEA.

Activer le débogage

Avant de commencer le débogage, vous devez effectuer les préparatifs suivants :

  • Activer le débogage sur votre appareil :

    Le débogage est activé par défaut dans l'émulateur. En revanche, pour un appareil connecté, vous devez activer le débogage dans les options pour développeurs de l'appareil.

  • Exécutez une variante de compilation débogable :

    Vous devez utiliser une variante de compilation qui inclut debuggable true dans sa configuration. En règle générale, vous pouvez simplement sélectionner la variante "debug" incluse par défaut dans tous les projets Android Studio (même si elle n'est pas visible dans le fichier build.gradle). Toutefois, si vous définissez de nouveaux types de compilation qui doivent être débogables, vous devez ajouter "debuggable true" au type de compilation :

    Groovy

    android {
        buildTypes {
            customDebugType {
                debuggable true
                ...
            }
        }
    }
    

    Kotlin

    android {
        buildTypes {
            create("customDebugType") {
                debuggable = true
                ...
            }
        }
    }
    

    Cette propriété s'applique également aux modules avec du code C/C++. (La propriété jniDebuggable n'est plus utilisée.)

    Si votre application dépend d'un module de bibliothèque que vous souhaitez également déboguer, cette bibliothèque doit également être packagée avec debuggable true pour conserver ses symboles de débogage. Pour vous assurer que les variantes débogables de votre projet d'application reçoivent la variante débogable d'un module de bibliothèque, veillez à publier les versions autres que celles par défaut de votre bibliothèque.

Démarrer le débogage

Pour démarrer une session de débogage :

  1. Définissez des points d'arrêt dans le code de l'application.
  2. Dans la barre d'outils, ouvrez le menu déroulant "Appareil cible" et sélectionnez un appareil sur lequel déboguer votre application.

    Menu déroulant de sélection de l'appareil cible.

    Si aucun appareil n'est configuré, vous devrez connecter un appareil via USB ou créer un appareil virtuel (AVD) pour utiliser Android Emulator.

  3. Dans la barre d'outils, cliquez sur Déboguer .

    Si une boîte de dialogue vous invite à passer de l'exécution au débogage, cela signifie que votre application est déjà en cours d'exécution sur l'appareil et qu'elle va redémarrer pour commencer le débogage. Si vous préférez continuer à exécuter la même instance de l'application, cliquez sur Annuler le débogage, puis associez le débogueur à votre application en cours d'exécution.

    Sinon, Android Studio compile un APK, le signe avec une clé de débogage, l'installe sur l'appareil sélectionné puis l'exécute. Si vous ajoutez du code C et C++ à votre projet, Android Studio exécute également le débogueur LLDB dans la fenêtre Déboguer pour déboguer votre code natif.

  4. Si la fenêtre Débogage n'est pas ouverte, sélectionnez Affichage > Fenêtres d'outils > Débogage (ou cliquez sur Déboguer dans la barre des fenêtres d'outils). Ensuite, cliquez sur l'onglet Débogueur, comme illustré dans la figure 1.

    Figure 1 : La fenêtre du débogueur, affichant le thread actuel et l'arborescence d'objets pour une variable.

Associer le débogueur à une application en cours d'exécution

Si votre application est déjà en cours d'exécution sur votre appareil, vous pouvez lancer le débogage sans la redémarrer :

  1. Cliquez sur Associer le débogueur à un processus Android .
  2. Dans la boîte de dialogue Sélectionner un processus, sélectionnez le processus auquel vous souhaitez associer le débogueur.

    Si vous utilisez un émulateur ou un appareil en mode root, vous pouvez cocher la case Afficher tous les processus pour afficher tous les processus.

    Le menu déroulant Sélectionner les paramètres du débogueur Android vous permet d'appliquer une configuration d'exécution/de débogage préexistante. (Pour le code C et C++, cela vous permet de réutiliser les commandes LLDB de démarrage et post-association, ainsi que les répertoires de symboles d'une configuration existante.) Si vous n'avez pas encore de configuration d'exécution/de débogage, sélectionnez Créer. Cette sélection active le menu déroulant Type de débogage, qui vous permet de sélectionner un autre type de débogage. Par défaut, Android Studio utilise le type de débogage Automatique pour sélectionner l'option de débogage la plus adaptée à votre projet, selon que votre projet inclut du code Java ou C/C++.

  3. Cliquez sur OK.

    La fenêtre Débogage s'affiche.

Remarque : Le débogueur et le récupérateur de mémoire d'Android Studio interagissent en couplage lâche. La machine virtuelle Android garantit que tous les objets dont le débogueur a connaissance sont exemptés de la récupération de mémoire jusqu'à la déconnexion du débogueur. Cela peut entraîner une accumulation d'objets au fil du temps, lorsque le débogueur reste connecté. Par exemple, si le débogueur analyse un thread en cours d'exécution, l'objet Thread associé n'est pas éliminé par la récupération de mémoire, même si le thread prend fin, et persiste jusqu'à la déconnexion du débogueur.

Modifier le type de débogueur

Étant donné que le code Java/Kotlin et le code C/C++ nécessitent différents outils de débogage, Android Studio vous permet de sélectionner le type de débogueur à utiliser. Par défaut, Android Studio détermine le débogueur à utiliser en fonction des langues qu'il détecte dans votre projet (lorsque le type de débogage est défini sur Automatique). Toutefois, vous pouvez sélectionner manuellement le débogueur dans la configuration de débogage (en cliquant sur Exécuter > Modifier les configurations) ou dans la boîte de dialogue qui s'affiche lorsque vous cliquez sur Exécuter > Associer le débogueur à un processus Android.

Les types de débogueur disponibles sont les suivants :

Auto
Sélectionnez ce type de débogueur si vous souhaitez qu'Android Studio détermine automatiquement la meilleure option pour le code à déboguer. Par exemple, si votre projet comporte du code C ou C++, Android Studio utilise automatiquement le type de débogage Double. Sinon, Android Studio utilise le type de débogage Java.
Java
Sélectionnez ce type de débogueur si vous souhaitez déboguer uniquement le code écrit en Java ou Kotlin. Le débogueur Java ignore les points d'arrêt ou d'observation que vous avez définis dans votre code natif.
Natif (code C/C++ uniquement)
Sélectionnez ce type de débogueur si vous souhaitez exclusivement utiliser LLDB pour déboguer votre code. Lorsque vous utilisez ce type, la vue de session du débogueur Java n'est pas disponible. Par défaut, LLDB n'inspecte que votre code natif et ignore les points d'arrêt dans votre code Java. Si vous souhaitez également déboguer votre code Java, vous devez choisir le type de débogage Automatique ou Double.

Le débogage natif ne fonctionne que sur les appareils qui répondent aux critères suivantes :

  • L'appareil est compatible avec run-as.

    Pour vérifier si l'appareil est compatible avec run-as, exécutez la commande suivante sur l'interface système ADB connectée à votre appareil :

    run-as your-package-name pwd
    

    Remplacez your-package-name par le nom du package de votre application. Si l'appareil est compatible avec run-as, la commande ne devrait renvoyer aucune erreur.

  • ptrace est activé sur l'appareil.

    Pour vérifier si ptrace est activé, exécutez la commande suivante sur l'interface système ADB connectée à votre appareil :

    sysctl kernel.yama.ptrace_scope
    

    Si ptrace est activé, la commande renvoie la valeur 0 ou une erreur unknown key. Si ptrace n'est pas activé, une valeur autre que 0 s'affiche.

Double (code C/C++ uniquement)
Sélectionnez ce type de débogueur si vous souhaitez passer du débogage Java au code natif et inversement. Android Studio associe deux débogueurs (Java et LLDB) à votre processus d'application, vous permettant d'inspecter les points d'arrêt dans votre code Java et natif sans redémarrer votre application ni modifier votre configuration de débogage.

Dans la figure 2, vous remarquerez les deux onglets situés à droite du titre de la fenêtre Débogage. Comme l'application utilise à la fois du code Java et C++, l'un de ces onglets sert à déboguer le code natif, et l'autre à déboguer le code Java (signalé par le suffixe -java).

Figure 2 : Les onglets de débogage dédiés respectivement au code natif et au code Java.

Remarque : Si vous déboguez du code natif optimisé par le compilateur, le message d'avertissement "This function was compiled with optimizations enabled. Some debugger features may not be available" peut s'afficher. Lorsque vous utilisez des indicateurs d'optimisation, tels que des -O, le compilateur adapte le mode de compilation pour une exécution plus efficace. Cette opération peut amener le débogueur à rapporter des informations inattendues ou incorrectes, car il rencontre des difficultés pour mapper le code compilé optimisé au code source d'origine. Pour éviter ce problème, vous devez désactiver les optimisations du compilateur pendant le débogage de votre code natif.

Utiliser le journal système

Le journal système affiche les messages du système pendant que vous déboguez votre application. Ces messages incluent des informations provenant d'applications exécutées sur l'appareil. Si vous souhaitez utiliser le journal système pour déboguer votre application, assurez-vous que votre code écrit des messages de journal et imprime la trace de la pile pour les exceptions tant que votre application est en phase de développement.

Écrire des messages de journal dans votre code

Pour écrire des messages de journal dans votre code, utilisez la classe Log. Les messages de journal aident à comprendre le flux d'exécution en collectant les résultats du débogage système pendant que vous interagissez avec votre application. Les messages de journal peuvent vous indiquer quelle partie de votre application ne fonctionne pas correctement. Pour en savoir plus sur la journalisation, consultez la page Écrire et afficher les journaux.

L'exemple suivant montre comment ajouter des messages de journal pour déterminer si des informations sur l'état antérieur sont disponibles lorsque votre activité commence :

Kotlin

import android.util.Log
...
private val TAG: String = MyActivity::class.java.simpleName
...
class MyActivity : Activity() {
    ...
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        if (savedInstanceState != null) {
            Log.d(TAG, "onCreate() Restoring previous state")
            /* restore state */
        } else {
            Log.d(TAG, "onCreate() No saved state available")
            /* initialize app */
        }
    }
}

Java

import android.util.Log;
...
public class MyActivity extends Activity {
    private static final String TAG = MyActivity.class.getSimpleName();
    ...
    @Override
    public void onCreate(Bundle savedInstanceState) {
       ...
       if (savedInstanceState != null) {
            Log.d(TAG, "onCreate() Restoring previous state");
            /* restore state */
        } else {
            Log.d(TAG, "onCreate() No saved state available");
            /* initialize app */
        }
    }
}

Lors du développement, votre code peut également détecter des exceptions et écrire la trace de la pile dans le journal système :

Kotlin

fun someOtherMethod() {
    try {
        ...
    } catch (e : SomeException) {
        Log.d(TAG, "someOtherMethod()", e)
    }
}

Java

void someOtherMethod() {
    try {
        ...
    } catch (SomeException e) {
        Log.d(TAG, "someOtherMethod()", e);
    }
}

Remarque : Supprimez les messages de journal de débogage et les appels d'impression de trace de la pile de votre code lorsque vous êtes prêt à publier votre application. Pour ce faire, vous pouvez définir un indicateur DEBUG et placer les messages de journal de débogage dans des instructions conditionnelles.

Consulter le journal système

Vous pouvez afficher et filtrer les messages de débogage et d'autres messages système dans la fenêtre Logcat. Par exemple, vous pouvez cibler les messages liés à la récupération de mémoire ou ceux que vous ajoutez à votre application avec la classe Log.

Pour utiliser Logcat, démarrez le débogage et sélectionnez l'onglet Logcat dans la barre d'outils inférieure, comme illustré dans la figure 3.

Figure 3 : La fenêtre Logcat avec les paramètres de filtre.

Pour une description de Logcat et de ses options de filtrage, consultez la page Écrire et afficher des journaux avec Logcat.

Utiliser des points d'arrêt

Android Studio est compatible avec plusieurs types de points d'arrêt, qui déclenchent différentes actions de débogage. Le type le plus courant est un point d'arrêt qui suspend l'exécution de votre application sur une ligne de code spécifiée. Pendant la mise en suspens, vous pouvez examiner les variables, évaluer les expressions, puis continuer l'exécution ligne par ligne pour déterminer les causes d'erreurs.

Pour ajouter un point d'arrêt :

  1. Repérez la ligne de code à laquelle vous souhaitez interrompre l'exécution, puis cliquez sur la gouttière gauche de cette ligne de code, ou placez le curseur de saisie sur la ligne et appuyez sur Ctrl+F8 (Commande+F8 sur Mac).
  2. Si votre application est déjà en cours d'exécution, vous n'avez pas besoin de la mettre à jour pour ajouter le point d'arrêt. Il vous suffit de cliquer sur Associer le débogueur à un processus Android . Sinon, commencez le débogage en cliquant sur Déboguer .

Figure 3 : Un point rouge apparaît à côté de la ligne lorsque vous définissez un point d'arrêt.

Lorsque l'exécution du code atteint le point d'arrêt, Android Studio suspend l'exécution de votre application. Vous pouvez ensuite utiliser les outils de l'onglet Débogage pour identifier l'état de l'application :

  • Pour rechercher une variable dans l'arborescence des objets, développez-la dans la vue Variables. Si la vue Variables n'est pas visible, cliquez sur Restaurer la vue Variables .

  • Pour évaluer une expression au point d'exécution actuel, cliquez sur Évaluer l'expression .

  • Pour passer à la ligne de code suivante (sans saisir de méthode), cliquez sur Passer .

  • Pour passer à la première ligne d'un appel de méthode, cliquez sur Descendre .

  • Pour passer à la ligne suivante en dehors de la méthode actuelle, cliquez sur Remonter .

  • Pour continuer l'exécution normale de l'application, cliquez sur Reprendre le programme .

Si votre projet utilise du code natif, le type de débogage Automatique associe les débogueurs Java et LLDB à votre application sous la forme de deux processus distincts. Vous pouvez ainsi basculer entre l'inspection du code Java et celle des points d'arrêt C/C++ sans redémarrer votre application ni modifier les paramètres.

Remarque : Pour qu'Android Studio détecte les points d'arrêt dans votre code C ou C++, vous devez utiliser un type de débogueur compatible avec LLDB, tel que Automatique, Natif ou Double. Vous pouvez changer le type de débogueur utilisé par Android Studio en modifiant votre configuration de débogage. Pour en savoir plus sur les différents types de débogueurs, consultez la section Modifier le type de débogueur.

Lorsque Android Studio déploie votre application sur l'appareil cible, la fenêtre de débogage s'ouvre avec un onglet ou une vue de session pour chaque processus de débogage, comme illustré dans la figure 4.

Figure 4 : Débogage de code natif à l'aide de LLDB.

  1. Android Studio affiche l'onglet <your-module> lorsque le débogueur LLDB rencontre un point d'arrêt dans votre code C/C++. Les volets Frames, Variables et Points d'observation sont également disponibles, et fonctionnent exactement comme lors du débogage de code Java. Bien que le volet Threads ne soit pas disponible dans la vue de session LLDB, vous pouvez accéder aux processus de votre application à l'aide de la liste déroulante du volet Frames. Pour en savoir plus sur ces volets, consultez les sections Déboguer les frames de fenêtre et Inspecter les variables.

    Remarque : Lors de l'inspection d'un point d'arrêt dans votre code natif, le système Android suspend la machine virtuelle qui exécute le bytecode Java de votre application. Cela signifie que vous ne pouvez pas interagir avec le débogueur Java ni récupérer des informations d'état à partir de votre session de débogage Java lors de l'inspection d'un point d'arrêt dans votre code natif.

  2. Android Studio bascule sur l'onglet <your-module>-java lorsque le débogueur Java rencontre un point d'arrêt dans le code Java.
  3. Lors du débogage avec LLDB, vous pouvez utiliser le terminal LLDB dans la vue de session LLDB pour transmettre les options de ligne de commande à LLDB. Si vous souhaitez que LLDB exécute certaines commandes chaque fois que vous commencez à déboguer votre application, que ce soit juste avant ou juste après l'association du débogueur au processus de votre application, vous pouvez ajouter des commandes à votre configuration de débogage.

Lors du débogage du code C/C++, vous pouvez également définir des points d'arrêt particuliers, appelés points d'observation, qui peuvent suspendre le processus de votre application lorsque celle-ci interagit avec un bloc de mémoire spécifique. Pour en savoir plus, consultez la section Ajouter des points d'observation.

Afficher et configurer des points d'arrêt

Pour afficher tous les points d'arrêt et configurer les paramètres correspondants, cliquez sur Afficher les points d'arrêt  à gauche de la fenêtre Débogage. La fenêtre Points d'arrêt s'affiche, comme illustré dans la figure 5.

Figure 5 : La fenêtre Points d'arrêt répertorie tous les points d'arrêt actuels et inclut leurs paramètres de comportement respectifs.

La fenêtre Points d'arrêt vous permet d'activer ou de désactiver chaque point d'arrêt depuis la liste située à gauche. Si un point d'arrêt est désactivé, Android Studio ne suspend pas l'exécution de votre application lorsque ce point est atteint. Sélectionnez un point d'arrêt dans la liste pour configurer ses paramètres. Vous pouvez configurer un point d'arrêt pour le désactiver dans un premier temps et laisser le système l'activer lorsqu'un autre point d'arrêt est atteint. Vous pouvez également configurer si un point d'arrêt doit être désactivé après avoir été atteint. Pour définir un point d'arrêt pour une exception, sélectionnez Points d'arrêt sur exception dans la liste des points d'arrêt.

Déboguer les frames de fenêtre

Dans la fenêtre Débogage, le volet Frames permet de vérifier le bloc de pile qui a provoqué l'activation du point d'arrêt actuel. Vous pouvez ainsi parcourir et examiner la pile de piles, et inspecter la liste des threads de votre application Android. Pour sélectionner un thread, utilisez le menu déroulant du sélecteur et affichez son bloc de pile. Cliquez sur les éléments du bloc pour ouvrir leur source dans l'éditeur. Vous pouvez également personnaliser la présentation du thread et exporter le bloc de pile, comme indiqué dans le guide sur les frames de fenêtre.

Inspecter les variables

Dans la fenêtre Débogage, le volet Variables vous permet d'inspecter les variables lorsque le système suspend votre application sur un point d'arrêt et que vous sélectionnez un frame depuis le volet Frames. Le volet Variables vous permet également d'évaluer des expressions ad hoc à l'aide de méthodes et/ou de variables statiques disponibles dans le frame sélectionné.

Le volet Points d'observation offre des fonctionnalités similaires, à la différence que les expressions ajoutées au volet Points d'observation persistent entre les sessions de débogage. Nous vous recommandons d'ajouter des points d'observation aux variables et champs auxquels vous accédez fréquemment, ou qui fournissent un état utile pour la session de débogage actuelle. Les volets Variables et Points d'observation s'affichent comme illustré dans la figure 5.

Pour ajouter une variable ou une expression à la liste Points d'observation :

  1. Lancez le débogage.
  2. Dans le volet Points d'observation, cliquez sur Ajouter .
  3. Dans la zone de texte qui s'affiche, saisissez le nom de la variable ou de l'expression que vous souhaitez surveiller, puis appuyez sur Entrée.

Pour supprimer un élément de la liste Points d'observation, sélectionnez-le puis cliquez sur Supprimer .

Pour réorganiser les éléments de la liste Points d'observation, sélectionnez un élément, puis cliquez sur Monter  ou Descendre .

Figure 6 : Les volets Variables et Points d'observation dans la fenêtre Débogage.

Ajouter des points d'observation

Lors du débogage du code C/C++, vous pouvez également définir des points d'arrêt particuliers, appelés points d'observation, qui peuvent suspendre le processus de votre application lorsque celle-ci interagit avec un bloc de mémoire spécifique. Par exemple, si vous définissez deux pointeurs vers un bloc de mémoire et que vous lui assignez un point d'observation, l'utilisation de l'un ou l'autre de ces pointeurs pour accéder à ce bloc de mémoire déclenche le point d'observation.

Dans Android Studio, vous pouvez créer un point d'observation pendant l'exécution en sélectionnant une variable spécifique. Toutefois, LLDB affecte le point d'observation uniquement au bloc de mémoire que le système alloue à cette variable, et non à la variable elle-même. Cette opération diffère de l'ajout d'une variable au volet Points d'observation, qui vous permet d'observer la valeur d'une variable, mais pas de suspendre le processus de votre application lorsque le système lit ou modifie la valeur en mémoire.

Remarque : Lorsque le processus de votre application quitte une fonction et que le système libère les variables locales en mémoire, vous devez réaffecter les points d'observation créés pour ces variables.

Pour définir un point d'observation, vous devez remplir les conditions suivantes :

  • Votre appareil physique ou votre émulateur cible utilise un processeur x86 ou x86_64. Si votre appareil utilise un processeur ARM, vous devez aligner les limites d'adresse de votre variable sur 4 octets pour les processeurs 32 bits ou sur 8 octets pour les processeurs 64 bits. Vous pouvez aligner une variable dans votre code natif en spécifiant __attribute__((aligned(num_bytes))) dans la décélération de la variable, comme indiqué ci-dessous :
    // For a 64-bit ARM processor
    int my_counter __attribute__((aligned(8)));
    
  • Vous n'avez attribué que trois points d'observation au maximum. Android Studio ne prend en charge que quatre points d'observation sur les appareils cibles avec processeur x86 ou x86_64. Certains autres appareils peuvent gérer moins de points d'observation.

Remarque : Lorsque vous déboguez votre application avec des ABI ARM 32 bits, ajouter un point d'observation ou pointer sur les variables dans le code pour examiner leurs valeurs peut entraîner un plantage. Pour contourner ce problème, veuillez effectuer votre débogage à l'aide d'un fichier binaire ARM 64 bits, x86 ou x86_64. Ce problème sera résolu dans une prochaine version d'Android Studio.

Si vous remplissez les conditions ci-dessus, vous pouvez ajouter un point d'observation comme suit :

  1. Pendant que votre application est suspendue au niveau du point d'arrêt, accédez au volet Variables de la vue de votre session LLDB.
  2. Effectuez un clic droit sur une variable qui occupe le bloc de mémoire dont vous souhaitez effectuer le suivi, puis sélectionnez Ajouter un point d'observation. Une boîte de dialogue permettant de configurer votre point d'observation s'affiche, comme illustré dans la figure 7.

    Figure 7. Ajout d'un point d'observation à une variable en mémoire.

  3. Configurez votre point d'observation à l'aide des options suivantes :
    • Activer : désélectionnez cette option si vous souhaitez qu'Android Studio ignore le point d'observation pour le moment. Android Studio enregistrera votre point d'observation pour vous permettre d'y accéder plus tard dans votre session de débogage.
    • Suspendre : par défaut, le système Android suspend le processus de votre application lorsqu'elle accède à un bloc de mémoire auquel vous assignez un point d'observation. Désélectionnez cette option si ce n'est pas le comportement recherché. Vous verrez alors d'autres options que vous pouvez utiliser pour personnaliser le comportement lorsque le système interagit avec votre point d'observation : Consigner un message dans la console et Supprimer quand [le point d'observation est] atteint.
    • Type d'accès : indiquez si votre application doit déclencher votre point d'observation lorsqu'elle tente de lire ou d'écrire dans le bloc de mémoire que le système alloue à la variable. Pour déclencher votre point d'observation en lecture et en écriture, sélectionnez Les deux.
  4. Cliquez sur OK.

Pour afficher tous vos points d'observation et configurer leurs paramètres, cliquez sur Afficher les points d'arrêt  à gauche de la fenêtre Débogage. La boîte de dialogue Points d'arrêt s'affiche, comme illustré dans la figure 8.

Figure 8 : La boîte de dialogue "Points d'arrêt" répertorie vos points d'observation actuels et inclut leurs paramètres de comportement respectifs.

Après avoir ajouté votre point d'observation, cliquez sur Reprendre le programme  à gauche de la fenêtre Débogage pour relancer le processus de l'application. Par défaut, si votre application tente d'accéder à un bloc de mémoire auquel vous avez assigné un point d'observation, le système Android suspend le processus et une icône de point d'observation  s'affiche à côté de la dernière ligne de code exécutée par votre application, comme illustré dans la figure 9.

Figure 9 : Android Studio indique la dernière ligne de code exécutée par votre application avant le déclenchement d'un point d'observation.

Afficher et modifier le format d'affichage des valeurs de ressource

En mode débogage, vous pouvez afficher les valeurs des ressources et sélectionner un autre format d'affichage pour les variables de votre code Java. Affichez l'onglet Variables, sélectionnez un frame, puis procédez comme suit :

  1. Dans la liste Variables, effectuez un clic droit n'importe où sur une ligne de ressource pour afficher une liste déroulante.
  2. Dans la liste déroulante, sélectionnez Format d'affichage, puis choisissez le format que vous souhaitez utiliser.

    Les formats disponibles dépendent du type de données de la ressource sélectionnée. Une ou plusieurs des options suivantes peuvent s'afficher :

    • Classe : affiche la définition de la classe.
    • toString : affiche le format de la chaîne.
    • Objet : affiche la définition de l'objet (instance d'une classe).
    • Tableau : affiche les valeurs sous forme de tableau.
    • Code temporel : affiche la date et l'heure au format aaaa-mm-jj hh:mm:ss.
    • Automatique : Android Studio choisit le meilleur format en fonction du type de données.
    • Binaire : affiche une valeur binaire composée de zéros et de uns.
    • MeasureSpec : la valeur transmise du parent à l'enfant sélectionné. Voir MeasureSpec.
    • Hex : affiche la valeur au format hexadécimal.
    • Primitive : affiche la valeur au format numérique à l'aide d'un type de données primitif.
    • Entier : affiche une valeur numérique de type Integer.

Vous pouvez créer un format personnalisé (moteur de rendu des types de données) comme suit :

  1. Effectuez un clic droit sur la valeur de la ressource.
  2. Sélectionnez Format d'affichage.
  3. Sélectionnez Créer. La boîte de dialogue Moteurs de rendu de types de données Java s'affiche.
  4. Suivez les instructions dans la section Moteurs de rendu des types de données Java.