Debugowanie aplikacji

Android Studio zawiera debuger, który pozwala między innymi:

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

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

Włącz debugowanie

Zanim rozpoczniesz 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 debuggable true (isDebuggable = true w skryptach Kotlin).

Zwykle możesz wybrać domyślny wariant „debugowania”, który jest dołączany do każdego projektu Android Studio, nawet jeśli nie jest on widoczny w pliku build.gradle. Jeśli jednak zdefiniujesz nowe typy kompilacji, które powinny dać się debugować, musisz dodać do typu kompilacji debuggable true:

Odlotowy

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

Kotlin

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

Ta właściwość dotyczy również 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 też chcesz debugować, musisz ją również spakować z atrybutem debuggable true, aby zachowała symbole debugowania. Aby mieć pewność, że możliwe do debugowania warianty projektu aplikacji otrzymają możliwy do debugowania wariant modułu biblioteki, opublikuj wersje biblioteki inne niż domyślne.

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 przez Wi-Fi lub utworzyć AVD, aby użyć 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 uruchamiania na debugowanie. Aby rozpocząć debugowanie, trzeba będzie ponownie uruchomić urządzenie. Aby pozostawiać tę samą instancję aplikacji, kliknij Anuluj debugowanie i zamiast tego dołącz debuger do uruchomionej aplikacji. W przeciwnym razie Android Studio skompiluje plik APK, podpisze go kluczem debugowania, zainstaluje na wybranym urządzeniu i uruchomi go.

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

4. Jeśli okno debugowania jest zamknięte, wybierz Widok > Okna narzędzi > Debugowanie lub kliknij Debugowanie na pasku okna narzędzi.

Podłącz debuger do uruchomionej aplikacji

Jeśli aplikacja jest już uruchomiona na urządzeniu, możesz rozpocząć debugowanie bez ponownego uruchamiania aplikacji, wykonując te czynności:

1. Kliknij Dołącz debuger do procesu Androida .
2. W oknie Wybierz proces wybierz proces, do którego chcesz podłączyć debuger.
   1. Jeśli używasz emulatora lub urządzenia z dostępem do roota, możesz zaznaczyć Pokaż wszystkie procesy, by zobaczyć wszystkie procesy. Na urządzeniu z dostępem do roota zobaczysz wszystkie procesy uruchomione na urządzeniu. Jednak na urządzeniu bez dostępu do roota widoczne będą tylko procesy możliwe do debugowania.
   2. W menu Użyj ustawień debugera Androida możesz wybrać dotychczasową konfigurację uruchamiania/debugowania. W przypadku kodów C i C++ pozwala to na ponowne wykorzystywanie poleceń startowych LLDB, poleceń post-attach LLDB i katalogów symboli w istniejącej konfiguracji.
   3. Jeśli nie masz żadnej konfiguracji do uruchamiania/debugowania, kliknij Utwórz nową. Po wybraniu tej opcji wyświetli się menu Typ debugowania, w którym możesz wybrać inny typ debugowania. Domyślnie Android Studio używa typu debugowania Wykryj automatycznie, aby wybrać najlepszą opcję debugera w zależności od 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ądzenia) zawiera też listę procesów, które można debugować. W tym miejscu możesz wybrać proces i wykonać wywołanie , wymuszanie lub podłączyć debuger do danego procesu .

Okno debugowania

Okno debugowania

1. Pasek narzędzi wykonywania i nawigacji – patrz artykuł Praca z punktami przerwania.
2. Selektor wątków
3. Ocena i wpisywanie wyrażenia obserwacji. Patrz Sprawdzanie zmiennych.
4. Wyświetlanie stosu
5. W panelu Zmienne. Patrz Sprawdzanie zmiennych.

Uwaga: debuger Android Studio i moduł czyszczenia pamięci są luźno zintegrowane. Maszyna wirtualna z Androidem gwarantuje, że do czasu odłączenia debugera żaden obiekt, o którym debuger zna, nie będzie zbierany śmieci. Może to spowodować nagromadzenie się obiektów, gdy debuger jest podłączony. Jeśli na przykład debuger wykryje aktywny wątek, powiązany obiekt Thread nie będzie zbierany do momentu odłączenia debugera, 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 debugujące, dlatego debuger Android Studio umożliwia wybór typu debugera do użycia. Domyślnie Android Studio decyduje, którego debugera użyć, na podstawie języków wykrytych w projekcie przy użyciu debugera Wykryj automatycznie.

Aby ręcznie wybrać debuger w konfiguracji debugowania, kliknij Uruchom > Edytuj konfiguracje. Możesz też wybrać debuger w oknie, które się wyświetli, gdy klikniesz 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ł najlepszą opcję dla debugowania kodu. Jeśli np. masz w projekcie kod w języku 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 Java ignoruje punkty przerwania i obserwacje ustawione w kodzie natywnym.

Tylko natywne (dostępne tylko z kodem C/C++)

Wybierz ten typ debugowania, jeśli chcesz używać tylko LLDB do debugowania kodu. Gdy używasz 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 też debugować kod Java, przełącz się na typ debugowania 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 interfejs run-as, uruchom to polecenie w powłoce ADB podłączonej do urządzenia:

  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ć się 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 włączona jest funkcja ptrace, polecenie wyświetli wartość 0 lub błąd unknown key. Jeśli zasada ptrace nie jest włączona, wyświetla wartość inną niż 0.

Dual (Java + natywne) – dostępny tylko w przypadku kodu C/C++

Wybierz ten typ debugowania, jeśli chcesz się przełączać 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 Java, jak i natywnym bez ponownego uruchamiania aplikacji i zmiany konfiguracji debugowania.

Na ilustracji 2 zwróć uwagę na 2 karty po prawej stronie tytułu okna Debugowanie. Aplikacja zawiera zarówno kod Java, jak i C++, więc jedna karta służy do debugowania kodu natywnego, a druga do debugowania kodu Java zgodnie z dyrektywą -java.

Uwaga: podczas debugowania kodu natywnego zoptymalizowanego przez kompilator może pojawić się 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 zgłosi nieoczekiwane lub nieprawidłowe informacje, ponieważ trudno jest mu zmapować zoptymalizowany skompilowany kod z powrotem na oryginalny kod źródłowy. Z tego powodu należy wyłączyć optymalizacje kompilatora podczas debugowania kodu natywnego.

Używanie dziennika systemowego

Dziennik systemowy wyświetla komunikaty systemowe podczas debugowania aplikacji. Obejmują one informacje z aplikacji uruchomionych na urządzeniu. Jeśli do debugowania aplikacji chcesz użyć logu systemowego, dopilnuj, aby w czasie, gdy aplikacja jest w fazie programowania, zapisano w kodzie komunikaty logu, a zrzut stosu na potrzeby wyjątków.

Zapisz w kodzie komunikaty logu

Aby zapisywać komunikaty logu w kodzie, użyj klasy Log. Komunikaty logu ułatwiają zrozumienie procesu wykonywania przez zbieranie danych wyjściowych debugowania systemu podczas korzystania z aplikacji. Komunikaty logów mogą też informować, która część aplikacji zakończyła się niepowodzeniem. Więcej informacji o logowaniu znajdziesz w artykule o zapisywaniu i wyświetlaniu logów w Logcat.

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

W trakcie programowania Twój kod może też wychwytywać wyjątki i zapisać 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ść komunikaty dziennika debugowania w instrukcjach warunkowych.

Wyświetl dziennik systemowy

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

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

Opis usługi Logcat i jej opcji filtrowania znajdziesz w artykule o zapisywaniu i wyświetlaniu logów przy użyciu 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 po określonym wierszu kodu. Po wstrzymaniu możesz analizować zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie wiersz po wierszu, aby ustalić przyczyny błędów działania.

Punkt przerwania metody

Punkt przerwania metody wstrzymuje działanie aplikacji po rozpoczęciu lub zamknięciu określonej metody. Po wstrzymaniu możesz analizować zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie wiersz po wierszu, aby ustalić przyczyny błędów działania. Gdy ustawisz punkt przerwania dla funkcji kompozycyjnej, debuger wyświetli 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 wykonywanie aplikacji, gdy odczytuje dane pole lub zapisuje w nim dane.

Punkt przerwania wyjątku

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

Możesz ustawić warunkowe punkty przerwania, które zawieszają wykonywanie tylko po spełnieniu określonych warunków. Możesz też ustawić punkty przerwania logowania, które zapisują dane w Logcat bez zawieszania wykonywania. Pomoże to uniknąć zaśmiecania kodu instrukcjami logu.

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

1. Znajdź wiersz kodu, w którym chcesz wstrzymać wykonywanie.
2. Kliknij margines po lewej stronie wzdłuż wiersza kodu lub umieść w nim kursor i naciśnij Control+F8 (w systemie macOS, Command+F8).
3. Jeśli aplikacja jest już uruchomiona, kliknij Dołącz debuger do procesu Androida . Jeśli nie, aby rozpocząć debugowanie, kliknij Debuguj .

Przy ustawianiu punktu przerwania obok linii pojawia się czerwona kropka, jak pokazano na ilustracji 5.

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

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

• Aby przejrzeć drzewo obiektów pod kątem zmiennej, rozwiń ją w widoku Zmienne. Jeśli widok Zmienne nie jest widoczny, kliknij Ustawienia układu i sprawdź, czy zmienne są zaznaczone.

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

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

• Aby przejść do następnego wiersza poza bieżącą metodą, kliknij Zakończ .

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

Jeśli w Twoim projekcie używany jest dowolny kod natywny, domyślnie typ debugowania Wykryj automatycznie wiąże debuger Javy i LLDB do aplikacji jako 2 oddzielne procesy. Możesz przełączać się między sprawdzaniem punktów przerwania w Javie i C/C++ bez ponownego uruchamiania aplikacji i zmieniania ustawień.

Uwaga: aby Android Studio wykrywał punkty przerwania w kodzie C lub C++, musisz użyć typu debugowania, który obsługuje LLDB, na przykład Wykryj automatycznie, Natywny lub Podwójny. Typ debugowania używany w Android Studio możesz zmienić, 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 wdraża Twoją aplikację na urządzeniu docelowym, otwiera się okno debugowania z kartą lub widokiem sesji debugowania dla poszczególnych procesów debugera, jak widać na ilustracji 6.

1. Android Studio przełącza się na kartę <your-module>, gdy debuger LLDB napotka punkt przerwania w kodzie C/C++. Dostępne są również panele Ramki, Zmienne i Zegarki, które działają dokładnie tak samo jak podczas debugowania kodu Java.

   Chociaż panel Threads nie jest dostępny w widoku sesji LLDB, możesz uzyskać dostęp do procesów aplikacji za pomocą 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 Javy Twojej aplikacji. Oznacza to, że podczas badania punktu przerwania w kodzie natywnym nie można korzystać z debugera Java ani pobierać żadnych informacji o stanie z sesji debugera Java.

2. Gdy debuger Java natrafi na 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żywać terminala LLDB w widoku sesji LLDB, aby przekazywać opcje wiersza poleceń do LLDB. Jeśli masz określone polecenia, które ma być wykonywane przez LLDB za każdym razem, gdy rozpoczynasz debugowanie aplikacji – bezpośrednio 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ż 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. Więcej informacji znajdziesz w sekcji dotyczącej dodawania punktów obserwacji.

Wyświetl i skonfiguruj punkty przerwania

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

Okno Punkty przerwania umożliwia włączanie i wyłączanie każdego punktu przerwania na liście w panelu. Jeśli punkt przerwania jest wyłączony, Android Studio nie wstrzymuje aplikacji, gdy dotrze do tego punktu.

Wybierz punkt przerwania z listy, aby skonfigurować jego ustawienia. Punkt przerwania możesz skonfigurować tak, aby był najpierw wyłączony, a system włącza go po trafieniu innego punktu przerwania. Możesz też skonfigurować, czy punkt przerwania ma być wyłączony po jego trafieniu. Aby ustawić punkt przerwania dla dowolnego wyjątku, wybierz Punkty przerwania wyjątku na liście punktów przerwania.

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

Debugowanie ramek okien

Okienko Ramki w oknie Debugera umożliwia sprawdzenie ramki stosu, która spowodowała trafienie bieżącego punktu przerwania. Dzięki temu możesz poruszać się po ramce stosu i ją sprawdzać, 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 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, co zostało omówione w przewodniku dotyczącym sprawdzania ramek.

Sprawdzanie zmiennych

W panelu Zmienne w oknie Debugera możesz sprawdzać zmienne, gdy system zatrzymuje działanie aplikacji w punkcie przerwania i wybierzesz ramkę w panelu Klatki. W panelu Zmienne możesz też oceniać doraźne wyrażenia za pomocą metod statycznych lub zmiennych dostępnych w wybranej ramce.

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

1. Wpisz wyrażenie do obejrzenia lub wyświetlenia
2. Aby jednorazowo ocenić wyrażenie, kliknij Dodaj do obserwowanych lub naciśnij Enter.

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

Obserwowane wyrażenia będą aktualizowane, gdy nastąpi trafienie punktów przerwania lub gdy przejdziesz przez kod.

Ocenione wyrażenia będą wyświetlane u góry drzewa obiektów, dopóki nie przejdziesz ręcznie do oceny 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ń zegarek śledzący.

Dodaj punkty obserwacji

Podczas debugowania kodu C/C++ możesz ustawić specjalne typy punktów przerwania (nazywane punktami obserwacji), które mogą zawiesić proces aplikacji, gdy będzie ona oddziaływać na konkretny blok pamięci. Jeśli na przykład ustawisz 2 wskaźniki na blok pamięci i przypiszesz do niego punkt obserwacji, dostęp do tego bloku pamięci aktywuje użycie dowolnego z tych wskaźników.

W Android Studio możesz utworzyć punkt obserwacji w trakcie działania, wybierając konkretną zmienną, ale LLDB przypisuje punkt obserwacji tylko do bloku pamięci, który system przydziela tej zmiennej, a nie do samej zmiennej. Różni się to od dodawania zmiennej do panelu Zegarki, która umożliwia obserwowanie wartości zmiennej, ale nie umożliwia zawieszenia procesu aplikacji, gdy system odczyta lub zmieni jej wartość w pamięci.

Uwaga: gdy proces aplikacji wyjdzie z funkcji, a system cofnie przypisanie zmiennych lokalnych 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 Twoje urządzenie korzysta z procesora ARM, granicę adresu zmiennej w pamięci musisz wyrównać 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 spowalnianiu zmiennej podaj __attribute__((aligned(num_bytes))), jak pokazano poniżej:

  // For a 64-bit ARM processor
  int my_counter __attribute__((aligned(8)));
  

• Masz już przypisane maksymalnie 3 punkty obserwacji. Android Studio obsługuje maksymalnie 4 punkty 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 ARM ARM dodanie punktu obserwacji lub najechanie kursorem na zmienne w kodzie w celu zbadania ich wartości może spowodować awarię. Aby obejść ten problem, debuguj plik za pomocą 64-bitowych plików binarnych ARM, x86 lub x86_64. Ten problem zostanie rozwiązany w nadchodzącej 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 kontrolny.

   

3. Pojawi się okno dialogowe umożliwiające skonfigurowanie punktu obserwacji, tak jak pokazano na ilustracji 9.

   Skonfiguruj punkt obserwacji za pomocą tych opcji:

   • Włączone: odznacz tę opcję, jeśli chcesz, aby Android Studio ignorował punkt obserwacji do czasu zmiany tego ustawienia. Android Studio zapisuje Twój punkt obserwacji, aby można było później uzyskać do niego dostęp.
   • Zawieś: domyślnie system Android zawiesza proces aplikacji, gdy uzyska dostęp do bloku pamięci przypisanego do punktu obserwacji. Jeśli nie chcesz, aby tak się stało, odznacz tę opcję. Uzyskasz dzięki temu dodatkowe opcje, których możesz użyć, aby dostosować działanie, gdy system wejdzie w interakcję z Twoim punktem obserwacyjnym: Zarejestruj wiadomość w konsoli i Usuwaj po kliknięciu.
   • Typ dostępu: określ, czy aplikacja ma wyzwalać punkt obserwacji, gdy próbuje Odczyt lub Zapis do bloku pamięci przydzielonego przez system do zmiennej. Aby aktywować punkt obserwacji podczas odczytu lub zapisu, wybierz Dowolny.
4. Kliknij Gotowe.

Aby wyświetlić wszystkie punkty obserwacji i skonfigurować ustawienia punktów obserwacji, w oknie debugowania kliknij Wyświetl punkty przerwania . Pojawi się okno Punkty przerwania, jak widać 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 ustawionego przez Ciebie na obserwację, system Android zawiesza proces aplikacji, a obok wiersza kodu, który aplikacja wykonała jako ostatnia, wyświetla się ikona punktu obserwacji , jak pokazano na rysunku 11.

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 wybranej ramce wykonaj te czynności:

1. Na liście Zmienne kliknij prawym przyciskiem myszy w dowolnym miejscu wiersza zasobu, by 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:

   • Klasa:wyświetla definicję klasy.
   • toString: format wyświetlanego ciągu znaków.
   • Obiekt: wyświetla definicję obiektu (wystąpienia klasy).
   • Tablica: wyświetla się w formacie tablicowym.
     
   • Sygnatura czasowa:data i godzina wyświetlają się w następujący sposób: rrrr-mm-dd gg:mm:ss.
   • Auto: Android Studio wybiera najlepszy format na podstawie typu danych.
     
   • Wartość binarna: umożliwia wyświetlanie wartości binarnej składającej się z zer i jedynek.
   • MeasureSpec: wartość przekazana z elementu nadrzędnego do wybranego elementu podrzędnego. Zobacz MeasureSpec.
   • Liczba szesnastkowa: wyświetla się jako wartość szesnastkowa.
   • Prywatna: służy do wyświetlania wartości liczbowych z wykorzystaniem prostego typu danych.
   • Liczba całkowita: wyświetlaj jako wartość liczbową 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 danych w języku Java. Wykonaj instrukcje opisane w artykule o mechanizmach renderowania typów danych w Javie.