Comment filtrer Android logcat par application?
Comment filtrer Android la sortie logcat par application? J'en ai besoin, car lorsque je connecte un périphérique, je ne parviens pas à trouver la sortie souhaitée à cause du spam généré par d'autres processus.
Edit: L'original est ci-dessous. Quand un Android Studio n'existait pas. Mais si vous souhaitez filtrer l’ensemble de votre application, j’utiliserais pidcat pour la visualisation de terminaux ou Android Studio. En utilisant pidcat au lieu de logcat, les balises ne doivent pas nécessairement être l'application. Vous pouvez simplement l'appeler avec pidcat com.your.application
Vous devriez utiliser votre propre tag, regardez: 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.
Selon http://developer.Android.com/tools/debugging/debugging-log.html :
Voici un exemple d'expression de filtre qui supprime tous les messages du journal, à l'exception de ceux portant la balise "ActivityManager", de priorité "Info" ou supérieure, et tous les messages de consignation portant la balise "MyApp", de priorité "Debug" ou supérieure:
adb logcat ActivityManager:I MyApp:D *:S
Le dernier élément de l'expression ci-dessus, *: S, définit le niveau de priorité de toutes les balises sur "silencieux", garantissant ainsi que seuls les messages de journal avec "View" et "MyApp" sont affichés.
- V - Verbose (priorité la plus basse)
- D - Déboguer
- I - Info
- W - Avertissement
- E - erreur
- F - Fatal
- S - Silencieux (priorité la plus élevée, sur laquelle rien n'est jamais imprimé)
Salut j'ai la solution en utilisant ceci:
Vous devez exécuter cette commande depuis le terminal. J'ai eu le résultat,
adb logcat | grep `adb Shell ps | grep com.package | cut -c10-15`
Je travaille sur Android Studio. Il existe une option intéressante permettant de recevoir le message à l'aide du nom du package. Dans "Modifier la configuration du filtre", vous pouvez créer un nouveau filtre en ajoutant le nom de votre package dans "par nom de package".
Si vous pouvez vivre avec le fait que vous vous connectez viennent d'une fenêtre de terminal supplémentaire, je pourrais recommander pidcat (Prenez uniquement le nom du paquet et suivez les modifications du PID.)
Supposons que votre application nommée MyApp contienne les composants suivants.
- MonActivité1
- MonActivité2
- Mon activité3
- MyService
Afin de filtrer la sortie de journalisation de votre application MyApp à l'aide de logcat, tapez ce qui suit.
adb logcat MyActivity1:v MyActivity2:v MyActivity3:v MyService:v *:s
Toutefois, cela nécessite que vous connaissiez les noms de balises pour tous les composants de votre application plutôt que de filtrer à l'aide du nom d'application MyApp. Voir logcat pour plus de détails.
Une solution permettant de filtrer au niveau de l'application serait d'ajouter un préfixe à chacun de vos TAG uniques.
- MyAppActivity1
- MyAppActivity2
- MyAppActivity3
- MyAppService
Maintenant, un filtre générique sur la sortie logcat peut être effectué en utilisant le préfixe TAG.
adb logcat | grep MyApp
Le résultat sera la sortie de toute l'application.
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}:"
alors: applog.sh com.example.my.package
Lorsque nous recevons une erreur de notre application, Logcat affichera automatiquement le filtre de session. Nous pouvons créer un filtre de session par nous-mêmes. Ajoutez simplement un nouveau filtre logcat, remplissez le formulaire du nom du filtre. Remplissez ensuite le nom de l'application avec votre dossier de candidature. (par exemple: mon application est "Adukan" et le package est "com.adukan", je remplis donc par nom d'application avec le package d'application "com.adukan")
Si vous utilisez Eclipse, vous pourrez filtrer par application, tout comme il est possible avec Android Studio présenté par shadmazumder.
Il suffit d'aller à logcat, cliquer sur afficher la vue Filtres enregistrés, puis ajouter un nouveau filtre logcat. Il apparaîtra ce qui suit:
Ensuite, vous ajoutez un nom au filtre et, à par nom d'application, vous spécifiez le package de votre application.
Sur mon ordinateur portable Windows 7, j'utilise 'adb logcat | recherchez "com.example.name" 'pour filtrer la sortie logcat associée au programme système du reste. La sortie du programme logcat est dirigée vers la commande find. Chaque ligne contenant 'com.example.name' est sortie dans la fenêtre. Les guillemets font partie de la commande de recherche.
Pour inclure le résultat de mes commandes Log, j'utilise le nom du paquet, ici "com.example.name", dans le cadre du premier paramètre de mes commandes Log, comme ceci:
Log.d("com.example.name activity1", "message");
Remarque: mon téléphone Samsung Galaxy génère beaucoup moins de sorties liées aux programmes que l'émulateur de niveau 17.
J'utilise pour le stocker dans un fichier:
int pid = Android.os.Process.myPid();
File outputFile = new File(Environment.getExternalStorageDirectory() + "/logs/logcat.txt");
try {
String command = "logcat | grep " + pid + " > " + outputFile.getAbsolutePath();
Process p = Runtime.getRuntime().exec("su");
OutputStream os = p.getOutputStream();
os.write((command + "\n").getBytes("ASCII"));
} catch (IOException e) {
e.printStackTrace();
}
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 facile comme un alias normal. Il suffit de taper la commande dans votre shell:
logcat
La configuration des alias le rend pratique. Et la 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 de hegazy. :)
En outre, 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`"
Oui maintenant vous l'obtiendrez automatiquement ....
Mise à jour vers AVD 14 , où le logcat sera automatique session filter
où il filtre enregistre dans votre application spécifique (package)
Dans la vue logcat, à gauche, vous avez les fenêtres "Filtres enregistrés". Ici, vous pouvez ajouter un nouveau filtre logcat par nom d'application (par exemple, com.votre.package).
En général, je fais cette commande "adb Shell ps" dans Prompt (permet de voir les processus en cours d'exécution) et il est possible de découvrir le pid d'une application. Avec ce pid entre les mains, accédez à Eclipse et écrivez pid: XXXX (XXXX est le pid de l’application), puis la sortie des journaux est filtrée par cette application.
Ou, plus facilement ... en vue logcat sur Eclipse, recherchez tout mot associé à l'application souhaitée, découvrez le pid, puis filtrez le pid "pid: XXXX".
ma fonction .bash_profile, elle peut être utile
logcat() {
if [ -z "$1" ]
then
echo "Process Id argument missing."; return
fi
pidFilter="\b$1\b"
pid=$(adb Shell ps | egrep $pidFilter | cut -c10-15)
if [ -z "$pid" ]
then
echo "Process $1 is not running."; return
fi
adb logcat | grep $pid
}
alias logcat-myapp="logcat com.sample.myapp"
Usage:
$ logcat-myapp
$ logcat com.Android.something.app
Dans Android Studio dans la fenêtre Android Monitor: 1. Sélectionnez l'application que vous souhaitez filtrer. 2. Sélectionnez "Afficher uniquement l'application sélectionnée".
vous pouvez y parvenir dans Eclipse logcat en entrant ce qui suit dans le champ de recherche.
app:com.example.myapp
com.example.myapp est le nom du package d'application.
Ce que je fais habituellement est d’avoir un filtre séparé par PID qui serait l’équivalent de la session en cours. Mais bien sûr, cela change à chaque fois que vous exécutez l'application. Pas bon, mais c'est le seul moyen d'avoir toutes les informations sur l'application, indépendamment de la balise de journal.
Sous Linux/Un * X/Cygwin, vous pouvez obtenir la liste de toutes les balises du projet (avec :V ajouté après) avec cette commande (divisée pour la lisibilité):
$ git grep 'String\s\+TAG\s*=\s*' | \
Perl -ne 's/.*String\s+TAG\s*=\s*"?([^".]+).*;.*/$1:V/g && print ' | \
sort | xargs
AccelerometerListener:V ADNList:V Ashared:V AudioDialog:V BitmapUtils:V # ...
Il couvre les balises définies des deux manières de définir les balises:
private static final String TAG = "AudioDialog";
private static final String TAG = SipProfileDb.class.getSimpleName();
Et ensuite, utilisez-le pour adb logcat.
J'ai trouvé une application sur le magasin qui peut afficher le nom/processus d'un journal. Étant donné que Android Studio ne fait que mettre un (?) Sur les journaux générés par les autres processus, j'ai trouvé utile de savoir quel processus génère ce journal. Mais toujours cette application manque le filtre par le nom du processus. Vous pouvez le trouver ici .
utilisez le premier paramètre comme nom de votre application. Log.d ("your_Application_Name", "message");
et dans LogCat: créer un filtre ---> Nom du filtre et par balise de journal: est égal à 'votre_nom_application', il créera un nouvel onglet pour votre application.
L'application Android Device Monitor disponible sous sdk/tools/monitor dispose d'une option logcat pour filtrer "par nom d'application", dans laquelle vous entrez le nom du package d'application.
Utilisez des noms de classe complets pour vos balises de journal:
public class MyActivity extends Activity {
private static final String TAG = MyActivity.class.getName();
}
Ensuite
Log.i(TAG, "hi");
Alors utilisez grep
adb logcat | grep com.myapp