Free Press

Android Studio dostarcza debuggera, który pozwala na następujące i więcej czynności:

• Wybierz urządzenie, na którym chcesz debugować swoją aplikację.
• Ustawiaj punkty przerwania w swoim kodzie Java, Kotlin i C/C++.
• Badaj zmienne i oceniaj wyrażenia w czasie wykonywania.

Ta strona zawiera instrukcje dotyczące podstawowych operacji debuggera. Aby uzyskać więcej dokumentacji, zobacz także dokumentację debugowania IntelliJ IDEA.

Włącz debugowanie

Przed rozpoczęciem debugowania należy przygotować się w następujący sposób:

• Włącz debugowanie na urządzeniu:

  Jeśli używasz emulatora, jest to domyślnie włączone. Ale w przypadku podłączonego urządzenia należy włączyć debugowanie w opcjach programisty urządzenia.

• Uruchom wariant kompilacji z możliwością debugowania:

  Musisz użyć wariantu kompilacji, który zawiera debuggable true w konfiguracji kompilacji. Zazwyczaj można po prostu wybrać domyślny wariant „debug”, który jest dołączony do każdego projektu Android Studio (nawet jeśli nie jest on widoczny w pliku build.gradle). Ale jeśli zdefiniujesz nowe typy kompilacji, które powinny być debugowalne, musisz dodać `debuggable true` do typu kompilacji:

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

  Ta właściwość dotyczy również modułów z kodem C/C++. (Właściwość jniDebuggable nie jest już używana.)

  Jeśli twoja aplikacja zależy od modułu biblioteki, który również chcesz debugować, ta biblioteka musi być również spakowana z debuggable true, aby zachowała swoje symbole debugowania.Aby upewnić się, że debugowalne warianty twojego projektu aplikacji otrzymają debugowalny wariant modułu biblioteki, upewnij się, że publikujesz nie-domyślne wersje swojej biblioteki.

Rozpoczęcie debugowania

Sesję debugowania można rozpocząć w następujący sposób:

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

   

   Jeśli nie masz skonfigurowanych żadnych urządzeń, musisz albo podłączyć urządzenie przez USB, albo utworzyć AVD, aby użyć emulatora Androida.

3. W pasku narzędzi kliknij Debug .

   Jeśli zobaczysz okno dialogowe z pytaniem, czy chcesz „przełączyć z uruchomienia na debugowanie”, oznacza to, że Twoja aplikacja jest już uruchomiona na urządzeniu i zostanie ponownie uruchomiona, aby rozpocząć debugowanie. Jeśli wolisz zachować tę samą instancję aplikacji, kliknij Anuluj debugowanie i zamiast tego dołącz debugger do działającej aplikacji.

   W przeciwnym razie, Android Studio buduje APK, podpisuje go kluczem debugowania, instaluje go na wybranym urządzeniu i uruchamia go. Jeśli dodasz do projektu kod C i C++, Android Studio uruchomi także debugger LLDB w oknie Debugowanie, aby debugować twój natywny kod.

4. Jeśli okno Debugowanie nie jest otwarte, wybierz Widok > Okna narzędziowe > Debugowanie (lub kliknij Debugowanie na pasku okien narzędziowych), a następnie kliknij kartę Debugowanie, jak pokazano na rysunku 1.

   Rysunek 1. Okno debuggera, pokazujące bieżący wątek i drzewo obiektów dla zmiennej

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

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

1. Kliknij Dołącz debugger do procesu Android .
2. W oknie dialogowym Wybierz proces wybierz proces, do którego chcesz dołączyć debugger.

   Jeśli używasz emulatora lub zrootowanego urządzenia, możesz zaznaczyć opcję Pokaż wszystkie procesy, aby zobaczyć wszystkie procesy.

   Z menu rozwijanego Użyj ustawień debuggera Androida możesz wybrać istniejącą konfigurację uruchamiania/debugowania. (Dla kodu C i C++, pozwala to na ponowne użycie poleceń startowych LLDB, poleceń po dołączeniu LLDB i katalogów symboli w istniejącej konfiguracji). Jeśli nie masz istniejącej konfiguracji uruchamiania/debugowania, wybierz Create New. Ten wybór powoduje wyświetlenie menu rozwijanego Typ debugowania, w którym można wybrać inny typ debugowania. Domyślnie Android Studio używa automatycznego typu debugowania, aby wybrać najlepszą opcję debugera dla Ciebie, w oparciu o to, czy Twój projekt zawiera kod Java czy C/C++.

3. Kliknij przycisk OK.

   Pojawi się okno Debug.

Uwaga: Debugger i garbage collector programu Android Studio są luźno zintegrowane. Maszyna wirtualna Androida gwarantuje, że każdy obiekt, o którym debugger wie, nie jest odśmiecany aż do momentu, gdy debugger się rozłączy. Może to powodować gromadzenie się obiektów w czasie, gdy debugger jest podłączony. Na przykład, jeśli debugger widzi działający wątek, powiązany Thread obiekt nie jest usuwany do czasu rozłączenia się debuggera, nawet jeśli wątek został zakończony.

Zmień typ debuggera

Ponieważ różne narzędzia debuggera są wymagane do debugowania kodu Java/Kotlin i kodu C/C++, debuggerAndroid Studio pozwala wybrać typ debuggera do użycia. Domyślnie Android Studiodeecyduje, który debugger użyć na podstawie języków, które wykryje w projekcie (z typemAuto debugger). Można jednak ręcznie wybrać debugger w konfiguracji debugowania (klikamy Uruchom > EdytujKonfiguracje) lub w oknie dialogowym, które pojawia się po kliknięciu Uruchom > Dołącz debugger do procesu Android.

Dostępne typy debugowania obejmują następujące elementy:

Auto Wybierz ten typ debugowania, jeśli chcesz, aby Android Studio automatycznie wybrało najlepszą opcję dla kodu, który debugujesz. Na przykład, jeśli masz jakikolwiek kod C lub C++ w swoim projekcie, Android Studio automatycznie używa typu debugowania Dual. W przeciwnym razie Android Studio użyje typu debugowania Java. Java Wybierz ten typ debugowania, jeśli chcesz debugować tylko kod napisany w Javie lub Kotlinie – debuger Java ignoruje wszelkie punkty przerwania lub zegarki ustawione w natywnym kodzie. Natywny (dostępny tylko z kodem C/C++) Wybierz ten typ debugowania, jeśli chcesz używać tylko LLDB do debugowania swojego kodu. Podczas korzystania z tego typu debugowania nie jest dostępny widok sesji debuggera Java. Domyślnie LLDB sprawdza tylko Twój natywny kod i ignoruje punkty przerwania w Twoim kodzie Java. Jeśli chcesz również debugować swój kod Java, powinieneś przełączyć się na typ debugowania Auto lub Dual.

Naturalne debugowanie działa tylko na urządzeniach spełniających następujące wymagania:

• Urządzenie obsługuje run-as.

  Aby sprawdzić, czy urządzenie obsługuje run-as, wykonaj następujące polecenie w powłoce ADB podłączonej do urządzenia:

  run-as your-package-name pwd

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

• Urządzenie ma włączoną funkcję ptrace.

  Aby sprawdzić, czy funkcja ptrace jest włączona, wykonaj następujące polecenie w powłoce ADB podłączonej do urządzenia:

  sysctl kernel.yama.ptrace_scope

  Jeśli funkcja ptrace jest włączona, polecenie wypisze wartość 0 lub błąd unknown key. Jeśli ptrace nie jest włączone, wypisze wartość inną niż 0.

Podwójny (dostępny tylko z kodem C/C++) Wybierz ten typ debugowania, jeśli chcesz przełączać się między debugowaniem zarówno kodu Java, jak i natywnego. Android Studio dołącza zarówno debugger Java jak i LLDB do procesu aplikacji, jeden dla debuggera Java i jeden dla LLDB, więc możesz sprawdzać punkty przerwania zarówno w kodzie Java jak i natywnym bez restartowania aplikacji lub zmiany konfiguracji debugowania.

Na rysunku 2, zauważ dwie zakładki po prawej stronie tytułu okna Debug. Ponieważ aplikacja zawiera zarówno kod Java, jak i C++, jedna zakładka służy do debugowania natywnego kodu, a druga do debugowania kodu Java, na co wskazuje opcja -java.

Rysunek 2. Zakładka do debugowania kodu natywnego i zakładka do debugowania kodu Java

Uwaga: Jeśli debugujesz kod natywny, który jest optymalizowany przez kompilator, możesz otrzymać następujący komunikat ostrzegawczy: This function was compiled with optimizations enabled. Some debugger features may not be available. Podczas używania flag optymalizacji, takich jak flagi -O, kompilator wprowadza zmiany w skompilowanym kodzie, aby działał on wydajniej. Może to spowodować, że debugger będzie zgłaszał nieoczekiwane lub nieprawidłowe informacje, ponieważ trudno jest mu odwzorować zoptymalizowany skompilowany kod z powrotem na oryginalny kod źródłowy. Z tego powodu, należy wyłączyć optymalizacje kompilatora podczas debugowania natywnego kodu.

Używaj dziennika systemowego

Dziennik systemowy pokazuje komunikaty systemowe podczas debugowania aplikacji. Te komunikaty zawierają informacje z aplikacji działających na urządzeniu. Jeśli chcesz używać dziennika systemowego do debugowania aplikacji, upewnij się, że twój kod zapisuje komunikaty dziennika i drukuje stacktrace dla wyjątków, gdy twoja aplikacja jest w fazie rozwoju.

Pisz komunikaty dziennika w swoim kodzie

Aby pisać komunikaty dziennika w swoim kodzie, użyj klasy Log. Komunikaty dziennika pomagają zrozumieć przepływ wykonania poprzez zbieranie danych wyjściowych debugowania systemu podczas interakcji z aplikacją. Komunikaty dziennika mogą powiedzieć, jaka część aplikacji nie powiodła się. Aby uzyskać więcej informacji na temat rejestrowania, zobacz rozdział Zapisywanie i przeglądanie dzienników.

Następujący przykład pokazuje, jak można dodać komunikaty dziennika, aby określić, czy poprzednie informacje o stanie są dostępne, gdy rozpoczyna się działanie:

Podczas rozwoju, twój kod może również wychwytywać wyjątki i zapisywać ślad stosu do dziennika systemowego:

Uwaga: Usuń komunikaty dziennika debugowania i wywołania drukowania śladu stosu z twojego kodu, gdy jesteś gotowy do opublikowania aplikacji. Można to zrobić ustawiając flagę DEBUG i umieszczając komunikaty dziennika debugowania wewnątrz instrukcji warunkowych.

Przeglądanie dziennika systemowego

W oknie Logcat można przeglądać i filtrować komunikaty debugowania i inne komunikaty systemowe. Na przykład, możesz zobaczyć komunikaty, gdy wystąpi zbieranie śmieci lub komunikaty, które dodajesz do swojej aplikacji za pomocą klasy Log.

Aby użyć logcat, rozpocznij debugowanie i wybierz zakładkę Logcat w dolnym pasku narzędzi, jak pokazano na rysunku 3.

Rysunek 3. Okno logcat z ustawieniami filtrów

Opis logcat i jego opcji filtrowania znajduje się w części Zapisywanie i przeglądanie logów za pomocą Logcat.

Praca z punktami przerwania

Android Studio obsługuje kilka typów punktów przerwania, które wyzwalają różne akcje debugowania. Najczęstszym typem jest linia breakpointthat pauzuje wykonanie aplikacji w określonym wierszu kodu. Podczas wstrzymania można badać zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie wiersz po wierszu, aby określić przyczyny błędów w czasie wykonywania.

Aby dodać punkt przerwania wiersza, wykonaj następujące czynności:

1. Znajdź wiersz kodu, w którym chcesz wstrzymać wykonywanie, a następnie kliknij lewą rynienkę wzdłuż tego wiersza kodu lub umieść wskaźnik na wierszu i naciśnij Control+F8 (na Macu Command+F8).
2. Jeśli Twoja aplikacja jest już uruchomiona, nie musisz jej aktualizować, aby dodać punkt przerwania – wystarczy kliknąć Dołącz debugger do procesu Android . W przeciwnym razie rozpocznij debugowanie, klikając Debug .

Rysunek 3. Czerwona kropka pojawia się obok linii, gdy ustawisz punkt przerwania

Gdy Twój kod osiągnie punkt przerwania, Android Studio wstrzymuje wykonywanie aplikacji. Następnie można użyć narzędzi z karty Debugger, aby określić stan aplikacji:

• Aby sprawdzić drzewo obiektów dla zmiennej, rozwiń ją w widoku Zmienne. Jeśli widok Zmienne nie jest widoczny, kliknij przycisk Przywróć widok zmiennych .

• Aby ocenić wyrażenie w bieżącym punkcie wykonania, kliknij polecenie Oceń wyrażenie .

• Aby przejść do następnego wiersza kodu (bez wprowadzania metody), kliknij polecenie Krok nad .

• Aby przejść do pierwszego wiersza wewnątrz wywołania metody, kliknij pozycję Step Into .

• Aby przejść do następnego wiersza poza bieżącą metodą, kliknij pozycję Step Out .

• Aby kontynuować normalne działanie aplikacji, kliknij pozycję Resume Program .

Jeśli twój projekt używa natywnego kodu, domyślnie typ debugowania Auto dołącza zarówno debugger Java, jak i LLDB do twojej aplikacji jako dwa oddzielne procesy, więc możesz przełączać się między sprawdzaniem punktów przerwania Java i C/C++ bez ponownego uruchamiania aplikacji lub zmiany ustawień.

Uwaga: Aby Android Studio wykryło punkty przerwania w twoim kodzie C lub C++, musisz użyć typu debugowania, który obsługuje LLDB, takiego jak Auto, Native lub Dual. Możesz zmienić typ debugowania, którego używa Android Studio poprzez edycję konfiguracji debugowania. Aby dowiedzieć się więcej o różnych typach debugowania, przeczytaj rozdział o używaniu innych typów debugowania.

Kiedy Android Studio wdraża twoją aplikację do urządzenia docelowego, okno Debugowanie otwiera się z zakładką lub widokiem sesji debugowania dla każdego procesu debugera, jak pokazano na rysunku 4.

Rysunek 4. Debugowanie natywnego kodu przy użyciu LLDB

1. Android Studio przełącza się na zakładkę <your-module>, gdy debugger LLDB napotka punkt przerwania w Twoim kodzie C/C++. Okienka Frames, Variables i Watches są również dostępne i działają dokładnie tak samo, jak w przypadku debugowania kodu Java. Mimo że panel Threads nie jest dostępny w widoku sesji LLDB, możesz uzyskać dostęp do procesów aplikacji, korzystając z listy rozwijanej w panelu Frames. Więcej o tych panelach dowiesz się z rozdziałów o tym, jak debugować ramki okien i kontrolować zmienne.

   Uwaga: Podczas sprawdzania punktu przerwania w kodzie natywnym, system Android zawiesza maszynę wirtualną, która uruchamia kod bajtowy Java Twojej aplikacji. Oznacza to, że nie jesteś w stanie współdziałać z debuggerem Java lub pobierać żadnych informacji o stanie z sesji debuggera Java podczas inspekcji punktu przerwania w kodzie natywnym.

2. Android Studio przełącza się do zakładki <your-module>-java, gdy debugger Java napotka punkt przerwania w twoim kodzie Java.
3. Podczas debugowania z LLDB, możesz użyć terminala LLDB w widoku sesji LLDB, aby przekazać opcje linii poleceń do LLDB. Jeśli masz pewne polecenia, które chciałbyś, aby LLDB wykonywał za każdym razem, gdy zaczynasz debugować swoją aplikację, tuż przed lub tuż po dołączeniu debuggera do procesu aplikacji, możesz dodać te polecenia do swojej konfiguracji debugowania.

Podczas debugowania kodu C/C++, można również ustawić specjalne typy punktów przerwania, zwane punktami obserwacyjnymi, które mogą zawiesić proces aplikacji, gdy aplikacja wchodzi w interakcję z określonym blokiem pamięci. Aby dowiedzieć się więcej, przeczytaj sekcję o tym, jak dodać punkty obserwacyjne.

Wyświetlanie i konfigurowanie punktów przerwania

Aby wyświetlić wszystkie punkty przerwania i skonfigurować ustawienia punktów przerwania, kliknij przycisk Wyświetl punkty przerwania po lewej stronie okna Debugowanie. Pojawi się okno Breakpoints, jak pokazano na rysunku 5.

Rysunek 5. Okno Breakpoints zawiera listę wszystkich bieżących punktów przerwania i zawiera ustawienia zachowania dla każdego

Okno Breakpoints pozwala włączyć lub wyłączyć każdy punkt przerwania z listy po lewej stronie. Jeśli punkt przerwania jest wyłączony, Android Studio nie wstrzymuje aplikacji, gdy trafi na ten punkt. Wybierz punkt przerwania z listy, aby skonfigurować jego ustawienia. Możesz skonfigurować punkt przerwania, aby był wyłączony na początku i mieć system włączyć go po innym punkcie przerwania jest trafiony. Można również skonfigurować, czy punkt przerwania ma być wyłączany po jego trafieniu. Aby ustawić punkt przerwania dla dowolnego wyjątku, wybierz Exception Breakpoints na liście punktów przerwania.

Ramki okna debugera

W oknie debugera, okienko Ramki pozwala na przeglądanie ramki stosu, która spowodowała trafienie bieżącego punktu przerwania. Umożliwia to nawigację i badanie ramki stosu, a także przeglądanie listy wątków w aplikacji Android. Aby wybrać wątek, użyj rozwijanego selektora wątku i wyświetl jego ramkę stosu. Kliknięcie elementów w ramce otwiera źródło w edytorze. Można również dostosować prezentację wątków i wyeksportować ramkę stosu w sposób omówiony w podręczniku Ramki okna.

Sprawdzanie zmiennych

W oknie Debugger panel Zmienne umożliwia sprawdzanie zmiennych, gdy system zatrzyma aplikację na punkcie przerwania i wybierzesz ramkę z panelu Ramki. Okienko Zmienne umożliwia również wykonywanie wyrażeń ad-hoc przy użyciu metod statycznych i/lub zmiennych dostępnych w wybranej ramce.

Okienko Obserwacje zapewnia podobną funkcjonalność, z tym że wyrażenia dodane do okienka Obserwacje są zachowywane między sesjami debugowania. Należy dodać obserwacje dla zmiennych i pól, z których często korzystamy lub które dostarczają stanów przydatnych w bieżącej sesji debugowania. Okienka Zmienne i Obserwacje są wyświetlane w sposób pokazany na rysunku 5.

Aby dodać zmienną lub wyrażenie do listy Obserwacje, wykonaj następujące czynności:

1. Rozpocznij debugowanie.
2. W okienku Obserwacje kliknij przycisk Dodaj .
3. W wyświetlonym polu tekstowym wpisz nazwę zmiennej lub wyrażenia, które chcesz obserwować, a następnie naciśnij klawisz Enter.

Aby usunąć element z listy Obserwacje, zaznacz go, a następnie kliknij przycisk Usuń .

Możesz zmienić kolejność elementów na liście Obserwacje, zaznaczając element, a następnie klikając przycisk W górę lub W dół .

Rysunek 6. Panele Variables i Watches w oknie Debugger

Dodawanie punktów obserwacyjnych

Podczas debugowania kodu C/C++ można ustawiać specjalne typy punktów przerwania, zwane punktami obserwacyjnymi, które mogą zawieszać proces aplikacji, gdy aplikacja wchodzi w interakcję z określonym blokiem pamięci. Na przykład, jeśli ustawisz dwa wskaźniki do bloku pamięci i przypiszesz do niego punkt obserwacyjny, użycie któregokolwiek z nich w celu uzyskania dostępu do tego bloku pamięci spowoduje uruchomienie punktu obserwacyjnego.

W Android Studio, możesz utworzyć punkt obserwacyjny podczas runtime, wybierając określoną zmienną, ale LLDB przypisuje punkt obserwacyjny tylko do bloku pamięci, który system przydziela do tej zmiennej, a nie do samej zmiennej. Różni się to od dodania zmiennej do panelu Watches, co pozwala na obserwowanie wartości zmiennej, ale nie pozwala na zawieszenie procesu aplikacji, gdy system odczytuje lub zmienia jej wartość w pamięci.

Uwaga: Gdy proces aplikacji kończy działanie, a system usuwa z pamięci zmienne lokalne, należy ponownie przypisać punkty obserwacyjne utworzone dla tych zmiennych.

Aby ustawić punkt obserwacyjny, należy spełnić następujące wymagania:

• Twoje docelowe urządzenie fizyczne lub emulator używa procesora x86 lub x86_64. Jeśli urządzenie używa procesora ARM, to musisz wyrównać granicę adresu zmiennej w pamięci do 4 bajtów dla procesorów 32-bitowych lub 8 bajtów dla procesorów 64-bitowych. Możesz wyrównać zmienną w swoim natywnym kodzie, określając __attribute__((aligned(num_bytes))) w opóźnieniu zmiennej, jak pokazano poniżej:

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

• Przypisałeś już trzy lub mniej punktów obserwacyjnych. Android Studio obsługuje tylko do czterech punktów obserwacyjnych na urządzeniach docelowych x86 lub x86_64. Inne urządzenia mogą obsługiwać mniejszą liczbę punktów obserwacyjnych.

Uwaga: Podczas debugowania aplikacji z 32-bitowymi ARM ABIs, dodanie punktu obserwacyjnego lub najechanie na zmienne wewnątrz kodu w celu zbadania ich wartości może spowodować awarię. Aby obejść ten problem, należy debugować przy użyciu 64-bitowych binariów ARM, x86 lub x86_64. Ten problem zostanie naprawiony w nadchodzącym wydaniu Android Studio.

Jeśli spełniasz powyższe wymagania, możesz dodać punkt obserwacyjny w następujący sposób:

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

2. Kliknij prawym przyciskiem myszy zmienną, która zajmuje blok pamięci, który chcesz śledzić, i wybierz Dodaj punkt obserwacyjny. Pojawi się okno dialogowe do skonfigurowania punktu obserwacyjnego, jak pokazano na rysunku 7.

   

   Rysunek 7. Dodawanie punktu obserwacyjnego do zmiennej w pamięci

3. Skonfiguruj swój punkt obserwacyjny za pomocą następujących opcji:
   • Enabled: Możesz odznaczyć tę opcję, jeśli chcesz powiedzieć Android Studio, aby na razie zignorował punkt obserwacyjny. Android Studio nadal zapisuje punkt obserwacyjny, dzięki czemu możesz uzyskać do niego dostęp później w sesji debugowania.
   • Zawieś: Domyślnie system Android zawiesza proces aplikacji, gdy uzyskuje on dostęp do bloku pamięci, który przypisujesz do punktu obserwacyjnego. Możesz odznaczyć tę opcję, jeśli nie chcesz tego zachowania – to ujawnia dodatkowe opcje, których możesz użyć, aby dostosować zachowanie, gdy system wchodzi w interakcję z punktem obserwacyjnym: Log message to console i Remove when hit.
   • Typ dostępu: Wybierz, czy Twoja aplikacja powinna wyzwalać punkt obserwacyjny, gdy próbuje odczytać lub zapisać blok pamięci, który system przydziela do zmiennej. Aby uruchomić punkt obserwacyjny przy odczycie lub zapisie, wybierz Dowolny.
4. Kliknij Gotowe.

Aby wyświetlić wszystkie punkty obserwacyjne i skonfigurować ustawienia punktów obserwacyjnych, kliknij polecenie Wyświetl punkty przerwania po lewej stronie okna Debugowanie. Pojawia się okno dialogowe Breakpoints, jak pokazano na rysunku 8.

Rysunek 8. Okno dialogowe Breakpoints zawiera listę bieżących punktów obserwacyjnych oraz ustawienia zachowania dla każdego z nich

Po dodaniu punktu obserwacyjnego kliknij przycisk Resume Program z lewej strony okna Debug, aby wznowić proces aplikacji. Domyślnie, jeśli Twoja aplikacja próbuje uzyskać dostęp do bloku pamięci, dla którego ustawiłeś punkt obserwacyjny, system Android zawiesza proces aplikacji, a ikona punktu obserwacyjnego pojawia się obok wiersza kodu, który Twoja aplikacja wykonała jako ostatni, jak pokazano na rysunku 9.

Rysunek 9. Android Studio wskazuje linię kodu, którą Twoja aplikacja wykonuje tuż przed wyzwoleniem punktu obserwacyjnego

Wyświetl i zmień format wyświetlania wartości zasobów

W trybie debugowania możesz wyświetlić wartości zasobów i wybrać inny format wyświetlania zmiennych w swoim kodzie Java. Mając wyświetloną kartę Zmienne i wybraną ramkę, wykonaj następujące czynności:

1. Na liście Zmienne kliknij prawym przyciskiem myszy w dowolnym miejscu wiersza zasobu, aby wyświetlić listę rozwijaną.
2. Na liście rozwijanej wybierz opcję 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 następujących opcji:

   • Klasa: Wyświetl definicję klasy.
   • toString: Wyświetl format łańcucha znaków.
   • Obiekt: Wyświetl definicję obiektu (instancji klasy).
   • Array: Wyświetlać w formacie tablicy.
   • Timestamp: Wyświetl datę i czas w następujący sposób: rrrr-mm-dd hh:mm:ss.
   • Auto: Android Studio wybiera najlepszy format na podstawie typu danych.
   • Binary: Wyświetla wartość binarną przy użyciu zer i jedynek.
   • MeasureSpec: Wartość przekazywana z rodzica do wybranego dziecka. Zobacz MeasureSpec.
   • Hex: Wyświetlanie jako wartość szesnastkowa.
   • Primitive: Wyświetlanie jako wartości liczbowej przy użyciu prymitywnego typu danych.
   • Integer: Wyświetlanie wartości numerycznej typu Integer.

Można utworzyć format niestandardowy (renderer typu danych), jak poniżej:

.