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 dokumentacji znajdziesz też przeczytaj dokumentację 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 u dewelopera urządzenia. .

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

Użyj wariantu kompilacji, który: w tym debuggable true (isDebuggable = true w skryptach Kotlin) 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 zdefiniować nowe typy kompilacji, które powinny być możliwy do debugowania, musisz dodać atrybut debuggable true do typu kompilacji:

Groovy

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: atrybut Usługa jniDebuggable nie jest już używana.

Jeśli aplikacja zależy od modułu biblioteki, który chcesz też debugować, ta biblioteka również musi być spakowany z elementem 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.

   

   Jeśli nie masz skonfigurowanych żadnych urządzeń, musisz: podłącz urządzenie przez USB, połączyć urządzenie przez Wi-Fi lub utwórz listę AVD, aby użyć Emulator Androida.

3. Na pasku narzędzi kliknij Debuguj .

   Jeśli aplikacja jest już uruchomiona na urządzeniu, wyświetli się okno z pytaniem, czy chcesz przełączyć się z trybu Uruchom na Debugowanie. Aby rozpocząć debugowanie, urządzenie musi zostać ponownie uruchomione. Do przy nieprzerwanym działaniu aplikacji, kliknij Anuluj debugowanie. dołącz debuger do uruchomionej aplikacji. W przeciwnym razie Android Studio tworzy plik APK, podpisuje go kluczem debugowania, instaluje go na wybranym urządzeniu i uruchamia.

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

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

Podłącz debuger 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 Dołącz debuger do procesu Androida .
2. W oknie Wybierz proces wskaż proces, który chcesz i podłączyć debuger.
   1. Jeśli używasz emulatora lub urządzenia z dostępem do roota, możesz sprawdzić Pokaż wszystkie procesy, aby zobaczyć wszystkie procesy. Na urządzeniu z dostępem do roota zostaną wyświetlone wszystkie na urządzeniu. Jednak na urządzeniach bez dostępu do roota ta opcja będzie wyświetlana tylko i debugować.
   2. W menu Use Android Debugger Settings (Użyj ustawień debugera Androida) możesz wybrać dotychczasowy konfiguracji uruchamiania i debugowania. W przypadku kodu w języku C i C++ pozwala to na ponowne wykorzystywanie poleceń startowych bazy danych LLDB, poleceń post-attach LLDB i symboli w istniejącej konfiguracji.
   3. Jeśli nie masz uruchomionego uruchomienia/debugowania wybierz Utwórz nową. Ten wybór włącza Typ debugowania gdzie możesz wybrać inny typ debugowania. Według domyślnie, Android Studio używa typu debugowania Wykryj automatycznie, aby wybrać za pomocą debugera w zależności od tego, czy projekt zawiera kod w języku Java czy C/C++.
3. Kliknij OK.

   Pojawi się okno debugowania.

Karta Procesy w Eksploratorze urządzeń (Widok > Okna narzędziowe > Eksplorator urządzenia). ma też listę procesów możliwych do debugowania. Możesz wybrać proces i wykonać operację kill lub stop, a także dołączyć debuger do danego procesu.

Okno debugowania

Okno debugowania jest podzielone na

1. Pasek narzędzi wykonywania i nawigacji – patrz Praca z punktami przerwania
2. Selektor wątku
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 i odśmieciarka w Android Studio są luźno połączone. Maszyna wirtualna z Androidem gwarantuje, że każdy obiekt jeśli debuger wie, że nie są pobierane żadne dane, dopóki debuger nie będzie zostanie rozłączony. Może to spowodować nagromadzenie się obiektów podczas połączenia z debugerem. Jeśli na przykład debuger wykryje aktywny wątek, powiązane Thread obiekt nie zostanie usunięty, dopóki debuger się nie odłączysz, 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 debugowania, Debuger Android Studio pozwala wybrać typ debugera, którego 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 dialogowym, które pojawia się po kliknij kolejno Uruchom > Podłącz debuger do procesu Androida.

Dostępne typy debugowania:

Wykrywaj automatycznie

Wybierz ten typ debugowania, jeśli chcesz, aby Android Studio automatycznie wybierało najlepszą opcję dla kodu, który debugujesz. Na przykład, jeśli masz kod w C lub C++ w projekcie, Android Studio automatycznie typu. 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. Środowisko tylko Java ignoruje punkty przerwania lub obserwuje 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. Jeśli używasz tej metody debugera Java, widok sesji debugera Java jest niedostępny. Domyślnie LLDB sprawdza tylko kod natywny i ignoruje punkty przerwania w Javie w kodzie. Jeśli chcesz debugować również kod w Javie, przełącz się na typu debugowania Wykryj automatycznie lub Podwójne.

Debugowanie natywne działa tylko na urządzeniach, które spełniają te wymagania:

• Urządzenie obsługuje run-as.

  Aby sprawdzić, czy urządzenie obsługuje run-as, uruchom to polecenie w powłoce ADB połączonej z urządzeniem:

  run-as your-package-name pwd
  

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

• Na urządzeniu jest włączona usługa ptrace.

  Aby sprawdzić, czy funkcja ptrace jest włączona, uruchom w ADB to polecenie podłączonej do urządzenia:

  sysctl kernel.yama.ptrace_scope
  

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

Dual (Java + Native) – dostępne tylko w przypadku kodu C/C++.

Wybierz ten typ debugowania, jeśli chcesz się przełączać między debugowaniem zarówno języka Java, jak i kodu natywnego. Android Studio dołącza do procesu aplikacji zarówno debuger Java, jak i LLDB, dzięki czemu możesz sprawdzać punkty przerwania zarówno w kodzie natywnym, jak i w kodzie natywnym bez restartowania aplikacji ani zmieniania 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 a drugi do debugowania kodu Java (wskazuje to -java).

Uwaga: podczas debugowania kodu natywnego optymalizowanego przez może pojawić się następujący komunikat ostrzegawczy:
This function was compiled with optimizations enabled. Some debugger features may not be available. Jeśli używasz flag optymalizacji, kompilator wprowadza zmiany w parametrze skompilować kod, żeby zwiększyć jego wydajność. Może to spowodować, że debuger zgłaszają nieoczekiwane lub nieprawidłowe informacje, ponieważ trudno w celu mapowania zoptymalizowanego skompilowanego kodu z powrotem na oryginalny kod źródłowy. Z tego powodu podczas debugowania lepiej wyłączyć optymalizacje kompilatora. do kodu natywnego.

Korzystanie z dziennika systemowego

Dziennik systemowy pokazuje komunikaty systemowe podczas debugowania aplikacji. Komunikaty te obejmują: informacji z aplikacji uruchomionych na urządzeniu. Jeśli chcesz użyć atrybutu log systemowy do debugowania aplikacji; upewnij się, że Twój kod zapisuje komunikaty logu i drukuje stos możesz śledzić wyjątki w fazie rozwoju aplikacji.

Zapisywanie komunikatów logu w kodzie

Aby zapisać komunikaty logu w kodzie, użyj klasy Log. Pomoc dotycząca komunikatów logu zapoznasz się z przebiegiem wykonania, zbierając dane wyjściowe debugowania systemu, podczas interakcji z aplikacją. Komunikaty dziennika mogą też informować, aplikacji nie udało się. Więcej informacji o rejestrowaniu znajdziesz w artykule Zapisywanie i wyświetlanie logów za pomocą narzędzia Logcat.

Poniższy przykład pokazuje, jak dodać komunikaty logu w celu określenia, czy poprzedni stan informacje 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 */
        }
        ...
    }
}

Podczas programowania kod może też wykrywać wyjątki i zapisywać zrzut stosu w systemie. dziennik:

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ć komunikaty debugowania i inne komunikaty systemowe, tak jak pokazano to poniżej na rys. 4. Możesz na przykład zobaczyć wiadomości o usuwaniu czyszczenia pamięci lub te, które: które dodasz do aplikacji za pomocą Log.

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

Opis aplikacji Logcat i jej opcji filtrowania znajdziesz w artykule zapisuj i wyświetlaj logi w aplikacji Logcat.

Praca z punktami przerwania

Android Studio obsługuje punkty przerwania, które uruchamiać 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 na określonym wiersza kodu. Po wstrzymaniu funkcji możesz sprawdzić zmienne, ocenić wyrażenia, a następnie przejść dalej wykonywania kodu po wierszu w celu określenia przyczyn błędów środowiska wykonawczego.

Punkt przerwania metody

Punkt przerwania metody wstrzymuje działanie aplikacji, gdy otwiera się ona lub zamyka . Po wstrzymaniu funkcji możesz sprawdzić zmienne, ocenić wyrażenia, a następnie przejść dalej wykonywania kodu po wierszu w celu określenia przyczyn błędów środowiska wykonawczego. Gdy ustawisz punkt przerwania funkcji kompozycyjnej, debuger wyświetla parametry funkcji kompozycyjnej i ich stan, aby zidentyfikować zmiany, które mogły spowodować zmianę kompozycji.

Punkt przerwania pola

Punkt przerwania pola wstrzymuje działanie aplikacji, gdy odczytuje ona dane lub zapisuje konkretne pole.

Punkt przerwania wyjątku

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

Możesz ustawić punkty przerwania warunkowe, które zawieszą wykonywanie kodu tylko wtedy, gdy zostaną spełnione określone warunki. Możesz też ustawić punkty przerwania logowania, które zapisują dane w Logcat bez zawieszania Dzięki temu nie musisz zaśmiecać kodu instrukcjami logowania.

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

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

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

Gdy wykonanie kodu dotrze do punktu 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.

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

• Aby przejść do pierwszego wiersza w wywołaniu metody, kliknij 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 używa dowolnego kodu natywnego, domyślnie wybierz typ „Wykryj automatycznie debugowanie”. dołącza debuger Java i LLDB do aplikacji jako 2 osobne Możesz przełączać się między sprawdzaniem punktów przerwania Javy i C/C++ bez potrzeby ponownego uruchamiania aplikacji i zmieniania ustawień.

Uwaga: aby Android Studio mógł 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. Do aby dowiedzieć się więcej o różnych typach debugowania, przeczytaj sekcję o używaniu inne typy debugowania.

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

1. Android Studio przechodzi na <your-module>, gdy debuger LLDB napotka w kodzie C/C++. Dostępne są też panele Ramki, Zmienne i Zegarki, które działają tak samo jak w przypadku debugowania kodu Java.

   Chociaż panel Wątki jest niedostępny w widoku sesji LLDB możesz uzyskać dostęp do procesów aplikacji za pomocą w panelu Klatki. Dowiedz się więcej na ten temat panele w sekcjach o sposobach debugowania okna ramki i sprawdzanie zmiennych.

   Uwaga: podczas sprawdzania punktu przerwania w kodzie natywnym funkcja System Android zawiesza maszynę wirtualną, na której działa Java aplikacji kod bajtowy. Oznacza to, że nie możesz korzystać z interfejsu Java debugera ani pobierać z niego żadnych informacji o stanie podczas sprawdzania punktu przerwania w kodzie natywnym.

2. Android Studio przechodzi na <your-module>, gdy debuger Java działa napotka punkt przerwania w kodzie Java lub Kotlin.
3. Podczas debugowania za pomocą LLDB możesz użyć terminala LLDB w widoku sesji LLDB, aby przekazać opcje wiersza poleceń do LLDB. Jeśli masz określone polecenia, które LLDB ma uruchamiać za każdym razem, gdy rozpoczynasz debugowanie bezpośrednio przed podłączeniem debugera do kodu lub tuż po podłączeniu procesu aplikacji można dodaj te polecenia do konfiguracji debugowania.

Podczas debugowania kodu C/C++ możesz też ustawiać specjalne typy punktów przerwania, nazywane punktami obserwacji, które mogą zawiesić proces aplikacji, gdy współdziała 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 przerwania. jak widać na rysunku 7.

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 i wstrzymuje działanie aplikacji po osiągnięciu tego punktu przerwania.

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

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

Ramki okien debugowania

W oknie Debuger w panelu Ramki możesz sprawdzać ramki stosu, która spowodowała trafienie bieżącego punktu przerwania. Dzięki temu należy przyjrzeć się ramce stosu, a także przejrzeć listę wątkach w aplikacji na Androida.

Aby wybrać wątek, użyj selektora wątków i wyświetl ramkę stosu. Klika elementy w ramce. aby otworzyć źródło w edytorze. Możesz też dostosować wątek i wyeksportować ramkę stosu zgodnie z opisem w Przewodnik dotyczący sprawdzania klatek

Sprawdzanie zmiennych

Panel Zmienne w oknie Debuger umożliwia: sprawdza zmienne, gdy system zatrzyma aplikację w punkcie przerwania, wybierz ramkę w panelu Klatki. Panel Zmienne pozwala oceniać wyrażenia doraźne za pomocą metod statycznych lub 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 przeciągnąć na górze 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.

Wyrażenia po przetworzeniu pozostają wyświetlane u góry drzewa obiektów, dopóki ręcznie nie przetworzysz innego wyrażenia lub nie przejdziesz przez kod.

Aby usunąć obserwowane wyrażenie z drzewa obiektów, kliknij je prawym przyciskiem myszy, a następnie kliknij Usuń zegarek.

Dodaj punkty obserwacji

Podczas debugowania kodu C/C++ możesz ustawić specjalne typy punktów przerwania, zwane watchpoints, które mogą zawiesić proces aplikacji, gdy współdziała 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 w czasie działania, wybierając określoną zmienną, ale LLDB przypisuje punkt kontrolny tylko do bloku którą system przydziela tej zmiennej, a nie samej zmiennej. Ten różni się od dodania zmiennej do panelu Zegarki, która umożliwia obserwować wartość zmiennej, ale nie pozwala na zawieszenie procesu aplikacji, gdy system odczytuje lub zmienia swoją wartość w pamięci.

Uwaga: gdy proces aplikacji zakończy działanie funkcji i system zwolnił pamięć z lokalnych zmiennych, musisz ponownie przypisać 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 jest wyposażony w procesor ARM, adres zmiennej w pamięci do 4 bajtów, w przypadku procesorów 32-bitowych lub do 8 bajtów bajtów (procesory 64-bitowe). Aby wyrównać zmienną w kodzie natywnym, w opóźnieniu 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ż przypisanych maksymalnie 3 punkty obserwacji. Android Studio obsługuje maksymalnie 4 punkty kontrolne na urządzeniach docelowych z procesorami x86 lub x86_64. Inny powód urządzenia mogą obsługiwać mniej punktów obserwacyjnych.

Uwaga: podczas debugowania aplikacji za pomocą 32-bitowych interfejsów ARM ABI dodanie punktu kontrolnego lub najechanie kursorem na zmienne wewnątrz kodu, aby je zbadać. mogą spowodować awarię. Aby obejść ten problem, debuguj za pomocą 64-bitowego procesora ARM, pliki binarne 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 na punkcie przerwania, przejdź w widoku sesji LLDB do panelu Zmienne.

2. Kliknij prawym przyciskiem myszy zmienną zajmującą blok pamięci, który chcesz śledzić i kliknąć 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 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ć.
   • Zawieś: domyślnie system Android zawiesza aplikację. gdy uzyskuje dostęp do bloku pamięci przypisanego do punktu kontrolnego. Odznacz tę opcję, jeśli nie chcesz, aby takie ustawienie było dostępne. Ten ujawnia dodatkowe opcje, które można wykorzystać do dostosowania działania, gdy system wchodzi w interakcję z punktem obserwacji: zapisz komunikat w konsoli. i Usuń po naciśnięciu.
   • Typ dostępu: określ, czy aplikacja ma uruchamiać gdy próbuje odczytać lub zapis w bloku przydzielona przez system do zmiennej. Aby aktywować punkt obserwacji przy odczytu lub zapisu, wybierz Dowolne.
4. Kliknij Gotowe.

Aby wyświetlić wszystkie punkty obserwacji 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 aby ją wznowić, w oknie debugowania proces tworzenia konta. Domyślnie, jeśli aplikacja próbuje uzyskać dostęp do bloku pamięci, system Android zawiesza proces aplikacji, ikona punktu obserwacji pojawia się obok wiersza kodu używanego przez aplikację jak widać 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 wybierać inny format wyświetlania zmiennych w kodzie Java lub Kotlin. z wyświetloną kartą Zmienne i ramką wykonaj te czynności:

1. Na liście Zmienne kliknij prawym przyciskiem myszy w dowolnym miejscu wiersza zasobu, 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 tablicy.
     
   • 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.
   • Szeszentosiowa: wyświetlanie wartości w systemie szesnastkowym.
   • Liczba podstawowa: wyświetlana jako wartość liczbowa z użyciem podstawowego typu danych.
   • Liczba całkowita: wyświetlana jako wartość liczbowa danego typu. Integer

Aby utworzyć format niestandardowy:

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