Diese Seite wurde von der Cloud Translation API übersetzt.

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 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 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 Debugging-Sitzung:

Haltepunkte im Code Ihrer App festlegen
Wählen Sie in der Symbolleiste im Zielgerätemenü das Gerät aus, auf dem Sie Ihre App debuggen möchten. <ph type="x-smartling-placeholder">
</ph>
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.
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. Bis Wenn dieselbe Instanz der App weiterhin ausgeführt wird, klicken Sie auf Cancel Debug (Fehlerbehebung abbrechen). Debugger mit einer laufenden Anwendung verknüpfen Andernfalls wird Android Studio erstellt ein APK, signiert es mit einem Schlüssel zur Fehlerbehebung, 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.
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 laufende Anwendung anhängen

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

Klicken Sie auf Debugger an Android-Prozess anhängen .
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 hier alle Prozesse, die auf dem Gerät ausgeführt werden. Auf einem nicht gerooteten Gerät wird dies Debug-fähigen Prozessen.
2. Im Menü Android Debugger-Einstellungen verwenden aus können Sie ein vorhandenes Konfiguration ausführen/Fehler beheben 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.
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 einen Kill ausführen. , Beenden erzwingen , oder den Debugger an einen bestimmten Prozess anhängen

Debugging-Fenster

Das Debug-Fenster ist in

Ausführungs- und Navigationssymbolleiste, siehe Mit Haltepunkten arbeiten
Thread-Auswahl
Auswertungs- und Überwachungsausdruck. Siehe Variablen prüfen.
Stapelanzeige
Variablen. Siehe 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 wird Android Studio entscheidet anhand der in Ihrem Projekt erkannten Sprachen mithilfe des Debugger-Typ Automatisch erkennen aus.

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 LLDB prüft nur den nativen Code und ignoriert 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 die 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 ein unknown key-Fehler. 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 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 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 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.

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, beginnen Sie mit der Fehlerbehebung 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 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.
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 einen zusammensetzbaren Funktion verwenden, listet der Debugger die Parameter der zusammensetzbaren Funktion und ihren Status auf, um 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: 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 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:

Suchen Sie die Codezeile, in der Sie die Ausführung anhalten möchten.
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).
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 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 die Objektstruktur auf eine Variable prüfen 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.
Um zur nächsten Zeile im Code zu springen, ohne eine Methode einzugeben, klicken Sie auf Schritt Mehr als .
Um zur ersten Zeile innerhalb eines Methodenaufrufs zu gelangen, klicken Sie auf Schritt In .
Um zur nächsten Zeile außerhalb der aktuellen Methode zu gelangen, klicken Sie auf Schritt Aus .
Wenn du die App weiter normal 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++-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.

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.

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 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-Software interagieren können, Debugger abzurufen oder Statusinformationen aus dem Java-Debugger abzurufen. während Sie einen Haltepunkt in Ihrem nativen Code untersuchen.
Android Studio wechselt zur <your-module>-Java-Tab, wenn der Java-Debugger in Ihrem Java- oder Kotlin-Code auf einen Haltepunkt stößt.
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 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.

</ph> **Abbildung 7**: Im Fenster "Breakpoints" werden alle aktuellen Haltepunkte und enthält Verhaltenseinstellungen für alle.

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“ prüfen, 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.

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 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 verfügbar sind.

So fügen Sie der Objektstruktur einen Ausdruck hinzu, während das Debugging der Anwendung läuft:

</ph> Abbildung 8: Objektstruktur und Ausdruckseingabefeld im Debugging-Fenster

Ausdruck eingeben, der beobachtet oder angezeigt werden soll
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.

Watchpoints 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))) in der variable Verlangsamung, wie unten gezeigt:
```
// For a 64-bit ARM processor
int my_counter __attribute__((aligned(8)));
```
Sie haben bereits drei oder weniger Watchpoints 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, kann das zu einem Absturz führen. 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 hinzufügen:

Ö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 gewünschten Arbeitsspeicherblock belegt und wählen Sie Watchpoint hinzufügen aus.
<ph type="x-smartling-placeholder">
</ph> <ph type="x-smartling-placeholder">
</ph> 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 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.
- 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 die Watchpoint zu, wenn er versucht, in den Block Arbeitsspeicher, den das System der Variablen zuweist. Watchpoint auslösen wählen Sie Beliebig aus.
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).

</ph> **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.

</ph> **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 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:

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. Eine oder mehrere der folgenden Optionen werden angezeigt:
- Klasse:Die Klassendefinition wird angezeigt.
- toString:Das Format des Strings wird angezeigt.
- Objekt:Die Definition des Objekts (eine Instanz einer Klasse) anzeigen.
- Array:Wird 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: Zeigt einen Binärwert mit Nullen und Einsen an.
- 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.
- Integer:Wird als numerischer Wert vom Typ angezeigt. Integer

So erstellen Sie ein benutzerdefiniertes Format:

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