Anwendung debuggen

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 Buildtyp debuggable true hinzufügen:

GroovyKotlin

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:

1. Haltepunkte im Code Ihrer App festlegen
2. 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.

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

4. Wenn das Debugfenster nicht geöffnet ist, wählen Sie Ansicht > Toolfenster > Debug aus oder klicken Sie in der Toolfensterleiste auf Debug .

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:

1. Klicken Sie auf Debugger an Android-Prozess anhängen .
2. Wählen Sie im Dialogfeld Prozess auswählen den Prozess aus, dem Sie den Debugger zuordnen möchten.
   1. 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.
   2. 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.
   3. 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.
3. Klicken Sie auf OK.

   Das Fenster „Debug“ wird angezeigt.

Ü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

Abbildung 2: Das Debugging-Fenster

Das Debug-Fenster ist in

1. Symbolleiste für Ausführung und Navigation Mit Haltepunkten arbeiten
2. Thread-Auswahl
3. Bewertungs- und Überwachungsausdruck. Siehe Variablen prüfen.
4. Stapelanzeige
5. Variablen. Weitere Informationen finden Sie unter Variablen prüfen.

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:

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

• 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 Wert 0 oder einen ein unknown key-Fehler. Ist ptrace nicht aktiviert, wird eine einen anderen Wert als 0.

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

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:

KotlinJava

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:

KotlinJava

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.

Abbildung 4: Logcat-Fenster mit Filtereinstellungen

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:

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.

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:

1. Suchen Sie die Codezeile, in der Sie die Ausführung anhalten möchten.
2. 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).
3. 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 einen Haltepunkt festlegen, wird neben der Zeile ein roter Punkt angezeigt (siehe Abbildung 5).

Abbildung 5: Neben dem Feld wenn Sie einen Haltepunkt festlegen.

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

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.

Abbildung 6: Fehlerbehebung bei nativem Code mit LLDB.

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

2. Android Studio wechselt zum Tab <your-module>-java, wenn der Java-Debugger einen Haltepunkt in Ihrem Java- oder Kotlin-Code findet.
3. 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.

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.

Abbildung 7: Im Fenster „Breakpoints“ werden alle aktuellen Haltestellen aufgelistet und es enthält Verhaltenseinstellungen für jede.

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:

Abbildung 8 Objektstruktur und Ausdruckseingabefeld im Debugging-Fenster

1. Zu beobachtenden oder anzuzeigenden Ausdruck eingeben
2. Klicken Sie auf Zu Smartwatches hinzufügen oder drücken Sie die Eingabetaste, um den Ausdruck einmal auszuwerten.

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:

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

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:

1. Öffnen Sie, während Ihre App an einem Haltepunkt gesperrt ist, den Variablenbereich in der LLDB-Sitzungsansicht

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

3. 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.
4. Klicken Sie auf Fertig.

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

Abbildung 10: Im Dialogfeld „Bruchstellen“ werden Ihre aktuellen Haltepunkte mit den zugehörigen Verhaltenseinstellungen aufgeführt.

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

Abbildung 11. Android Studio gibt die Codezeile an, kurz bevor ein Watchpoint ausgelöst wird.

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:

1. Klicken Sie in der Variablenliste mit der rechten Maustaste auf eine beliebige Stelle in einer Ressourcenzeile, um sie anzuzeigen. auf der Liste.
2. 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.

So erstellen Sie ein benutzerdefiniertes Format:

1. Klicken Sie mit der rechten Maustaste auf den Ressourcenwert.
2. Wählen Sie Ansehen als aus.
3. Wählen Sie Erstellen aus.
4. Das Dialogfeld Java-Datentyp-Renderer wird angezeigt. Folgen Sie der Anleitung unter Java-Datentyp-Renderer.