Anwendung debuggen

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

  • Wählen Sie ein Gerät aus, auf dem Sie Ihre App debuggen möchten.
  • Setzen Sie Haltepunkte in Ihrem Java-, Kotlin- und C/C++-Code.
  • Variablen untersuchen und Ausdrücke zur Laufzeit auswerten

Diese Seite enthält Anweisungen für grundlegende Debugger-Vorgänge. Weitere Informationen finden Sie Weitere Informationen finden Sie in den Fehlerbehebungsdokumenten für IntelliJ IDEA.

Fehlerbehebung aktivieren

Bevor Sie mit dem Debugging 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 Debug-fähige Build-Variante aus.

Verwenden Sie eine Build-Variante, die enthält debuggable true (isDebuggable = true in Kotlin-Skripts) in der Build-Konfiguration.

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 Wenn du neue Build-Typen definierst, die debug-fähig sein sollen, musst du debuggable true hinzufügen. auf den Build-Typ hinzu:

Cool

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

Kotlin

android {
    buildTypes {
        create("customDebugType") {
            isDebuggable = true
            ...
        }
    }
}

Diese Eigenschaft gilt auch für Module mit C/C++ Code.

Hinweis: Das Die Property jniDebuggable wird nicht mehr verwendet.

Wenn Ihre App von einem Bibliotheksmodul abhängt, das Sie auch debuggen möchten, muss diese Bibliothek ebenfalls mit debuggable true gepackt werden, damit die Debugsymbole 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 Debugging-Sitzung:

  1. Haltepunkte im Code Ihrer App festlegen
  2. Wählen Sie in der Symbolleiste im Zielgerätemenü das Gerät aus, auf dem Sie Ihre App debuggen möchten.
    Menü des Zielgeräts.
    Abbildung 1: Menü des Zielgeräts.

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

    Wenn Ihre App bereits auf dem Gerät ausgeführt wird, wird ein Dialogfeld angezeigt, in dem Sie gefragt werden, ob Sie von „Ausführen“ zu „Debuggen“ wechseln möchten. 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 Ihrem Projekt C- und C++-Code hinzufügen, führt Android Studio im Fenster „Debuggen“ auch den LLDB-Debugger aus, um Ihren nativen Code zu debuggen.

  4. Falls das Fenster zur Fehlerbehebung nicht geöffnet ist, wählen Sie Ansicht > Tool-Fenster > Fehler beheben Alternativ können Sie auch in der Leiste des Toolfensters auf Fehlerbehebung klicken.

Debugger an eine laufende App anhängen

Wenn Ihre App bereits auf Ihrem Gerät ausgeführt wird, können Sie mit der Fehlerbehebung beginnen, ohne App neu starten:

  1. Klicken Sie auf Debugger an Android-Prozess anhängen .
  2. Wählen Sie im Dialogfeld Prozess auswählen den Prozess aus, den Sie ausführen möchten. den Debugger anhängen.
    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 Prozesse angezeigt, die auf dem Gerät ausgeführt werden. Auf einem nicht gerooteten Gerät werden jedoch nur debuggbare Prozesse angezeigt.
    2. Wählen Sie im Menü Android-Debuggereinstellungen verwenden von eine vorhandene Ausführungs-/Debug-Konfiguration aus. Für C- und C++-Code So können Sie die LLDB-Startbefehle, LLDB-Post-attach-Befehle und in einer bestehenden Konfiguration.
    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. Von verwendet Android Studio den Debug-Typ „Automatisch erkennen“, um den besten -Debugger-Option für Sie, je nachdem, ob Ihr Projekt Java- oder C/C++-Code enthält.
  3. Klicken Sie auf OK.

    Das Fenster zur Fehlerbehebung 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 ihn beenden (), zum Beenden zwingen () oder den Debugger an einen bestimmten Prozess anhängen ().

Debugging-Fenster

Abbildung 2: Das Debugging-Fenster

Das Debug-Fenster ist in

  1. Ausführungs- und Navigationssymbolleiste, siehe 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 die automatische Speicherbereinigung sind lose integriert sind. 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.

Debugger-Typ ändern

Da zum Debuggen von Java-/Kotlin-Code und C/C++-Code verschiedene Debugger-Tools erforderlich sind, Im Android Studio-Debugger können Sie auswählen, welcher Debugger-Typ verwendet werden soll. Standardmäßig entscheidet Android Studio anhand der in Ihrem Projekt erkannten Sprachen, welcher Debugger verwendet werden soll. Dazu wird der Debuggertyp Automatisch erkennen verwendet.

Um den Debugger manuell in der Fehlerbehebungskonfiguration auszuwählen, klicken Sie auf Ausführen > Bearbeiten Konfigurationen. Sie können den Debugger auch in dem 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 Sie beispielsweise C- oder C++-Code in Ihrem Projekt verwenden, verwendet Android Studio automatisch den Dual Debug Typ. Andernfalls verwendet Android Studio den Debug-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. Das Nur Java Der Debugger ignoriert alle Haltepunkte oder Überwachungen, 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 zu „Automatisch erkennen“ oder „Duales Debuggen“.

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 für die ADB aus, um zu prüfen, ob ptrace aktiviert ist Shell, 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. Ist ptrace nicht aktiviert, wird eine einen anderen Wert als 0.

Dual (Java und nativ) – nur mit C/C++-Code verfügbar
Wählen Sie diesen Debugtyp aus, wenn Sie zwischen dem Debuggen von Java- und nativem Code wechseln möchten. Android Studio koppelt sowohl den Java-Debugger als auch LLDB an Ihren App-Prozess, sodass Sie sowohl Java- als auch nativen Code prüfen können, ohne die App neu starten oder die Debug-Konfiguration ändern zu müssen.

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 zum Debuggen des nativen Codes und der andere zum Debuggen von Java-Code, wie durch -java angegeben.

Abbildung 3: Tab zum Debuggen von nativem Code und Tab für das Debugging von Java-Code.

Hinweis: Bei der Fehlerbehebung für nativen Code, der vom erhalten Sie möglicherweise die folgende Warnmeldung:
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 Compileroptimierungen beim Debuggen Ihres nativen Codes deaktivieren.

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.

Logeinträge in Ihren 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

Das folgende Beispiel zeigt, wie Sie Lognachrichten hinzufügen können, um zu ermitteln, ob der vorherige Status Informationen sind verfügbar, wenn Ihre Aktivität beginnt:

Kotlin

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

Java

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 System schreiben Protokoll:

Kotlin

fun someOtherMethod() {
    try {
        ...
    } catch (e : SomeException) {
        Log.d(TAG, "someOtherMethod()", e)
    }
}

Java

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 Debug- und andere Systemmeldungen im Logcat-Fenster anzeigen und filtern, wie hier gezeigt in Abbildung 4. Sie können beispielsweise Meldungen sehen, wenn die automatische Speicherbereinigung stattfindet, oder Nachrichten, die die Sie Ihrer App mit der Klasse Log.

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, Debugging-Aktionen auslösen können. Es gibt verschiedene Arten von Haltepunkten:

Zeilen-Unterbrechungspunkt
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.
Haltepunkt für Methode
Ein Methodenhaltepunkt pausiert die Ausführung Ihrer App, wenn sie eine bestimmte . 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.
Ausnahmehaltepunkt
Mit einem Ausnahme-Haltepunkt wird die Ausführung Ihrer App angehalten, 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 Haltepunkte für die Protokollierung festlegen, die in Logcat schreiben, ohne anzuhalten Ausführung. So können Sie vermeiden, dass Ihr Code mit Loganweisungen überfrachtet wird.

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 Bundsteg entlang dieser Codezeile oder platzieren Sie das Caret-Zeichen auf der 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 setzen, wird neben der Linie ein roter Punkt angezeigt (siehe Abbildung 5).

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

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 .

  • Um zur ersten Zeile innerhalb eines Methodenaufrufs zu gelangen, klicken Sie auf Schritt In .

  • Wenn Sie zur nächsten Zeile außerhalb der aktuellen Methode wechseln möchten, klicken Sie auf Aus Schritt .

  • Wenn Sie die App wie gewohnt ausführen möchten, klicken Sie 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++-Haltenpunkten wechseln ohne die App neu zu starten oder Einstellungen zu ändern.

Hinweis:Damit Android Studio Haltepunkte in Ihrem C- oder C++-Code erkennt, müssen Sie einen Debugging-Typ verwenden, der LLDB unterstützt, z. B. „Automatisch erkennen“, „Nativ“ oder Dual. Sie können den Debug-Typ ändern, der in Android Studio verwendet wird, indem Sie die Fehlerbehebungskonfiguration bearbeiten. Bis Weitere Informationen zu den verschiedenen Fehlerbehebungstypen finden Sie im Abschnitt zur Verwendung von andere Arten der Fehlerbehebung.

Wenn Ihre App von Android Studio auf Ihrem Zielgerät bereitgestellt wird, wird das Debugging-Fenster wird mit einem Tab oder einer Ansicht der Debug-Sitzung für jeden Debugger-Prozess geöffnet (siehe Abbildung). in Abbildung 6.

Abbildung 6: Fehlerbehebung bei nativem Code mit LLDB.
  1. Android Studio wechselt zur <your-module>, wenn der LLDB-Debugger eine in Ihrem C/C++ Code ein. Die Frames, Variablen und Smartwatches sind ebenfalls verfügbar und funktionieren genauso, wie das Debugging von Java-Code.

    Der Bereich „Threads“ ist in der LLDB-Sitzungsansicht zwar nicht verfügbar, Sie können aber über die Liste im Bereich „Frames“ auf Ihre App-Prozesse zugreifen. Weitere Informationen zu diesen Bereiche in den Abschnitten zum Debug-Fenster Frames und Variablen prüfen.

    Hinweis:Wenn Sie einen Haltepunkt in Ihrem nativen Code prüfen, Das Android-System hält die virtuelle Maschine an, auf der das Java Ihrer App ausgeführt wird Bytecode. 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 zur <your-module>-Java-Tab, wenn der Java-Debugger in Ihrem Java- oder Kotlin-Code auf einen Haltepunkt stößt.
  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 haben, die LLDB jedes Mal ausführen soll, wenn Sie mit dem Debuggen Ihrer App beginnen, entweder kurz vor oder kurz nach dem Anhängen des Debuggers an Ihren App-Prozess, können Sie diese Befehle Ihrer Debug-Konfiguration 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 unter im Abschnitt zum Hinzufügen von Watchpoints.

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 der Liste im Fenster. Wenn ein Haltepunkt deaktiviert ist, die App pausieren, wenn sie diesen Haltepunkt erreicht.

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. Um einen Haltepunkt für eine Ausnahme festzulegen, wählen Sie Ausnahme Haltepunkte in der Liste der Haltepunkte.

Wenn Sie alle Haltepunkte vorübergehend deaktivieren möchten, klicken Sie auf Haltepunkte ausblenden. in der Debugging-Fenster. Klicken Sie noch einmal, um sie wieder zu aktivieren.

Debugging-Fensterrahmen

Im Debugger-Fenster können Sie im Bereich "Frames" Der Stapelframe, der dazu geführt hat, dass der aktuelle Haltepunkt getroffen wurde. Dies ermöglicht um im Stapelframe zu navigieren und die Liste der Threads in Ihrer Android-App.

Wählen Sie einen Thread aus, indem Sie das Menü „Threadauswahl“ verwenden und sich den Stack-Frame ansehen. Klicken Sie auf die Elemente im Frame, um die Quelle im Editor zu öffnen. Sie können den Thread auch anpassen, Präsentation und exportieren Sie den Stapelframe, wie in den Anleitung „Frames untersuchen“.

Variablen prüfen

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“ aus. 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 setzen Sie zwei Zeiger auf einen Speicherblock und weisen ihm einen Watchpoint zu. einer der Zeiger für den Zugriff auf diesen Speicherblock löst den Watchpoint aus.

In Android Studio können Sie während der Laufzeit einen Watchpoint erstellen, indem Sie Variable zugewiesen. Beim LLDB wird der Watchpoint jedoch nur dem Block Arbeitsspeicher, den das System dieser Variablen zuweist, nicht der Variablen selbst. Dieses anders als das Hinzufügen einer Variablen zum Bereich „Watches“, mit dem den Wert einer Variablen beobachten, aber nicht zulassen, dass Sie App-Prozess, wenn das System seinen Speicherwert liest oder ändert.

Hinweis:Wenn bei Ihrem App-Prozess eine Funktion beendet wird und das System seine lokalen Variablen aus dem Arbeitsspeicher aufteilt, müssen Sie die Sie für diese Variablen erstellt haben.

Sie müssen die folgenden Anforderungen erfüllen, um einen Watchpoint einzurichten:

  • 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. Um eine Variable in Ihrem nativen Code auszurichten, geben Sie __attribute__((aligned(num_bytes))) im variable Verlangsamung, wie unten gezeigt: 
    // For a 64-bit ARM processor
int my_counter __attribute__((aligned(8)));
  • Du hast bereits drei oder weniger Wiedergabepunkte zugewiesen. Nur Android Studio unterstützt bis zu vier Watchpoints auf x86- oder x86_64-Zielgeräten. Sonstiges Geräte unterstützen möglicherweise weniger Watchpoints.

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, können die Werte einen Absturz verursachen. Um das Problem zu umgehen, verwenden Sie einen 64-Bit-ARM, x86-, x86-64-Binärdateien. Dieses Problem wird in einer kü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 Watchpoints wird angezeigt (siehe Abbildung 9).

    Konfigurieren Sie Ihren Watchpoint mit den folgenden Optionen:

    • Aktiviert:Deaktivieren Sie diese Option, wenn Sie Android Studio ignoriert den Watchpoint, bis Sie die Einstellung ändern. Android-Geräte In Studio wird Ihr Watchpoint gespeichert, damit Sie später darauf zugreifen können.
    • Anhalten: Standardmäßig hält das Android-System Ihren App-Prozess an, wenn er auf einen Arbeitsspeicherblock 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 die Watchpoint zu, wenn er versucht, in den Block Arbeitsspeicher, den das System der Variablen zuweist. Watchpoint auslösen wählen Sie Beliebig aus.
  4. Klicken Sie auf Fertig.

Wenn Sie alle Watchpoints aufrufen und die Watchpoint-Einstellungen konfigurieren möchten, klicken Sie auf Haltepunkte ansehen. im Debugging-Fenster aus. Die Das Dialogfeld mit den Haltepunkten wird angezeigt (siehe Abbildung 10).

Abbildung 10: Im Dialogfeld "Breakpoints" werden Ihre aktuellen Watchpoints und enthält Verhaltenseinstellungen für die einzelnen Optionen.

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, den Sie einen Watchpoint festgelegt haben, sperrt das Android-System Ihren App-Prozess und Neben der Codezeile, die Ihre App enthält, wird das Watchpoint-Symbol angezeigt. wie in Abbildung 11 gezeigt.

Abbildung 11. Android Studio zeigt die Codezeile an, die Ihre App ausführt, kurz bevor ein Watchpoint ausgelöst wird.

Anzeigeformat für Ressourcenwerte aufrufen und ändern

Im Debug-Modus können Sie sich Ressourcenwerte ansehen und ein anderes Anzeigeformat für Variablen in Ihrem Java- oder Kotlin-Code. Der Tab „Variables“ (Variablen) und ein Frame sind zu sehen. gehen Sie so vor:

  1. Klicken Sie in der Liste „Variablen“ mit der rechten Maustaste auf eine beliebige Stelle in einer Ressourcenzeile, um die Liste aufzurufen.
  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: Hier wird die Definition des Objekts (einer Instanz einer Klasse) angezeigt.
    • 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: Als Hexadezimalwert anzeigen.
    • Primitiv:Wird als numerischer Wert mit einem primitiven Datentyp angezeigt.
    • Integer:Wird als numerischer Wert vom Typ angezeigt. Integer

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. Befolgen Sie die Anweisungen unter Renderer für Java-Datentypen