Ho osservato che quando uso Logcat con Eclipse con ADT per Android, ricevo anche messaggi da molte altre applicazioni. C'è un modo per filtrare questo e mostrare solo i messaggi solo dalla mia stessa applicazione.

I nomi dei pacchetti sono garantiti come univoci in modo da poter utilizzare la Logfunzione con il tag come nome del pacchetto e quindi filtrare per nome del pacchetto :

NOTA: a partire da Build Tools 21.0.3 questo non funzionerà più poiché i TAG sono limitati a 23 caratteri o meno.

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

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

-dindica un dispositivo reale e -eindica un emulatore. Se è in esecuzione più di 1 emulatore, puoi utilizzare -s emulator-<emulator number>(ad es. -s emulator-5558)

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

Oppure, se si utilizza System.out.printper inviare messaggi al registro, è possibile utilizzare adb -d logcat System.out:I *:Sper mostrare solo le chiamate a System.out.

Puoi trovare tutti i livelli di registro e maggiori informazioni qui: https://developer.android.com/studio/command-line/logcat.html

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

EDIT: Sembra che ho saltato un po 'la pistola e ho appena realizzato che stavi chiedendo del logcat in Eclipse. Quello che ho pubblicato sopra è per l'utilizzo di logcat tramite adb dalla riga di comando. Non sono sicuro che gli stessi filtri vengano trasferiti su Eclipse.

Linux e OS X

Usa ps / grep / cut per afferrare il PID, quindi grep per le voci logcat con quel PID. Ecco il comando che uso:

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

(Potresti migliorare ulteriormente la regex per evitare il problema teorico delle linee di registro non correlate contenenti lo stesso numero, ma non è mai stato un problema per me)

Questo funziona anche quando si abbinano più processi.

finestre

Su Windows puoi fare:

adb logcat | findstr com.example.package

Da Android 7.0, logcat ha l'opzione --pid filter ed è disponibile il comando pidof, sostituisci com.example.app con il nome del pacchetto.
(terminale Ubuntu / da Android 7.0)

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

o

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

Per maggiori informazioni sul comando pidof:
https://stackoverflow.com/a/15622698/7651532

Aggiungi filtro

Specifica i nomi

Scegli il filtro

Per me questo funziona in mac Terminal
Arrivato alla cartella in cui è stato adbquindi digitato sotto il comando nel terminale

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

Qui filtrerà tutti i registri di MyTAGeAndroidRuntime

Aggiornamento del 17 maggio

Sono passati alcuni anni e le cose sono cambiate. E Eclipse non è più ufficialmente supportato. Quindi, ecco altri due approcci aggiornati:

1. Android Studio

Nella Android monitorcasella degli strumenti è possibile filtrare logcat per debuggable process. Normalmente, quando si sviluppa un'applicazione, è un processo di debug. Ogni tanto ho problemi con questo, e faccio quanto segue:

1. Tools-> Android-> Enable ADB Integration.
   Se era già abilitato, disattivalo e riaccendilo

2. Scollegare e ricollegare il dispositivo mobile.

Ci sono anche opzioni per filtrare tramite regex e il livello di debug

2. logcat-color

Questo è un bel wrapper in pitone adb logcatse vuoi usare una soluzione basata su terminali. La cosa positiva è che puoi salvare più configurazioni e semplicemente riutilizzarle. Il filtro per tagsè abbastanza affidabile. Puoi anche filtrare packageper visualizzare solo i log di una o più app, ma inizi logcat-colorsubito prima di avviare l'app.

Vecchia risposta:

Sembra che non posso commentare le risposte precedenti, quindi ne posterò una nuova. Questo è un commento alla risposta di Tom Mulcahy , che mostra come il comando dovrebbe cambiare in modo da funzionare sulla maggior parte dei dispositivi, poiché la adb shell pscolonna PID è variabile.

NOTA: il comando seguente funziona per i casi in cui sono stati collegati molti dispositivi. Quindi device idè necessario. Altrimenti, puoi semplicemente omettere le parentesi '[', ']'

1. Per scoprire la colonna di pid, digitare:

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

Ora memorizza il numero di colonna per il PID. La numerazione inizia da 1.

2. Quindi digitare quanto segue:

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

Inserisci semplicemente la colonna in cui hai memorizzato PUT_COLUMN_HERE, ad es$5

Avvertimento

Ogni volta che si esegue nuovamente l'applicazione, è necessario eseguire nuovamente il 2o comando, poiché l'applicazione ottiene un nuovo PID dal sistema operativo.

Questo ha funzionato per me in git bash:

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

mettilo su 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}:"

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

Questo funziona per me con il debug USB:

1. Connetti il ​​dispositivo e usa:

   adb shell

2. Utilizzare il logcat quando connesso:

   logcat | grep com.yourapp.packagename

Se si utilizza Android Studio, è possibile selezionare il processo da cui si desidera ricevere i logcats. Ecco lo screenshot.

Ho scritto uno script di shell per filtrare logcat in base al nome del pacchetto, che ritengo sia più affidabile dell'uso

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

Utilizza / proc / $ pid / cmdline per scoprire il pid effettivo, quindi eseguire un grep su logcat

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

Ubuntu: adb logcat -b all -v color --pid = `adb shell pidof -s com.packagename` Con colore e registro continuo dell'app

ADT v15 per Eclipse ti consente di specificare un nome di applicazione (che in realtà è il valore del pacchetto nel tuo androidmanifest.xml).

Adoro poter filtrare per app, ma il nuovo logcat ha un bug con lo scorrimento automatico. Quando scorri un po 'verso l'alto per guardare i registri precedenti, scorre automaticamente verso il basso in un paio di secondi. Sembra che scorra 1/2 del registro in alto impedendogli di tornare indietro, ma questo è spesso inutile.

EDIT: ho provato a specificare un filtro app dalla riga di comando - ma senza fortuna. Se qualcuno lo capisce O come fermare lo scorrimento automatico, per favore fatemi sapere.

Utilizzo di Windows prompt dei comandi: adb logcat -d | findstr <package>.

* Questo è stato menzionato per la prima volta da jj_ , ma mi ci sono voluti anni per trovarlo nei commenti ...

Come variante è possibile utilizzare lo script PID Cat di terze parti di Jake Wharton. Questo script ha due vantaggi principali:

• mostra le voci di registro per i processi da uno specifico pacchetto dell'applicazione
• logcat a colori

Dalla documentazione:

Durante lo sviluppo dell'applicazione, spesso si desidera visualizzare solo i messaggi di registro provenienti dalla propria app. Sfortunatamente, poiché l'ID del processo cambia ogni volta che si esegue l'implementazione sul telefono, diventa una sfida eseguire grep per la cosa giusta.

Questo script risolve il problema filtrando per pacchetto dell'applicazione.

Sembra un output

Non sono sicuro che ci sia un modo per vedere solo i messaggi di sistema relativi alla tua app, ma puoi filtrare in base a una stringa. Se stai eseguendo un registro all'interno del programma, puoi semplicemente includere una determinata parola chiave univoca e filtrare in base a quella parola.

Prova: Finestra -> Preferenze -> Android -> LogCat. Modificare il campo "Mostra vista logcat se ..." il valore "VERBOSE". Mi ha aiutato

Se si utilizza Eclipse , premere il segno verde + nella finestra di logCat in basso e inserire il nome del pacchetto (com.example.yourappname) nella casella per Nome applicazione . Inoltre, scegli un nome a te comodo nella casella Nome filtro e fai clic su OK. Vedrai solo i messaggi relativi alla tua applicazione quando il filtro appena aggiunto viene scelto dal riquadro sinistro in logCat.

Dai un nome al tuo registro. Ho chiamato il mio "wawa".

In Android Studio, vai su Android-> Modifica configurazioni filtro

Quindi digitare il nome assegnato ai registri. Nel mio caso, si chiama "wawa". Ecco alcuni esempi dei tipi di filtri che puoi fare. È possibile filtrare per System.out, System.err, Log o nomi dei pacchetti:

Questa è probabilmente la soluzione più semplice.

Oltre a una soluzione di Tom Mulcahy, puoi semplificarla ulteriormente come di seguito:

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

L'uso è facile come alias normale. Basta digitare il comando nella shell:

logcat

L'impostazione dell'alias lo rende utile. E regex lo rende robusto per le app multi-processo, supponendo che ti interessi solo al processo principale.

Di sicuro puoi impostare più alias per ogni processo come preferisci. O usa la soluzione di hegazy. :)

Inoltre, se si desidera impostare i livelli di registrazione, lo è

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

Su Windows 10, usando Ionic, ciò che ha funzionato alla grande è stato combinare 'findstr' con "INFO: CONSOLE" generato da tutti i messaggi delle app. Quindi, il mio comando nella riga di comando è:

adb logcat | findstr INFO:CONSOLE

Ho provato a usare la risposta di Tom Mulcahy ma sfortunatamente non funzionava per applicazioni con più processi, quindi l'ho modificata per adattarmi alle mie esigenze.

#!/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"

Usa -s!

Dovresti usare il tuo tag, guarda: http://developer.android.com/reference/android/util/Log.html

Piace.

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

E poi quando vuoi leggere il registro usa>

adb logcat -s AlexeysActivity

Ciò filtra tutto ciò che non utilizza lo stesso tag.

fonte

Oltre alla risposta di Tom Mulcahy , se vuoi filtrare per PID sulla console di Windows, puoi creare un piccolo file batch come questo:

@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%

Questa è ovviamente una domanda volta a utilizzare Logcat dall'esterno del dispositivo di sviluppo, tuttavia se si desidera visualizzare l'output di Logcat sul dispositivo ( a livello di codice ), è sufficiente:

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

Alla *:Dfine filtra tutti i messaggi al di sotto del livello di registro di debug, ma puoi lasciarlo fuori.

Per indirizzare l'output, ad esempio, a TextView, vedere ad esempio qui .

Ora è possibile digitare tag: nameofthetag o app: nameoftheapp per filtrare senza aggiungere nuovi filtri alla barra dei filtri salvata

In intelliJ (e probabilmente anche in eclipse) puoi filtrare l'output di logcat tramite webview di testo , quindi stampa praticamente tutto ciò che produce phonegap

Ancora un'altra variante di Gavriel applog.shcon supporto di numerosi dispositivi e applicazioni con più processi:

#!/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}"

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

In Linux, questo ha funzionato per me:

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