Android
Loggar och använder Logcat

Syntax

• 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)

parametrar

Anmärkningar

Filtrera logcat-utgången

Det är bra att filtrera logcat-utdatorn eftersom det finns många meddelanden som inte är av intresse. För att filtrera utdata öppnar du "Android Monitor" och klickar på rullgardinsmen längst upp till höger och väljer Redigera filterkonfiguration

Nu kan du lägga till anpassade filter för att visa meddelanden som är av intresse, samt filtrera bort kända logglinjer som säkert kan ignoreras. För att ignorera en del av utgången kan du definiera ett regelbundet uttryck . Här är ett exempel på att utesluta matchande taggar:

^(?!(HideMe|AndThis))

Detta kan anges genom att följa detta exempel:

Ovanstående är ett regelbundet uttryck som utesluter ingångar. Om du ville lägga till en annan tagg till svartlistan , lägg till den efter ett rör | karaktär. Om du till exempel ville svartlista "GC" skulle du använda ett filter som detta:

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

---

För mer dokumentation och exempel, besök Logga in och använda Logcat

Skogsavverkning

Varje Android-applikation av kvalitet håller reda på vad den gör genom applikationsloggar. Dessa loggar möjliggör enkel felsökningshjälp för utvecklaren att diagnostisera vad som händer med applikationen. Full Android-dokumentation kan hittas här , men en sammanfattning följer:

---

Grundläggande loggning

Log är den viktigaste källan för att skriva utvecklarloggar, genom att ange en tag och ett message . Taggen är vad du kan använda för att filtrera loggmeddelanden genom att identifiera vilka rader som kommer från din specifika aktivitet. Bara ringa

Log.v(String tag, String msg);

Och Android-systemet kommer att skriva ett meddelande till 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

DRICKS:
Lägg märke till process-id och tråd-id. Om de är desamma - kommer loggen från huvud / UI-tråden!

Alla taggar kan användas, men det är vanligt att använda klassnamnet som en tagg:

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

---

Loggnivåer

Android-loggern har 6 olika nivåer, som var och en tjänar ett visst syfte:

• ERROR : Log.e()
  • Används för att indikera kritiskt fel, detta är nivån som skrivs ut när du kastar ett Exception .
• WARN : Log.w()
  • Används för att indikera en varning, främst för återvinningsbara fel
• INFO : Log.i()
  • Används för att ange information på högre nivå om applikationens tillstånd
• DEBUG : Log.d()
  • Används för att logga in information som skulle vara användbart att veta vid felsökning av applikationen, men som skulle komma i vägen när du kör applikationen
• VERBOSE : Log.v()
  • Används för att logga information som återspeglar de små detaljerna om applikationens tillstånd
• ASSERT : Log.wtf()
  • Används för att logga information om ett tillstånd som aldrig ska hända.
  • wtf står för "What a Terrible Failure".

---

Motivation för loggning

Motivationen för loggning är att enkelt hitta fel, varningar och annan information genom att titta på händelsekedjan från applikationen. Föreställ dig till exempel ett program som läser rader från en textfil, men antar felaktigt att filen aldrig kommer att vara tom. Loggspåret (för en app som inte loggar) skulle se ut så här:

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

Följt av ett gäng stapelspår som så småningom skulle leda till den kränkande linjen, där att kliva igenom med en felsökare så småningom skulle leda till problemet

Loggspåret för en applikation med loggning aktiverad kan dock se ut så här:

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

Ett snabbt blick på stockarna och det är uppenbart att filen var tom.

---

Saker att tänka på när du loggar:

Även om loggning är ett kraftfullt verktyg som gör det möjligt för Android-utvecklare att få en större inblick i den inre funktionen av deras applikation, har loggning vissa nackdelar.

Loggbarhet:

Det är vanligt att Android-applikationer har flera loggar som körs synkront. Som sådan är det mycket viktigt att varje logg är lättläsbar och endast innehåller relevant, nödvändig information.

Prestanda:

Loggning kräver en liten mängd systemresurser. I allmänhet garanterar detta inte oro, men om överanvändning kan loggning ha en negativ inverkan på applikationsprestanda.

Säkerhet:

Nyligen har flera Android-applikationer lagts till på Google Play marknadsplats som gör det möjligt för användaren att se loggar över alla applikationer som körs. Denna oavsiktliga visning av data kan göra det möjligt för användare att se konfidentiell information. Som tumregel ska du alltid ta bort loggar som innehåller icke-offentliga uppgifter innan du publicerar din ansökan på marknaden.

---

Slutsats:

Loggning är en väsentlig del av en Android-applikation på grund av kraften som den ger utvecklarna. Möjligheten att skapa ett användbart loggspår är en av de mest utmanande aspekterna av mjukvaruutveckling, men Android: s Log-klass hjälper till att göra det mycket enklare.

---

För mer dokumentation och exempel, besök Logga in och använda Logcat

Logga med länk till källan direkt från Logcat

Detta är ett trevligt trick att lägga till en länk till koden, så det blir lätt att hoppa till koden som utfärdade loggen.

Med följande kod, detta samtal:

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

Kommer att resultera i:

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

Det här är koden (i en klass som heter 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());
}

Detta är ett grundläggande exempel, det kan enkelt utökas för att utfärda en länk till den som ringer (ledtråd: stacken är [4] istället för [3]), och du kan också lägga till annan relevant information.

Använda Logcat

Logcat är ett kommandoradsverktyg som släpper en logg med systemmeddelanden, inklusive stapelspår när enheten kastar ett fel och meddelanden som du har skrivit från din app med klassen Logg.

Logcat-utgången kan visas i Android Studios Android Monitor eller med adb-kommandoraden.

I Android Studio

Visa genom att klicka på ikonen "Android Monitor": Eller genom att trycka på Alt + 6 på Windows / Linux eller CMD + 6 på Mac.

via kommandorad:

Enkel användning:

$ adb logcat

Med tidsstämplar:

$ adb logcat -v time

Filtrera efter specifik text:

$ adb logcat -v time | grep 'searchtext'

Det finns många alternativ och filter tillgängliga för kommandoradsloggar , dokumenterade här .
Ett enkelt men användbart exempel är följande filteruttryck som visar alla loggmeddelanden med prioritetsnivå "fel" på alla taggar:

$ adb logcat *:E

Genererar loggningskod

Android Studio Live templates kan erbjuda en hel del genvägar för snabb loggning.
För att använda Live-mallar, allt du behöver göra är att börja skriva mallnamnet och slå TAB eller ange för att infoga uttalandet.

Exempel:

• logi → förvandlas till → android.util.Log.i(TAG, "$METHOD_NAME$: $content$");
  • $METHOD_NAME$ kommer automatiskt att ersättas med ditt metodnamn, och markören väntar på att innehållet ska fyllas.
• loge → samma, för fel
• etc. för resten av loggningsnivåerna.

Fullständig lista över mallar finns i Android Studio : s inställningar ( ALT + s och skriv "live"). Och det är möjligt att lägga till dina anpassade mallar också.

Om du hittar Android Studio Live templates inte tillräckligt för dina behov kan du överväga Android Postfix Plugin

Detta är ett mycket användbart bibliotek som hjälper dig att undvika att skriva logglinjen manuellt.

Syntaxen är helt enkel:

.log - Loggning. Om det finns en konstant variabel "TAG" använder den "TAG". Annars använder du klassnamn.

Användning av Android Studio

1. Dölj / visa tryckt information:

2. Kontrollera logos:

3. Inaktivera / aktivera öppningsloggfönstret när programmet startar körning / felsökning

Rensa loggar

För att rensa (spola) hela loggen:

adb logcat -c