Mit Sammlungen den Überblick behalten
Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.
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:
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:
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.
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.
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.
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.
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.
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.
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
<ph type="x-smartling-placeholder"></ph>
Abbildung 2: Das Debugging-Fenster
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.
<ph type="x-smartling-placeholder"></ph>
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
importandroid.util.Log...classMyActivity:Activity(){...overridefunonCreate(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 */}...}...companionobject{privatevalTAG:String=MyActivity::class.java.simpleName...}}
Java
importandroid.util.Log;...publicclassMyActivityextendsActivity{privatestaticfinalStringTAG=MyActivity.class.getSimpleName();...@OverridepublicvoidonCreate(BundlesavedInstanceState){...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:
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.
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).
<ph type="x-smartling-placeholder"></ph>
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.
<ph type="x-smartling-placeholder"></ph>
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 type="x-smartling-placeholder"></ph>
<ph type="x-smartling-placeholder"></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 type="x-smartling-placeholder"></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 processorintmy_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 type="x-smartling-placeholder"></ph>
<ph type="x-smartling-placeholder"></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 type="x-smartling-placeholder"></ph>
<ph type="x-smartling-placeholder"></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
Alle Inhalte und Codebeispiele auf dieser Seite unterliegen den Lizenzen wie im Abschnitt Inhaltslizenz beschrieben. Java und OpenJDK sind Marken oder eingetragene Marken von Oracle und/oder seinen Tochtergesellschaften.