Android Studio bietet einen Debugger, mit dem Sie unter anderem Folgendes tun können:
- Wähle ein Gerät aus, auf dem du deine App debuggen möchtest.
- Setzen Sie Haltepunkte in Ihrem Java-, Kotlin- und C/C++-Code.
- Variablen prüfen und Ausdrücke zur Laufzeit auswerten
Auf dieser Seite finden Sie eine Anleitung für grundlegende Debugger-Vorgänge. Weitere Informationen finden Sie in der IntelliJ IDEA-Dokumentation zum Debuggen.
Debug aktivieren
Bevor Sie mit der Fehlerbehebung beginnen können, müssen Sie Folgendes tun:
- Aktiviere die Fehlerbehebung auf deinem Gerät.
- Wenn Sie den Emulator verwenden, ist die Fehlerbehebung standardmäßig aktiviert. Bei einem verbundenen Gerät Sie müssen das Debugging im Gerätehersteller aktivieren. Optionen.
- Führen Sie eine debugfähige Buildvariante aus.
Verwenden Sie eine Buildvariante, die
debuggable true
(isDebuggable = true
in Kotlin-Scripts) in der Build-Konfiguration enthält.Normalerweise können Sie die Standardeinstellung die in allen Android Studio- Projekt, auch wenn es in der Datei
build.gradle
nicht sichtbar ist. Wenn Sie jedoch neue Buildtypen definieren, die debugfähig sein sollen, müssen Sie dem Buildtypdebuggable true
hinzufügen:- Haltepunkte im Code Ihrer App festlegen
- Wählen Sie in der Symbolleiste im Menü „Zielgerät“ ein Gerät aus, auf dem Sie Ihre App debuggen möchten.
Abbildung 1: Menü „Zielgerät“. Wenn Sie keine Geräte konfiguriert haben, müssen Sie entweder Gerät über USB verbinden, Gerät über WLAN verbinden oder erstellen Sie ein AVD, um das Android-Emulator.
- Klicken Sie in der Symbolleiste auf Fehler beheben
.
Wenn Ihre App bereits auf dem Gerät ausgeführt wird, werden Sie in einem Dialogfeld gefragt, ob Sie von „Run“ zu „Debug“ wechseln. Das Gerät muss neu gestartet werden, um mit der Fehlerbehebung zu beginnen. Wenn Sie dieselbe Instanz der App weiterhin ausführen möchten, klicken Sie auf Debugging abbrechen und verknüpfen Sie den Debugger stattdessen mit einer laufenden App. Andernfalls erstellt Android Studio ein APK, signiert es mit einem Debug-Schlüssel, installiert es auf dem ausgewählten Gerät und führt es aus.
Wenn Sie fügen Sie Ihrem Projekt C- und C++-Code hinzu, Android Studio führt außerdem den LLDB-Debugger in der Fehlerbehebung um Ihren nativen Code zu debuggen.
- Wenn das Debugfenster nicht geöffnet ist, wählen Sie Ansicht > Toolfenster > Debug aus oder klicken Sie in der Toolfensterleiste auf Debug
.
- Klicken Sie auf Debugger an Android-Prozess anhängen
.
- Wählen Sie im Dialogfeld Prozess auswählen den Prozess aus, dem Sie den Debugger zuordnen möchten.
- Wenn Sie einen Emulator oder ein gerootetes Gerät verwenden, Alle Prozesse anzeigen, um alle Prozesse zu sehen. Auf einem gerooteten Gerät werden alle auf dem Gerät laufenden Prozesse angezeigt. Auf einem nicht gerooteten Gerät werden jedoch nur debuggbare Prozesse angezeigt.
- Im Menü Android Debugger-Einstellungen verwenden aus können Sie ein vorhandenes Konfiguration ausführen/Fehler beheben Bei C- und C++-Code können Sie so die LLDB-Startbefehle, LLDB-Befehle nach dem Anhängen und Symbolverzeichnisse in einer vorhandenen Konfiguration wiederverwenden.
- Wenn noch keine Ausführung/Fehlerbehebung vorhanden ist wählen Sie Neu erstellen aus. Durch diese Auswahl wird der Debug Type (Typ der Fehlerbehebung) aktiviert. in dem Sie einen anderen Fehlerbehebungstyp auswählen können. Standardmäßig verwendet Android Studio den Debug-Typ „Automatisch erkennen“, um die beste Debugger-Option für Sie auszuwählen. Dabei wird berücksichtigt, ob Ihr Projekt Java- oder C/C++-Code enthält.
- Klicken Sie auf OK.
Das Fenster „Debug“ wird angezeigt.
- Symbolleiste für Ausführung und Navigation Mit Haltepunkten arbeiten
- Thread-Auswahl
- Bewertungs- und Überwachungsausdruck. Siehe Variablen prüfen.
- Stapelanzeige
- Variablen. Weitere Informationen finden Sie unter Variablen prüfen.
- Automatisch erkennen
- Wählen Sie diesen Fehlerbehebungstyp aus, wenn Android Studio automatisch die beste Option auswählen soll für den Code, den Sie debuggen. Wenn Ihr Projekt beispielsweise C- oder C++-Code enthält, verwendet Android Studio automatisch den Dual-Debugging-Typ. Andernfalls verwendet Android Studio den Debugging-Typ „Nur Java“.
- Nur Java
- Wählen Sie diesen Typ aus, wenn Sie nur Code debuggen möchten, der in Java oder Kotlin geschrieben wurde. Der Java-Debugger ignoriert alle Haltepunkte oder Watches, die Sie in Ihrem nativen Code festgelegt haben.
- Nur nativ (nur mit C/C++ Code verfügbar)
-
Wählen Sie diesen Debug-Typ aus, wenn Sie nur LLDB zur Fehlerbehebung in Ihrem Code verwenden möchten. Bei Verwendung dieses
Debug-Typ verwenden, ist die Sitzungsansicht für den Java-Debugger nicht verfügbar. Standardmäßig
Die LLDB-Funktion prüft nur den nativen Code und ignoriert die Haltepunkte in Java.
Code. Wenn Sie auch Ihren Java-Code debuggen möchten, wechseln Sie entweder
den Debug-Typ „Automatisch erkennen“ oder „Dual“.
Das native Debugging funktioniert nur auf Geräten, die die folgenden Anforderungen erfüllen:
Das Gerät unterstützt
run-as
.Führen Sie den folgenden Befehl aus, um zu prüfen, ob das Gerät
run-as
unterstützt der mit deinem Gerät verbundenen ADB-Shell:run-as
your-package-name pwdErsetzen Sie
your-package-name
durch den Paketnamen Ihrer App. Wenn das Gerätrun-as
unterstützt, sollte der Befehl ohne Fehler zurückgegeben werden.Auf dem Gerät ist
ptrace
aktiviert.Führen Sie den folgenden Befehl in der ADB-Shell aus, die mit Ihrem Gerät verbunden ist, um zu prüfen, ob
ptrace
aktiviert ist:sysctl kernel.yama.ptrace_scope
Wenn
ptrace
aktiviert ist, gibt der Befehl den Wert0
oder einen einunknown key
-Fehler. Istptrace
nicht aktiviert, wird eine einen anderen Wert als0
.
- Dual (Java + Native) – nur mit C/C++-Code verfügbar
-
Wählen Sie diesen Debug-Typ aus, wenn Sie zwischen der Fehlerbehebung für Java und nativen Code wechseln möchten.
Android Studio fügt Ihrer App sowohl den Java-Debugger als auch LLDB hinzu
damit Sie prüfen können,
Haltepunkte in Java und nativem Code fest, ohne die App neu starten zu müssen.
oder die Fehlerbehebungskonfiguration ändern.
In Abbildung 2 sehen Sie die beiden Tabs rechts neben dem Titel des Debug-Fensters. Da die App sowohl Java- als auch C++ Code enthält, dient ein Tab für die Fehlerbehebung des nativen und die andere zum Debuggen von Java-Code, wie durch -java angegeben.
Abbildung 3: Tab zum Debuggen von nativem Code und Tab zum Debuggen von Java-Code - Zeilenhaltepunkt
- Der häufigste Typ ist ein Haltepunkt, mit dem die Ausführung der App an einem bestimmten Codezeile. Während der Ausführungspause können Sie Variablen prüfen, Ausdrücke auswerten und die Ausführung dann zeilenweise fortsetzen, um die Ursachen von Laufzeitfehlern zu ermitteln.
- Methoden-Haltepunkt
- Mit einem Methoden-Bruchpunkt wird die Ausführung Ihrer App angehalten, wenn eine bestimmte Methode aufgerufen oder verlassen wird. Während der Pausierung können Sie Variablen überprüfen, Ausdrücke auswerten und dann fortfahren. Zeile für Zeile ausführen, um die Ursachen von Laufzeitfehlern zu ermitteln. Wenn Sie einen Haltepunkt für eine zusammensetzbare Funktion setzen, listet der Debugger die Parameter der zusammensetzbaren Funktion und ihren Status auf, um zu ermitteln, welche Änderungen die Neuzusammensetzung verursacht haben könnten.
- Haltepunkt für Feld
- Ein Feldhaltepunkt pausiert die Ausführung Ihrer App, wenn sie Daten aus einem ein bestimmtes Feld hinzu.
- Ausnahme-Haltepunkt
- Ein Ausnahmehaltepunkt pausiert die Ausführung deiner App, wenn eine Ausnahme ausgelöst wird.
- Suchen Sie die Codezeile, in der Sie die Ausführung anhalten möchten.
- Klicken Sie auf den linken Rand dieser Codezeile oder setzen Sie den Cursor in die Zeile und drücken Sie Strg + F8 (unter macOS Befehlstaste + F8).
- Wenn Ihre App bereits ausgeführt wird, klicken Sie auf Debugger an Android-Prozess anhängen.
Klicken Sie andernfalls auf Fehler beheben, um mit der Fehlerbehebung zu beginnen.
-
Wenn Sie den Objektbaum für eine Variable untersuchen möchten, maximieren Sie sie in der Ansicht „Variablen“. Wenn ist die Variablenansicht nicht sichtbar, klicken Sie auf Layouteinstellungen.
und achten Sie darauf, dass variables aktiviert ist.
-
Wenn Sie zur nächsten Zeile im Code springen möchten, ohne eine Methode einzugeben, klicken Sie auf Überspringen
.
-
Wenn Sie zur ersten Zeile in einem Methodenaufruf springen möchten, klicken Sie auf Einblenden
.
-
Wenn Sie zur nächsten Zeile außerhalb der aktuellen Methode wechseln möchten, klicken Sie auf Aus Schritt
.
-
Wenn du die App weiter wie gewohnt ausführen möchtest, klicke auf Programm fortsetzen.
- Android Studio wechselt zum Tab <your-module>, wenn der LLDB-Debugger einen Haltepunkt in Ihrem C/C++-Code findet. Die Bereiche „Frames“, „Variablen“ und „Wertelisten“ sind ebenfalls verfügbar und funktionieren genau wie beim Debuggen von Java-Code.
Obwohl der Bereich „Threads“ nicht verfügbar ist in der LLDB-Sitzungsansicht können Sie über die im Bereich „Frames“ ein. Weitere Informationen zu diesen Bereichen finden Sie in den Abschnitten zum Debuggen von Fensterframes und zum Prüfen von Variablen.
Hinweis: Beim Prüfen eines Haltepunkts in Ihrem nativen Code pausiert das Android-System die virtuelle Maschine, auf der der Java-Bytecode Ihrer App ausgeführt wird. Das bedeutet, dass Sie nicht mit der Java- Debugger abzurufen oder Statusinformationen aus dem Java-Debugger abzurufen. während Sie einen Haltepunkt in Ihrem nativen Code untersuchen.
- Android Studio wechselt zum Tab <your-module>-java, wenn der Java-Debugger einen Haltepunkt in Ihrem Java- oder Kotlin-Code findet.
- Beim Debugging mit LLDB können Sie das LLDB-Terminal in der Ansicht der LLDB-Sitzung zur Weitergabe von Befehlszeilenoptionen an LLDB Wenn Sie bestimmte Befehle, die LLDB bei jedem Start der Fehlerbehebung ausführen soll direkt vor oder direkt nach dem Einfügen des Debuggers an Ihre App-Prozess haben, können Sie der Fehlerbehebungskonfiguration diese Befehle hinzufügen.
- Zu beobachtenden oder anzuzeigenden Ausdruck eingeben
- Klicken Sie auf Zu Smartwatches hinzufügen oder drücken Sie die Eingabetaste, um den Ausdruck einmal auszuwerten.
- Ihr physisches Zielgerät oder Emulator verwendet eine x86- oder x86_64-CPU. Wenn
oder Ihr Gerät eine ARM-CPU verwendet, müssen Sie die Begrenzung des
Adresse der Variablen im Speicher entweder auf 4 Byte, bei 32-Bit-Prozessoren, oder auf 8
Byte für 64-Bit-Prozessoren. Wenn Sie eine Variable in Ihrem nativen Code ausrichten möchten, geben Sie
__attribute__((aligned(num_bytes)))
in der Variablendeklaration an, wie unten gezeigt:// For a 64-bit ARM processor int my_counter __attribute__((aligned(8)));
- Du hast bereits drei oder weniger Wiedergabepunkte 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 Wiedergabepunkte.
- Öffnen Sie, während Ihre App an einem Haltepunkt gesperrt ist, den Variablenbereich in der LLDB-Sitzungsansicht
-
Klicken Sie mit der rechten Maustaste auf eine Variable, die den Speicherblock belegt, den Sie überwachen möchten, und wählen Sie Wachpunkt hinzufügen aus.
Abbildung 9: Fügen Sie einer Variablen im Arbeitsspeicher einen Watchpoint hinzu. Ein Dialogfeld zum Konfigurieren des Watchpoint wird angezeigt (siehe Abbildung 9).
Konfigurieren Sie den Watchpoint mit den folgenden Optionen:
- Aktiviert:Deaktivieren Sie diese Option, wenn Sie Android Studio ignoriert den Watchpoint, bis Sie die Einstellung ändern. Android Studio speichert den Watchpoint, damit Sie später darauf zugreifen können.
- Sperren:Ihre App wird standardmäßig vom Android-System angehalten. wenn er auf einen Speicherblock zugreift, den Sie einem Watchpoint zuweisen. Deaktivieren Sie diese Option, wenn Sie das nicht möchten. Dieses werden zusätzliche Optionen angezeigt, mit denen Sie das Verhalten anpassen können, wenn das System interagiert mit Ihrem Watchpoint: Nachricht an Konsole protokollieren und Nach Treffer entfernen.
- Zugriffstyp: Wählen Sie aus, ob Ihre App den Watchpoint auslösen soll, wenn versucht wird, zu lesen oder zu schreiben in den Speicherblock, den das System der Variablen zuweist. Wenn der Watchpoint bei einem Lese- oder Schreibvorgang ausgelöst werden soll, wählen Sie Beliebig aus.
- Klicken Sie auf Fertig.
- Klicken Sie in der Variablenliste mit der rechten Maustaste auf eine beliebige Stelle in einer Ressourcenzeile, um sie anzuzeigen. auf der Liste.
- Wählen Sie in der Liste Anzeigen als und dann das gewünschte Format aus.
Die verfügbaren Formate hängen vom Datentyp der ausgewählten Ressource ab. Möglicherweise sehen Sie eine oder mehrere der folgenden Optionen:
- Klasse:Die Klassendefinition wird angezeigt.
- toString:Das Format des Strings wird angezeigt.
- Objekt:Die Definition des Objekts (eine Instanz einer Klasse) anzeigen.
- Array: Die Daten werden in einem Arrayformat angezeigt.
- Zeitstempel:Geben Sie Datum und Uhrzeit wie folgt an: jjjj-mm-tt hh:mm:ss.
- Auto:In Android Studio wird basierend auf dem Datentyp das beste Format ausgewählt.
- Binär: Ein Binärwert wird mit Nullen und Einsen dargestellt.
- MeasureSpec: Der Wert, der vom übergeordneten Element an das ausgewählte untergeordnete Element übergeben wird.
Weitere Informationen finden Sie unter
MeasureSpec
. - Hex:Wird als Hexadezimalwert angezeigt.
- Primitiv:Wird als numerischer Wert mit einem primitiven Datentyp angezeigt.
- Ganzzahl: Wird als numerischer Wert vom Typ
Integer
angezeigt.
- Klicken Sie mit der rechten Maustaste auf den Ressourcenwert.
- Wählen Sie Ansehen als aus.
- Wählen Sie Erstellen aus.
- Das Dialogfeld Java-Datentyp-Renderer wird angezeigt. Folgen Sie der Anleitung unter Java-Datentyp-Renderer.
android { buildTypes { customDebugType { debuggable true ... } } }
android { buildTypes { create("customDebugType") { isDebuggable = true ... } } }
Diese Eigenschaft gilt auch für Module mit C/C++ Code.
Hinweis: Das Attribut jniDebuggable
wird nicht mehr verwendet.
Wenn Ihre App von einem Bibliotheksmodul abhängt, das Sie ebenfalls debuggen möchten, muss diese Bibliothek ebenfalls
mit debuggable true
gepackt, damit die Debugging-Symbole erhalten bleiben.
Damit die Debug-fähigen Varianten Ihres App-Projekts die debug-fähige Variante von
ein Bibliotheksmodul haben, veröffentlichen Sie nicht standardmäßige Versionen Ihrer Bibliothek.
Fehlerbehebung starten
So starten Sie eine Sitzung zur Fehlerbehebung:
Debugger an eine laufende App anhängen
Wenn Ihre App bereits auf Ihrem Gerät ausgeführt wird, können Sie das Debuggen starten, ohne die App neu zu starten. Gehen Sie dazu so vor:
Über den Tab Prozesse im Geräte-Explorer (Ansicht > Toolfenster > Geräte-Explorer)
enthält auch eine Liste
mit Debug-fähigen Prozessen. Dort können Sie einen Prozess auswählen und einen Kill ausführen.
,
Beenden erzwingen
,
oder den Debugger an einen bestimmten Prozess anhängen
Das Debug-Fenster

Das Debug-Fenster ist in
Hinweis: Der Android Studio-Debugger und der Garbage Collector sind nur lose miteinander verbunden. Die virtuelle Android-Maschine
garantiert, dass jedes Objekt
Der Debugger erkennt, wird erst nach dem Debugger automatisch bereinigt.
getrennt wird. Dies kann zur Ansammlung von Objekten führen, während der
Debugger ist verbunden. Wenn der Debugger beispielsweise
einen laufenden Thread erkennt,
die zugehörigen Thread
-Objekt wird erst dann automatisch bereinigt, wenn die Verbindung zum Debugger getrennt wird, selbst wenn der Thread beendet wurde.
Debuggertyp ändern
Da zum Debuggen von Java-/Kotlin-Code und C-/C++-Code unterschiedliche Debugger-Tools erforderlich sind, können Sie im Android Studio-Debugger auswählen, welchen Debugger-Typ Sie verwenden möchten. Standardmäßig wird Android Studio entscheidet anhand der in Ihrem Projekt erkannten Sprachen mithilfe des Debugger-Typ Automatisch erkennen aus.
Wenn Sie den Debugger in der Debug-Konfiguration manuell auswählen möchten, klicken Sie auf Ausführen > Konfigurationen bearbeiten. Sie können den Debugger auch über das Dialogfeld auswählen, das angezeigt wird, wenn Sie Klicken Sie auf Ausführen > Debugger an Android-Prozess anhängen.
Folgende Fehlerbehebungstypen sind verfügbar:
Hinweis: Beim Debuggen von nativem Code, der vom Compiler optimiert wird, wird möglicherweise die folgende Warnung angezeigt:This function was
compiled with optimizations enabled. Some debugger features may not be
available
. Bei der Verwendung von Optimierungs-Flags nimmt der Compiler Änderungen an Ihren
kompilierten Code,
damit er effizienter ausgeführt wird. Dies kann dazu führen, dass der Debugger
unerwartete oder falsche Informationen zu melden,
, um den optimierten kompilierten Code wieder dem ursprünglichen Quellcode zuzuordnen.
Aus diesem Grund sollten Sie beim Debugging die Compiler-Optimierungen deaktivieren.
Ihren nativen Code.
Systemprotokoll verwenden
Im Systemprotokoll werden Systemmeldungen angezeigt, während Sie Fehler in Ihrer App beheben. Zu diesen Nachrichten gehören Informationen aus Apps, die auf dem Gerät ausgeführt werden. Wenn Sie die Methode Systemprotokolls zum Debuggen Ihrer App verwenden, achten Sie darauf, dass Ihr Code Log-Nachrichten schreibt und den Stapel ausgibt. und suche nach Ausnahmen, während sich deine App in der Entwicklungsphase befindet.
Lognachrichten in den Code schreiben
Verwenden Sie die Klasse
Log
, um Logeinträge in Ihren Code zu schreiben. Hilfe zu Logeinträgen
Sie verstehen den Ausführungsablauf,
indem Sie die Debug-Ausgabe des Systems erfassen,
mit Ihrer App interagieren. Protokollmeldungen können auch Aufschluss darüber geben, welcher Teil der
App fehlgeschlagen. Weitere Informationen zum Logging finden Sie unter
Logs mit Logcat schreiben und ansehen
Im folgenden Beispiel wird gezeigt, wie Sie Protokollmeldungen hinzufügen können, um zu ermitteln, ob Informationen zum vorherigen Status verfügbar sind, wenn Ihre Aktivität beginnt:
import android.util.Log ... class MyActivity : Activity() { ... override fun onCreate(savedInstanceState: Bundle?) { ... if (savedInstanceState != null) { Log.d(TAG, "onCreate() Restoring previous state") /* restore state */ } else { Log.d(TAG, "onCreate() No saved state available") /* initialize app */ } ... } ... companion object { private val TAG: String = MyActivity::class.java.simpleName ... } }
import android.util.Log; ... public class MyActivity extends Activity { private static final String TAG = MyActivity.class.getSimpleName(); ... @Override public void onCreate(Bundle savedInstanceState) { ... if (savedInstanceState != null) { Log.d(TAG, "onCreate() Restoring previous state"); /* restore state */ } else { Log.d(TAG, "onCreate() No saved state available"); /* initialize app */ } ... } }
Während der Entwicklung kann Ihr Code auch Ausnahmen abfangen und den Stacktrace in das Systemprotokoll schreiben:
fun someOtherMethod() { try { ... } catch (e : SomeException) { Log.d(TAG, "someOtherMethod()", e) } }
void someOtherMethod() { try { ... } catch (SomeException e) { Log.d(TAG, "someOtherMethod()", e); } }
Hinweis:Entfernen Sie Fehlerbehebungsprotokollmeldungen und Stacktrace-Druckaufrufe aus
um Ihre App zu veröffentlichen. Legen Sie dazu eine DEBUG
fest.
Debug-Logmeldungen in bedingte Anweisungen zu kennzeichnen und zu platzieren.
Systemprotokoll aufrufen
Sie können im Logcat-Fenster Debug- und andere Systemmeldungen aufrufen und filtern, wie in Abbildung 4 dargestellt. Sie können beispielsweise Meldungen sehen, wenn die Garbage Collection ausgeführt wird, oder Meldungen, die Sie Ihrer App mit der Klasse Log
hinzufügen.
Wenn Sie Logcat verwenden möchten, starten Sie das Debuggen und wählen Sie den Tab „Logcat“ aus.

Eine Beschreibung von Logcat und seiner Filteroptionen finden Sie unter Logs mit Logcat schreiben und ansehen
Mit Haltepunkten arbeiten
Android Studio unterstützt Haltepunkte, verschiedene Debugging-Aktionen auslösen. Es gibt verschiedene Arten von Haltepunkten:
Sie können bedingte Haltepunkte festlegen, die die Ausführung nur unter bestimmten Bedingungen unterbrechen erfüllt sind. Sie können auch Logging-Bruchstellen festlegen, die in Logcat schreiben, ohne die Ausführung anzuhalten. So können Sie Ihren Code nicht mit Protokollanweisungen überladen.
So fügen Sie einen Zeilenhaltepunkt hinzu:
Wenn Sie einen Haltepunkt festlegen, wird neben der Zeile ein roter Punkt angezeigt (siehe Abbildung 5).

Wenn Ihre Codeausführung den Haltepunkt erreicht, Android Studio pausiert die Ausführung Ihrer App.
Um den App-Status zu ermitteln, Verwenden Sie die Tools auf dem Tab „Debugger“:
Wenn Ihr Projekt nativen Code verwendet, ist standardmäßig der Debug-Typ „Automatisch erkennen“ fügt sowohl den Java-Debugger als auch LLDB als zwei separate Prozesse. Sie können zwischen der Prüfung von Java- und C/C++-Bruchpunkten wechseln, ohne die App neu zu starten oder die Einstellungen zu ändern.
Hinweis: Damit Android Studio Haltestellen in Ihrem C- oder C++-Code erkennt, müssen Sie einen Debugtyp verwenden, der LLDB unterstützt, z. B. „Automatisch erkennen“, „Native“ oder „Dual“. Sie können den Debug-Typ ändern, der in Android Studio verwendet wird, indem Sie die Fehlerbehebungskonfiguration bearbeiten. Weitere Informationen zu den verschiedenen Debug-Typen finden Sie im Abschnitt zur Verwendung anderer Debug-Typen.
Wenn Android Studio Ihre App auf dem Zielgerät bereitstellt, wird das Debugfenster mit einem Tab oder einer Debug-Sitzungsansicht für jeden Debuggerprozess geöffnet, wie in Abbildung 6 dargestellt.

Beim Debuggen von C/C++ Code können Sie auch spezielle Arten von Haltepunkten festlegen, Watchpoints, mit denen Ihr App-Prozess angehalten werden kann, wenn Ihre App mit einem bestimmten Speicherblock interagiert. Weitere Informationen finden Sie im Abschnitt Beobachtungspunkte hinzufügen.
Haltepunkte ansehen und konfigurieren
Um alle Haltepunkte anzuzeigen und die Haltepunkteinstellungen zu konfigurieren, klicken Sie auf
Haltepunkte ansehen
in der
Debugging-Fenster. Das Fenster "Breakpoints" wird angezeigt.
wie in Abbildung 7 dargestellt.

Im Fenster „Breakpoints“ können Sie jeden Haltepunkt in der Liste aktivieren oder deaktivieren. Wenn ein Haltepunkt deaktiviert ist, wird Ihre App in Android Studio nicht pausiert, wenn dieser Haltepunkt erreicht wird.
Wählen Sie einen Haltepunkt aus der um die Einstellungen zu konfigurieren. Sie können einen Haltepunkt so konfigurieren, dass er deaktiviert wird und vom System nach einem anderen Haltepunkt aktivieren. Sie können auch konfigurieren, ob ein Haltepunkt deaktiviert werden soll, nachdem er Treffer. Wenn Sie einen Breakpoint für eine Ausnahme festlegen möchten, wählen Sie in der Liste der Breakpoints die Option Ausnahme-Breakpoints aus.
Wenn Sie alle Haltepunkte vorübergehend deaktivieren möchten, klicken Sie auf Haltepunkte ausblenden.
in der
Debugging-Fenster. Klicken Sie noch einmal, um die Funktion wieder zu aktivieren.
Fensterrahmen für die Fehlerbehebung
Im Debugger-Fenster können Sie im Bereich „Frames“ den Stackframe prüfen, der dazu geführt hat, dass der aktuelle Haltepunkt erreicht wurde. Dies ermöglicht um im Stapelframe zu navigieren und die Liste der Threads in Ihrer Android-App.
Thread-Auswahl verwenden, um einen Thread auszuwählen und den Stapelframe anzeigen. Klicken Sie auf die Elemente im Frame. um den Quellcode im Editor zu öffnen. Sie können die Darstellung des Threads auch anpassen und den Stack-Frame exportieren, wie im Leitfaden zum Prüfen von Frames beschrieben.
Variablen prüfen
Im Debugger-Fenster können Sie im Bereich „Variablen“ Variablen prüfen, wenn das System Ihre App an einem Haltepunkt beendet und Sie im Bereich „Frames“ einen Frame auswählen. Im Bereich „Variablen“ können Sie Ad-hoc-Ausdrücke mithilfe statischer Methoden und/oder Variablen, die im ausgewählten Frame verfügbar sind.
So fügen Sie der Objektstruktur einen Ausdruck hinzu, während die Anwendung debuggt wird:

Wenn die Objektstruktur den Ausdruck enthält, den Sie beobachten möchten, können Sie hinzufügen, um ihn als beobachteten Ausdruck hinzuzufügen.
Beobachtete Ausdrücke werden aktualisiert, wenn Haltepunkte erreicht werden oder Sie den Code durchlaufen.
Ausgewertete Ausdrücke werden so lange oben in der Objektstruktur angezeigt, bis Sie manuell einen weiteren Ausdruck oder einen Schritt in Ihrem Code auszuwerten.
Um einen beobachteten Ausdruck aus der Objektstruktur zu entfernen, klicken Sie mit der rechten Maustaste auf den Ausdruck und dann Klicken Sie auf Smartwatch entfernen.
Hinweise hinzufügen
Beim Debuggen von C/C++ Code können Sie spezielle Arten von Haltepunkten festlegen, Watchpoints, mit denen Ihr App-Prozess angehalten werden kann, wenn Ihre App mit einem bestimmten Speicherblock interagiert. Wenn Sie beispielsweise zwei Zeiger auf einen Speicherblock setzen und ihm einen Watchpoint zuweisen, wird der Watchpoint ausgelöst, wenn Sie über einen der beiden Zeiger auf diesen Speicherblock zugreifen.
In Android Studio können Sie während der Laufzeit einen Watchpoint erstellen, indem Sie eine bestimmte Variable auswählen. LLDB weist den Watchpoint jedoch nur dem Speicherblock zu, den das System dieser Variablen zuweist, nicht der Variablen selbst. Das ist anders als das Hinzufügen einer Variablen zum Bereich „Beobachtete Objekte“. Damit können Sie den Wert einer Variablen beobachten, aber den App-Prozess nicht anhalten, wenn das System den Wert im Arbeitsspeicher liest oder ändert.
Hinweis: Wenn Ihr App-Prozess eine Funktion beendet und das System die lokalen Variablen aus dem Arbeitsspeicher deallociert, müssen Sie alle Watchpoints neu zuweisen, die Sie für diese Variablen erstellt haben.
Damit Sie einen Watchpoint setzen können, müssen die folgenden Voraussetzungen erfüllt sein:
Hinweis:Wenn Sie Fehler in Ihrer App mit 32-Bit-ARM-ABIs beheben, einen Watchpoint hinzufügen oder den Mauszeiger darauf bewegen über Variablen im Code, um zu untersuchen, kann das zu einem Absturz führen. Um das Problem zu umgehen, beheben Sie die Fehlerbehebung mit 64-Bit-ARM, x86-, x86-64-Binärdateien. Dieses Problem wird in einer zukünftigen Version von Android Studio behoben.
Wenn Sie die Anforderungen erfüllen, können Sie einen Watchpoint so hinzufügen:
Wenn Sie alle Ihre Haltepunkte aufrufen und die Einstellungen für Haltepunkte konfigurieren möchten, klicken Sie im Debugfenster auf Haltepunkte ansehen . Das Dialogfeld „Bruchstellen“ wird angezeigt (siehe Abbildung 10).

Nachdem Sie den Watchpoint hinzugefügt haben, klicken Sie auf Programm fortsetzen.
im Fehlerbehebungsfenster ein, um die App fortzusetzen.
. Wenn Ihre App versucht, auf einen Speicherblock zuzugreifen, für den Sie einen Watchpoint festgelegt haben, wird der App-Prozess standardmäßig vom Android-System angehalten und neben der Codezeile, die Ihre App zuletzt ausgeführt hat, wird ein Watchpoint-Symbol
angezeigt (siehe Abbildung 11).

Anzeigeformat für Ressourcenwerte ansehen und ändern
Im Debug-Modus können Sie Ressourcenwerte aufrufen und ein anderes Darstellungsformat für Variablen in Ihrem Java- oder Kotlin-Code auswählen. Der Tab „Variables“ (Variablen) und ein Frame sind zu sehen. gehen Sie so vor:
So erstellen Sie ein benutzerdefiniertes Format: