Android
Journalisation et utilisation de Logcat

Syntaxe

• Log.v(String tag, String msg, Throwable tr)
• Log.v(String tag, String msg)
• Log.d(String tag, String msg, Throwable tr)
• Log.d(String tag, String msg)
• Log.i(String tag, String msg, Throwable tr)
• Log.i(String tag, String msg)
• Log.w(String tag, String msg, Throwable tr)
• Log.w(String tag, String msg)
• Log.e(String tag, String msg, Throwable tr)
• Log.e(String tag, String msg)

Paramètres

Remarques

Filtrage de la sortie logcat

Il est utile de filtrer la sortie logcat car il existe de nombreux messages sans intérêt. Pour filtrer la sortie, ouvrez le "moniteur Android" et cliquez sur le menu déroulant en haut à droite et sélectionnez Modifier la configuration du filtre

Vous pouvez maintenant ajouter des filtres personnalisés pour afficher les messages qui vous intéressent, ainsi que filtrer les lignes de journal connues qui peuvent être ignorées en toute sécurité. Pour ignorer une partie de la sortie, vous pouvez définir une expression régulière . Voici un exemple d'exclusion de balises correspondantes:

^(?!(HideMe|AndThis))

Cela peut être saisi en suivant cet exemple:

Ce qui précède est une expression régulière qui exclut les entrées. Si vous souhaitez ajouter un autre tag à la liste noire , ajoutez-le après un tube | personnage. Par exemple, si vous souhaitez mettre en liste noire "GC", vous utiliseriez un filtre comme celui-ci:

^(?!(HideMe|AndThis|GC))

---

Pour plus de documentation et d’exemples, consultez la section Journalisation et utilisation de Logcat.

Enregistrement

Toute application Android de qualité gardera une trace de ce qu'elle fait via les journaux d'application. Ces journaux facilitent le débogage pour aider le développeur à diagnostiquer ce qui se passe avec l'application. La documentation complète d'Android peut être trouvée ici , mais un résumé suit:

---

Enregistrement de base

La classe Log est la principale source d'écriture des journaux de développement, en spécifiant une tag et un message . La balise est ce que vous pouvez utiliser pour filtrer les messages de journal en identifiant les lignes provenant de votre activité particulière. Il suffit d'appeler

Log.v(String tag, String msg);

Et le système Android écrira un message au logcat:

07-28 12:00:00.759 24812-24839/my.packagename V/MyAnimator: Some log messages
 └ time stamp             |  app.package┘     |    └ any tag  |
     process & thread ids ┘          log level┘               └ the log message

POINTE:
Notez l'ID de processus et l'ID de thread. S'ils sont identiques, le journal provient du thread principal / de l'interface utilisateur!

N'importe quelle balise peut être utilisée, mais il est courant d'utiliser le nom de la classe en tant que balise:

public static final String tag = MyAnimator.class.getSimpleName();

---

Niveaux de journal

Le logger Android dispose de 6 niveaux différents, chacun servant un objectif spécifique:

• ERROR : Log.e()
  • Utilisé pour indiquer une défaillance critique, il s'agit du niveau imprimé lors du lancement d'une Exception .
• WARN : Log.w()
  • Utilisé pour indiquer un avertissement, principalement pour les défaillances récupérables
• INFO : Log.i()
  • Utilisé pour indiquer des informations de niveau supérieur sur l'état de l'application
• DEBUG : Log.d()
  • Utilisé pour enregistrer des informations qui seraient utiles lors du débogage de l'application, mais qui entraveraient l'exécution de l'application
• VERBOSE : Log.v()
  • Utilisé pour enregistrer des informations qui reflètent les petits détails sur l'état de l'application
• ASSERT : Log.wtf()
  • Utilisé pour enregistrer des informations sur une condition qui ne devrait jamais se produire.
  • wtf signifie "What a Terrible Failure".

---

Motivation pour l'enregistrement

La motivation pour la journalisation est de trouver facilement les erreurs, les avertissements et autres informations en parcourant la chaîne des événements de l'application. Par exemple, imaginez une application qui lit les lignes d'un fichier texte, mais suppose à tort que le fichier ne sera jamais vide. La trace du journal (d'une application qui ne se connecte pas) ressemblerait à ceci:

E/MyApplication: Process: com.example.myapplication, PID: 25788
                          com.example.SomeRandomException: Expected string, got 'null' instead

Suivi par un tas de traces de pile qui mèneraient éventuellement à la ligne incriminée, où passer en revue avec un débogueur finirait par poser le problème

Cependant, la trace de journal d'une application avec la journalisation activée pourrait ressembler à ceci:

V/MyApplication: Looking for file myFile.txt on the SD card
D/MyApplication: Found file myFile.txt at path <path>
V/MyApplication: Opening file myFile.txt
D/MyApplication: Finished reading myFile.txt, found 0 lines
V/MyApplication: Closing file myFile.txt
...
E/MyApplication: Process: com.example.myapplication, PID: 25788
                          com.example.SomeRandomException: Expected string, got 'null' instead

Un rapide coup d’œil aux journaux et il est évident que le fichier était vide.

---

Choses à considérer lors de la journalisation:

Bien que la journalisation soit un outil puissant permettant aux développeurs Android de mieux comprendre le fonctionnement interne de leur application, la journalisation présente certains inconvénients.

La lisibilité du journal:

Il est courant que les applications Android exécutent plusieurs journaux de manière synchrone. En tant que tel, il est très important que chaque journal soit facilement lisible et ne contienne que des informations pertinentes et nécessaires.

Performance:

La journalisation nécessite une petite quantité de ressources système. En général, cela ne pose pas de problème, cependant, en cas de surutilisation, la journalisation peut avoir un impact négatif sur les performances des applications.

Sécurité:

Récemment, plusieurs applications Android ont été ajoutées au marché Google Play pour permettre à l'utilisateur de consulter les journaux de toutes les applications en cours d'exécution. Cet affichage involontaire de données peut permettre aux utilisateurs d'afficher des informations confidentielles. En règle générale, supprimez toujours les journaux contenant des données non publiques avant de publier votre application sur le marché.

---

Conclusion:

La journalisation est une partie essentielle d'une application Android, en raison de la puissance qu'elle donne aux développeurs. La possibilité de créer une trace de journal utile est l'un des aspects les plus difficiles du développement logiciel, mais la classe Log d'Android facilite grandement la tâche.

---

Pour plus de documentation et d’exemples, consultez la section Journalisation et utilisation de Logcat.

Journal avec un lien vers la source directement depuis Logcat

C'est un bon truc pour ajouter un lien au code, il sera donc facile de passer directement au code qui a généré le journal.

Avec le code suivant, cet appel:

MyLogger.logWithLink("MyTag","param="+param);

Aura pour résultat:

07-26...012/com.myapp D/MyTag: MyFrag:onStart(param=3)  (MyFrag.java:2366) // << logcat converts this to a link to source!

Voici le code (dans une classe appelée MyLogger):

static StringBuilder sb0 = new StringBuilder(); // reusable string object

public static void logWithLink(String TAG, Object param) {
    StackTraceElement stack = Thread.currentThread().getStackTrace()[3];
    sb0.setLength(0);
    String c = stack.getFileName().substring(0, stack.getFileName().length() - 5); // removes the ".java"
    sb0.append(c).append(":");
    sb0.append(stack.getMethodName()).append('(');
    if (param != null) {
        sb0.append(param);
    }
    sb0.append(") ");
    sb0.append(" (").append(stack.getFileName()).append(':').append(stack.getLineNumber()).append(')');
    Log.d(TAG, sb0.toString());
}

Ceci est un exemple élémentaire, il peut être facilement étendu pour créer un lien vers l'appelant (conseil: la pile sera [4] au lieu de [3]), et vous pouvez également ajouter d'autres informations pertinentes.

Utiliser le logcat

Logcat est un outil de ligne de commande qui affiche un journal des messages système, y compris des traces de pile lorsque le périphérique génère une erreur et des messages que vous avez écrits à partir de votre application avec la classe Log.

La sortie Logcat peut être affichée dans le moniteur Android d'Android Studio ou avec la ligne de commande adb.

Dans Android Studio

Afficher en cliquant sur l'icône "Android Monitor": Ou en appuyant sur Alt + 6 sous Windows / Linux ou CMD + 6 sur Mac.

via la ligne de commande:

Utilisation simple:

$ adb logcat

Avec timestamps:

$ adb logcat -v time

Filtrer sur un texte spécifique:

$ adb logcat -v time | grep 'searchtext'

Il existe de nombreuses options et filtres disponibles pour logcat en ligne de commande , documentés ici .
Un exemple simple mais utile est l'expression de filtre suivante qui affiche tous les messages de journal avec le niveau de priorité "erreur", sur toutes les balises:

$ adb logcat *:E

Générer un code de journalisation

Live templates Android Studio peuvent offrir plusieurs raccourcis pour une journalisation rapide.
Pour utiliser des modèles Live, il vous suffit de commencer à taper le nom du modèle et d' TAB sur TAB ou d'entrer pour insérer l'instruction.

Exemples:

• logi → devient → android.util.Log.i(TAG, "$METHOD_NAME$: $content$");
  • $METHOD_NAME$ sera automatiquement remplacé par le nom de votre méthode et le curseur attendra que le contenu soit rempli.
• loge → même, pour erreur
• etc. pour le reste des niveaux de journalisation.

La liste complète des modèles se trouve dans Android Studio paramètres d' Android Studio ( ALT + s et tapez "live"). Et il est également possible d'ajouter vos modèles personnalisés.

Si vous trouvez Android Studio Live templates Android Studio insuffisants pour vos besoins, vous pouvez envisager le plugin Android Postfix

Ceci est une bibliothèque très utile qui vous aide à éviter d’écrire manuellement la ligne de journalisation.

La syntaxe est absolument simple:

.log - Journalisation. S'il existe une variable constante "TAG", il utilise "TAG". Sinon, utilisez le nom de la classe.

Utilisation d'Android Studio

1. Masquer / afficher les informations imprimées:

2. Contrôle de la verbosité de la journalisation:

3. Désactiver / activer l'ouverture de la fenêtre de journal au démarrage de l'application run / debug

Effacer les journaux

Pour effacer (rincer) le journal entier:

adb logcat -c