J'ai observé que lorsque j'utilise Logcat avec Eclipse avec ADT pour Android, je reçois également des messages de nombreuses autres applications. Existe-t-il un moyen de filtrer cela et d'afficher uniquement les messages de ma propre application.

Les noms de package sont garantis comme uniques, vous pouvez donc utiliser la Logfonction avec la balise comme nom de package, puis filtrer par nom de package :

REMARQUE: à partir de Build Tools 21.0.3, cela ne fonctionnera plus car les TAGS sont limités à 23 caractères ou moins.

Log.<log level>("<your package name>", "message");

adb -d logcat <your package name>:<log level> *:S

-ddésigne un périphérique réel et -eun émulateur. S'il y a plus d'un émulateur en cours d'exécution, vous pouvez utiliser -s emulator-<emulator number>(par exemple, -s emulator-5558)

Exemple: adb -d logcat com.example.example:I *:S

Ou si vous utilisez System.out.printpour envoyer des messages au journal, vous pouvez utiliser adb -d logcat System.out:I *:Spour afficher uniquement les appels à System.out.

Vous pouvez trouver tous les niveaux de journalisation et plus d'informations ici: https://developer.android.com/studio/command-line/logcat.html

http://developer.android.com/reference/android/util/Log.html

EDIT: On dirait que j'ai un peu sauté le pistolet et vient de réaliser que vous posiez des questions sur logcat dans Eclipse. Ce que j'ai posté ci-dessus est pour utiliser logcat via adb à partir de la ligne de commande. Je ne sais pas si les mêmes filtres sont transférés dans Eclipse.

Linux et OS X

Utilisez ps / grep / cut pour saisir le PID, puis grep pour les entrées logcat avec ce PID. Voici la commande que j'utilise:

adb logcat | grep -F "`adb shell ps | grep com.asanayoga.asanarebel  | tr -s [:space:] ' ' | cut -d' ' -f2`"

(Vous pouvez améliorer davantage l'expression régulière pour éviter le problème théorique des lignes de journal non liées contenant le même nombre, mais cela n'a jamais été un problème pour moi)

Cela fonctionne également lors de la correspondance de plusieurs processus.

les fenêtres

Sous Windows, vous pouvez faire:

adb logcat | findstr com.example.package

Depuis Android 7.0, logcat a l'option de filtre --pid et la commande pidof est disponible, remplacez com.example.app par le nom de votre package.
(Terminal Ubuntu / Depuis Android 7.0)

adb logcat --pid=`adb shell pidof -s com.example.app`

ou

adb logcat --pid=$(adb shell pidof -s com.example.app)

Pour plus d'informations sur la commande pidof:
https://stackoverflow.com/a/15622698/7651532

Ajouter un filtre

Précisez les noms

Choisissez votre filtre.

Pour moi, cela fonctionne sous mac Terminal
Vous êtes dans le dossier où vous avez adbpuis tapez la commande ci-dessous dans le terminal

./adb logcat MyTAG:V AndroidRuntime:E *:S

Ici, il filtrera tous les journaux de MyTAGetAndroidRuntime

Mise à jour du 17 mai

Cela fait quelques années, et les choses ont changé. Et Eclipse n'est plus officiellement pris en charge. Voici donc deux autres approches à jour:

1. Android Studio

Dans la Android monitorboîte à outils, vous pouvez filtrer logcat par debuggable process. Normalement, lorsque vous développez une application, il s'agit d'un processus débogable. De temps en temps, j'ai des problèmes avec cela, et procédez comme suit:

1. Tools-> Android-> Enable ADB Integration.
   S'il était déjà activé, désactivez-le, puis réactivez-le.

2. Débranchez et rebranchez votre appareil mobile.

Il existe également des options pour filtrer via l'expression régulière et le niveau de débogage

2. logcat-color

Il s'agit d'un joli emballage python adb logcatsi vous souhaitez utiliser une solution basée sur un terminal. La bonne chose à ce sujet est que vous pouvez enregistrer plusieurs configurations et simplement les réutiliser. Le filtrage par tagsest assez fiable. Vous pouvez également filtrer par packagepour voir les journaux d'une ou plusieurs applications uniquement, mais vous commencez logcat-colorjuste avant de lancer votre application.

Ancienne réponse:

Il semble que je ne puisse pas commenter les réponses précédentes, donc j'en posterai une nouvelle. Ceci est un commentaire de la réponse de Tom Mulcahy , qui montre comment la commande doit changer pour fonctionner sur la plupart des appareils, car la adb shell pscolonne PID est variable.

REMARQUE: la commande ci-dessous fonctionne pour les cas où vous avez connecté de nombreux appareils. C'est donc device idnécessaire. Sinon, vous pouvez simplement omettre les crochets '[', ']'

1. Pour connaître la colonne de pid, tapez:

adb [-s DEVICE_ID] shell ps | head -n 1

Maintenant, mémorisez le numéro de colonne pour le PID. La numérotation commence à partir de 1.

2. Tapez ensuite ce qui suit:

adb [-s DEVICE_ID] logcat | grep $(adb [-s DEVICE_ID] shell ps \
| grep "com.example" | awk -F" " ' {print $PUT_COLUMN_HERE}')

Mettez simplement la colonne dans laquelle vous avez mémorisé PUT_COLUMN_HERE, par exemple$5

Caveat

Chaque fois que vous réexécutez votre application, vous devez réexécuter la 2e commande, car l'application obtient un nouveau PID du système d'exploitation.

Cela a fonctionné pour moi dans git bash:

$ pid=$(adb shell ps | grep <package name> | cut -c11-15) ; adb logcat | grep $pid

mettez ceci à applog.sh

#!/bin/sh
PACKAGE=$1
APPPID=`adb -d shell ps | grep "${PACKAGE}" | cut -c10-15 | sed -e 's/ //g'`
adb -d logcat -v long \
 | tr -d '\r' | sed -e '/^\[.*\]/ {N; s/\n/ /}' | grep -v '^$' \
 | grep " ${APPPID}:"

puis: applog.sh com.example.my.package

Cela fonctionne pour moi avec le débogage USB:

1. Connectez l'appareil et utilisez:

   adb shell

2. Utilisez le logcat une fois connecté:

   logcat | grep com.yourapp.packagename

Si vous utilisez Android Studio, vous pouvez sélectionner le processus à partir duquel vous souhaitez recevoir des logcats. Voici la capture d'écran.

J'ai écrit un script shell pour filtrer logcat par nom de package, ce qui je pense est plus fiable que d'utiliser

ps | grep com.example.package | cut -c10-15

Il utilise / proc / $ pid / cmdline pour trouver le pid réel, puis fait un grep sur logcat

https://gist.github.com/kevinxucs/7340e1b1dd2239a2b04a

Ubuntu: adb logcat -b all -v color --pid = `adb shell pidof -s com.packagename` Avec couleur et journal continu de l'application

ADT v15 pour Eclipse vous permet de spécifier un nom d'application (qui est en fait la valeur du package dans votre androidmanifest.xml).

J'adore pouvoir filtrer par application, mais le nouveau logcat a un bug avec le défilement automatique. Lorsque vous faites défiler un peu pour consulter les journaux précédents, il revient automatiquement au bas en quelques secondes. Il semble que le défilement à mi-chemin du journal l'empêche de sauter vers le bas, mais cela est souvent inutile.

EDIT: J'ai essayé de spécifier un filtre d'application à partir de la ligne de commande - mais pas de chance. Si quelqu'un comprend cela OU comment arrêter le défilement automatique, faites-le moi savoir.

Utilisation de l'invite de commande Windows: adb logcat -d | findstr <package> .

* Cela a été mentionné pour la première fois par jj_ , mais il m'a fallu beaucoup de temps pour le trouver dans les commentaires ...

En variante, vous pouvez utiliser le script tiers PID Cat de Jake Wharton. Ce script présente deux avantages majeurs:

• affiche les entrées de journal pour les processus d'un package d'application spécifique
• logcat couleur

De la documentation:

Lors du développement de l'application, vous souhaitez souvent afficher uniquement les messages de journal provenant de votre application. Malheureusement, parce que l'ID de processus change chaque fois que vous vous déployez sur le téléphone, il devient difficile de rechercher la bonne chose.

Ce script résout ce problème en filtrant par package d'application.

Une sortie ressemble à

Je ne suis pas sûr qu'il existe un moyen de voir uniquement les messages système concernant votre application, mais vous pouvez filtrer en fonction d'une chaîne. Si vous créez un journal dans le programme, vous pouvez simplement inclure un certain mot-clé unique et filtrer en fonction de ce mot.

Essayez: Fenêtre -> Préférences -> Android -> LogCat. Modifiez le champ "Afficher la vue logcat si ..." la valeur "VERBOSE". Ça m'a aidé.

Si vous utilisez Eclipse , appuyez sur le signe vert + dans la fenêtre logCat ci-dessous et mettez votre nom de package (com.example.yourappname) dans la zone par nom d'application . Choisissez également un nom qui vous convient dans la zone Nom du filtre et cliquez sur OK. Vous ne verrez que les messages liés à votre application lorsque le filtre que vous venez d'ajouter est choisi dans le volet gauche du logCat.

Donnez un nom à votre journal. J'ai appelé le mien "wawa".

Dans Android Studio, accédez à Android-> Modifier les configurations de filtre

Tapez ensuite le nom que vous avez donné aux journaux. Dans mon cas, ça s'appelle "wawa". Voici quelques exemples des types de filtres que vous pouvez effectuer. Vous pouvez filtrer par System.out, System.err, Logs ou noms de package:

C'est probablement la solution la plus simple.

En plus d'une solution de Tom Mulcahy, vous pouvez la simplifier davantage comme ci-dessous:

alias logcat="adb logcat | grep `adb shell ps | egrep '\bcom.your.package.name\b' | cut -c10-15`"

L'utilisation est aussi simple qu'un alias normal. Tapez simplement la commande dans votre shell:

logcat

La configuration de l'alias le rend pratique. Et le regex le rend robuste pour les applications multi-processus, en supposant que vous vous souciez uniquement du processus principal.

Bien sûr, vous pouvez définir plus d'alias pour chaque processus à votre guise. Ou utilisez la solution d'Hegazy. :)

De plus, si vous souhaitez définir des niveaux de journalisation, il est

alias logcat-w="adb logcat *:W | grep `adb shell ps | egrep '\bcom.your.package.name\b' | cut -c10-15`"

Sur Windows 10, en utilisant Ionic, ce qui fonctionnait très bien pour moi était de combiner 'findstr' avec "INFO: CONSOLE" généré par tous les messages de l'application. Donc, ma commande en ligne de commande est:

adb logcat | findstr INFO:CONSOLE

J'ai essayé d'utiliser la réponse de Tom Mulcahy mais malheureusement, cela ne fonctionnait pas pour les applications avec plusieurs processus, je l'ai donc modifiée pour répondre à mes besoins.

#!/bin/bash
if [ "$#" -ne 1 ]; then echo "Illegal number of parameters"; exit 1; fi
echo "Lof for package name: $1"
PROCESSES=`adb shell ps | grep "$1" | cut -c10-15`
NUM_OF_PROCESSES=`echo "$PROCESSES" | wc -l`
if [ $NUM_OF_PROCESSES -eq 0 ]; then echo "The application is not running!"; exit 1; fi
COUNTER=1
for process in $PROCESSES; do
        if [ $COUNTER -eq 1 ]; then GREP_TEXT="("; fi
        GREP_TEXT+=$process
        if [ $COUNTER -eq $NUM_OF_PROCESSES ]; then GREP_TEXT+=")"; else GREP_TEXT+="|"; fi
        let COUNTER=COUNTER+1 
        if [ $COUNTER -gt $NUM_OF_PROCESSES ]; then break; fi  
done
adb logcat | grep -E "$GREP_TEXT"

Utilisez -s!

Vous devez utiliser votre propre balise, consultez: http://developer.android.com/reference/android/util/Log.html

Comme.

Log.d("AlexeysActivity","what you want to log");

Et puis quand vous voulez lire le journal, utilisez>

adb logcat -s AlexeysActivity

Cela filtre tout ce qui n'utilise pas la même balise.

La source

En plus de la réponse de Tom Mulcahy , si vous souhaitez filtrer par PID sur la console Windows, vous pouvez créer un petit fichier batch comme ça:

@ECHO OFF

:: find the process id of our app (2nd token)
FOR /F "tokens=1-2" %%A IN ('adb shell ps ^| findstr com.example.my.package') DO SET PID=%%B

:: run logcat and filter the output by PID
adb logcat | findstr %PID%

C'est évidemment une question destinée à l'utilisation de Logcat depuis l' extérieur du périphérique développeur, mais si vous souhaitez afficher la sortie Logcat sur le périphérique (par programme), vous avez juste besoin de ceci:

Runtime.getRuntime().exec("logcat " + android.os.Process.myPid() + " *:D");

le *:D la fin, tous les messages en dessous du niveau du journal de débogage sont filtrés, mais vous pouvez les laisser de côté.

Pour diriger la sortie vers, disons, un TextView, voir par exemple ici .

Il est maintenant possible de taper tag: nameofthetag ou app: nameoftheapp pour filtrer sans ajouter de nouveaux filtres à la barre de filtres enregistrée

Dans intelliJ (et probablement aussi dans eclipse), vous pouvez filtrer la sortie logcat par text webview , de sorte qu'il imprime essentiellement tout ce que phonegap produit

Encore une autre variante de Gavriel applog.shavec prise en charge de plusieurs appareils et applications avec plusieurs processus:

#!/bin/sh
PKG=$1
shift

APPIDS=`adb $@ shell ps | awk -v PKG="$PKG" '
    (NR == 1){appcolumn=2; for (i=1; i<=NF; i++) if ($i=="PID") {appcolumn=i}}
    index($0,PKG){print $(appcolumn)}' | paste -d \| -s`

echo "PID's: $APPIDS"
adb $@ logcat -v color | awk  "(\$3 ~ /$APPIDS/){print \$0}"

Usage: applog.sh com.example.my.package [-s <specific device>]

Sous Linux, cela a fonctionné pour moi:

adb logcat | grep `adb shell ps | grep your.package | awk '{print $2}'`