Debugowanie aplikacji

Android Studio udostępnia debuger, który umożliwia m.in.:

  • Wybierz urządzenie, na którym chcesz debugować aplikację.
  • ustawiać punkty przerwania w kodzie Java, Kotlin i C/C++;
  • Sprawdzaj zmienne i oceniaj wyrażenia w czasie działania.

Ta strona zawiera instrukcje dotyczące podstawowych operacji debugera. Więcej informacji znajdziesz w dokumentacji debugowania w IntelliJ IDEA.

Włączanie debugowania

Zanim zaczniesz debugowanie, wykonaj te czynności:

Włącz debugowanie na urządzeniu.
Jeśli używasz emulatora, debugowanie jest domyślnie włączone. W przypadku połączonego urządzenia musisz włączyć debugowanie w opcjach programisty na urządzeniu.
Uruchom wariant kompilacji z możliwością debugowania.

Użyj wariantu kompilacji, który zawiera debuggable true (isDebuggable = true w skryptach Kotlin) w konfiguracji kompilacji.

Zwykle możesz wybrać domyślny wariant „debug”, który jest uwzględniony w każdym projekcie Android Studio, nawet jeśli nie jest widoczny w pliku build.gradle. Jeśli jednak definiujesz nowe typy kompilacji, które powinny być możliwe do debugowania, musisz dodać do nich debuggable true:

Dynamiczny

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

Kotlin

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

Ta właściwość dotyczy też modułów z kodem C/C++.

Uwaga: właściwość jniDebuggable nie jest już używana.

Jeśli aplikacja zależy od modułu biblioteki, który też chcesz debugować, ta biblioteka musi być również spakowana z debuggable true, aby zachować symbole debugowania. Aby mieć pewność, że warianty projektu aplikacji z możliwością debugowania otrzymają wariant modułu biblioteki z możliwością debugowania, opublikuj niestandardowe wersje biblioteki.

Rozpoczynanie debugowania

Sesję debugowania możesz rozpocząć w ten sposób:

  1. ustawiać punkty przerwania w kodzie aplikacji,
  2. Na pasku narzędzi wybierz urządzenie, na którym chcesz debugować aplikację, z menu urządzeń docelowych.
    Menu urządzenia docelowego.
    Rysunek 1. Menu urządzenia docelowego.

    Jeśli nie masz skonfigurowanych żadnych urządzeń, musisz podłączyć urządzenie przez USB, podłączyć urządzenie przez Wi-Fi lub utworzyć urządzenie wirtualne z Androidem, aby korzystać z Android Emulatora.

  3. Na pasku narzędzi kliknij Debuguj .

    Jeśli aplikacja jest już uruchomiona na urządzeniu, pojawi się okno z pytaniem, czy chcesz przełączyć się z trybu uruchamiania na tryb debugowania. Aby rozpocząć debugowanie, musisz ponownie uruchomić urządzenie. Aby zachować tę samą instancję aplikacji, kliknij Anuluj debugowanie i dołącz debuger do uruchomionej aplikacji. W przeciwnym razie Android Studio utworzy plik APK, podpisze go kluczem debugowania, zainstaluje na wybranym urządzeniu i uruchomi.

    Jeśli dodasz do projektu kod C i C++, Android Studio uruchomi też debuger LLDB w oknie debugowania, aby debugować kod natywny.

  4. Jeśli okno debugowania nie jest otwarte, wybierz Widok > Okna narzędzi > Debugowanie lub kliknij Debugowanie na pasku okien narzędzi.

Dołączanie debugera do działającej aplikacji

Jeśli aplikacja jest już uruchomiona na urządzeniu, możesz rozpocząć debugowanie bez jej ponownego uruchamiania w ten sposób:

  1. Kliknij Attach debugger to Android process (Dołącz debuger do procesu Androida) .
  2. W oknie Wybierz proces wybierz proces, do którego chcesz dołączyć debuger.
    1. Jeśli używasz emulatora lub urządzenia z dostępem do roota, możesz zaznaczyć Pokaż wszystkie procesy, aby wyświetlić wszystkie procesy. Na urządzeniu z dostępem do roota będą widoczne wszystkie procesy uruchomione na urządzeniu. Jednak na urządzeniu bez dostępu do roota będą widoczne tylko procesy z możliwością debugowania.
    2. W menu Use Android Debugger Settings from (Użyj ustawień debugera Androida z) możesz wybrać istniejącą konfigurację uruchamiania i debugowania. W przypadku kodu C i C++ umożliwia to ponowne użycie poleceń uruchamiania LLDB, poleceń LLDB po dołączeniu i katalogów symboli w istniejącej konfiguracji.
    3. Jeśli nie masz konfiguracji uruchamiania i debugowania, wybierz Utwórz nową. Ta opcja włącza menu Typ debugowania, w którym możesz wybrać inny typ debugowania. Domyślnie Android Studio używa typu debugowania Wykrywaj automatycznie, aby wybrać najlepszą opcję debugera na podstawie tego, czy projekt zawiera kod Java czy C/C++.
  3. Kliknij OK.

    Pojawi się okno debugowania.

Karta Procesy w Eksploratorze urządzeń (Widok > Okna narzędzi > Eksplorator urządzeń) zawiera też listę procesów z możliwością debugowania. Możesz tam wybrać proces i go zakończyć , wymusić jego zatrzymanie  lub dołączyć do niego debuger .

Okno debugowania

Rysunek 2. Okno debugowania.

Okno debugowania jest podzielone na

  1. Pasek narzędzi wykonywania i nawigacji (patrz Praca z punktami przerwania)
  2. Selektor wątków
  3. Wpis wyrażenia do oceny i obserwowania. Więcej informacji znajdziesz w artykule Sprawdzanie zmiennych.
  4. Wyświetlanie stosu
  5. Panel Zmienne. Więcej informacji znajdziesz w artykule Sprawdzanie zmiennych.

Uwaga: debuger Android Studio i moduł odzyskiwania pamięci są luźno zintegrowane. Maszyna wirtualna Androida gwarantuje, że żaden obiekt, o którym wie debuger, nie zostanie usunięty przez moduł czyszczenia pamięci, dopóki debuger się nie rozłączy. Może to spowodować nagromadzenie obiektów, gdy debuger jest połączony. Jeśli na przykład debuger wykryje działający wątek, powiązany obiekt Thread nie zostanie usunięty przez moduł czyszczenia pamięci, dopóki debuger nie zostanie odłączony, nawet jeśli wątek został zakończony.

Zmień typ debugera

Do debugowania kodu w języku Java/Kotlin i C/C++ wymagane są różne narzędzia, dlatego debuger Android Studio umożliwia wybór typu debugera. Domyślnie Android Studio decyduje, którego debugera użyć, na podstawie języków wykrytych w projekcie za pomocą typu debugera Detect Automatically (Wykrywaj automatycznie).

Aby ręcznie wybrać debuger w konfiguracji debugowania, kliknij Uruchom > Edytuj konfiguracje. Możesz też wybrać debuger w oknie, które pojawi się po kliknięciu Uruchom > Dołącz debuger do procesu Androida.

Dostępne są te typy debugowania:

Wykrywaj automatycznie
Wybierz ten typ debugowania, jeśli chcesz, aby Android Studio automatycznie wybierało najlepszą opcję dla debugowanego kodu. Jeśli na przykład w projekcie masz kod C lub C++, Android Studio automatycznie użyje typu debugowania Dual. W przeciwnym razie Android Studio używa typu debugowania Tylko Java.
Tylko Java
Wybierz ten typ debugowania, jeśli chcesz debugować tylko kod napisany w języku Java lub Kotlin. Debuger tylko dla Javy ignoruje wszystkie punkty przerwania i obserwowane zmienne ustawione w kodzie natywnym.
Tylko kod natywny (dostępne tylko w przypadku kodu C/C++)
Wybierz ten typ debugowania, jeśli chcesz używać tylko LLDB do debugowania kodu. Podczas korzystania z tego typu debugowania widok sesji debugera Javy jest niedostępny. Domyślnie LLDB sprawdza tylko kod natywny i ignoruje punkty przerwania w kodzie Java. Jeśli chcesz też debugować kod Java, przełącz się na typ debugowania Wykrywaj automatycznie lub Podwójne.

Debugowanie natywne działa tylko na urządzeniach, które spełniają te wymagania:

  • Urządzenie obsługuje run-as.

    Aby sprawdzić, czy urządzenie obsługuje run-as, uruchom to polecenie w powłoce ADB połączonej z urządzeniem:

    run-as your-package-name pwd

    Zastąp your-package-name nazwą pakietu aplikacji. Jeśli urządzenie obsługuje run-as, polecenie powinno zostać wykonane bez błędów.

  • Na urządzeniu jest włączona funkcja ptrace.

    Aby sprawdzić, czy usługa ptrace jest włączona, uruchom to polecenie w powłoce ADB połączonej z urządzeniem:

    sysctl kernel.yama.ptrace_scope

    Jeśli ptrace jest włączone, polecenie wyświetli wartość 0 lub błąd unknown key. Jeśli usługa ptrace nie jest włączona, zostanie wyświetlona wartość inna niż 0.

Dual (Java + Native) – dostępny tylko z kodem C/C++
Wybierz ten typ debugowania, jeśli chcesz przełączać się między debugowaniem kodu Java i kodu natywnego. Android Studio dołącza do procesu aplikacji zarówno debuger Javy, jak i LLDB, dzięki czemu możesz sprawdzać punkty przerwania zarówno w kodzie Javy, jak i w kodzie natywnym bez konieczności ponownego uruchamiania aplikacji czy zmiany konfiguracji debugowania.

Na rysunku 2 widać 2 karty po prawej stronie tytułu okna debugowania. Aplikacja zawiera kod w językach Java i C++, dlatego jedna karta służy do debugowania kodu natywnego, a druga do debugowania kodu w języku Java, co jest oznaczone jako -java.

Rysunek 3. Karta do debugowania kodu natywnego i karta do debugowania kodu w języku Java.

Uwaga: podczas debugowania kodu natywnego zoptymalizowanego przez kompilator może pojawić się ten komunikat ostrzegawczy:
This function was compiled with optimizations enabled. Some debugger features may not be available. Gdy używasz flag optymalizacji, kompilator wprowadza zmiany w skompilowanym kodzie, aby działał on wydajniej. Może to spowodować, że debuger będzie zgłaszać nieoczekiwane lub nieprawidłowe informacje, ponieważ trudno mu będzie zmapować zoptymalizowany skompilowany kod z powrotem na oryginalny kod źródłowy. Z tego powodu podczas debugowania kodu natywnego należy wyłączyć optymalizacje kompilatora.

Korzystanie z logu systemowego

Log systemowy wyświetla komunikaty systemowe podczas debugowania aplikacji. Te komunikaty zawierają informacje z aplikacji działających na urządzeniu. Jeśli chcesz używać logu systemowego do debugowania aplikacji, upewnij się, że kod zapisuje komunikaty logu i drukuje zrzut stosu dla wyjątków, gdy aplikacja jest w fazie programowania.

Zapisywanie komunikatów logu w kodzie

Aby zapisywać komunikaty logu w kodzie, użyj klasy Log. Komunikaty logu pomagają zrozumieć przepływ wykonywania, ponieważ zbierają dane wyjściowe debugowania systemu podczas interakcji z aplikacją. Komunikaty logu mogą też wskazywać, która część aplikacji nie działa. Więcej informacji o logowaniu znajdziesz w artykule Zapisywanie i wyświetlanie logów za pomocą Logcata.

Poniższy przykład pokazuje, jak dodać komunikaty logu, aby określić, czy informacje o poprzednim stanie są dostępne po rozpoczęciu aktywności:

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

Podczas programowania kod może też przechwytywać wyjątki i zapisywać zrzut stosu w logu systemowym:

Kotlin

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

Java

void someOtherMethod() {
    try {
        ...
    } catch (SomeException e) {
        Log.d(TAG, "someOtherMethod()", e);
    }
}

Uwaga: gdy aplikacja będzie gotowa do opublikowania, usuń z kodu komunikaty dziennika debugowania i wywołania drukowania zrzutu stosu. Aby to zrobić, ustaw flagę DEBUG i umieść komunikaty dziennika debugowania w instrukcjach warunkowych.

Wyświetlanie logu systemowego

W oknie Logcat możesz wyświetlać i filtrować komunikaty debugowania i inne komunikaty systemowe, jak pokazano na rysunku 4. Możesz na przykład zobaczyć komunikaty o usuwaniu nieużywanych obiektów lub komunikaty dodane do aplikacji za pomocą klasy Log.

Aby użyć Logcat, rozpocznij debugowanie i wybierz kartę Logcat.

Rysunek 4. Okno Logcat z ustawieniami filtra.

Opis Logcata i jego opcji filtrowania znajdziesz w artykule Zapisywanie i wyświetlanie logów za pomocą Logcata.

Praca z punktami przerwania

Android Studio obsługuje punkty przerwania, które wywołują różne działania debugowania. Istnieje kilka typów punktów przerwania:

Punkt przerwania wiersza
Najczęstszym typem jest punkt przerwania w linii, który wstrzymuje wykonywanie aplikacji w określonej linii kodu. Po wstrzymaniu możesz sprawdzić zmienne, ocenić wyrażenia, a następnie kontynuować wykonywanie wiersz po wierszu, aby określić przyczyny błędów środowiska wykonawczego.
Punkt przerwania metody
Punkt przerwania metody wstrzymuje wykonywanie aplikacji, gdy wchodzi ona do określonej metody lub ją opuszcza. Po wstrzymaniu możesz sprawdzić zmienne, ocenić wyrażenia, a następnie kontynuować wykonywanie wiersz po wierszu, aby określić przyczyny błędów środowiska wykonawczego. Gdy ustawisz punkt przerwania w funkcji typu „composable”, debuger wyświetli listę parametrów tej funkcji i ich stan, aby pomóc Ci zidentyfikować zmiany, które mogły spowodować rekompozycję.
Punkt przerwania pola
Punkt przerwania pola wstrzymuje wykonywanie aplikacji, gdy odczytuje ona dane z określonego pola lub zapisuje je w nim.
Punkt przerwania wyjątku
Punkt przerwania wyjątku wstrzymuje wykonywanie aplikacji, gdy zostanie zgłoszony wyjątek.

Możesz ustawić warunkowe punkty przerwania, które będą wstrzymywać wykonywanie tylko wtedy, gdy zostaną spełnione określone warunki. Możesz też ustawić punkty przerwania logowania, które zapisują dane w Logcat bez zawieszania wykonywania. Dzięki temu nie musisz zaśmiecać kodu instrukcjami logowania.

Aby dodać punkt przerwania wiersza, wykonaj te czynności:

  1. Znajdź wiersz kodu, w którym chcesz wstrzymać wykonywanie.
  2. Kliknij lewy margines wzdłuż tej linii kodu lub umieść kursor na linii i naciśnij Control + F8 (na macOS: Command + F8).
  3. Jeśli aplikacja jest już uruchomiona, kliknij Attach debugger to Android process (Dołącz debuger do procesu Androida) . Jeśli nie, kliknij Debuguj , aby rozpocząć debugowanie.

Po ustawieniu punktu przerwania obok wiersza pojawi się czerwona kropka, jak pokazano na rysunku 5.

Rysunek 5. Gdy ustawisz punkt przerwania, obok wiersza pojawi się czerwona kropka.

Gdy wykonywanie kodu dotrze do punktu przerwania, Android Studio wstrzyma wykonywanie aplikacji.

Aby określić stan aplikacji, użyj narzędzi na karcie Debugger:

  • Aby sprawdzić drzewo obiektów zmiennej, rozwiń je w widoku Zmienne. Jeśli widok Zmienne nie jest widoczny, kliknij Ustawienia układu i upewnij się, że opcja Zmienne jest zaznaczona.

  • Aby przejść do następnego wiersza kodu bez wprowadzania metody, kliknij Przejdź nad .

  • Aby przejść do pierwszego wiersza w wywołaniu metody, kliknij Step Into (Wejdź do funkcji) .

  • Aby przejść do następnego wiersza poza bieżącą metodą, kliknij Wyjdź .

  • Aby kontynuować normalne działanie aplikacji, kliknij Wznów program .

Jeśli projekt używa kodu natywnego, domyślnie typ debugowania Wykrywaj automatycznie dołącza do aplikacji zarówno debuger Javy, jak i LLDB jako 2 osobne procesy. Możesz przełączać się między sprawdzaniem punktów przerwania w języku Java i C/C++ bez ponownego uruchamiania aplikacji i zmieniania ustawień.

Uwaga: aby Android Studio wykrywało punkty przerwania w kodzie C lub C++, musisz użyć typu debugowania, który obsługuje LLDB, np. Wykrywaj automatycznie, Natywny lub Podwójny. Możesz zmienić typ debugowania używany przez Android Studio, edytując konfigurację debugowania. Aby dowiedzieć się więcej o różnych typach debugowania, przeczytaj sekcję o korzystaniu z innych typów debugowania.

Gdy Android Studio wdroży aplikację na urządzeniu docelowym, otworzy się okno debugowania z kartą lub widokiem sesji debugowania dla każdego procesu debugera, jak pokazano na rysunku 6.

Rysunek 6. Debugowanie kodu natywnego za pomocą LLDB.
  1. Gdy debuger LLDB napotka punkt przerwania w kodzie C/C++, Android Studio przełączy się na kartę <your-module>. Dostępne są też panele Ramki, Zmienne i Obserwowane, które działają dokładnie tak samo jak podczas debugowania kodu w języku Java.

    Chociaż panel Threads (Wątki) nie jest dostępny w widoku sesji LLDB, możesz uzyskać dostęp do procesów aplikacji, korzystając z listy w panelu Frames (Ramki). Więcej informacji o tych panelach znajdziesz w sekcjach dotyczących debugowania ramek okien i sprawdzania zmiennych.

    Uwaga: podczas sprawdzania punktu przerwania w kodzie natywnym system Android zawiesza maszynę wirtualną, która uruchamia kod bajtowy Javy aplikacji. Oznacza to, że podczas sprawdzania punktu przerwania w kodzie natywnym nie możesz korzystać z debugera Javy ani pobierać żadnych informacji o stanie z sesji debugera Javy.

  2. Android Studio przełącza się na kartę <your-module>-java, gdy debuger Javy napotka punkt przerwania w kodzie Javy lub Kotlina.
  3. Podczas debugowania za pomocą LLDB możesz używać terminala LLDB w widoku sesji LLDB, aby przekazywać opcje wiersza poleceń do LLDB. Jeśli masz określone polecenia, które LLDB ma wykonywać przy każdym uruchomieniu debugowania aplikacji, tuż przed dołączeniem debugera do procesu aplikacji lub tuż po nim, możesz dodać te polecenia do konfiguracji debugowania.

Podczas debugowania kodu C/C++ możesz też ustawić specjalne typy punktów przerwania, zwane punktami obserwacji, które mogą zawiesić proces aplikacji, gdy aplikacja wejdzie w interakcję z określonym blokiem pamięci. Więcej informacji znajdziesz w sekcji poświęconej dodawaniu punktów obserwacji.

Wyświetlanie i konfigurowanie punktów przerwania

Aby wyświetlić wszystkie punkty przerwania i skonfigurować ich ustawienia, w oknie debugowania kliknij View Breakpoints (Wyświetl punkty przerwania) . Pojawi się okno Breakpoints (Punkty przerwania), jak pokazano na rysunku 7.

Rysunek 7. W oknie Punkty przerwania znajdziesz listę wszystkich bieżących punktów przerwania wraz z ustawieniami ich działania.

Okno Punkty przerwania umożliwia włączanie i wyłączanie poszczególnych punktów przerwania z listy w panelu. Jeśli punkt przerwania jest wyłączony, Android Studio nie wstrzymuje aplikacji, gdy osiągnie ona ten punkt.

Wybierz punkt przerwania z listy, aby skonfigurować jego ustawienia. Możesz skonfigurować punkt przerwania tak, aby był początkowo wyłączony, a system włączył go po osiągnięciu innego punktu przerwania. Możesz też skonfigurować, czy punkt przerwania ma być wyłączony po jego osiągnięciu. Aby ustawić punkt przerwania dla dowolnego wyjątku, na liście punktów przerwania wybierz Punkty przerwania wyjątków.

Aby tymczasowo wyłączyć wszystkie punkty przerwania, w oknie debugowania kliknij Wycisz punkty przerwania . Kliknij ponownie, aby włączyć.

Ramki okna debugowania

W oknie debugera panel Ramki umożliwia sprawdzenie ramki stosu, która spowodowała osiągnięcie bieżącego punktu przerwania. Dzięki temu możesz poruszać się po ramce stosu i ją sprawdzać, a także przeglądać listę wątków w aplikacji na Androida.

Aby wybrać wątek, użyj menu wyboru wątku i wyświetl jego ramkę stosu. Kliknij elementy w ramce, aby otworzyć źródło w edytorze. Możesz też dostosować prezentację wątku i wyeksportować ramkę stosu zgodnie z opisem w przewodniku po sprawdzaniu ramek.

Sprawdzanie zmiennych

W oknie debugera panel Zmienne umożliwia sprawdzanie zmiennych, gdy system zatrzyma aplikację w punkcie przerwania i wybierzesz ramkę w panelu Ramki. Panel Zmienne umożliwia też ocenę wyrażeń ad hoc przy użyciu metod statycznych lub zmiennych dostępnych w wybranej ramce.

Aby dodać wyrażenie do drzewa obiektów (podczas debugowania aplikacji):

Rysunek 8. Drzewo obiektów i pole wprowadzania wyrażeń w oknie debugowania.
  1. Wpisz wyrażenie, które chcesz obserwować lub wyświetlić
  2. Kliknij Dodaj do obserwowanych lub naciśnij Enter, aby jednorazowo ocenić wyrażenie.

Jeśli drzewo obiektów zawiera wyrażenie, które chcesz obserwować, możesz przeciągnąć je na górę drzewa, aby dodać je jako obserwowane wyrażenie.

Obserwowane wyrażenia będą aktualizowane po osiągnięciu punktów przerwania lub podczas przechodzenia przez kod.

Ocenione wyrażenia będą wyświetlane u góry drzewa obiektów, dopóki nie ocenisz ręcznie innego wyrażenia lub nie przejdziesz przez kod.

Aby usunąć obserwowane wyrażenie z drzewa obiektów, kliknij je prawym przyciskiem myszy, a następnie kliknij Usuń obserwowane.

Dodawanie punktów obserwacji

Podczas debugowania kodu C/C++ możesz ustawić specjalne typy punktów przerwania, nazywane punktami obserwacji, które mogą zawiesić proces aplikacji, gdy wejdzie ona w interakcję z określonym blokiem pamięci. Jeśli na przykład ustawisz 2 wskaźniki na blok pamięci i przypiszesz do niego punkt obserwacji, użycie dowolnego wskaźnika do uzyskania dostępu do tego bloku pamięci spowoduje aktywowanie punktu obserwacji.

W Android Studio możesz utworzyć punkt obserwacji w czasie działania, wybierając konkretną zmienną, ale LLDB przypisuje punkt obserwacji tylko do bloku pamięci przydzielonego przez system do tej zmiennej, a nie do samej zmiennej. Różni się to od dodania zmiennej do panelu Obserwowane, co umożliwia obserwowanie wartości zmiennej, ale nie pozwala na zawieszenie procesu aplikacji, gdy system odczytuje lub zmienia jej wartość w pamięci.

Uwaga: gdy proces aplikacji opuści funkcję, a system zwolni jej zmienne lokalne z pamięci, musisz ponownie przypisać wszystkie punkty obserwacji utworzone dla tych zmiennych.

Aby ustawić punkt obserwacji, musisz spełniać te wymagania:

  • Docelowe urządzenie fizyczne lub emulator używa procesora x86 lub x86_64. Jeśli urządzenie korzysta z procesora ARM, musisz wyrównać granicę adresu zmiennej w pamięci do 4 bajtów w przypadku procesorów 32-bitowych lub 8 bajtów w przypadku procesorów 64-bitowych. Aby wyrównać zmienną w kodzie natywnym, określ __attribute__((aligned(num_bytes))) w deklaracji zmiennej, jak pokazano poniżej: 
    // For a 64-bit ARM processor
int my_counter __attribute__((aligned(8)));
  • Masz już przypisane co najwyżej 3 punkty obserwacji. Android Studio obsługuje tylko do 4 punktów obserwacji na urządzeniach docelowych x86 lub x86_64. Inne urządzenia mogą obsługiwać mniej punktów obserwacji.

Uwaga: podczas debugowania aplikacji za pomocą 32-bitowych interfejsów ABI ARM dodanie punktu obserwacji lub najechanie kursorem na zmienne w kodzie w celu sprawdzenia ich wartości może spowodować awarię. Aby obejść ten problem, debuguj za pomocą 64-bitowych plików binarnych ARM, x86 lub x86_64. Ten problem zostanie rozwiązany w nadchodzącej wersji Android Studio.

Jeśli spełniasz wymagania, możesz dodać punkt obserwacji w ten sposób:

  1. Gdy aplikacja zostanie zawieszona w punkcie przerwania, przejdź do panelu Zmienne w widoku sesji LLDB.

  2. Kliknij prawym przyciskiem myszy zmienną, która zajmuje blok pamięci, który chcesz śledzić, i wybierz Dodaj punkt obserwacji.

    Rysunek 9. Dodaj punkt obserwacji do zmiennej w pamięci.

  3. Pojawi się okno konfiguracji punktu obserwacji, jak pokazano na rysunku 9.

    Skonfiguruj punkt obserwacji, korzystając z tych opcji:

    • Włączony:odznacz tę opcję, jeśli chcesz, aby Android Studio ignorowało punkt obserwacji, dopóki nie zmienisz ustawienia. Android Studio zapisuje punkt obserwacji, aby można było uzyskać do niego dostęp później.
    • Zawieś:domyślnie system Android zawiesza proces aplikacji, gdy uzyskuje ona dostęp do bloku pamięci przypisanego do punktu obserwacji. Odznacz tę opcję, jeśli nie chcesz, aby tak się działo. Spowoduje to wyświetlenie dodatkowych opcji, których możesz użyć do dostosowania zachowania, gdy system wejdzie w interakcję z punktem obserwacji: Zapisz komunikat logu w konsoli i Usuń po trafieniu.
    • Typ dostępu: wybierz, czy aplikacja ma aktywować punkt obserwacji, gdy próbuje odczytać lub zapisać blok pamięci przydzielony przez system zmiennej. Aby aktywować punkt obserwacji podczas odczytu lub zapisu, wybierz Dowolny.
  4. Kliknij Gotowe.

Aby wyświetlić wszystkie punkty obserwacji i skonfigurować ich ustawienia, w oknie debugowania kliknij Wyświetl punkty przerwania . Pojawi się okno Breakpoints (Punkty przerwania), jak na rysunku 10.

Rysunek 10. W oknie Punkty przerwania znajdziesz listę bieżących punktów obserwacji oraz ustawienia zachowania dla każdego z nich.

Po dodaniu punktu obserwacji kliknij Wznów program w oknie debugowania, aby wznowić proces aplikacji. Domyślnie, jeśli aplikacja próbuje uzyskać dostęp do bloku pamięci, dla którego ustawiono punkt obserwacji, system Android zawiesza proces aplikacji, a obok ostatniego wykonanego wiersza kodu pojawia się ikona punktu obserwacji , jak pokazano na rysunku 11.

Rysunek 11. Android Studio wskazuje wiersz kodu, który aplikacja wykonuje tuż przed aktywowaniem punktu obserwacji.

Wyświetlanie i zmienianie formatu wyświetlania wartości zasobów

W trybie debugowania możesz wyświetlać wartości zasobów i wybierać inny format wyświetlania zmiennych w kodzie Java lub Kotlin. Po wyświetleniu karty Zmienne i wybraniu klatki wykonaj te czynności:

  1. Na liście zmiennych kliknij prawym przyciskiem myszy w dowolnym miejscu w wierszu zasobu, aby wyświetlić listę.
  2. Na liście kliknij Wyświetl jako i wybierz format, którego chcesz użyć.

    Dostępne formaty zależą od typu danych wybranego zasobu. Możesz zobaczyć jedną lub kilka z tych opcji:

    • Class (Klasa): wyświetla definicję klasy.
    • toString: format ciągu znaków do wyświetlenia.
    • Obiekt:wyświetla definicję obiektu (instancji klasy).
    • Tablica:wyświetlanie w formacie tablicy.
    • Sygnatura czasowa: wyświetla datę i godzinę w formacie rrrr-mm-dd gg:mm:ss.
    • Automatycznie:Android Studio wybiera najlepszy format na podstawie typu danych.
    • Dwójkowy: wyświetla wartość binarną za pomocą zer i jedynek.
    • MeasureSpec: wartość przekazywana z elementu nadrzędnego do wybranego elementu podrzędnego. Zobacz: MeasureSpec.
    • Hex:wyświetlanie jako wartość szesnastkowa.
    • Typ podstawowy: wyświetlaj jako wartość liczbową, używając podstawowego typu danych.
    • Liczba całkowita: wyświetla jako wartość liczbową typu Integer.

Aby utworzyć format niestandardowy:

  1. Kliknij prawym przyciskiem myszy wartość zasobu.
  2. Kliknij Wyświetl jako.
  3. Kliknij Utwórz.
  4. Pojawi się okno Java Data Type Renderers (Renderery typów danych Java). Postępuj zgodnie z instrukcjami podanymi w artykule Java Data type renderers (Renderery typów danych w języku Java).