Programmier Tutorial – Teil 5: Refactoring und Logging in Android Studio

---

Im fünften Teil unseres großen Android™ Tutorials werden wir den Projektordner unserer Android App etwas aufräumen.

Dazu verwenden wir das Refactoring-Werkzeug von Android Studio. Weiterhin werden wir das Logging System von Android vorstellen und die sechs Logging-Level näher beleuchten.

Unsere Android App kann in der momentanen Entwicklungsstufe einen scrollbaren ListView, der mit Beispielaktiendaten gefüllt ist, darstellen.

Später wird unsere Anwendung in der Lage sein simulierte Finanzdaten von unserem Web-Server anstelle der Beispieldaten anzuzeigen.

Doch zunächst möchten wir unser Android Projekt etwas aufräumen und einige Umbenennungen durchführen.

Nachdem wir unser Android Projekt neu strukturiert haben, werden wir einen genaueren Blick auf das Logging in Android werfen. Für die Entwicklung von Android Anwendungen ist das Ausgeben von Status- und Fehlermeldungen unverzichtbar. Daher werden wir Logging-Meldungen beispielhaft in unsere App einfügen.

1. Restrukturierung unseres Android Studio Projekts

Was ist Refactoring (Restrukturierung)?

In der Softwareentwicklung spielt Refactoring (Restrukturierung des Quellcodes) eine wichtige Rolle. Je komplexer eine Anwendung ist, umso unübersichtlicher und unverständlicher kann der Quellcode werden. Um genau dies zu verhindern, wird Refactoring während der Entwicklung angewandt.

Der Begriff Refactoring bezeichnet die manuelle oder automatische Strukturverbesserung des Quelltextes, wobei das Programmverhalten erhalten bleibt.

Durch Refactoring sollen folgende Eigenschaften des Quellcodes verbessert werden:

• Lesbarkeit
• Erweiterbarkeit
• Übersichtlichkeit
• Verständlichkeit
• Erleichterung des Testens
• Eliminierung von Redundanz

Eine weiterführende Beschreibung zu Refactoring findet ihr hier: http://de.wikipedia.org/wiki/Refactoring.

Wir werden Refactoring einsetzen, um unseren bisherigen Quellcode übersichtlicher und modularer zu gestalten.

---

Dazu werden wir in den nächsten Abschnitten Änderungen an unserer Android App vornehmen, ohne dabei Einfluss auf das Verhalten der Anwendung zu nehmen.

1.1 Umbenennen der Klasse MainActivityFragment.java

Der entscheidende Quellcode unserer Android Anwendung befindet sich momentan in der Klasse MainActivityFragment.java. Der bisherige Klassenname ist nicht selbsterklärend. Daher ist unser erster Schritt den Namen dieser Klasse in einen selbsterklärenden Namen zu ändern.

Für die Umbenennung der Klasse greifen wir auf das Refactoring-Werkzeug Rename... zurück und führen die folgenden Schritte aus:

1. Mit der rechten Maustaste auf die Datei MainActivityFragment in der Projektleiste klicken.
2. Im Kontext-Menü auf Refactor klicken.
3. Danach auf den oberen Eintrag Rename... klicken.

Nachdem wir auf Rename... geklickt haben, öffnet sich der Rename-Dialog in Android Studio.

Wir benennen nun die Klasse von MainActivityFragment zu AktienlisteFragment um und klicken den Refactor-Button. Android Studio aktualisiert jetzt automatisch die entsprechenden Stellen im Quellcode, so dass überall der neue Klassenname verwendet wird.

Jetzt ist der Klassenname selbsterklärend, aber die zugehörige Layout-Datei trägt noch den alten Namen. Diesen werden wir als Nächstes entsprechend umbenennen.

1.2 Umbenennen der Layout-Datei fragment_main.xml

Als nächsten Schritt nennen wir die XML-Layout Datei fragment_main.xml entsprechend um. Die Layout-Datei wird umbenannt in fragment_aktienliste.xml. Dadurch erkennt man sofort, dass die Layout-Datei zu dem Fragment AktienlisteFragment gehört.

Für die Umbenennung der Layout-Datei greifen wir wieder auf das Refactoring-Werkzeug Rename... zurück und führen die folgenden Schritte aus:

1. Mit der rechten Maustaste auf die Datei fragment_main.xml in der Projektleiste klicken.
2. Im Kontext-Menü auf Refactor klicken.
3. Danach auf den oberen Eintrag Rename... klicken.

Nachdem wir auf Rename... geklickt haben, öffnet sich der Rename-Dialog.

Wir benennen nun die Layout-Datei von fragment_main.xml zu fragment_aktienliste.xml um und klicken anschließend den Refactor-Button. Android Studio aktualisiert jetzt automatisch die entsprechenden Stellen im Quellcode, so dass überall die neue Bezeichnung verwendet wird.

Jetzt müssen wir als letzten Refactoring-Schritt die Context-Angabe in der eben umbenannten Layout-Datei fragment_aktienliste.xml anpassen.

Dazu ersetzen wir den alten Klassennamen MainActivityFragment mit dem neuen Namen AktienlisteFragment in der Zeile tools:context. Vor dem Klassennamen muss ein Punkt (.) stehen, siehe folgende Abbildung (Markierung A).

Da wir jetzt die notwendigen Anpassungen an unserem Quellcode vorgenommen haben, sind unsere Refactoring-Maßnahmen nun abgeschlossen.

Wir sollten nun unsere Android Anwendung zur Probe ausführen und auf Fehlverhalten untersuchen. Wenn alle Änderungen fehlerfrei ausgeführt wurden, sollte unsere Anwendung wie vorher funktionieren.

2. Kompilieren und Testen unserer Android App

Unsere Android Anwendung muss nun neu kompiliert werden.

Mit einem Klick auf das Make Project-Symbol in der oberen Menüleiste wird der Kompilierprozess gestartet:

Das Kompilieren des Quellcodes dauert einen kleinen Moment und sollte ohne Fehlermeldungen abgeschlossen werden. Ist dies der Fall, können wir als Nächstes unsere App im Emulator und auf unserem Android Gerät starten.

2.1 Starten der App im Android Emulator

Zuerst wollen wir die App im Android Emulator ausführen. Dazu klicken wir auf das Run 'app'-Symbol in der oberen Menüleiste.

Siehe die folgende Abbildung:

Jetzt wird unser Projekt erstellt und anschließend öffnet sich der Select Deployment Target-Dialog. Wir wählen unser Android Virtual Device aus, welches wir in Teil 2 des Android Tutorials erstellt hatten (Das AVD muss vorher im AVD Manager gestartet werden), und klicken abschließend auf den OK-Button.

Siehe folgende Abbildung:

Nun startet Android Studio den Emulator und installiert automatisch unsere App auf dem ausgewählten AVD (Android Virtual Device). Sobald die Installation abgeschlossen wurde, startet Android Studio unsere App auf dem AVD. Die Anwendung sollte noch exakt so wie in der vorherigen Android Tutorial Lektion funktionieren.

2.2 Starten der App auf einem Android Gerät

Damit wir unsere App auf dem Smartphone oder Tablet starten können, müssen alle Schritte von Teil 3 des Android Tutorials befolgt worden sein.

Zuerst schließen wir unser Android Gerät an den PC an und stellen eine Verbindung über die ADB (Android Debug Bridge) her. Danach klicken wir auf das Run 'app'-Symbol in der oberen Menüleiste. Siehe folgende Abbildung:

Nach einigen Momenten öffnet sich der Select Deployment Target-Dialog. In ihm nehmen wir die folgenden Einstellungen vor:

1. Das angeschlossene Android Gerät unter Connected Devices auswählen.
2. Mit einem Klick auf den OK-Button die Installation unserer App auf das Gerät starten.

Der Dialog schließt sich und unsere Android App wird auf das angeschlossene Gerät übertragen und installiert. Die Installation dauert nur einen kurzen Augenblick und verläuft fast unbemerkt im Hintergrund. Danach wird unsere App automatisch gestartet.

Unsere Android App sollte nun sowohl im Emulator als auch auf dem angeschlossenen Android Gerät fehlerfrei ausgeführt werden. Somit ist die Umstrukturierung (Refactoring) unserer Android Anwendung erfolgreich durchgeführt worden.

3. Logging in Android Studio

Das Android Logging System ermöglicht uns System Debug Ausgaben zu betrachten und auch zu sammeln.

Die Log-Meldungen der Android Anwendungen und des Systems selbst werden in Ringpuffern gespeichert und können mit Hilfe des logcat-Befehls betrachtet und gefiltert werden.

Die Log-Buffer von Android können auf zwei Arten ausgelesen werden:

• Über die Konsole mit dem Android Debug Bridge (ADB) Befehl: adb logcat
• Mit Hilfe des Dalvik Debug Monitor Server (DDMS) in Android Studio

3.1 Die Logging Level in Android und die Klasse Log

Die Log-Klasse ist eine Logging-Klasse, die wir in unserer Anwendung nutzen können, um wichtige Meldungen über LogCat auszugeben. Für das Ausgeben unserer Meldungen stehen uns die folgenden fünf Methoden zur Verfügung:

• v(String, String) -> verbose = wortreich
• d(String, String) -> debug = Fehler beseitigen
• i(String, String) -> information = Information
• w(String, String) -> warning = Warnung
• e(String, String) -> error = Fehler

Möchten wir bspw. eine kurze Information über LogCat ausgeben, so schreiben wir:

Log.i("AktieHQ", "MyClass.getView() — Elementnummer: " + position);

Unsere Log-Meldung wird dann von LogCat folgendermaßen ausgegeben:

LogCat Ausgabe: I/AktieHQ(12345): MyClass.getView() — Elementnummer: 1.

Die oben aufgeführten fünf Logging-Methoden repräsentieren fünf Prioritäts-Level. Dabei entspricht verbose der niedrigsten und error der höchsten der fünf Prioritäten. In Android sind aber noch zwei weitere Prioritäts-Level definiert, diese sind fatal und silent.

Insgesamt sind in Android die folgenden Prioritäts-Level definiert, einige davon farblich codiert:

• V — Verbose (niedrigste Priorität)
• D — Debug
• I — Info
• W — Warning
• E — Error
• F — Fatal
• S — Silent (höchste Priorität, hier wird niemals etwas ausgegeben)

Wie bereits geschrieben, können wir Log-Meldungen der ersten fünf Prioritäten von unserer Anwendung aus ausgeben lassen. Es sollte aber unbedingt darauf geachtet werden, dass wir kein Log-Spamming betreiben. Die fertige Anwendung sollte keine verbose und debug Meldungen enthalten.

4. Log-Meldungen in unserer App ausgeben

Zu Testzwecken werden wir nun von unserer Android App jeweils eine Log-Meldung pro Logging-Level ausgeben lassen. Die Meldungen werden einmal beim Starten unserer Anwendung ausgegeben.

Eine Log-Meldung besteht aus zwei Elementen, dem Tag und der Nachricht. Als Tag werden wir den Namen unserer Klasse verwenden. Als Nachricht geben wir die jeweilige Priorität der Log-Meldung aus.

Der Quelltext für das Ausgeben unserer Log-Meldungen sieht dann wie folgt aus:

String LOG_TAG = AktienlisteFragment.class.getSimpleName();

Log.v(LOG_TAG, "verbose     - Meldung");
Log.d(LOG_TAG, "debug       - Meldung");
Log.i(LOG_TAG, "information - Meldung");
Log.w(LOG_TAG, "warning     - Meldung");
Log.e(LOG_TAG, "error       - Meldung");

Den oben angegebenen Quelltext fügen wir zu Testzwecken in unsere Android App in die Klasse AktienlisteFragment ein.

Dazu fügen wir den Codeblock und die benötigte Import-Anweisung, wie in der unteren Abbildung dargestellt, in die onCreateView-Methode ganz oben ein.

Jetzt kompilieren wir unsere Anwendung, indem wir auf das Make Project-Symbol in der oberen Menüleiste klicken. Unser Projekt sollte nun ohne Kompilierfehler erstellt worden sein. Falls es zu einem Fehler kam, kann dies an dem fehlenden Import der Log-Klasse liegen.

Dies könnt ihr manuell mit der Import-Anweisung import android.util.Log; nachholen.

5. Betrachten von Log-Meldungen in Android Studio

Unsere Android App gibt jetzt direkt nach dem Starten fünf Log-Meldungen aus.

Diese Meldungen werden aber nicht auf dem Smartphone- oder Tablet-Display angezeigt, sondern werden im Hintergrund von dem Android Logging System behandelt.

Um unsere Log-Meldungen zu betrachten, müssen wir mit Hilfe der Android Debug Bridge (ADB) den LogCat-Befehl nutzen. Da in den Log-Buffern Unmengen von Meldungen gehalten werden, müssen wir aus ihnen, die für uns wichtigen Meldungen, herausfiltern.

5.1 Auslesen der Log-Meldungen über die Konsole

Mit dem folgenden Konsolenbefehl filtern wir unsere Log-Meldungen heraus:

adb logcat AktienlisteFragment:v *:s

Dabei werden mit:

• dem Parameter AktienlisteFragment:v alle Log-Meldungen mit dem Tag AktienlisteFragment der Priorität v (verbose) und höher angezeigt.
• dem Parameter *:s alle anderen Log-Meldungen abgeblockt, da nur Meldungen der Priorität s (silent) angezeigt werden.

Um den Log-Output mittels LogCat betrachten zu können, müsst ihr in das sdk\plattform-tools-Verzeichnis in der Kommandozeile navigieren und den ADB-Befehl darin ausführen.

Damit wir unsere Log-Meldungen auch in der Kommandozeile angezeigt bekommen, müssen wir nun die folgenden fünf Schritte durchführen:

1. Ausführen unserer App mit Klick auf Run 'app'-Symbol.
2. Als Device unser angeschlossenes Android Gerät auswählen und OK klicken.
3. Kommandozeile öffnen und in das Verzeichnis AndroidSDK\plattform-tools wechseln.
4. Jetzt den Befehl adb logcat AktienlisteFragment:v *:s in der Kommandozeile eingeben.
5. Unsere Android App erneut auf dem Android Gerät über das Hauptmenü starten.

Wir sollten jetzt folgende Ausgabe in der Kommandozeile erhalten:

Dabei ist der ADB-Befehl mit einer 1 markiert und unsere fünf Log-Meldungen mit dem roten Rahmen (2). In der Abbildung ist auch die Prozess ID zu erkennen, sie lautet 11598.

5.2 Auslesen der Log-Meldungen mit Hilfe des Dalvik Debug Monitor Servers (DDMS)

Etwas komfortabler lassen sich Log-Meldungen mittels Dalvik Debug Monitor Server (DDMS) betrachten. Der DDMS ist ein sehr mächtiges Debug-Werkzeug und bereits in Android Studio integriert. Mit dem DDMS können Log-Meldungen sehr übersichtlich angezeigt werden.

Den DDMS starten wir mit einem Klick auf das Android Device Monitor-Symbol in der oberen Menüleiste.

Der DDMS kann auch über den Menüeintrag Tools>Android>Android Device Monitor gestartet werden.

Bis der Android Device Monitor mit DDMS vollständig gestartet ist, vergeht eine kleine Weile, daher wird etwas Geduld benötigt.

Um die Log-Meldungen betrachten zu können, muss euer Android Gerät am PC angeschlossen sein. Wie ihr euer Android Gerät korrekt mit dem PC verbindet, haben wir in Teil 3 des Android Tutorials ausführlich beschrieben.

Die Benutzeroberfläche des Android Device Monitor mit DDMS informiert uns über viele Anwendungs- und Geräte-Details.

Wir interessieren uns im Moment nur für die Log-Meldungen, die mit folgenden Einstellungen im unteren Bereich der Benutzeroberfläche angezeigt werden:

1. Als Erstes klicken wir auf unsere App, um die Log-Meldungen für das angeschlossene Android Gerät betrachten zu können.
2. Anschließend auf den LogCat-Tab unten links klicken, wodurch rechts unten die Log-Meldungen aufgelistet werden.
3. In der Suchleiste kann gezielt nach Log-Meldungen gesucht werden, z.B. mit Prozess ID (pid), Meldungs-Tag (tag) oder Meldungs-Text (text).
4. Einstellung des Prioritäts-Level. Als Standard ist verbose ausgewählt, wodurch alle Log-Meldungen ausgegeben werden.

Die Log-Meldungen werden im unteren Bereich in einer Tabelle angezeigt. Wir haben die folgenden Spalten blau markiert:

1. Prozess ID = PID
2. Tag der Log-Meldung = Tag
3. Text der Log-Meldung = Text

Momentan werden uns alle Log-Meldungen angezeigt. Da wir uns nur für unsere Log-Meldungen interessieren, werden wir als Nächstes mit Hilfe der Suchleiste nach ihnen suchen.

1. In der Suchleiste suchen wir mit pid:11598 nach der Prozess ID unserer App. Der Wert der Prozess ID ist im Devices-Bereich nach dem vollständigen Namen unserer App aufgeführt.
2. Es werden alle Log-Meldungen angezeigt, also verbose und höhere Priorität.
3. In der Prozess ID-Spalte (PID) wird nur die ID 11598 aufgeführt.

Uns werden insgesamt 6 Log-Meldungen angezeigt. Dabei sind die letzten 5 Meldungen von unserer App selbst erstellt und ausgegeben worden. Außerdem ist die farbliche Kodierung der verschiedenen Prioritäts-Level gut zu erkennen.

Als Nächstes möchten wir uns nur die Log-Meldungen unserer Android App anzeigen lassen. Dabei gehen wir folgendermaßen vor:

1. In der Suchleiste suchen wir mit tag:AktienlisteFragment nach einem bestimmten Meldungs-Tag.
2. Auch diesmal werden alle Log-Meldungen angezeigt, also verbose und höhere Priorität.
3. In der Tag-Spalte (Tag) wird nur der Tag AktienlisteFragment aufgeführt.

Diesmal werden uns nur noch 5 Log-Meldungen angezeigt und zwar alle Meldungen, die in der AktienlisteFragment-Klasse erzeugt wurden.

Als letztes Beispiel möchten wir neben dem Meldungs-Tag auch den Prioritäts-Level der Log-Meldung in der Suche vorgeben. Dazu führen wir folgende Schritte aus:

1. In der Suchleiste suchen wir mit tag:AktienlisteFragment nach dem gewünschten Meldungs-Tag.
2. Wir wählen als Prioritäts-Level den Level info aus, wodurch uns nur Log-Meldungen mit der Priorität information und höher angezeigt werden.
3. In der Level-Spalte (Level) werden nur die Prioritäts-Level information, warning und error angezeigt.

Diesmal werden uns nur 3 Log-Meldungen angezeigt und zwar alle Meldungen unserer Anwendung mit einem Prioritäts-Level von mindestens information.

Auf diese Weise kann mit Hilfe des Android Device Monitors und DDMS sehr effektiv nach wichtigen Log-Meldungen gesucht werden. Als eine große Hilfe bei der Überwachung der eigenen Android App ist auch die farbliche Kodierung der Log-Meldungen zu bewerten.

Zusammenfassung

In diesem Teil unseres großen Android Tutorials haben wir zuerst den Quellcode unserer Android App umstrukturiert.

Als Refactoring-Maßnahmen haben wir die Klasse MainActivityFragment in AktienlisteFragment umbenannt. Anschließend haben wir die XML-Ressourcen Datei fragment_main.xml in fragment_aktienliste.xml umbenannt und den, unter tools_context gespeicherten, Klassenpfad entsprechend angepasst.

Im zweiten Teil dieser Android Lektion haben wir das Logging System von Android und die Log-Klasse vorgestellt. Zu Testzwecken haben wir verschiedene Log-Meldungen in unserer Android Anwendung erzeugt und diese auf der Konsole und dem Android Device Manager betrachtet.

Abschließend haben wir die Benutzeroberfläche des Android Device Managers näher beschrieben und mit Hilfe des Dalvik Debug Monitor Servers (DDMS) nach unseren Log-Meldungen gesucht.

In den nächsten Teilen unseres Android Tutorials werden wir unsere App um neue Funktionen erweitern, so dass sie schließlich echte Online-Aktiendaten abfragt und in dem ListView anzeigt. Um dies zu erreichen, werden wir schrittweise vorgehen. Der nächste Schritt wird sein, unsere App um ein Menü zu erweitern.

---

---