Debugowanie aplikacji

W Android Studio dostępny jest debuger, który pozwala wykonywać między innymi 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 w dokumentacji debugowania IntelliJ IDEA.

Włącz debugowanie

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 urządzenia.

Uruchom wariant kompilacji z możliwością debugowania.

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

Zwykle można wybrać domyślny wariant „debugowania”, który jest dostępny w każdym projekcie Android Studio, mimo że nie jest on widoczny w pliku build.gradle. Jeśli jednak zdefiniujesz nowe typy kompilacji, które powinny być debugowane, musisz dodać do typu kompilacji debuggable true:

Odlotowe

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

Kotlin

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

Ta właściwość odnosi się też do modułów z kodem w C/C++.

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

Jeśli Twoja aplikacja wymaga modułu biblioteki, który chcesz też debugować, musisz też spakować tę bibliotekę z elementem debuggable true, aby zachowała ona symbole debugowania. Aby mieć pewność, że możliwe do debugowania warianty projektu aplikacji otrzymają możliwą do debugowania wersję modułu biblioteki, opublikuj inne wersje biblioteki.

Rozpocznij debugowanie

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

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

   

   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 Debuguj .

   Jeśli Twoja aplikacja jest już uruchomiona na urządzeniu, pojawi się okno z pytaniem, czy chcesz przełączyć się z Uruchom na Debugowanie. Aby rozpocząć debugowanie, urządzenie musi zostać ponownie uruchomione. Aby nie przerywać działania tej samej instancji, kliknij Anuluj debugowanie i dołącz debuger do uruchomionej aplikacji. W przeciwnym razie Android Studio skompiluje plik APK, podpisze go kluczem debugowania, zainstaluje go na wybranym urządzeniu i uruchomi.

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

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

Podłącz debuger 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 Dołącz debuger do procesu Androida .
2. W oknie Wybierz proces wskaż proces, do którego chcesz podłączyć debuger.
   1. Jeśli używasz emulatora lub urządzenia z dostępem do roota, zaznacz opcję Pokaż wszystkie procesy, aby wyświetlić wszystkie procesy. Na urządzeniu z dostępem do roota wyświetlane są wszystkie procesy uruchomione na urządzeniu. Jednak na urządzeniach bez dostępu do roota wyświetlą się tylko procesy możliwe do debugowania.
   2. W menu Użyj ustawień Android Debugger możesz wybrać istniejącą konfigurację uruchamiania/debugowania. W przypadku kodu w C i C++ umożliwia to ponowne wykorzystanie poleceń startowych LLDB, poleceń post-attach LLDB i katalogów symboli w istniejącej konfiguracji.
   3. Jeśli nie masz konfiguracji uruchamiania/debugowania, wybierz Utwórz nową. Wybranie tej opcji włącza menu Typ debugowania, w którym możesz wybrać inny typ debugowania. Domyślnie Android Studio używa typu Wykryj automatycznie debugowanie, aby wybrać najlepszą opcję debugera w zależności od tego, czy Twój projekt zawiera kod w Javie czy w 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ć. W tym miejscu możesz wybrać proces i wykonać zatrzymanie , wymusić zatrzymanie lub podłączyć debuger do danego procesu .

Okno debugowania

Okno debugowania jest podzielone na te obszary:

1. Pasek narzędzi wykonywania i nawigacji – patrz Praca z punktami przerwania
2. Selektor wątków
3. Wpis wyrażenia oceny i obserwowanego elementu. Przeczytaj sekcję Sprawdzanie zmiennych.
4. Wyświetlanie stosu
5. Panel Zmienne. Przeczytaj sekcję Sprawdzanie zmiennych.

Uwaga: debuger Android Studio i moduł czyszczenia pamięci są luźno zintegrowane. Maszyna wirtualna z Androidem gwarantuje, że zauważony przez debuger obiekt nie będzie wywoływany do czyszczenia pamięci, dopóki debuger się nie odłączysz. Może to spowodować nagromadzenie obiektów, gdy debuger jest podłączony. Jeśli na przykład debuger wykryje aktywny wątek, powiązany obiekt Thread nie zostanie usunięty, dopóki debuger się nie wyłączy, nawet jeśli wątek został zakończony.

Zmiana typu debugera

Do debugowania kodu Java/Kotlin i C/C++ wymagane są różne narzędzia, dlatego debuger w Android Studio pozwala wybrać typ debugera, którego chcesz użyć. Domyślnie Android Studio wybiera debugera do użycia na podstawie języków wykrytych w projekcie za pomocą 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:

Wykrywaj automatycznie

Wybierz ten typ debugowania, jeśli chcesz, aby Android Studio automatycznie wybierał najlepszą opcję dla kodu, który debugujesz. Jeśli np. w projekcie masz dowolny kod w C lub C++, Android Studio automatycznie użyje typu debugowania Podwójne. W przeciwnym razie Android Studio używa typu debugowania opartego tylko na Javie.

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 z kodem C/C++)

Wybierz ten typ debugowania, jeśli do debugowania kodu chcesz używać tylko bazy danych LLDB. W przypadku korzystania z tego typu debugowania widok sesji debugera Java jest niedostępny. Domyślnie LLDB sprawdza tylko kod natywny i ignoruje punkty przerwania w kodzie Java. Jeśli chcesz także debugować kod w Javie, przełącz się na typ debugowania „Wykrywaj automatycznie” lub „Podwójny”.

Debugowanie natywne działa tylko na urządzeniach spełniających 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 interfejs run-as, polecenie powinno zostać zwrócone bez błędów.

• Na urządzeniu jest włączona usługa 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 zasada ptrace nie jest włączona, wyświetli wartość inną niż 0.

Podwójny (Java + natywna) – dostępny tylko przy użyciu kodu C/C++

Wybierz ten typ debugowania, jeśli chcesz się przełączać między debugowaniem zarówno kodu Java, jak i kodu natywnego. Android Studio dołącza do procesu aplikacji zarówno debuger Java, jak i LLDB, dzięki czemu możesz badać punkty przerwania zarówno w Javie, jak i w kodzie natywnym bez ponownego uruchamiania aplikacji i zmiany konfiguracji debugowania.

Na ilustracji 2 zwróć uwagę na 2 karty po prawej stronie tytułu Okno debugowania. Aplikacja zawiera zarówno kod w Javie, jak i w C++, więc jedna karta służy do debugowania kodu natywnego, a druga do debugowania kodu Javy (wskazano w nim -java).

Uwaga: podczas debugowania kodu natywnego, który jest zoptymalizowany przez kompilator, możesz zobaczyć takie 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 działał wydajniej. Może to spowodować zgłoszenie nieoczekiwanych lub nieprawidłowych informacji, ponieważ utrudniają mu zmapowanie zoptymalizowanego skompilowanego kodu z powrotem na pierwotny kod źródłowy. Z tego powodu podczas debugowania kodu natywnego wyłącz 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 do debugowania aplikacji chcesz używać logu systemowego, dopilnuj, by w czasie, gdy aplikacja jest w fazie programowania, kod zapisał komunikaty logu i drukował zrzut stosu w poszukiwaniu wyjątków.

Zapisywanie komunikatów logu w kodzie

Aby zapisać komunikaty logu w kodzie, użyj klasy Log. Komunikaty logu ułatwiają zrozumienie przepływu wykonania, ponieważ zbierają dane wyjściowe debugowania systemu podczas korzystania z aplikacji. Komunikaty logu mogą również informować o tym, w której części aplikacji wystąpił błąd. Więcej informacji o logowaniu znajdziesz w artykule o zapisywaniu i wyświetlaniu logów za pomocą Logcat.

Poniższy przykład pokazuje, jak dodać komunikaty logu, aby określić, czy informacje o poprzednim stanie są dostępne w momencie rozpoczęcia 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 Twój kod może też wykrywać 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 wszystko będzie gotowe do opublikowania aplikacji, usuń z kodu komunikaty dziennika debugowania i wywołania drukowania zrzutu stosu. Aby to zrobić, ustaw flagę DEBUG i umieść wiadomości dziennika debugowania w instrukcjach warunkowych.

Wyświetlanie dziennika systemowego

W oknie Logcat możesz wyświetlać i filtrować komunikaty debugowania i inne komunikaty systemowe, jak pokazano na ilustracji 4. Możesz na przykład zobaczyć wiadomości dotyczące czyszczenia pamięci lub wiadomości dodane do aplikacji za pomocą klasy Log.

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

Opis i opcje filtrowania Logcat znajdziesz w artykule o zapisywaniu i wyświetlaniu logów w Logcat.

Praca z punktami przerwania

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

Punkt przerwania wiersza

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 wiersz po wierszu, aby ustalić przyczyny błędów środowiska wykonawczego.

Punkt przerwania metody

Punkt przerwania metody wstrzymuje wykonywanie aplikacji, gdy otworzy się ona lub zejdzie z określonej metody. Po wstrzymaniu funkcji możesz sprawdzać zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie kodu wiersz po wierszu, aby ustalić przyczyny błędów środowiska wykonawczego. Po ustawieniu punktu przerwania funkcji kompozycyjnej debuger wyświetla listę parametrów funkcji kompozycyjnej i ich stanu, aby pomóc w zidentyfikowaniu zmian, które mogły spowodować zmianę kompozycji.

Punkt przerwania pola

Punkt przerwania pola wstrzymuje działanie aplikacji, gdy dochodzi do odczytu lub zapisu w określonym polu.

Punkt przerwania wyjątku

Punkt przerwania wyjątku wstrzymuje działanie aplikacji po zgłoszeniu wyjątku.

Możesz ustawić warunkowe punkty przerwania, które spowodują zawieszenie wykonania tylko w przypadku spełnienia określonych warunków. Możesz też ustawić punkty przerwania logowania, które zapisują dane w Logcat bez zawieszania wykonywania. Pozwala to uniknąć zaśmiecania kodu instrukcjami dziennika.

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

1. Znajdź wiersz kodu, w którym chcesz wstrzymać wykonywanie.
2. Kliknij lewą kratę wzdłuż tej linii kodu lub umieść kursor na tym wierszu i naciśnij Control + F8 (w systemie macOS Command + F8).
3. Jeśli aplikacja jest już uruchomiona, kliknij Dołącz debuger do procesu Androida . W przeciwnym razie, aby rozpocząć debugowanie, kliknij Debuguj .

Po ustawieniu punktu przerwania obok linii pojawi się czerwona kropka, tak jak na ilustracji 5.

Gdy wykonanie kodu osiągnie punkt przerwania, Android Studio wstrzymuje wykonywanie aplikacji.

Aby określić stan aplikacji, skorzystaj z narzędzi na karcie Debuger:

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

• Aby przejść do następnego wiersza kodu bez podawania metody, kliknij Krok ponad .

• 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 nadal normalnie uruchamiać aplikację, kliknij Wznów program .

Jeśli Twój projekt korzysta z dowolnego kodu natywnego, domyślnie typ „Wykryj automatycznie” dołącza do aplikacji zarówno debuger Java, jak i LLDB jako 2 osobne 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 usługa Android Studio wykrywała punkty przerwania w kodzie w języku C lub C++, musisz użyć typu debugowania obsługującego LLDB, na przykład Wykryj automatycznie, Natywna lub Podwójna. Typ debugowania używany w Android Studio możesz zmienić, edytując konfigurację debugowania. Więcej informacji o różnych typach debugowania znajdziesz w sekcji o korzystaniu z 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.

1. Android Studio przełącza się na kartę <your-module>, gdy debuger LLDB natrafi na punkt przerwania w kodzie C/C++. 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.

   Okienko Wątki jest niedostępne w widoku sesji LLDB, ale możesz uzyskać dostęp do procesów aplikacji, korzystając z listy w panelu Klatki. 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 Android zawiesza maszynę wirtualną, na której działa kod bajtowy aplikacji w Javie. Oznacza to, że podczas sprawdzania punktu przerwania w kodzie natywnym nie można korzystać z debugera Java ani pobierać z jego sesji żadnych informacji o stanie.

2. Gdy debuger Java napotka punkt przerwania w kodzie Java lub Kotlin, Android Studio przełączy się na kartę Java <your-module>.
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 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ż ustawić specjalne typy punktów przerwania (tzw. watchpoints), które mogą zawiesić proces aplikacji, gdy wejdzie w interakcję z określonym blokiem pamięci. Więcej informacji znajdziesz w sekcji poświęconej dodawaniu ważnych informacji.

Wyświetlanie i konfigurowanie punktów przerwania

Aby wyświetlić wszystkie punkty przerwania i skonfigurować ustawienia tych punktów, kliknij Wyświetl punkty przerwania w oknie debugowania. Pojawi się okno Punkty przerwania, tak jak na ilustracji 7.

Okno Punkty przerwania pozwala włączać i wyłączać każdy punkt przerwania na liście w panelu. Jeśli punkt przerwania jest wyłączony, Android Studio nie wstrzymuje aplikacji po dotarciu do tego punktu.

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ż określić, czy punkt przerwania ma być wyłączony po jego działaniu. Aby ustawić punkt przerwania dla dowolnego wyjątku, wybierz Wyjątki punktów przerwania na liście punktów przerwania.

Aby tymczasowo wyłączyć wszystkie punkty przerwania, kliknij Ignoruj punkty przerwania w oknie debugowania. Kliknij jeszcze raz, aby włączyć tę funkcję.

Ramki okien 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 badać ramkę stosu, a także sprawdzać listę wątków w aplikacji na Androida.

Aby wybrać wątek, użyj menu selektora wątków i wyświetl 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 dotyczącym sprawdzania ramek.

Sprawdzanie zmiennych

Panel Zmienne w oknie Debugera umożliwia sprawdzanie zmiennych, gdy system zatrzyma aplikację w punkcie przerwania i wybierzesz ramkę w panelu Klatki. 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):

1. Wpisz wyrażenie, które chcesz oglądać lub wyświetlić
2. Kliknij Dodaj do zegarków lub naciśnij Enter, aby jednorazowo ocenić wyrażenie.

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

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

Ocenione wyrażenia będą wyświetlane na górze drzewa obiektów, dopóki nie ręcznie ocenisz innego wyrażenia lub nie sprawdzisz kodu.

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 ustawić specjalne typy punktów przerwania (tzw. watchpoints), które mogą zawiesić proces aplikacji, gdy wejdzie w interakcję z określonym blokiem pamięci. Jeśli na przykład ustawisz 2 wskaźniki do bloku pamięci i przypiszesz do niego punkt obserwacji, użycie dowolnego z nich pozwoli uzyskać dostęp do tego bloku pamięci.

W Android Studio możesz utworzyć punkt obserwacji w czasie działania, wybierając konkretną zmienną, ale LLDB przypisuje ten punkt tylko do bloku pamięci, który system przypisze do tej zmiennej, a nie do samej zmiennej. Różni się to od dodawania zmiennej do panelu zegarów, który umożliwia obserwowanie wartości zmiennej, ale nie pozwala zawiesić procesu aplikacji, gdy system odczytuje lub zmienia 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 ma procesor 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 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 przy użyciu 32-bitowych interfejsów ARM ABI dodanie punktu kontrolnego lub najechanie kursorem na zmienne w kodzie w celu zbadania ich wartości może spowodować awarię. Aby obejść ten problem, debuguj przy użyciu plików binarnych 64-bitowych ARM, x86 lub x86_64. Ten problem zostanie naprawiony w kolejnej wersji Androida Studio.

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

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

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

   

3. Pojawi się okno konfigurowania punktu obserwacji, tak jak na ilustracji 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 zapisze punkt obserwacyjny, aby można go było później otworzyć.
   • 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. Poznasz dodatkowe opcje, za pomocą których możesz dostosować działanie, gdy system wchodzi w interakcję z Twoim punktem obserwacji: Zapisz komunikat do konsoli i Usuń po kliknięciu.
   • Typ dostępu:określ, czy aplikacja ma aktywować punkt obserwacji przy próbie odczytu czy zapisu do bloku pamięci przydzielonego przez system do zmiennej. 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, tak jak na ilustracji 10.

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 wiersza kodu ostatnio wykonanego przez aplikację, jak widać na rysunku 11, pojawi się ikona punktu kontrolnego .

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

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

1. Na liście Zmienne kliknij prawym przyciskiem myszy w dowolnym miejscu wiersza zasobów, aby wyświetlić listę.
2. Z listy wybierz 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:

   • Klasa:wyświetla definicję klasy.
   • toString: wyświetlany format ciągu znaków.
   • Obiekt: wyświetl definicję obiektu (instancji klasy).
   • tablica: wyświetlanie w formacie tablicowym.
     
   • Sygnatura czasowa:wyświetlaj datę i godzinę w taki sposób: 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ść przekazywana z elementu nadrzędnego do wybranego elementu podrzędnego. Zobacz MeasureSpec.
   • Wartość szesnastkowa: wartość szesnastkowa.
   • Liczba podstawowa: wyświetlana jako wartość liczbowa z użyciem podstawowego typu danych.
   • Liczba całkowita: wyświetlana jako wartość liczbowa typu Integer.

Aby utworzyć format niestandardowy:

1. Kliknij prawym przyciskiem myszy wartość zasobu.
2. Wybierz Wyświetl jako.
3. Kliknij Utwórz.
4. Pojawi się okno Mechanizmy renderowania typu danych Java. Wykonaj instrukcje opisane w artykule o mechanizmach renderowania typu danych Java.