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.
  • Haltepunkte in Ihrem Java-, Kotlin- und C/C++-Code festlegen
  • Variablen prüfen und Ausdrücke zur Laufzeit auswerten.

Diese Seite enthält Anleitungen für grundlegende Debugger-Vorgänge. Weitere Informationen finden Sie in der Dokumentation zum Debugging in IntelliJ IDEA.

Debugging aktivieren

Bevor Sie mit dem Debugging beginnen können, müssen Sie Folgendes tun:

Aktivieren Sie das Debugging auf Ihrem Gerät.
Wenn Sie den Emulator verwenden, ist die Fehlerbehebung standardmäßig aktiviert. Für ein verbundenes Gerät müssen Sie jedoch das Debugging in den Entwickleroptionen des Geräts aktivieren.
Führen Sie eine Build-Variante aus, die sich debuggen lässt.

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

In der Regel können Sie die Standardvariante „debug“ auswählen, die in jedem Android Studio-Projekt enthalten ist, auch wenn sie in der Datei build.gradle nicht sichtbar ist. Wenn Sie jedoch neue Build-Typen definieren, die debuggfähig sein sollen, müssen Sie dem Build-Typ debuggable true hinzufügen:

Groovy

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

Kotlin

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

Diese Property 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 auch mit debuggable true verpackt werden, damit die Debug-Symbole erhalten bleiben. Damit die debugfähigen Varianten Ihres App-Projekts die debugfähige Variante eines Bibliotheksmoduls erhalten, veröffentlichen Sie nicht standardmäßige Versionen Ihrer Bibliothek.

Debugging starten

So starten Sie eine Debugging-Sitzung:

  1. Legen Sie Haltepunkte im Code Ihrer Anwendung fest.
  2. Wählen Sie in der Symbolleiste im Menü für Zielgeräte ein Gerät aus, auf dem Sie Ihre App debuggen möchten.
    Menü „Zielgerät“
    Abbildung 1: Menü „Zielgerät“.

    Wenn Sie keine Geräte konfiguriert haben, müssen Sie entweder ein Gerät über USB verbinden, ein Gerät über WLAN verbinden oder ein AVD erstellen, um den Android Emulator zu verwenden.

  3. Klicken Sie in der Symbolleiste auf Debuggen .

    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 dem Debugging zu beginnen. Wenn Sie dieselbe Instanz der App weiter ausführen möchten, klicken Sie auf Cancel Debug (Debugging abbrechen) und hängen Sie stattdessen den Debugger an eine laufende App an. 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 Debug-Fenster auch den LLDB-Debugger aus, um Fehler im nativen Code zu beheben.

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

Debugger an eine laufende Anwendung anhängen

Wenn Ihre App bereits auf Ihrem Gerät ausgeführt wird, können Sie das Debugging ohne Neustart der App so starten:

  1. Klicken Sie auf Debugger an Android-Prozess anhängen .
  2. Wählen Sie im Dialogfeld Choose Process den Prozess aus, an den Sie den Debugger anhängen möchten.
    1. Wenn Sie einen Emulator oder ein gerootetes Gerät verwenden, können Sie Alle Prozesse anzeigen aktivieren, 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 debugfähige Prozesse angezeigt.
    2. Im Menü Android-Debugger-Einstellungen verwenden von können Sie eine vorhandene Konfiguration ausführen/debuggen auswählen. Bei C- und C++-Code können Sie so die LLDB-Startbefehle, die LLDB-Befehle nach dem Anhängen und die Symbolverzeichnisse in einer vorhandenen Konfiguration wiederverwenden.
    3. Wenn Sie noch keine Konfiguration zum Ausführen/Debuggen haben, wählen Sie Neu erstellen aus. Durch diese Auswahl wird das Menü Debug-Typ aktiviert, in dem Sie einen anderen Debug-Typ auswählen können. Standardmäßig verwendet Android Studio den Debug-Typ „Automatisch erkennen“, um die beste Debugger-Option für Sie auszuwählen, je nachdem, ob Ihr Projekt Java- oder C/C++-Code enthält.
  3. Klicken Sie auf OK.

    Das Debug-Fenster wird angezeigt.

Der Tab Prozesse im Geräte-Explorer (Ansicht > Toolfenster > Geräte-Explorer) enthält ebenfalls eine Liste der debugfähigen Prozesse. Dort können Sie einen Prozess auswählen und ihn beenden , das Beenden erzwingen oder den Debugger an einen bestimmten Prozess anhängen .

Das Debug-Fenster

Abbildung 2.Das Debug-Fenster.

Das Debug-Fenster ist in

  1. Symbolleiste für Ausführung und Navigation. Weitere Informationen finden Sie unter Mit Haltepunkten arbeiten.
  2. Thread-Auswahl
  3. Auswertung und Eingabe von Überwachungsausdrücken. Siehe Variablen prüfen.
  4. Stapelanzeige
  5. Bereich „Variablen“ Siehe Variablen prüfen.

Hinweis:Der Debugger und der Garbage Collector von Android Studio sind nur lose integriert. Die virtuelle Android-Maschine sorgt dafür, dass alle Objekte, die dem Debugger bekannt sind, erst nach dem Trennen des Debuggers bereinigt werden. Dies kann dazu führen, dass sich Objekte ansammeln, während der Debugger verbunden ist. Wenn der Debugger beispielsweise einen laufenden Thread erkennt, wird das zugehörige Thread-Objekt erst dann durch die automatische Speicherbereinigung gelöscht, wenn die Verbindung zum Debugger getrennt wird, auch wenn der Thread beendet wurde.

Debugger-Typ ändern

Da für das Debugging von Java-/Kotlin-Code und C/C++-Code unterschiedliche Debugger-Tools erforderlich sind, können Sie im Android Studio-Debugger den gewünschten Debugger-Typ auswählen. Standardmäßig entscheidet Android Studio anhand der im Projekt erkannten Sprachen, welcher Debugger verwendet werden soll. Dazu wird der Debugger-Typ Automatisch erkennen verwendet.

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 im Dialogfeld auswählen, das angezeigt wird, wenn Sie auf Ausführen > Debugger an Android-Prozess anhängen klicken.

Folgende Debug-Typen sind verfügbar:

Automatisch erkennen
Wähle diesen Debug-Typ aus, wenn Android Studio automatisch die beste Option für den Code auswählen soll, den du debuggst. Wenn Ihr Projekt beispielsweise C- oder C++-Code enthält, verwendet Android Studio automatisch den Debug-Typ „Dual“. Andernfalls verwendet Android Studio den Debug-Typ „Nur Java“.
Nur Java
Wählen Sie diesen Debug-Typ aus, wenn Sie nur Code debuggen möchten, der in Java oder Kotlin geschrieben wurde. Der Java-Only-Debugger ignoriert alle Haltepunkte oder Watches, die Sie in Ihrem nativen Code festlegen.
Nur nativ (nur mit C/C++-Code verfügbar)
Wählen Sie diesen Debug-Typ aus, wenn Sie nur LLDB zum Debuggen Ihres Codes verwenden möchten. Wenn Sie diesen Debug-Typ verwenden, ist die Ansicht der Java-Debugger-Sitzung nicht verfügbar. Standardmäßig prüft LLDB nur Ihren nativen Code und ignoriert Haltepunkte in Ihrem Java-Code. Wenn Sie auch Ihren Java-Code debuggen möchten, wechseln Sie entweder zum 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ühre den folgenden Befehl in der ADB-Shell aus, die mit deinem Gerät verbunden ist, um zu prüfen, ob das Gerät run-as unterstützt:

    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 unknown key-Fehler aus. Wenn ptrace nicht aktiviert ist, wird ein anderer Wert als 0 ausgegeben.

Dual (Java + Nativ) – nur mit C/C++-Code verfügbar
Wählen Sie diesen Debug-Typ aus, wenn Sie zwischen dem Debuggen von Java- und nativem Code wechseln möchten. Android Studio hängt sowohl den Java-Debugger als auch LLDB an den App-Prozess an, sodass Sie Haltepunkte sowohl im Java- als auch im nativen Code prüfen können, ohne die App neu zu starten oder die Debug-Konfiguration zu ä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, ist ein Tab für das Debugging des nativen Codes und der andere für das Debugging des Java-Codes vorgesehen, 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 wurde, wird möglicherweise die folgende Warnmeldung angezeigt:
This function was compiled with optimizations enabled. Some debugger features may not be available. Wenn Sie Optimierungs-Flags verwenden, nimmt der Compiler Änderungen am kompilierten Code vor, damit er effizienter ausgeführt wird. Dies kann dazu führen, dass der Debugger unerwartete oder falsche Informationen meldet, da es für den Debugger schwierig ist, den optimierten kompilierten Code dem ursprünglichen Quellcode zuzuordnen. Aus diesem Grund sollten Sie Compileroptimierungen beim Debuggen von nativem Code deaktivieren.

Systemprotokoll verwenden

Im Systemprotokoll werden Systemmeldungen angezeigt, während Sie Ihre App debuggen. Diese Meldungen enthalten Informationen von Apps, die auf dem Gerät ausgeführt werden. Wenn Sie das Systemprotokoll zum Debuggen Ihrer Anwendung verwenden möchten, achten Sie darauf, dass Ihr Code Logeinträge schreibt und den Stacktrace für Ausnahmen ausgibt, während sich Ihre Anwendung in der Entwicklungsphase befindet.

Logeinträge in Ihren Code schreiben

Verwenden Sie die Klasse Log, um Logeinträge in Ihren Code zu schreiben. Logeinträge helfen Ihnen, den Ausführungsablauf zu verstehen, indem sie die System-Debug-Ausgabe erfassen, während Sie mit Ihrer App interagieren. Logeinträge können Ihnen auch Aufschluss darüber geben, welcher Teil Ihrer App fehlgeschlagen ist. Weitere Informationen zum Logging finden Sie unter Logs mit Logcat schreiben und ansehen.

Das folgende Beispiel zeigt, wie Sie Logeinträge hinzufügen können, um zu ermitteln, ob beim Start Ihrer Aktivität Informationen zum vorherigen Status verfügbar sind:

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 Systemprotokoll schreiben:

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 Debugging-Logeinträge und Stacktrace-Druckaufrufe aus Ihrem Code, wenn Sie Ihre App veröffentlichen möchten. Setzen Sie dazu ein DEBUG-Flag und platzieren Sie Debugging-Logeinträge in bedingten Anweisungen.

Systemprotokoll ansehen

Im Logcat-Fenster können Sie Debug- und andere Systemmeldungen ansehen und filtern, wie in Abbildung 4 dargestellt. Sie können beispielsweise Nachrichten sehen, wenn die automatische Speicherbereinigung erfolgt, oder Nachrichten, die Sie Ihrer Anwendung mit der Klasse Log hinzufügen.

Wenn Sie Logcat verwenden möchten, starten Sie das Debugging und wählen Sie den Tab „Logcat“ aus.

Abbildung 4: Logcat-Fenster mit Filtereinstellungen.

Eine Beschreibung von Logcat und den Filteroptionen finden Sie unter Logs mit Logcat schreiben und ansehen.

Mit Haltepunkten arbeiten

Android Studio unterstützt Haltepunkte, die verschiedene Debugging-Aktionen auslösen. Es gibt verschiedene Arten von Haltepunkten:

Zeilenhaltepunkt
Der häufigste Typ ist ein Zeilen-Haltepunkt, der die Ausführung Ihrer Anwendung an einer bestimmten Codezeile pausiert. Während der Pause können Sie Variablen prüfen, Ausdrücke auswerten und dann die Ausführung Zeile für Zeile fortsetzen, um die Ursachen von Laufzeitfehlern zu ermitteln.
Methoden-Haltepunkt
Ein Methoden-Haltepunkt pausiert die Ausführung Ihrer App, wenn sie eine bestimmte Methode aufruft oder verlässt. Während der Pause können Sie Variablen prüfen, Ausdrücke auswerten und dann die Ausführung Zeile für Zeile fortsetzen, um die Ursachen von Laufzeitfehlern zu ermitteln. Wenn ihr einen Haltepunkt für eine zusammensetzbare Funktion festlegt, listet der Debugger die Parameter der zusammensetzbaren Funktion und ihren Status auf. So könnt ihr leichter erkennen, welche Änderungen die Neuzusammensetzung verursacht haben könnten.
Feldhaltepunkt
Ein Feld-Haltepunkt pausiert die Ausführung Ihrer Anwendung, wenn sie aus einem bestimmten Feld liest oder in ein bestimmtes Feld schreibt.
Ausnahme-Haltepunkt
Ein Ausnahme-Haltepunkt pausiert die Ausführung Ihrer App, wenn eine Ausnahme ausgelöst wird.

Sie können bedingte Haltepunkte festlegen, die die Ausführung nur dann unterbrechen, wenn bestimmte Bedingungen erfüllt sind. Sie können auch Logging-Haltepunkte festlegen, die in Logcat schreiben, ohne die Ausführung zu unterbrechen. So können Sie vermeiden, dass Ihr Code mit Logberichten überladen wird.

So fügen Sie einen Zeilen-Haltepunkt hinzu:

  1. Suchen Sie die Codezeile, an der Sie die Ausführung pausieren möchten.
  2. Klicken Sie auf den linken Rand neben dieser Codezeile oder platzieren Sie den Cursor 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 Debuggen , um mit dem Debuggen zu beginnen.

Wenn Sie einen Haltepunkt festlegen, wird neben der Zeile ein roter Punkt angezeigt, wie in Abbildung 5 zu sehen.

Abbildung 5. Wenn Sie einen Haltepunkt festlegen, wird neben der Zeile ein roter Punkt angezeigt.

Wenn die Codeausführung den Haltepunkt erreicht, pausiert Android Studio die Ausführung Ihrer App.

Verwenden Sie die Tools auf dem Tab „Debugger“, um den Status der App zu ermitteln:

  • Wenn Sie den Objektbaum für eine Variable prüfen möchten, maximieren Sie ihn in der Ansicht „Variablen“. Wenn die Ansicht „Variablen“ nicht sichtbar ist, klicken Sie auf Layouteinstellungen und prüfen Sie, ob Variablen aktiviert ist.

  • Wenn Sie zur nächsten Zeile im Code wechseln möchten, ohne eine Methode einzugeben, klicken Sie auf Überspringen .

  • Wenn Sie zur ersten Zeile innerhalb eines Methodenaufrufs wechseln möchten, klicken Sie auf Einzelschritt .

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

  • Klicken Sie auf Programm fortsetzen , um die App normal weiter auszuführen.

Wenn Ihr Projekt nativen Code verwendet, werden beim Debug-Typ „Automatisch erkennen“ standardmäßig sowohl der Java-Debugger als auch LLDB als zwei separate Prozesse an Ihre App angehängt. Sie können zwischen der Prüfung von Java- und C/C++-Haltepunkten wechseln, ohne die Anwendung neu zu starten oder Einstellungen zu ändern.

Hinweis:Damit Android Studio Haltepunkte in Ihrem C- oder C++-Code erkennt, müssen Sie einen Debug-Typ verwenden, der LLDB unterstützt, z. B. „Automatisch erkennen“, „Nativ“ oder „Dual“. Sie können den von Android Studio verwendeten Debug-Typ ändern, indem Sie die Debug-Konfiguration 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 Debug-Fenster mit einem Tab oder einer Debug-Sitzungsansicht für jeden Debugger-Prozess geöffnet, wie in Abbildung 6 dargestellt.

Abbildung 6: Nativer Code mit LLDB debuggen.
  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 „Überwachungsausdrücke“ sind ebenfalls verfügbar und funktionieren genau so, als würden Sie Java-Code debuggen.

    Obwohl der Bereich „Threads“ in der LLDB-Sitzungsansicht nicht verfügbar ist, können Sie über die Liste im Bereich „Frames“ auf Ihre App-Prozesse zugreifen. Weitere Informationen zu diesen Bereichen finden Sie in den Abschnitten zum Debugging von Fensterframes und zum Prüfen von Variablen.

    Hinweis:Während ein Haltepunkt in Ihrem nativen Code untersucht wird, hält das Android-System die virtuelle Maschine an, auf der der Java-Bytecode Ihrer App ausgeführt wird. Das bedeutet, dass Sie nicht mit dem Java-Debugger interagieren oder Statusinformationen aus Ihrer Java-Debugger-Sitzung abrufen können, während Sie einen Haltepunkt in Ihrem nativen Code prüfen.

  2. Android Studio wechselt zum Tab <your-module>-java, wenn der Java-Debugger einen Haltepunkt in Ihrem Java- oder Kotlin-Code findet.
  3. Beim Debuggen mit LLDB können Sie das LLDB-Terminal in der LLDB-Sitzungsansicht verwenden, um Befehlszeilenoptionen an LLDB zu übergeben. Wenn Sie bestimmte Befehle haben, die LLDB bei jedem Debugging-Start Ihrer App ausführen soll, 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, die als Überwachungspunkte bezeichnet werden. Diese können den App-Prozess anhalten, wenn Ihre App mit einem bestimmten Speicherblock interagiert. Weitere Informationen finden Sie im Abschnitt Beobachtungspunkte hinzufügen.

Haltepunkte ansehen und konfigurieren

Klicken Sie im Debug-Fenster auf Haltepunkte ansehen , um alle Haltepunkte aufzurufen und die Haltepunkteinstellungen zu konfigurieren. Das Fenster „Breakpoints“ wird angezeigt, wie in Abbildung 7 zu sehen.

Abbildung 7: Im Fenster „Haltepunkte“ werden alle aktuellen Haltepunkte und die zugehörigen Verhaltenseinstellungen aufgeführt.

Im Fenster „Haltepunkte“ können Sie jeden Haltepunkt in der Liste im Bereich aktivieren oder deaktivieren. Wenn ein Haltepunkt deaktiviert ist, wird die App in Android Studio nicht pausiert, wenn sie diesen Haltepunkt erreicht.

Wählen Sie einen Haltepunkt aus der Liste aus, um seine Einstellungen zu konfigurieren. Sie können einen Haltepunkt so konfigurieren, dass er zuerst deaktiviert ist und vom System aktiviert wird, nachdem ein anderer Haltepunkt erreicht wurde. Sie können auch konfigurieren, ob ein Haltepunkt deaktiviert werden soll, nachdem er erreicht wurde. Wenn Sie einen Haltepunkt für eine beliebige Ausnahme festlegen möchten, wählen Sie in der Liste der Haltepunkte Ausnahme-Haltepunkte aus.

Wenn Sie alle Haltepunkte vorübergehend deaktivieren möchten, klicken Sie im Debug-Fenster auf Haltepunkte stummschalten . Klicken Sie noch einmal, um die Funktion wieder zu aktivieren.

Fenster-Frames für die Fehlerbehebung

Im Debugger-Fenster können Sie im Bereich „Frames“ den Stapelframe prüfen, der den aktuellen Haltepunkt ausgelöst hat. So können Sie den Stapelframe aufrufen und prüfen und sich die Liste der Threads in Ihrer Android-App ansehen.

Wählen Sie einen Thread im Thread-Auswahlmenü aus und rufen Sie den zugehörigen Stapelframe auf. Klicken Sie auf die Elemente im Frame, um die Quelle im Editor zu öffnen. Sie können auch die Thread-Darstellung anpassen und den Stapelframe 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 anhält und Sie im Bereich „Frames“ einen Frame auswählen. Im Bereich „Variablen“ können Sie auch Ad-hoc-Ausdrücke mit statischen Methoden und/oder Variablen auswerten, die im ausgewählten Frame verfügbar sind.

So fügen Sie dem Objektbaum einen Ausdruck hinzu (während die Anwendung debuggt wird):

Abbildung 8. Der Objektbaum und das Feld für die Eingabe von Ausdrücken im Fenster „Fehlerbehebung“.
  1. Geben Sie den Ausdruck ein, der beobachtet oder angezeigt werden soll.
  2. Klicken Sie auf Zu Beobachtungen hinzufügen oder drücken Sie die Eingabetaste, um den Ausdruck einmal auszuwerten.

Wenn der Objektbaum den Ausdruck enthält, den Sie beobachten möchten, können Sie ihn alternativ an den Anfang des Baums ziehen, um ihn als beobachteten Ausdruck hinzuzufügen.

Beobachtete Ausdrücke werden aktualisiert, wenn Haltepunkte erreicht werden oder Sie den Code schrittweise durchgehen.

Ausgewertete Ausdrücke werden oben im Objektbaum angezeigt, bis Sie manuell einen anderen Ausdruck auswerten oder den Code schrittweise durchgehen.

Wenn Sie einen überwachten Ausdruck aus der Objektstruktur entfernen möchten, rechtsklicken Sie auf den Ausdruck und dann auf Überwachung entfernen.

Hinweise hinzufügen

Beim Debuggen von C/C++-Code können Sie spezielle Arten von Haltepunkten festlegen, die als Überwachungspunkte bezeichnet werden. Diese können den App-Prozess anhalten, 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 mit einem der beiden Zeiger auf diesen Speicherblock zugreifen.

In Android Studio könnt ihr während der Laufzeit einen Watchpoint erstellen, indem ihr eine bestimmte Variable auswählt. LLDB weist den Watchpoint jedoch nur dem Speicherblock zu, den das System dieser Variablen zuweist, nicht der Variablen selbst. Dies unterscheidet sich vom Hinzufügen einer Variablen zum Bereich „Überwachungsausdrücke“, mit dem Sie den Wert einer Variablen beobachten können, aber den App-Prozess nicht anhalten können, wenn das System den Wert im Arbeitsspeicher liest oder ändert.

Hinweis: Wenn der Anwendungsprozess eine Funktion verlässt und das System die lokalen Variablen aus dem Speicher entfernt, müssen Sie alle Watchpoints, die Sie für diese Variablen erstellt haben, neu zuweisen.

Zum Festlegen eines Watchpoints müssen die folgenden Anforderungen erfüllt sein:

  • Ihr physisches Zielgerät oder Ihr Emulator verwendet eine x86- oder x86_64-CPU. Wenn Ihr Gerät eine ARM-CPU verwendet, müssen Sie die Grenze der Adresse Ihrer Variablen im Arbeitsspeicher entweder auf 4 Byte (für 32-Bit-Prozessoren) oder auf 8 Byte (für 64-Bit-Prozessoren) ausrichten. 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)));
  • Sie haben bereits drei oder weniger Beobachtungspunkte 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 Watchpoints.

Hinweis:Wenn Sie Ihre App mit 32-Bit-ARM-ABIs debuggen, kann es zu einem Absturz kommen, wenn Sie einen Watchpoint hinzufügen oder den Mauszeiger auf Variablen im Code bewegen, um deren Werte zu untersuchen. Als Behelfslösung können Sie 64-Bit-ARM-, x86- oder x86_64-Binärdateien zum Debuggen verwenden. Dieses Problem wird in einer künftigen Android Studio-Version behoben.

Wenn Sie die Anforderungen erfüllen, können Sie einen Watchpoint so hinzufügen:

  1. Während die App an einem Haltepunkt angehalten ist, rufen Sie in der LLDB-Sitzungsansicht den Bereich „Variablen“ auf.

  2. Rechtsklicken Sie auf eine Variable, die den Speicherblock belegt, den Sie beobachten möchten, und wählen Sie Watchpoint hinzufügen aus.

    Abbildung 9. Fügt einer Variablen im Speicher einen Watchpoint hinzu.

  3. Ein Dialogfeld zum Konfigurieren des Watchpoints wird angezeigt, wie in Abbildung 9 zu sehen.

    Konfigurieren Sie den Watchpoint mit den folgenden Optionen:

    • Aktiviert:Heben Sie die Auswahl dieser Option auf, wenn Sie Android Studio anweisen möchten, den Watchpoint zu ignorieren, bis Sie die Einstellung ändern. Android Studio speichert den Watchpoint, damit Sie später darauf zugreifen können.
    • Anhalten:Standardmäßig hält das Android-System den App-Prozess an, wenn er auf einen Speicherblock zugreift, den Sie einem Watchpoint zugewiesen haben. Deaktivieren Sie diese Option, wenn Sie das nicht möchten. Dadurch werden zusätzliche Optionen angezeigt, mit denen Sie das Verhalten anpassen können, wenn das System mit Ihrem Watchpoint interagiert: Logeintrag in die Console schreiben und Bei Treffer entfernen.
    • Zugriffstyp: Wählen Sie aus, ob Ihre App den Watchpoint auslösen soll, wenn sie versucht, den Speicherblock, den das System der Variablen zuweist, zu lesen oder zu beschreiben. Wenn der Watchpoint sowohl beim Lesen als auch beim Schreiben ausgelöst werden soll, wählen Sie Beliebig aus.
  4. Klicken Sie auf Fertig.

Wenn Sie alle Ihre Watchpoints aufrufen und die Watchpoint-Einstellungen konfigurieren möchten, klicken Sie im Debug-Fenster auf Haltepunkte ansehen . Das Dialogfeld „Haltepunkte“ wird angezeigt, wie in Abbildung 10 zu sehen.

Abbildung 10: Im Dialogfeld „Haltepunkte“ werden Ihre aktuellen Beobachtungspunkte und die Verhaltenseinstellungen für jeden Beobachtungspunkt aufgeführt.

Nachdem Sie den Watchpoint hinzugefügt haben, klicken Sie im Debug-Fenster auf Programm fortsetzen , um den App-Prozess 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. Neben der Codezeile, die Ihre App zuletzt ausgeführt hat, wird ein Watchpoint-Symbol  angezeigt, wie in Abbildung 11 zu sehen.

Abbildung 11. Android Studio zeigt die Codezeile an, die Ihre App unmittelbar vor dem Auslösen eines Watchpoints ausführt.

Anzeigeformat für Ressourcenwerte ansehen und ändern

Im Debug-Modus können Sie Ressourcenwerte ansehen und ein anderes Anzeigeformat für Variablen in Ihrem Java- oder Kotlin-Code auswählen. Gehen Sie bei angezeigtem Tab „Variablen“ und ausgewähltem Frame so vor:

  1. Klicken Sie in der Variablenliste 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 werden eine oder mehrere der folgenden Optionen angezeigt:

    • Klasse: Zeigt die Klassendefinition an.
    • toString: Stringformat für die Anzeige.
    • Objekt: Zeigt die Objektdefinition (eine Instanz einer Klasse) an.
    • Array: Im Array-Format anzeigen.
    • Zeitstempel:Datum und Uhrzeit werden so angezeigt: jjjj-mm-tt hh:mm:ss.
    • Automatisch:Android Studio wählt das beste Format basierend auf dem Datentyp aus.
    • 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: Als Hexadezimalwert anzeigen.
    • Primitiv:Wird als numerischer Wert mit einem primitiven Datentyp angezeigt.
    • Ganzzahl: Als numerischer Wert vom Typ Integer anzeigen.

So erstellen Sie ein benutzerdefiniertes Format:

  1. Rechtsklicken Sie auf den Ressourcenwert.
  2. Wählen Sie Anzeigen als aus.
  3. Wählen Sie Erstellen aus.
  4. Das Dialogfeld Java Data Type Renderers wird angezeigt. Folgen Sie der Anleitung unter Java-Datentyp-Renderer.