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żna wybrać domyślną opcję „debugowanie”. dostępny w każdym Android Studio. projektu, mimo że nie jest on 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:

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: 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 warianty projektu aplikacji możliwe do debugowania otrzymywały możliwy do debugowania wariant z modułu bibliotecznego, możesz publikować 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ę.
    Menu urządzenia docelowego.
    Rysunek 1. Menu urządzenia docelowego.

    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, pojawi się okno z pytaniem, czy chcesz przełącz z 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 uruchom aplikację 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. Tutaj możesz wybrać proces i zakończyć proces zabijania , wymuszanie zatrzymania , lub dołączyć debuger do danego procesu.

Okno debugowania

Rys. 2. 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 i moduł czyszczenia pamięci Androida Studio nie są z niepełnosprawnością. 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 prowadzić do gromadzenia się obiektów, gdy jest podłączony debuger. 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 decyduje, którego debugera użyć, na podstawie języków wykrytych w projekcie za pomocą Wykrywaj automatycznie typ debugera.

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ł 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 opartego tylko na Javie.
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 spełniających te wymagania:

  • Urządzenie obsługuje run-as.

    Aby sprawdzić, czy urządzenie obsługuje run-as, uruchom następujące polecenie na powłoka ADB podłączona do urządzenia:

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

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 języka Java, jak i kodu natywnego. Android Studio łączy z aplikacją debuger Java i LLDB i sprawdzać, punkty przerwania w kodzie Java i natywnym bez ponownego uruchamiania aplikacji lub zmianę 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).

Rysunek 3. Karta do debugowania kodu natywnego i karty do debugowania kodu 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 logowaniu znajdziesz w zapisuj i wyświetlaj logi w aplikacji 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: usuń komunikaty dziennika debugowania i wywołania drukowania zrzutu stosu z kodu, gdy wszystko będzie gotowe do opublikowania aplikacji. Aby to zrobić, ustaw DEBUG flagi i umieszczać komunikaty dziennika debugowania w instrukcjach 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.

Rysunek 4. Okno Logcat z ustawieniami filtrów.

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ć warunkowe punkty przerwania, które spowodują zawieszenie wykonania tylko wtedy, gdy zostaną spełnione określone warunki są spełnione. Możesz też ustawić punkty przerwania logowania, które zapisują dane w Logcat bez zawieszania 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 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. Jeśli nie, kliknij Debuguj, aby rozpocząć debugowanie.

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

Rysunek 5. Czerwona kropka znajduje się obok po ustawieniu punktu przerwania.

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 Krok Wyeliminowanie .

  • 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 debugera, jak pokazano na ilustracji na rys. 6.

Rysunek 6. debugowanie kodu natywnego za pomocą LLDB;
  1. Android Studio przechodzi na <your-module>, gdy debuger LLDB napotka w kodzie C/C++. Ramki, Zmienne Dostępne są również panele zegarków, które działają dokładnie tak samo, jak debugowali kod w Javie.

    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 przy użyciu LLDB możesz używać terminala LLDB w widok sesji LLDB, który przekazuje 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: sekcji dotyczącej dodawania punktów obserwacyjnych.

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: Okno debugowania. Pojawi się okno Punkty przerwania. jak widać na rysunku 7.

Rysunek 7. Okno Punkty przerwania zawiera listę wszystkich bieżących oraz określa ustawienia zachowania dla każdego z nich.

Okno Punkty przerwania pozwala włączyć lub wyłączyć każdy punkt przerwania listę 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ć wyłączenie punktu przerwania i włącz ją po wystąpieniu innego punktu przerwania. Możesz też określić, czy punkt przerwania ma być wyłączony po jego . Aby ustawić punkt przerwania dla dowolnego wyjątku, wybierz Wyjątek Punkty przerwania na liście punktów 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):

Rysunek 8. Pole do wpisywania drzewa obiektów i wyrażenia w oknie debugowania.
  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.

Ocenione wyrażenia będą wyświetlane na górze drzewa obiektów, dopóki nie wykonasz tych czynności ręcznie wartości innego wyrażenia lub wykonywania kodu.

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 ustaw dwa wskaźniki na blok pamięci i przypisz do niego punkt obserwacji, używając funkcji albo wskaźnik umożliwiający dostęp do tego bloku pamięci, uruchamia się punkt 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 wychodzi z funkcji, a system przydziału jego zmiennych lokalnych z pamięci, trzeba ponownie przypisać wszystkie utworzone dla tych zmiennych i punktów monitorowania.

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, wpisz __attribute__((aligned(num_bytes))) w: zgodnie z poniższym przykładem: 
    // For a 64-bit ARM processor
int my_counter __attribute__((aligned(8)));
  • Masz już przypisanych maksymalnie 3 punkty obserwacji. Tylko Android Studio obsługuje do 4 punktów obserwacji na urządzeniach docelowych 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 w punkcie przerwania, otwórz Okienko Zmienne w widoku sesji LLDB.

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

    Rysunek 9. Dodaj punkt obserwacji do zmiennej w pamięci.

  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 podać, Android Studio będzie ignorować punkt obserwacji, dopóki nie zmienisz tego ustawienia. Android, Studio zapisze Twój punkt obserwacji, aby móc uzyskać do niego dostęp później.
    • 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.

Rysunek 10. W oknie Punkty przerwania zobaczysz bieżący i uwzględnia ustawienia zachowania dla każdego z nich.

Po dodaniu punktu obserwacji kliknij Wznów program w oknie debugowania, aby wznowić aplikację. 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.

Rysunek 11. Android Studio wskazuje wiersz kodu, który aplikacja jest uruchamiana tuż przed aktywacją 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 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 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 danego 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. Postępuj zgodnie z instrukcjami na stronie Mechanizmy renderowania typu danych Java.