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++.
  • sprawdzać zmienne i obliczać wyrażenia w czasie działania;

Ta strona zawiera instrukcje dotyczące podstawowych operacji w debugerze. Więcej informacji znajdziesz też w dokumentacji debugowania 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 podłączyć urządzenie przez USB, podłączyć urządzenie przez Wi-Fi lub utworzyć AVD, aby korzystać z 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, musisz ponownie uruchomić urządzenie. 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 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ń debugera Androida możesz wybrać istniejące ustawienie wykonywania lub 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ądzenia (Widok > Okna narzędzi > 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: Praca z punktami kontrolnymi
  2. Selektor wątku
  3. Obliczanie i wyrażenie do oglądania. Zapoznaj się z artykułem 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 przeznaczony tylko do Java ignoruje wszystkie punkty przerwania i punkty obserwacji 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ójny”.

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 zwrócić wynik bez błędów.

  • Na urządzeniu musi być włączona funkcja ptrace.

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

    sysctl kernel.yama.ptrace_scope

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

Dual (Java + Native) – dostępne tylko w przypadku 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 debuger Java i LLDB, dzięki czemu możesz sprawdzać punkty przerwania zarówno w kodzie natywnym, jak i w kodzie natywnym, bez restartowania aplikacji lub 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 sygnalizowane 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

Podczas debugowania aplikacji dziennik systemowy wyświetla komunikaty systemowe. 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
Najczęstszym typem jest punkt przerwania linii, który wstrzymuje wykonywanie aplikacji w określonym wierszu kodu. W trybie pauzy możesz sprawdzać zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie kodu liniowo, aby określić przyczyny błędów w czasie wykonywania.
Punkt przerwania metody
Punkt przerwania metody wstrzymuje wykonywanie aplikacji, gdy wchodzi ona do określonej metody lub z niej wychodzi. W trybie pauzy możesz sprawdzać zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie kodu liniowo, aby określić przyczyny błędów w czasie wykonywania. Gdy ustawisz punkt przerwania w funkcji kompozytowej, debuger wyświetli parametry tej funkcji kompozytowej i 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
Przystanek wyjątku wstrzymuje wykonywanie aplikacji, gdy zostanie zgłoszony wyjątek.

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 rejestrowania, które zapisują dane w Logcat bez zawieszania wykonania. Dzięki temu nie musisz zaśmiecać kodu instrukcjami logowania.

Aby dodać punkt przełamania wiersza:

  1. Odszukaj wiersz kodu, w którym chcesz wstrzymać wykonywanie kodu.
  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 Załą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. Gdy ustawisz punkt kontrolny, 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 sprawdzić, czy zmienna znajduje się w drzewie obiektów, 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 w wywołaniu metody, kliknij Wejdź 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. Możesz przełączać się między punktami kontrolnymi w Javie i C/C++ bez restartowania aplikacji ani zmieniania 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 wdroży aplikację na urządzeniu docelowym, otworzy się okno Debugowanie 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 debugger 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 Zegarki, które działają dokładnie tak samo jak w przypadku debugowania kodu Java.

    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>-java.
  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 polecenia, które chcesz wykonywać w LLDB za każdym razem, gdy rozpoczynasz debugowanie aplikacji, tuż przed lub tuż po dołączeniu debugera do procesu aplikacji, 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 do niego dojdzie.

Wybierz punkt kontrolny z listy, aby skonfigurować jego ustawienia. Możesz skonfigurować punkt kontrolny tak, aby był najpierw wyłączony, a system włączył go po osiągnięciu innego punktu kontrolnego. 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, w oknie debugowania kliknij Wyłącz punkty przerwania . Kliknij ponownie, aby ponownie 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 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. Na panelu Zmienne możesz też oceniać wyrażenia ad hoc za pomocą metod statycznych lub zmiennych dostępnych w wybranym ramach.

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ą się aktualizować, gdy zostaną osiągnięte punkty przerwania lub gdy będziesz przechodzić 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 i wybierz Usuń obserwowanie.

Dodawanie punktów kontrolnych

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 jej wartości, ale nie pozwala zawiesić procesu aplikacji, gdy system odczytuje lub zmieni jej wartość w pamięci.

Uwaga: gdy proces aplikacji zakończy działanie funkcji i system zwolnił pamięć lokalną z tych zmiennych, musisz ponownie przypisać punkty kontrolne utworzone dla tych zmiennych.

Aby ustawić punkt kontrolny, 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 dopasować 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, w hamowaniu zmiennej podaj wartość __attribute__((aligned(num_bytes))), jak pokazano poniżej: 
    // For a 64-bit ARM processor
int my_counter __attribute__((aligned(8)));
  • Masz już przypisane co najmniej 3 punkty kontrolne. 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 kontrolnych.

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 rozwiązany w kolejnej wersji Android 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 Android Studio ignorował punkt kontrolny, dopóki nie zmienisz ustawienia. Android Studio zapisuje punkt obserwacji, aby można było do niego później wrócić.
    • Wstrzymanie: system Android domyślnie wstrzymuje proces aplikacji, gdy ten uzyskuje dostęp do bloku pamięci przypisanego do punktu obserwacji. Odznacz tę opcję, jeśli nie chcesz, aby tak było. 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 kliknięciu.
    • 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 punkt obserwacji był uruchamiany przy odczycie lub zapisie, wybierz Dowolny.
  4. Kliknij Gotowe.

Aby wyświetlić wszystkie punkty kontrolne i skonfigurować ich ustawienia, w oknie debugowania kliknij Wyświetl punkty kontrolne . Pojawi się okno Punkty przerwania (jak na rysunku 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 aplikacji. Jeśli aplikacja próbuje uzyskać dostęp do bloku pamięci, dla którego ustawiono punkt kontrolny, system Android zawiesza proces aplikacji, a obok ostatniego wykonanego przez aplikację wiersza kodu pojawia się ikona punktu kontrolnego  (patrz rys. 11).

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. Gdy wyświetlona jest karta Zmienne i wybrany jest element, 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 więcej z tych opcji:

    • Class (Klasa): wyświetla definicję klasy.
    • toString: format ciągu wyświetlania.
    • Obiekt: wyświetla definicję obiektu (wystąpienia klasy).
    • Tablica:wyświetlanie w formacie tablicy.
    • 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.
    • Binarne: wyświetlanie wartości binarnej za pomocą 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 Wyświetlacze typu danych Java. Postępuj zgodnie z instrukcjami podanymi w artykule Wyświetlacze typów danych Java.