Programmier Tutorial - Apps für Android entwickeln - Refactoring und Logging in Android Studio

Programmier Tutorial: Apps für Android entwickeln – Teil 5: Refactoring und Logging in Android Studio


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.
android refactoring class

Umbenennen der Klasse MainActivityFragment mit dem Android Studio Refactoring-Tool

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.

android refactoring rename

Umbenennen der Klasse MainActivityFragment in AktienlisteFragment

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.
android refactoring layout

Umbenennen der Layout-Datei fragment_main.xml mit dem Android Studio Refactoring-Tool

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.

android refactoring layout rename

Umbenennen der Layout-Datei fragment_main.xml in fragment_aktienliste.xml

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

android refactoring context

Context an den neuen Klassennamen anpassen

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:

android compile project

Kompilieren unseres Projekts durch Klick auf das Make Project Symbol

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:

android studio project avd run

Android App über das Run App-Symbol starten

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:

android studio project avd choose

Auswählen des AVDs auf dem die App ausgeführt werden soll

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:

android studio project avd run

Android App über das Run App-Symbol starten

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.
android device run app

Auswählen des angeschlossenen Android Geräts zum Aufspielen unserer App

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.

android logging

Logging Anweisungen in unsere Android App einfügen

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:

android adb logcat

ADB-Befehl logcat zum Ausgeben unserer Log-Meldungen in der Konsole

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.

android ddms symbol

Den Dalvik Debug Monitor Server (DDMS) über das Android Device Monitor-Symbol starten

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

android ddms menu

Den Dalvik Debug Monitor Server (DDMS) über das obere Menü starten

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.
android ddms

Benutzeroberfläche des Android Device Monitors mit DDMS

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.
Android Device Monitor

Log-Meldungen einer vorgegebenen Prozess ID (pid) herausfiltern

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.
android device

Log-Meldungen eines vorgegebenen Meldungs-Tag (Tag) herausfiltern

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.
android logging

Log-Meldungen eines vorgegebenen Meldungs-Tag (Tag) mit Prioritäts-Vorgabe herausfiltern

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.



Comments 35

  1. Pingback: Android Tutorial: Daten mit einem Listview anzeigen

  2. Pingback: Android Tutorial: Options Menu und Action Bar in Android

  3. Pingback: Android Tutorial: Daten von einer Webseite abfragen in Android

  4. Hallo,

    bin bei Kapitel 5.1 hängen geblieben. Wenn ich alles in die Kommandozeile eingegen habe, erscheint folgende Meldung:

    Note: log switch off, only log_main and log_events will have logs!
    ——— beginning of /dev/log/main

    und hier stoppt es dann, die folgende Zeile
    ——— beginning of /dev/log/main
    bzw. die gewünschte Ausgabe erscheinen nicht.

    Wie kann ich log switch auf „on“ stellen?

    Danke im Voraus, tolle Webseite übrigens, und viele Grüße
    Daniela

    1. Bin trotzdem mal weiter zu 5.2 gegangen und habe logs mithilfe des DDMS gesucht, erhielt aber erwartungsgemäß keine Werte, weder über die Suche per „pid:“ noch „tag:“.

      Ist es eine Einstellung an meinem angeschlossenen Android-Gerät selbst? Bei stackoverflow bzw. google habe ich bisher leider auch keine Lösung gefunden, um log-Daten anzeigen zu lassen.
      Wäre super, wenn mir jemand noch weiterhelfen könnte.

      Ich arbeite übrigens mit Android 23 als Zielsystem. Bisher konnte ich deinem Kurs dennoch ohne Probleme folgen.

    2. Post
      Author

      Hallo Daniela,

      ich hatte bisher noch keine Probleme mit den Log-Meldungen, von daher fehlt mir leider die Erfahrung.

      Kann vielleicht ein Leser aushelfen, der schon ähnliche Probleme hatte?

      Viele Grüße, Chris

    3. Versuchs einfach mal über den Android Monitor (Alt+6 oder unten links in der Leiste) und, dann den Tag suchen ohne das „tag:“ davor.
      Ich hatte auch erst Probleme bei dem im Terminal da weiß ich leider nicht mehr wie ich das Problem behoben habe.
      Ich hoffe ich konnte helfen.

      LG
      HkVK

  5. Hallo,

    weiterhin erhalte ich keine Log-Meldungen. Das Problem vermute ich eher beim Quellcode bzw. einer Einstellung bei Android Studio. Das Smartphone schließe ich aus, schließlich erhalte ich keine Logmeldungen, ob das Smartphone angeschlossen ist oder nicht. Vielleicht hat doch jemand noch einen Tipp für mich?

    Viele Grüße,
    Daniela

  6. Also erstmal was sehr angebracht ist
    Ein großes Lob und vielen dank für diese Anleitung. Welche wirklich gut und sehr ausführlich für Anfänger geschrieben ist.

    Folgendes Problem habe ich an der Stelle 5.2
    Sobald ich auf Dalvik Debug Monitor Servers (DDMS) drücke
    Bekomme ich in einem externen monitor die Fehlermeldung : An error has occurred. See the log File
    c:\Android\sdk1\tools\lib\monitor -x86_64\configuration\1448369689367.log

    Als blutiger Anfänger kann ich damit nicht wirklich viel anfangen und würde nur raten ob es vielleicht mit dem Intel HAXM Treiber zu tun hat und man diese fehler vielleicht dann umgehen kann.
    Werde diesen Teil somit dann erstenmal überspringen.
    Veleicht ist dieser Fehler dir ja bekannt oder/und du weißt eine Lösung dafür.

    Vielen lieben Dank

    1. Post
      Author

      Hallo Mark,

      danke für die lobenden Worte!

      Die genaue Fehlermeldung steht in dem Log-File drin. So ist es nicht möglich zu sagen, welches Problem der DDMS genau hat.

      Für das Tutorial ist der DDMS aber nicht zwingend erforderlich. Du kannst die Log-Meldungen auch über die Konsole verfolgen, das geht genauso gut. Für komplexe Analysen, bspw. Speicherbedarf oder Netzwerkaktivitäten, ist dann der DDMS richtig. Im Tutorial machen wir so etwas aber nicht. Daher reicht die Konsole.

      Viele Grüße, Chris

  7. Wieder einmal ein sehr schönes Tutorial für Anfänger!

    Genauso wie im vorherigen Kapitel wird die App hier zuerst auf dem AVD und anschließend auf einem realen Gerät getestet. Leider braucht die AVD sehr lange bei mir und ich frage mich, ob ich die Funktion „Run ‚app'“ für AVD und reales Gerät kurz nacheinander starten kann. Kann Android Studio sowas gleichzeitig verwalten oder sollte man sowas unterlassen, damit das Programm nicht „durcheinander“ kommt?

    Bislang habe ich die AVD abgewartet, alles angeschaut, AVD geschlossen und dann erst die App auf dem realen Gerät ausgeführt.

    Viele Grüße,
    Marvin

    1. Post
      Author

      Hallo Marvin,

      keine Angst… Android Studio kommt dadurch nicht „durcheinander“.

      Es ist auch möglich die eigene App gleichzeitig auf das AVD und das reale Gerät aufzuspielen über die „Run App“-Funktion. Dazu einfach mit der Shift-Taste beide Devices auswählen.

      Viele Grüße, Chris

  8. Auch von mir erst mal ein großes Lob. Das Tutorial ist wirklich sehr gut und verständlich verfasst.

    Zu dem Problem mit den nicht erscheinenden Log-Meldungen, was ich anfänglich auch hatte: Bei mir hat es funktioniert, nachdem ich
    1. App auf mein Smartphone übertragen hatte
    2. Erscheinende App geschlossen hatte
    3. App vom Smartphone neu starten und dann schließen

    Anschließend erschienen die Meldungen, zumindest über DDMS.

    1. Post
      Author

      Hallo Wolfgang,

      danke für Deinen sehr hilfreichen Hinweis. Er wird bestimmt einigen Lesern weiterhelfen.

      Viele Grüße, Chris

    2. Hallo,

      der Rat vom Wolfgang hat mein Problem gelöst mit dem nichtanzeigen der Log-Meldungen.
      Vielen Dank dafür.

      Außerdem bis hier hin ein super Tutorial, ich finde das gut wie die verschieden Schichten einer App, behandelt werden. Hoffe es geht so weiter gut voran.

      Viele Grüße
      Denis

    3. Post
      Author

      Hallo Dennis,

      danke für’s Lob! Ja das Tutorial geht in diesem Stil weiter. Schicht für Schicht, Stück für Stück wird die Android App erweitert.

      Viele Grüße, Chris

  9. Hallo Chris, leider erscheint auf meinem Huawei (4.3) das Options-Menu (Overflow) nicht, während es auf dem Nexus erscheint. Kann das an der Android-Version liegen ? Ich bin ziemlich sicher, dass ich bei der Eingabe nichts weggelassen habe .
    Vielen Dank für eine Antwort !

    1. Post
      Author

      Hallo Norbert,

      es hatten schon einige Leser ein Problem mit der Action Bar und dem Options Menu. Woran es liegt weiß ich momentan leider noch nicht. Manchmal wurden die Menüeinträge des Options Menu angezeigt, wenn der (Hardware) Menü-Button auf dem Android Gerät gedrückt wird. Also nicht der Back-Button, sondern der Button links neben dem Home-Button.

      Wenn Du möchtest, kann ich mir Deinen Quellcode mal in Android Studio ansehen und testen, ob bei mir das Menü angezeigt wird. Dazu würde ich die Projektdateien als ZIP per E-Mail benötigen.

      Ich habe außerdem bei StackOverflow einige Tipps finden können. Dort wird empfohlen das App-Theme zu ändern. Siehe folgender Link:

      action bar does not show

      Viele Grüße, Chris

    2. Hallo Chris, die Änderung des Themes bewirkt die Beendigung der App auf meinem Gerät !
      Grüße ! Norbert

    3. Post
      Author

      Hallo Norbert,

      Ohh. Das hört sich nicht gut an. Das ist ein grundsätzliches Problem bei der Android Programmierung, dass die App zu so vielen verschiedenen Geräten kompatibel sein sollte und man sie nur auf einigen wenigen testen kann.

      Viele Grüße, Chris

  10. Hallo

    Ersteinmal vielen Dank für diese tolle Tutorial!
    Jetzt aber zu meiner Frage: Ich bekomme die Meldungen im Terminal angezeigt, aber nicht im DDMS. Das DDMS zeigt sie aber weder bei einem angeschlossenen Gerät, noch bei den Emulatoren an. Wie geschrieben, im Terminal tauchen Sie aber auf …

    Viele Grüße
    Asta

    1. Post
      Author

      Hallo Asta,

      schwierig zu sagen, woran es liegt. Ich hatte dieses Problem bisher noch nicht auf meinen Entwicklungssystemen. Vielleicht hatten andere Leser bereits ähnliche Probleme und können Tipps geben?

      Viele Grüße, Chris

  11. Hi

    also bei mir hat das ADO gut funktioniert der DDMS aber gar nicht.
    ich bekomme beim Klick auf „Tools -> Android -> Android Device Monitor“ immer die Meldung
    An error has occurred. See the log file.
    Und im Log steht halt das:

    java.io.IOException: The folder "C:\Users\User%20Name\.android\monitor-workspace\.metadata" is read-only.
    	at org.eclipse.core.runtime.internal.adaptor.BasicLocation.lock(BasicLocation.java:206)
    

    Nun hab ich in dem besagten Ordner nachgesehen und er hatte recht der Ordner .android war schreibgeschützt. Hab ich also den Schreibschutz entfernt. Hat aber nichts geändert…
    Dann ist mir aufgefallen: ordner monitor-workspace gibt es bei mir gar nicht.
    hab ich ihn per hand erzeugt .. immer noch selbe meldung.
    .metadata konnte ich nicht erzeugen das lässt windows nicht zu ..
    wie komme ich hier weiter?

    mfg Kala

    1. Post
      Author
  12. Wirklich ein sehr gutes Tutorial und ich hoffe mir wird in den folgenden Lektionen noch alles klar .
    Noch ein kleiner Hinweis : bei mir wurde nach der umbenennung automatisch die import bezeichnung geändert daher bitte mal mit neuer version wiederholen.und wenn es alternative möglichkeiten gibt diese auch direkt mit angeben denn mit dem terminal das ist ja eh (für mich unnötig) und mit dem Device Monitor geht es auch viel einfacher

    1. Post
      Author
  13. Hallo

    Erstmal, danke für dieses Tutorial.
    Ich habe folgendes Problem:
    Bei Schritt 5.1 werden bei meinem Terminal nicht 5 sondern 20 Log-Meldungen.
    Ich hoffe ihr könnt mir hierbei helfen!

    MfG,
    Leonhard

    1. Ich habe das Problem gefunden: ich hatte mehrere Projekte offen dadurch wurden mehr log-Meldungen in der Kommandozeile angezeigt, allerdings tritt beim DDMS das gleiche Problem ein, wenn ich pid:12345 eingebe zeigt es mir mehr an als erwünscht. Wenn ich tag:AktienlisteFragment werden mir 5 angezeigt. Diesmal habe ich nur dieses eine Projekt offen.

  14. Servus Chris!

    Wirklich tolles Tutorial hast du erstellt. Man sieht, dass ziemlich viel Arbeit drin steckt und erst bereitet wirklich viel Freude.

    Meine Nachfrage zur DDMS: Auf Mac OS X muss ich dazu eine ältere Flash Version (6.0) installieren. Gibt es eine entsprechende „neue Version“ der DDMS, die mit dem neuem Flash auskommt? Die Maske finde ich grundsätzlich besser als LogCat. Und da dieses Tutorial doch auf einer älteren Version von Android Studio beruht, hat sich vielleicht etwas neues ergeben?

    Merci für die Antwort und nochmals besten Dank für das Tutorial!

    Beste Grüße,
    Sebastian

  15. Hallo,

    vielen Dank für Ihre Hilfe. Für Anfänger ist das sehr hilfreich.
    Ich habe ein Problem, und zwar unter „Tool“ gibt es keinen „Android“ Eintrag und DDMS kann ich nirgendwo finden.
    Ich habe die Version 3.1.1. Ich habe im Internet recherchiert aber nichts gefunden.
    In der SDK Manager sieht so aus, wie hier in der Lektion 1.
    Vielen Dank im Voraus.

    Viele Grüße
    Ion

    1. Post
      Author

      Hallo Ion,

      danke für dein Lob!

      Die Benutzeroberfläche von Android Studio hat sich seit dem Erstellen dieses Tutorials teilweise verändert. Das Android-Tool wird nun als Logcat Tool Window in Android Studio geführt. Und DDMS wird nicht mehr weitergepflegt. Ich werde dieses Tutorial demnächst aktualisieren und die Screenshots an die neue GUI von Android Studio anpassen.

      Viele Grüße, Chris

  16. Hallo Chris,
    auch erstmal danke für die ausführliche Anleitung. Ich habe auch ein Problem mit den log Dateien. Mit meinem alten Huawei (Android 4.4.2) habe ich mir im Terminal (Mac) diese verbose, debug.. Meldungen ausspucken lassen können, nachdem ich auf dem Handy *#*#2846579#*#* gewählt habe und log auf on gestellt habe.

    Aber auf meinem LG (Android 7) spuckt mir das Terminal nichts aus. Ein Fehler im Logcat Fenster von Android Studio ist:
    Neither user 10223 nor current process has android.permission.READ_PHONE_STATE.

    Ich habe gelesen, dass seit Android 6.0 gewisse permissions gebraucht werden.
    Also habe ich in mein Manifest mal

    hinzugefügt, aber das reicht anscheinend nicht.
    Ich habe noch viel rumgesucht und auch Code probiert, aber leider ohne Erfolg, da ich auch noch nicht sehr tief in der Thematik stecke. Kannst du mir da weiterhelfen, oder das Tutorial um diese permissions erweitern, da das ja wahrscheinlich alle betrifft, die mit Android 6.0 oder höher arbeiten?

    Vielen Dank,
    Max

    1. Post
      Author

      Hallo Max,

      die Log-Meldungen sollten auch ohne Permissions ausgegeben werden. Sie werden ja über die Android Debug Bridge empfangen. Jedoch scheint es bei manchen Smartphones und Tablets zu Problemen mit den Log-Meldungen zu kommen. Ich selbst hatte diese Art von Problemen auf meinen Testgeräten noch nicht.

      Hast du die App auch einmal auf einem Android Virtual Device im Emulator laufen lassen?

      Viele Grüße, Chris

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.