Free Press

Android Studio bietet einen Debugger, mit dem Sie unter anderem Folgendes tun können:

• Wählen Sie ein Gerät zum Debuggen Ihrer App aus.
• Setzen Sie Haltepunkte in Ihrem Java-, Kotlin- und C/C++-Code.
• Untersuchen Sie Variablen und werten Sie Ausdrücke zur Laufzeit aus.

Diese Seite enthält Anweisungen für grundlegende Debugger-Operationen. Weitere Dokumentation finden Sie auch in den IntelliJ IDEA Debugging-Dokumenten.

Debugging aktivieren

Bevor Sie mit dem Debugging beginnen können, müssen Sie folgende Vorbereitungen treffen:

• Debugging auf Ihrem Gerät aktivieren:

  Wenn Sie den Emulator verwenden, ist dies standardmäßig aktiviert. Aber für ein angeschlossenes Gerät müssen Sie das Debugging in den Entwickleroptionen des Geräts aktivieren.

• Führen Sie eine debuggfähige Build-Variante aus:

  Sie müssen eine Build-Variante verwenden, die debuggable true in der Build-Konfiguration enthält. Normalerweise können Sie einfach die Standard-„Debug“-Variante auswählen, die in jedem Android Studio-Projekt enthalten ist (auch wenn sie in der build.gradle-Datei nicht sichtbar ist). Wenn Sie jedoch neue Build-Typen definieren, die debuggable sein sollen, müssen Sie `debuggable true` zum Build-Typ hinzufügen:

  android { buildTypes { customDebugType { debuggable true ... } }}

  Diese Eigenschaft gilt auch für Module mit C/C++-Code. (Die Eigenschaft jniDebuggable wird nicht mehr verwendet.)

  Wenn Ihre Anwendung von einem Bibliotheksmodul abhängt, das Sie auch debuggen wollen, muss diese Bibliothek auch mit debuggable true gepackt werden, damit sie ihre Debugsymbole behält.Um sicherzustellen, dass die debuggable Varianten Ihres Anwendungsprojekts die debuggable Variante eines Bibliotheksmoduls erhalten, stellen Sie sicher, dass Sie nicht standardmäßige Versionen Ihrer Bibliothek veröffentlichen.

Starten Sie eine Debugging-Sitzung

Sie können eine Debugging-Sitzung wie folgt starten:

1. Setzen Sie einige Haltepunkte im App-Code.
2. Wählen Sie in der Symbolleiste aus dem Dropdown-Menü „Zielgerät“ ein Gerät aus, auf dem Sie Ihre App debuggen möchten.

   

   Wenn Sie keine Geräte konfiguriert haben, müssen Sie entweder ein Gerät über USB anschließen oder eine AVD erstellen, um den Android-Emulator zu verwenden.

3. Klicken Sie in der Symbolleiste auf Debuggen .

   Wenn Sie ein Dialogfeld sehen, in dem Sie gefragt werden, ob Sie von „Ausführen“ zu „Debuggen“ wechseln möchten, bedeutet dies, dass Ihre App bereits auf dem Gerät ausgeführt wird und es neu gestartet wird, um mit dem Debuggen zu beginnen. Wenn Sie lieber die gleiche Instanz der App laufen lassen möchten, klicken Sie auf Debug abbrechen und fügen Sie stattdessen den Debugger an eine laufende App an.

   Andernfalls erstellt Android Studio eine APK, signiert sie mit einem Debug-Schlüssel, installiert sie auf dem ausgewählten Gerät und führt sie aus. Wenn Sie C- und C++-Code zu Ihrem Projekt hinzufügen, führt Android Studio auch den LLDB-Debugger im Debug-Fenster aus, um Ihren nativen Code zu debuggen.

4. Wenn das Debug-Fenster nicht geöffnet ist, wählen Sie Ansicht > Werkzeugfenster > Debug (oder klicken Sie auf Debug in der Werkzeugfensterleiste) und klicken Sie dann auf die Registerkarte Debugger, wie in Abbildung 1 dargestellt.

   Abbildung 1. Das Debugger-Fenster, das den aktuellen Thread und den Objektbaum für eine Variable anzeigt

Hängen Sie den Debugger an eine laufende App an

Wenn Ihre App bereits auf Ihrem Gerät läuft, können Sie das Debugging wie folgt starten, ohne Ihre App neu zu starten:

1. Klicken Sie auf Debugger an Android-Prozess anhängen .
2. Wählen Sie im Dialogfeld Prozess auswählen den Prozess aus, an den Sie den Debugger anhängen möchten.

   Wenn Sie einen Emulator oder ein gerootetes Gerät verwenden, können Sie Alle Prozesse anzeigen aktivieren, um alle Prozesse zu sehen.

   Aus dem Dropdown-Menü Android-Debugger-Einstellungen verwenden von können Sie eine vorhandene Start-/Debug-Konfiguration auswählen. (Für C- und C++-Code können Sie so die LLDB-Startbefehle, LLDB-Nachbearbeitungsbefehle und Symbolverzeichnisse in einer vorhandenen Konfiguration wiederverwenden). Wenn Sie keine bestehende Run/Debug-Konfiguration haben, wählen Sie Neu erstellen. Diese Auswahl aktiviert das Dropdown-Menü Debug-Typ, in dem Sie einen anderen Debug-Typ auswählen können. Standardmäßig verwendet Android Studio den Debug-Typ Auto, um die beste Debugger-Option für Sie auszuwählen, je nachdem, ob Ihr Projekt Java- oder C/C++-Code enthält.

3. Klicken Sie auf OK.

   Das Debug-Fenster wird angezeigt.

Hinweis: Der Android Studio Debugger und der Garbage Collector sind lose integriert. Die virtuelle Android-Maschine garantiert, dass jedes Objekt, das dem Debugger bekannt ist, erst nach dem Trennen des Debuggers in den Garbage Collector aufgenommen wird. Dies kann dazu führen, dass sich im Laufe der Zeit Objekte ansammeln, während der Debugger verbunden ist. Wenn der Debugger zum Beispiel einen laufenden Thread sieht, wird das zugehörige Thread Objekt erst nach dem Trennen des Debuggers gelöscht, selbst wenn der Thread beendet wurde.

Ändern Sie den Debugger-Typ

Da zum Debuggen von Java/Kotlin-Code und C/C++-Code unterschiedliche Debugger-Tools erforderlich sind, können Sie imAndroid Studio Debugger auswählen, welcher Debugger-Typ verwendet werden soll. Standardmäßig entscheidet Android Studiodebugger, welcher Debugger verwendet werden soll, basierend auf den Sprachen, die in Ihrem Projekt erkannt werden (mit dem Debugger-TypAuto). Sie können den Debugger jedoch manuell in der Debug-Konfiguration auswählen (klicken Sie auf Ausführen > Konfigurationen bearbeiten) oder in dem Dialog, der angezeigt wird, wenn Sie auf Ausführen > Debugger an AndroidProzess anhängen klicken.

Folgende Debug-Typen sind verfügbar:

Auto Wählen Sie diesen Debug-Typ, wenn Android Studio automatisch die beste Option für den zu debuggenden Code auswählen soll. Wenn Sie beispielsweise C- oder C++-Code in Ihrem Projekt haben, verwendet Android Studio automatisch den Dual-Debug-Typ. Andernfalls verwendet Android Studio den Java-Debug-Typ. Java Wählen Sie diesen Debug-Typ, wenn Sie nur in Java oder Kotlin geschriebenen Code debuggen möchten – der Java-Debugger ignoriert alle Haltepunkte oder Überwachungen, die Sie in Ihrem nativen Code setzen. Nativ (nur bei C/C++-Code verfügbar) Wählen Sie diesen Debug-Typ, wenn Sie nur LLDB zum Debuggen Ihres Codes verwenden möchten. Wenn Sie diesen Debug-Typ verwenden, ist die Java-Debugger-Sitzungsansicht nicht verfügbar. Standardmäßig prüft LLDB nur Ihren nativen Code und ignoriert Haltepunkte in Ihrem Java-Code. Wenn Sie auch Ihren Java-Code debuggen möchten, sollten Sie entweder auf den Debug-Typ Auto oder Dual umschalten.

Natives Debugging funktioniert nur auf Geräten, die die folgenden Anforderungen erfüllen:

• Das Gerät unterstützt run-as.

  Um zu überprüfen, ob das Gerät run-as unterstützt, führen Sie den folgenden Befehl in der ADB-Shell aus, die mit Ihrem Gerät verbunden ist:

  run-as your-package-name pwd

  Ersetzen Sie your-package-name durch den Paketnamen Ihrer App. Wenn das Gerät run-as unterstützt, sollte der Befehl ohne Fehler zurückgegeben werden.

• Das Gerät hat ptrace aktiviert.

  Um zu überprüfen, ob ptrace aktiviert ist, führen Sie den folgenden Befehl auf der ADB-Shell aus, die mit Ihrem Gerät verbunden ist:

  sysctl kernel.yama.ptrace_scope

  Wenn ptrace aktiviert ist, gibt der Befehl den Wert 0 oder einen unknown key Fehler aus. Wenn ptrace nicht aktiviert ist, wird ein anderer Wert als 0 ausgegeben.

Dual (nur bei C/C++-Code verfügbar) Wählen Sie diesen Debug-Typ, wenn Sie zwischen dem Debuggen von Java- und nativem Code wechseln möchten. Android Studio fügt sowohl den Java-Debugger als auch LLDB an Ihren App-Prozess an, einen für den Java-Debugger und einen für LLDB, so dass Sie Haltepunkte sowohl in Ihrem Java- als auch in Ihrem nativen Code überprüfen können, ohne Ihre App neu zu starten oder Ihre Debug-Konfiguration zu ändern.

In Abbildung 2 sehen Sie die beiden Registerkarten rechts neben dem Titel des Debug-Fensters. Da die Anwendung sowohl Java- als auch C++-Code enthält, ist eine Registerkarte für das Debuggen des nativen Codes und die andere für das Debuggen von Java-Code vorgesehen, wie durch -java angegeben.

Abbildung 2. Registerkarte zum Debuggen von nativem Code und Registerkarte zum Debuggen von Java-Code

Hinweis: Wenn Sie nativen Code debuggen, der vom Compiler optimiert wurde, kann die folgende Warnmeldung angezeigt werden: This function was compiled with optimizations enabled. Some debugger features may not be available. Bei der Verwendung von Optimierungsflags, wie z. B. -O-Flags, nimmt der Compiler Änderungen an Ihrem kompilierten Code vor, damit dieser effizienter ausgeführt werden kann. Dies kann dazu führen, dass der Debugger unerwartete oder falsche Informationen meldet, da es für den Debugger schwierig ist, den optimierten kompilierten Code dem ursprünglichen Quellcode zuzuordnen. Aus diesem Grund sollten Sie Compiler-Optimierungen beim Debuggen Ihres nativen Codes deaktivieren.

Verwenden Sie das Systemprotokoll

Das Systemprotokoll zeigt Systemmeldungen an, während Sie Ihre Anwendung debuggen. Diese Meldungen enthalten Informationen von Anwendungen, die auf dem Gerät ausgeführt werden. Wenn Sie das Systemprotokoll zum Debuggen Ihrer Anwendung verwenden möchten, stellen Sie sicher, dass Ihr Code Protokollmeldungen schreibt und den Stacktrace für Ausnahmen ausgibt, während sich Ihre Anwendung in der Entwicklungsphase befindet.

Schreiben Sie Protokollmeldungen in Ihrem Code

Um Protokollmeldungen in Ihren Code zu schreiben, verwenden Sie die Klasse Log. Log-Meldungen helfen Ihnen, den Ausführungsfluss zu verstehen, indem sie die Debug-Ausgaben des Systems sammeln, während Sie mit Ihrer Anwendung interagieren. Protokollnachrichten können Ihnen mitteilen, welcher Teil Ihrer Anwendung fehlgeschlagen ist. Weitere Informationen zur Protokollierung finden Sie unter Schreiben und Anzeigen von Protokollen.

Das folgende Beispiel zeigt, wie Sie Protokollmeldungen hinzufügen können, um festzustellen, ob beim Start Ihrer Aktivität frühere Statusinformationen verfügbar sind:

Während der Entwicklung kann Ihr Code auch Ausnahmen abfangen und den Stack-Trace in das Systemprotokoll schreiben:

Hinweis: Entfernen Sie Debug-Protokollmeldungen und Stack-Trace-Druckaufrufe aus Ihrem Code, wenn Sie bereit sind, Ihre Anwendung zu veröffentlichen. Sie können dies tun, indem Sie ein DEBUGFlag setzen und Debug-Protokollmeldungen in bedingten Anweisungen platzieren.

Systemprotokoll anzeigen

Sie können Debug- und andere Systemmeldungen im Logcat-Fenster anzeigen und filtern. Zum Beispiel können Sie Meldungen sehen, wenn Garbage Collection auftritt, oder Meldungen, die Sie mit der Klasse Log zu Ihrer App hinzufügen.

Um Logcat zu verwenden, starten Sie das Debugging und wählen Sie die Registerkarte Logcat in der unteren Symbolleiste, wie in Abbildung 3 dargestellt.

Abbildung 3. Logcat-Fenster mit Filtereinstellungen

Für eine Beschreibung von Logcat und seinen Filteroptionen siehe Schreiben und Anzeigen von Protokollen mit Logcat.

Arbeiten mit Haltepunkten

Android Studio unterstützt mehrere Arten von Haltepunkten, die verschiedene Debugging-Aktionen auslösen. Der häufigste Typ ist ein Zeilen-Breakpoint, der die Ausführung Ihrer App an einer bestimmten Codezeile anhält. Während der Unterbrechung können Sie Variablen untersuchen, Ausdrücke auswerten und dann die Ausführung zeilenweise fortsetzen, um die Ursachen von Laufzeitfehlern zu ermitteln.

Um einen Zeilenunterbrechungspunkt hinzuzufügen, gehen Sie wie folgt vor:

1. Lokalisieren Sie die Codezeile, in der Sie die Ausführung unterbrechen möchten, und klicken Sie dann entweder auf die linke Leiste entlang der Codezeile oder platzieren Sie den Cursor auf der Zeile und drücken Sie Strg+F8 (auf Mac: Befehl+F8).
2. Wenn Ihre App bereits läuft, müssen Sie sie nicht aktualisieren, um den Haltepunkt hinzuzufügen – klicken Sie einfach auf Debugger an Android-Prozess anhängen . Andernfalls starten Sie das Debugging, indem Sie auf Debuggen klicken.

Abbildung 3. Ein roter Punkt erscheint neben der Zeile, wenn Sie einen Haltepunkt setzen

Wenn Ihre Codeausführung den Haltepunkt erreicht, hält Android Studio die Ausführung Ihrer App an. Sie können dann die Tools auf der Registerkarte „Debugger“ verwenden, um den Status der App zu ermitteln:

• Um den Objektbaum auf eine Variable zu untersuchen, erweitern Sie sie in der Ansicht „Variablen“. Wenn die Ansicht „Variablen“ nicht sichtbar ist, klicken Sie auf Variablenansicht wiederherstellen .

• Um einen Ausdruck am aktuellen Ausführungspunkt auszuwerten, klicken Sie auf Ausdruck auswerten .

• Um zur nächsten Zeile im Code zu gelangen (ohne eine Methode einzugeben), klicken Sie auf Schritt über .

• Um zur ersten Zeile innerhalb eines Methodenaufrufs zu gelangen, klicken Sie auf Step Into .

• Um zur nächsten Zeile außerhalb der aktuellen Methode zu gelangen, klicken Sie auf Step Out .

• Um die Anwendung normal weiterzuführen, klicken Sie auf Resume Program .

Wenn Ihr Projekt nativen Code verwendet, fügt der Debug-Typ Auto standardmäßig sowohl den Java-Debugger als auch LLDB als zwei separate Prozesse an Ihre App an, so dass Sie zwischen der Überprüfung von Java- und C/C++-Breakpoints wechseln können, ohne Ihre App neu zu starten oder die Einstellungen zu ändern.

Hinweis: Damit Android Studio Breakpoints in Ihrem C- oder C++-Code erkennen kann, müssen Sie einen Debug-Typ verwenden, der LLDB unterstützt, z. B. Auto, Native oder Dual. Sie können den von Android Studio verwendeten Debug-Typ ändern, indem Sie Ihre Debug-Konfiguration bearbeiten. Um mehr über die verschiedenen Debug-Typen zu erfahren, lesen Sie den Abschnitt über die Verwendung anderer Debug-Typen.

Wenn Android Studio Ihre App auf dem Zielgerät bereitstellt, wird das Debug-Fenster mit einer Registerkarte oder Debug-Sitzungsansicht für jeden Debugger-Prozess geöffnet, wie in Abbildung 4 dargestellt.

Abbildung 4. Debuggen von nativem Code mit LLDB

1. Android Studio wechselt zur Registerkarte <Ihr Modul>, wenn der LLDB-Debugger auf einen Haltepunkt in Ihrem C/C++-Code trifft. Die Fenster Frames, Variablen und Watches sind ebenfalls verfügbar und funktionieren genauso wie beim Debuggen von Java-Code. Obwohl das Threads-Fenster in der LLDB-Sitzungsansicht nicht verfügbar ist, können Sie über die Dropdown-Liste im Frames-Fenster auf Ihre Anwendungsprozesse zugreifen. Weitere Informationen zu diesen Fenstern finden Sie in den Abschnitten über das Debuggen von Fensterrahmen und das Inspizieren von Variablen.

   Hinweis: Während Sie einen Haltepunkt in Ihrem nativen Code untersuchen, setzt das Android-System die virtuelle Maschine aus, auf der der Java-Bytecode Ihrer App ausgeführt wird. Dies bedeutet, dass Sie nicht in der Lage sind, mit dem Java-Debugger zu interagieren oder Statusinformationen aus Ihrer Java-Debugger-Sitzung abzurufen, während Sie einen Haltepunkt in Ihrem nativen Code untersuchen.

2. Android Studio wechselt zur <Ihr-Modul>-java-Registerkarte, wenn der Java-Debugger auf einen Haltepunkt in Ihrem Java-Code stößt.
3. Während des Debuggens mit LLDB können Sie das LLDB-Terminal in der LLDB-Sitzungsansicht verwenden, um Befehlszeilenoptionen an LLDB zu übergeben. Wenn Sie bestimmte Befehle haben, die LLDB jedes Mal ausführen soll, wenn Sie mit dem Debuggen Ihrer Anwendung beginnen, entweder kurz bevor oder kurz nachdem der Debugger an Ihren Anwendungsprozess angehängt wird, können Sie diese Befehle zu Ihrer Debug-Konfiguration hinzufügen.

Beim Debuggen von C/C++-Code können Sie auch spezielle Arten von Haltepunkten, so genannte Watchpoints, setzen, die Ihren App-Prozess anhalten können, wenn Ihre App mit einem bestimmten Speicherblock interagiert. Um mehr zu erfahren, lesen Sie den Abschnitt über das Hinzufügen von Watchpoints.

Haltepunkte anzeigen und konfigurieren

Um alle Haltepunkte anzuzeigen und Haltepunkteinstellungen zu konfigurieren, klicken Sie auf Haltepunkte anzeigen auf der linken Seite des Debug-Fensters. Das Fenster Haltepunkte wird angezeigt, wie in Abbildung 5 dargestellt.

Abbildung 5. Das Haltepunkte-Fenster listet alle aktuellen Haltepunkte auf und enthält Verhaltenseinstellungen für jeden

Im Haltepunkte-Fenster können Sie jeden Haltepunkt in der Liste auf der linken Seite aktivieren oder deaktivieren. Wenn ein Haltepunkt deaktiviert ist, hält Android Studio Ihre App nicht an, wenn sie auf diesen Haltepunkt trifft. Wählen Sie einen Haltepunkt aus der Liste aus, um seine Einstellungen zu konfigurieren. Sie können einen Haltepunkt so konfigurieren, dass er zunächst deaktiviert ist und das System ihn aktiviert, nachdem ein anderer Haltepunkt erreicht wurde. Sie können auch konfigurieren, ob ein Haltepunkt deaktiviert werden soll, nachdem er getroffen wurde. Um einen Haltepunkt für eine beliebige Ausnahme zu setzen, wählen Sie Ausnahme-Haltepunkte in der Liste der Haltepunkte.

Frames des Debug-Fensters

Im Debugger-Fenster können Sie im Bereich Frames den Stack-Frame untersuchen, der den aktuellen Haltepunkt ausgelöst hat. Auf diese Weise können Sie durch den Stack-Frame navigieren und ihn untersuchen und auch die Liste der Threads in Ihrer Android-App einsehen. Um einen Thread auszuwählen, verwenden Sie das Dropdown-Menü für die Thread-Auswahl und zeigen Sie dessen Stack-Frame an. Wenn Sie auf die Elemente im Rahmen klicken, wird die Quelle im Editor geöffnet. Sie können auch die Thread-Darstellung anpassen und den Stack-Frame exportieren, wie im Handbuch Fensterrahmen beschrieben.

Variablen untersuchen

Im Debugger-Fenster können Sie im Bereich Variablen Variablen untersuchen, wenn das System Ihre App an einem Haltepunkt anhält und Sie einen Frame aus dem Bereich Frames auswählen. Im Bereich Variablen können Sie auch Ad-hoc-Ausdrücke mit statischen Methoden und/oder Variablen auswerten, die im ausgewählten Frame verfügbar sind.

Der Bereich Überwachen bietet eine ähnliche Funktionalität, mit dem Unterschied, dass Ausdrücke, die dem Bereich Überwachen hinzugefügt werden, zwischen Debugging-Sitzungen bestehen bleiben. Sie sollten Watches für Variablen und Felder hinzufügen, auf die Sie häufig zugreifen oder die einen Status bereitstellen, der für die aktuelle Debugging-Sitzung hilfreich ist. Die Bereiche „Variablen“ und „Überwachen“ werden wie in Abbildung 5 dargestellt angezeigt.

Um eine Variable oder einen Ausdruck zur Liste „Überwachen“ hinzuzufügen, führen Sie die folgenden Schritte aus:

1. Beginnen Sie mit dem Debuggen.
2. Klicken Sie im Bereich „Überwachen“ auf „Hinzufügen“ .
3. Geben Sie in das angezeigte Textfeld den Namen der Variablen oder des Ausdrucks ein, den Sie überwachen möchten, und drücken Sie die Eingabetaste.

Um ein Element aus der Liste Überwachen zu entfernen, wählen Sie das Element aus und klicken Sie auf Entfernen .

Sie können die Elemente in der Liste Überwachen neu anordnen, indem Sie ein Element auswählen und dann auf Nach oben oder Nach unten .

Abbildung 6. Die Bereiche „Variablen“ und „Überwachen“ im Debugger-Fenster

Watchpoints hinzufügen

Beim Debuggen von C/C++-Code können Sie spezielle Arten von Haltepunkten, so genannte Watchpoints, setzen, die den Prozess Ihrer Anwendung anhalten können, wenn Ihre Anwendung mit einem bestimmten Speicherblock interagiert. Wenn Sie beispielsweise zwei Zeiger auf einen Speicherblock setzen und diesem einen Watchpoint zuweisen, wird der Watchpoint ausgelöst, wenn Sie mit einem der beiden Zeiger auf diesen Speicherblock zugreifen.

In Android Studio können Sie einen Watchpoint während der Laufzeit erstellen, indem Sie eine bestimmte Variable auswählen, aber LLDB weist den Watchpoint nur dem Speicherblock zu, den das System dieser Variablen zuweist, nicht der Variablen selbst. Dies unterscheidet sich vom Hinzufügen einer Variablen zum Watches-Fenster, das es Ihnen ermöglicht, den Wert einer Variablen zu beobachten, aber es erlaubt Ihnen nicht, Ihren App-Prozess anzuhalten, wenn das System den Wert im Speicher liest oder ändert.

Hinweis: Wenn Ihr App-Prozess eine Funktion beendet und das System die Zuweisung seiner lokalen Variablen aus dem Speicher aufhebt, müssen Sie alle Watchpoints, die Sie für diese Variablen erstellt haben, neu zuweisen.

Um einen Watchpoint zu setzen, müssen Sie die folgenden Voraussetzungen erfüllen:

• Ihr physisches Zielgerät oder Emulator verwendet eine x86- oder x86_64-CPU. Wenn Ihr Gerät eine ARM-CPU verwendet, müssen Sie die Begrenzung der Adresse Ihrer Variablen im Speicher entweder auf 4 Byte für 32-Bit-Prozessoren oder auf 8 Byte für 64-Bit-Prozessoren ausrichten. Sie können eine Variable in Ihrem nativen Code ausrichten, indem Sie __attribute__((aligned(num_bytes))) in der Variablenverzögerung angeben, wie unten gezeigt:

  // For a 64-bit ARM processorint my_counter __attribute__((aligned(8)));

• Sie haben bereits drei oder weniger Watchpoints zugewiesen. Android Studio unterstützt nur bis zu vier Watchpoints auf x86- oder x86_64-Zielgeräten. Andere Geräte unterstützen möglicherweise weniger Watchpoints.

Hinweis: Wenn Sie Ihre Anwendung mit 32-Bit-ARM-ABIs debuggen, kann das Hinzufügen eines Watchpoints oder das Überfahren von Variablen innerhalb des Codes, um deren Werte zu untersuchen, einen Absturz verursachen. Als Workaround sollten Sie 64-Bit-ARM-, x86- oder x86_64-Binärdateien zum Debuggen verwenden. Dieses Problem wird in einer der nächsten Android Studio-Versionen behoben.

Wenn Sie die oben genannten Anforderungen erfüllen, können Sie einen Watchpoint wie folgt hinzufügen:

1. Während Ihre App an einem Haltepunkt angehalten wird, navigieren Sie in der LLDB-Sitzungsansicht zum Bereich „Variablen“.

2. Klicken Sie mit der rechten Maustaste auf eine Variable, die den Speicherblock belegt, den Sie verfolgen möchten, und wählen Sie Watchpoint hinzufügen. Es erscheint ein Dialogfeld zur Konfiguration des Watchpoints, wie in Abbildung 7 dargestellt.

   

   Abbildung 7. Hinzufügen eines Watchpoints zu einer Variable im Speicher

3. Konfigurieren Sie Ihren Watchpoint mit den folgenden Optionen:
   • Aktiviert: Sie können diese Option abwählen, wenn Sie Android Studio anweisen möchten, den Watchpoint vorerst zu ignorieren. Android Studio speichert den Watchpoint trotzdem, damit Sie später in Ihrer Debug-Sitzung darauf zugreifen können.
   • Anhalten: Standardmäßig hält das Android-System Ihren App-Prozess an, wenn er auf einen Speicherblock zugreift, den Sie einem Watchpoint zuweisen. Sie können diese Option deaktivieren, wenn Sie dieses Verhalten nicht wünschen. Dadurch werden zusätzliche Optionen angezeigt, mit denen Sie das Verhalten bei der Interaktion des Systems mit Ihrem Watchpoint anpassen können: Log message to console und Remove when hit.
   • Zugriffstyp: Wählen Sie aus, ob Ihre Anwendung Ihren Watchpoint auslösen soll, wenn sie versucht, den Speicherblock zu lesen oder zu schreiben, den das System der Variablen zuweist. Um Ihren Watchpoint entweder beim Lesen oder beim Schreiben auszulösen, wählen Sie Any.
4. Klicken Sie auf Fertig.

Um alle Ihre Watchpoints anzuzeigen und Watchpoint-Einstellungen zu konfigurieren, klicken Sie auf Breakpoints anzeigen auf der linken Seite des Debug-Fensters. Das Dialogfeld Breakpoints wird angezeigt, wie in Abbildung 8 dargestellt.

Abbildung 8. Der Breakpoints-Dialog listet Ihre aktuellen Watchpoints auf und enthält Einstellungen zum Verhalten für jeden

Nachdem Sie Ihren Watchpoint hinzugefügt haben, klicken Sie auf Resume Program auf der linken Seite des Debug-Fensters, um den Prozess Ihrer App fortzusetzen. Wenn Ihre App versucht, auf einen Speicherblock zuzugreifen, für den Sie einen Watchpoint gesetzt haben, unterbricht das Android-System standardmäßig Ihren App-Prozess und ein Watchpoint-Symbol erscheint neben der Codezeile, die Ihre App zuletzt ausgeführt hat, wie in Abbildung 9 dargestellt.

Abbildung 9. Android Studio zeigt die Codezeile an, die Ihre App kurz vor dem Auslösen eines Watchpoints ausführt

Anzeigen und Ändern des Anzeigeformats von Ressourcenwerten

Im Debug-Modus können Sie Ressourcenwerte anzeigen und ein anderes Anzeigeformat für Variablen in Ihrem Java-Code auswählen. Wenn die Registerkarte „Variablen“ angezeigt wird und ein Rahmen ausgewählt ist, gehen Sie wie folgt vor:

1. Klicken Sie in der Liste „Variablen“ mit der rechten Maustaste auf eine Ressourcenzeile, um die Dropdown-Liste anzuzeigen.
2. Wählen Sie in der Dropdown-Liste „Anzeigen als“ und wählen Sie das gewünschte Format aus.

   Die verfügbaren Formate hängen vom Datentyp der ausgewählten Ressource ab. Sie können eine oder mehrere der folgenden Optionen sehen:

   • Klasse: Zeigt die Klassendefinition an.
   • toString: String-Format anzeigen.
   • Objekt: Zeigt die Objektdefinition (eine Instanz einer Klasse) an.
   • Array: Anzeige in einem Array-Format.
   • Zeitstempel: Datum und Uhrzeit wie folgt anzeigen: yyyy-mm-dd hh:mm:ss.
   • Auto: Android Studio wählt das beste Format basierend auf dem Datentyp.
   • Binär: Zeigt einen binären Wert mit Nullen und Einsen an.
   • MeasureSpec: Der Wert, der vom Elternteil an das ausgewählte Kind übergeben wird. Siehe MeasureSpec.
   • Hex: Anzeige als Hexadezimalwert.
   • Primitiv: Anzeige als numerischer Wert unter Verwendung eines primitiven Datentyps.
   • Integer: Anzeige eines numerischen Wertes vom Typ Integer.

Sie können ein benutzerdefiniertes Format (Datentyp-Renderer) erstellen, wie folgt: