Debugowanie aplikacji

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

  • Wybierz urządzenie, na którym chcesz debugować aplikację.
  • Ustaw punkty przerwania w kodzie Java, Kotlin i C/C++.
  • Badanie zmiennych i ocenianie wyrażeń w czasie działania.

Na tej stronie znajdziesz instrukcje dotyczące podstawowych operacji debugowania. Więcej informacji znajdziesz też w dokumentacji dotyczącej 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 dla deweloperów.
Uruchom wariant kompilacji z możliwością debugowania.

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

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

Groovy

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 jest zależna od modułu biblioteki, który również chcesz debugować, ta biblioteka musi być skompilowana z debuggable true, aby zachować symbole debugowania. Aby mieć pewność, że wersje z możliwością debugowania projektu aplikacji otrzymają wersję z możliwością debugowania modułu biblioteki, opublikuj wersje biblioteki inne niż domyślna.

Rozpocznij debugowanie

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

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

    Jeśli nie masz skonfigurowanych żadnych urządzeń, musisz połączyć urządzenie przez USB, połączyć je z Wi-Fi lub utworzyć urządzenie AVD, aby używać emulatora Androida.

  3. Na pasku narzędzi kliknij Debugowanie .

    Jeśli aplikacja jest już uruchomiona na urządzeniu, wyświetli się okno z pytaniem, czy chcesz przełączyć się z trybu Uruchom na Debugowanie. Aby rozpocząć debugowanie, urządzenie musi zostać ponownie uruchomione. Aby utrzymać uruchomioną tę samą instancję aplikacji, kliknij Anuluj debugowanie i podłącz zamiast tego 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 Debugowanie jest zamknięte, kliknij Widok > Okna narzędzi > Debugowanie lub kliknij Debugowanie na pasku okna narzędzi.

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

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

  1. Kliknij Załącz debugger 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 rootem, możesz zaznaczyć pole Pokaż wszystkie procesy, aby wyświetlić wszystkie procesy. Na urządzeniu z rootem wyświetli się lista wszystkich procesów działających na urządzeniu. Jednak na urządzeniu bez uprawnień roota będą widoczne tylko procesy, które można debugować.
    2. W menu Użyj ustawień Android Debugger możesz wybrać istniejącą konfigurację uruchamiania/debugowania. W przypadku kodu C i C++ umożliwia to ponowne użycie poleceń uruchamiania LLDB, poleceń LLDB po załączeniu i katalogów symboli w dotychczasowej konfiguracji.
    3. Jeśli nie masz konfiguracji uruchomienia/debugowania, wybierz Utwórz nową. Ta opcja umożliwia wyświetlenie menu Typ debugowania, w którym możesz wybrać inny typ debugowania. Domyślnie Android Studio używa opcji Wykrywanie automatycznie, aby wybrać dla Ciebie najlepszą opcję debugowania na podstawie tego, czy Twój projekt zawiera kod Java czy C/C++.
  3. Kliknij OK.

    Pojawi się okno debugowania.

Na karcie Procesy w Eksploratorze urządzeń (Widok > Okna narzędziowe > Eksplorator urządzenia) znajduje się też lista procesów, które można debugować. Możesz wybrać proces i wykonać operację kill lub stop, a także dołączyć debuger do danego procesu.

Okno debugowania

Rysunek 2. Okno debugowania.

Okno debugowania jest podzielone na

  1. Pasek narzędzi do wykonywania i przechodzenia między funkcjami Zobacz Praca z punktami kontrolnymi
  2. Selektor wątku
  3. Obliczanie i wyrażenie do oglądania. Przeczytaj sekcję Sprawdzanie zmiennych.
  4. Wyświetlanie grupy
  5. Panel Zmienne Zapoznaj się z artykułem Sprawdzanie zmiennych.

Uwaga: debuger i odśmieciarka w Android Studio są luźno połączone. Wirtualna maszyna Androida gwarantuje, że żaden obiekt znany debugerowi nie zostanie zebrany jako śmieci, dopóki debuger nie zostanie odłączony. Może to spowodować nagromadzenie się obiektów podczas połączenia z debugerem. Jeśli na przykład debuger widzi działający wątek, powiązany z nim obiekt Thread nie jest usuwany do czasu, gdy debuger się rozłączy, nawet jeśli wątek został zakończony.

Zmiana typu debugera

Debugowanie kodu w języku Java/Kotlin i C/C++ wymaga użycia różnych narzędzi debugowania, dlatego w debugerze Android Studio możesz wybrać, którego z nich chcesz użyć. Domyślnie Android Studio wybiera, którego debugera użyć, na podstawie języków wykrytych w projekcie przy użyciu typu debugera 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 typy debugowania:

Wykryj automatycznie
Wybierz ten typ debugowania, jeśli chcesz, aby Android Studio automatycznie wybierało najlepszą opcję dla kodu, który debugujesz. 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 Java-Only.
Tylko Java
Wybierz ten typ debugowania, jeśli chcesz debugować tylko kod napisany w języku Java lub Kotlin. Debuger, który działa tylko w Javie, ignoruje punkty przerwania lub obserwacje ustawione w kodzie natywnym.
Tylko natywne (dostępne tylko w przypadku kodu C/C++)
Wybierz ten typ debugowania, jeśli chcesz debugować kod tylko za pomocą LLDB. Gdy używasz tego typu debugowania, widok sesji w debugerze Java jest niedostępny. DomyślnieLLDB sprawdza tylko kod natywny i ignoruje punkty przerwania w kodzie Java. Jeśli chcesz debugować kod Java, zmień typ debugowania na „Wykrywaj automatycznie” lub „Podwójne debugowanie”.

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 swojej aplikacji. Jeśli urządzenie obsługuje run-as, polecenie powinno zwrócić wynik bez błędów.

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

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

    sysctl kernel.yama.ptrace_scope

    Jeśli zasada ptrace jest włączona, polecenie wyświetli wartość 0 lub błąd unknown key. Jeśli opcja ptrace nie jest włączona, zostanie wydrukowana wartość inna niż 0.

Podwójny (Java + natywna) – dostępny tylko przy użyciu kodu C/C++
Wybierz ten typ debugowania, jeśli chcesz przełączać się między debugowaniem kodu natywnego i Java. Android Studio dołącza do procesu aplikacji zarówno debuger Javy, jak i LLDB, aby umożliwić Ci sprawdzanie punktów przerwania w kodzie natywnym i w kodzie w Javie bez restartowania aplikacji ani zmiany konfiguracji debugowania.

Na rysunku 2 widać 2 karty po prawej stronie tytułu okna Debugowanie. Aplikacja zawiera kod zarówno w języku Java, jak i C++, więc jedna karta służy do debugowania kodu natywnego, a druga – do debugowania kodu Java, co jest wskazywane przez parametr -java.

Rysunek 3. Karta do debugowania kodu natywnego i karta do debugowania kodu Java.

Uwaga: podczas debugowania kodu natywnego zoptymalizowanego przez kompilator możesz zobaczyć to ostrzeżenie:
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 zwiększyć jego wydajność. Może to spowodować, że debuger będzie raportować nieoczekiwane lub nieprawidłowe informacje, ponieważ trudno jest mu przypisać zoptymalizowany skompilowany kod do pierwotnego kodu źródłowego. Z tego powodu podczas debugowania kodu natywnego należy wyłączyć optymalizacje kompilatora.

Korzystanie z dziennika systemowego

Dziennik systemowy pokazuje komunikaty systemowe podczas debugowania aplikacji. Zawierają one informacje z aplikacji działających na urządzeniu. Jeśli chcesz debugować aplikację za pomocą dziennika systemowego, zadbaj o to, aby Twój kod zapisywał komunikaty dziennika i wyświetlał ślad stosu w przypadku wyjątków na etapie tworzenia aplikacji.

Pisanie komunikatów logowania w kodzie

Aby zapisywać komunikaty dziennika w kodzie, użyj klasy Log. Komunikaty logowania pomagają zrozumieć przepływ wykonywania, ponieważ zbierają dane debugowania systemu podczas interakcji z aplikacją. Mogą też informować, która część aplikacji uległa awarii. Więcej informacji o rejestrowaniu znajdziesz w artykule Zapisywanie i wyświetlanie logów za pomocą narzędzia Logcat.

Ten przykład pokazuje, jak dodać komunikaty logowania, aby określić, czy informacje o poprzednim stanie są dostępne, gdy rozpoczyna się Twoja aktywność:

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 tworzenia kod może też przechwytywać wyjątki i zapisywać zrzuty stosu do dziennika systemu:

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 jej kodu komunikaty z logu debugowania i wyświetlenia wyników wywołań w zrzucie stosu. Aby to zrobić, ustaw flagę DEBUG i umieścić komunikaty z logu debugowania w oświadczeniach warunkowych.

Wyświetlanie dziennika systemowego

W oknie Logcat możesz wyświetlać i filtrować debugowanie oraz inne komunikaty systemowe (patrz rys. 4). Możesz na przykład zobaczyć komunikaty o zbieraniu pamięci podręcznej lub komunikaty dodane do aplikacji za pomocą klasy Log.

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

Rysunek 4. Okno Logcat z ustawieniami filtra

Opis narzędzia Logcat i jego opcji filtrowania znajdziesz w artykule Zapisywanie i wyświetlanie dzienników za pomocą narzędzia Logcat.

Praca z punktami przerwania

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

Punkt przerwania linii
Najpopularniejszym typem jest punkt przerwania wiersza, który wstrzymuje wykonanie aplikacji w określonym wierszu kodu. Po wstrzymaniu funkcji możesz sprawdzać zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie kodu po jednym w wierszu, aby ustalić przyczyny błędów środowiska wykonawczego.
Punkt przerwania metody
Punkt przerwania metody wstrzymuje wykonywanie aplikacji, gdy wchodzi ona do określonej metody lub z niej wychodzi. Po wstrzymaniu funkcji możesz sprawdzać zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie kodu po jednym w wierszu, aby ustalić przyczyny błędów środowiska wykonawczego. Gdy ustawisz punkt przerwania w funkcji kompozytowej, debuger wyświetli parametry tej funkcji kompozytowej oraz ich stan, aby ułatwić określenie, jakie zmiany mogły spowodować jej ponowne skompilowanie.
Punkt przerwania pola
Punkt przerwania w polu wstrzymuje wykonywanie aplikacji, gdy ta odczytuje lub zapisze dane w określonym polu.
Punkt przerwania wyjątku
Punkt przerwania wyjątku wstrzymuje działanie aplikacji po zgłoszeniu wyjątku.

Możesz ustawić punkty przerwania warunkowe, które zawieszą wykonywanie kodu 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 przełamania wiersza:

  1. Znajdź wiersz kodu, w którym chcesz wstrzymać wykonywanie.
  2. Kliknij lewą krawędź pola po lewej stronie danej linii kodu lub umieść kursor na linii i naciśnij Control+F8 (w systemie macOS Command+F8).
  3. Jeśli aplikacja jest już uruchomiona, kliknij Dołącz debuger do procesu Androida . Aby rozpocząć debugowanie, kliknij Debuguj.

Gdy ustawisz punkt kontrolny, obok linii pojawi się czerwona kropka (patrz rysunek 5).

Rysunek 5. Po ustawieniu punktu przerwania obok linii pojawi się czerwona kropka.

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

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

  • Aby przeanalizować drzewo obiektów pod kątem zmiennej, rozwiń ją w widoku Zmienne. Jeśli widok Zmienne jest niewidoczny, kliknij Ustawienia układu i upewnij się, że zaznaczona jest opcja Zmienna.

  • Aby przejść do następnego wiersza kodu bez wpisywania metody, kliknij Step Over .

  • Aby przejść do pierwszego wiersza wywołania metody, kliknij Step Into (Krok do) .

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

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

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

Uwaga: aby Android Studio mogło wykrywać punkty przerwania w kodzie C lub C++, musisz użyć typu debugowania, który obsługuje LLDB, np. wykrywanie automatyczne, natywny lub podwójny. Aby zmienić typ debugowania używany przez Android Studio, edytuj konfigurację debugowania. Aby dowiedzieć się więcej o różnych typach debugowania, przeczytaj sekcję o używaniu innych typów debugowania.

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

Rysunek 6. Debugowanie kodu natywnego za pomocą LLDB.
  1. Gdy debugger LLDB napotka punkt przerwania w kodzie C/C++, Android Studio przełączy się na kartę <your-module>. Dostępne są również panele Ramki, Zmienne i Zegarki. Działają one dokładnie w taki sam sposób, w jaki działają one w przypadku debugowania kodu w Javie.

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

    Uwaga: podczas sprawdzania punktu przerwania w kodzie natywnym system Android zawiesza maszynę wirtualną, która wykonuje bajtkod Java aplikacji. Oznacza to, że podczas sprawdzania punktu przerwania w kodzie natywnym nie możesz wchodzić w interakcję z debugerem Java ani pobierać żadnych informacji o stanie z sesji debugera Java.

  2. Gdy debuger Java napotka punkt przerwania w kodzie Java lub Kotlin, Android Studio przełączy się na kartę <your-module>.
  3. Podczas debugowania za pomocą LLDB możesz użyć terminala LLDB w widoku sesji LLDB, aby przekazać opcje wiersza poleceń do LLDB. Jeśli masz określone polecenia, które LLDB ma być wykonywane za każdym razem, gdy rozpoczynasz debugowanie aplikacji – tuż przed dołączeniem debugera do procesu aplikacji lub tuż po jego podłączeniu, możesz dodać te polecenia do konfiguracji debugowania.

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

Wyświetlanie i konfigurowanie punktów przerwania

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

Rysunek 7. W oknie Punkty graniczne wyświetla się lista wszystkich punktów granicznych wraz z ustawieniami zachowania dla każdego z nich.

W oknie Punkty przerwania możesz włączać i wyłączać poszczególne punkty przerwania na liście w panelu. Jeśli punkt przerwania jest wyłączony, Android Studio nie wstrzymuje aplikacji, gdy osiągnie ten punkt przerwania.

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

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

Ramki okna debugowania

Okienko Klatki w oknie Debuger umożliwia sprawdzenie ramki stosu, która spowodowała działanie bieżącego punktu przerwania. Dzięki temu możesz poruszać się po ramce stosu i sprawdzać ją, a także przeglądać listę wątków w aplikacji na Androida.

Aby wybrać wątek, użyj menu selektora 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 ramkach.

Sprawdzanie zmiennych

W oknie debugera panel Zmienne umożliwia sprawdzanie zmiennych, gdy system zatrzyma aplikację w miejscu punktu przerwania, a Ty wybierzesz kadr w panelu Kadry. W panelu Zmienne możesz też oceniać wyrażenia doraźne z użyciem 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żenia w oknie debugowania
  1. Wpisz wyrażenie, które chcesz wyświetlić lub obejrzeć
  2. Kliknij Dodaj do obserwowanych lub naciśnij klawisz Enter, aby przeanalizować wyrażenie raz.

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

Obserwowane wyrażenia będą aktualizowane po wystąpieniu punktów przerwania lub gdy przejdziesz przez kod.

Wyrażenia po przetworzeniu pozostają wyświetlane u góry drzewa obiektów, dopóki ręcznie nie przetworzysz 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 wybierz Usuń zegarek.

Dodaj punkty obserwacji

Podczas debugowania kodu C/C++ możesz ustawiać specjalne typy punktów przerwania, zwane punktami obserwacji, które mogą zawieszać proces aplikacji, gdy aplikacja wchodzi 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 z tych wskaźników do uzyskania dostępu do tego bloku pamięci spowoduje wywołanie punktu obserwacji.

W Android Studio możesz utworzyć punkt obserwacji podczas działania aplikacji, wybierając konkretną zmienną, ale LLDB przypisuje punkt obserwacji tylko do bloku pamięci przydzielonego przez system tej zmiennej, a nie do samej zmiennej. Różnica polega na tym, że dodanie zmiennej do panelu Obserwacje umożliwia obserwowanie wartości zmiennej, ale nie pozwala zawiesić procesu aplikacji, gdy system odczytuje lub zmieni jej wartość w pamięci.

Uwaga: gdy proces aplikacji wyjdzie z funkcji, a system przydzieli jej zmienne lokalne z pamięci, musisz ponownie przypisać wszystkie punkty kontrolne utworzone dla tych zmiennych.

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

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

Uwaga: podczas debugowania aplikacji z 32-bitowymi 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 naprawiony w kolejnej wersji Androida Studio.

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

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

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

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

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

    Skonfiguruj punkt obserwacji, korzystając z tych opcji:

    • Włączone: odznacz tę opcję, jeśli chcesz, aby usługa Android Studio ignorowała punkt obserwacji, dopóki nie zmienisz tego ustawienia. Android Studio zapisuje punkt obserwacji, aby można było do niego później wrócić.
    • Zawieś: domyślnie system Android zawiesza proces aplikacji po uzyskaniu dostępu do bloku pamięci przypisanego do punktu kontrolnego. Odznacz tę opcję, jeśli nie chcesz, aby takie ustawienie było dostępne. Wyświetli to dodatkowe opcje, których możesz użyć do dostosowania działania systemu podczas interakcji z punktem kontrolnym: Zapisywanie wiadomości w konsoli i Usuwanie po trafieniu.
    • Typ dostępu: wybierz, czy aplikacja ma wywoływać punkt kontrolny, gdy próbuje odczytać lub zapisać do bloku pamięci przydzielonego zmiennej przez system. Aby aktywować punkt obserwacji przy odczyty lub zapisie, wybierz Dowolna.
  4. Kliknij Gotowe.

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

Rysunek 10. W oknie Punkty kontrolne wyświetla się lista bieżących punktów kontrolnych i ich ustawienia.

Po dodaniu punktu kontrolnego kliknij Wznów program w oknie debugowania, aby wznowić proces w aplikacji. Domyślnie, jeśli aplikacja spróbuje uzyskać dostęp do bloku pamięci, dla którego ustawisz punkt obserwacji, system Android zawiesi proces aplikacji, a obok wiersza kodu, który został przez aplikację wykonany jako ostatni, jak widać na rysunku 11, pojawi się ikona punktu obserwacji .

Rysunek 11. Android Studio wskazuje wiersz kodu, który aplikacja wykonuje tuż przed wywołaniem 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 ramki wykonaj te czynności:

  1. Aby wyświetlić listę, kliknij prawym przyciskiem myszy dowolne miejsce na liście Zmienne w miejscu, w którym znajduje się linia zasobu.
  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 wyświetlania.
    • Obiekt: wyświetl definicję obiektu (instancji klasy).
    • tablica: wyświetlanie w formacie tablicowym.
    • Znaczniki czasu: wyświetlanie daty i godziny w formacie rrrr-mm-dd gg:mm:ss.
    • Automatycznie: Android Studio wybiera najlepszy format na podstawie typu danych.
    • Wartość binarna: wyświetlaj wartość binarną składającą się z zer i jedynek.
    • MeasureSpec: wartość przekazana z elementu nadrzędnego do wybranego podrzędnego. Zobacz MeasureSpec.
    • Hex: wyświetlanie jako wartości szesnastkowej.
    • Prymityw: wyświetlanie jako wartości liczbowej za pomocą prymitywnego typu danych.
    • Liczba całkowita: wyświetlanie jako wartość liczbowa typu Integer.

Aby utworzyć format niestandardowy:

  1. Kliknij wartość zasobu prawym przyciskiem myszy.
  2. Kliknij Wyświetl jako.
  3. Kliknij Utwórz.
  4. Pojawi się okno Mechanizmy renderowania typu danych Java. Postępuj zgodnie z instrukcjami podanymi w artykule Wyświetlacze typów danych Java.