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łączanie debugowania

Zanim zaczniesz debugowanie, wykonaj te czynności:

Włącz debugowanie na urządzeniu.
Jeśli używasz emulatora, debugowanie jest domyślnie włączone. W przypadku połączonego urządzenia musisz włączyć debugowanie w opcjach dla deweloperów.
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 zdefiniujesz nowe typy wersji, które mają być debugowane, musisz dodać debuggable true do typu wersji:

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

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

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

Jeśli aplikacja jest zależna od modułu biblioteki, który również chcesz debugować, ta biblioteka musi być skompilowana z 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łączyć urządzenie przez USB, podłączyć urządzenie przez Wi-Fi lub utworzyć AVD, aby korzystać z emulatora 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, musisz ponownie uruchomić urządzenie. Do przy nieprzerwanym działaniu aplikacji, kliknij Anuluj debugowanie, a następnie 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 dodasz do projektu kod C i C++, Android Studio uruchomi też debuger LLDB w oknie Debugowanie, aby debugować kod natywny.

  4. Jeśli okno debugowania jest zamknięte, kliknij Widok > Okna narzędzi > Debugowanie lub kliknij Debugowanie  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 Załącz debugger 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 rootem wyświetli się lista wszystkich procesów działających na urządzeniu. Jednak na urządzeniach bez dostępu do roota ta opcja będzie wyświetlana tylko i debugować.
    2. W menu Użyj ustawień debugera Androida możesz wybrać istniejące ustawienie wykonywania lub debugowania. W przypadku kodu C i C++ umożliwia to ponowne użycie poleceń uruchamiania LLDB, poleceń LLDB po załączeniu i katalogów symboli w dotychczasowej 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. Domyślnie Android Studio używa opcji Wykrywanie automatycznie, aby wybrać dla Ciebie najlepszą opcję debugowania na podstawie tego, czy Twój projekt zawiera kod Java czy C/C++.
  3. Kliknij OK.

    Pojawi się okno debugowania.

Na karcie Procesy w Eksploratorze urządzenia (Widok > Okna narzędzia > Eksplorator urządzenia) znajduje się też lista procesów, które można debugować. Możesz wybrać proces i wykonać operację kill lub stop, a także dołączyć debuger do danego procesu.

Okno debugowania

Rys. 2. Okno debugowania.

Okno debugowania jest podzielone na

  1. Pasek narzędzi do wykonywania i przechodzenia między funkcjami: Praca z punktami kontrolnymi
  2. Selektor wątku
  3. Obliczanie i wyrażenie do oglądania. Przeczytaj sekcję Sprawdzanie zmiennych.
  4. Wyświetlanie grupy
  5. Panel Zmienne. Zapoznaj się z artykułem Sprawdzanie zmiennych.

Uwaga: debuger i odśmieciarka w Android Studio są luźno połączone. Wirtualna maszyna Androida gwarantuje, że żaden obiekt znany debugerowi nie zostanie zebrany jako śmieci, dopóki debuger nie zostanie odłączony. Może to spowodować nagromadzenie się obiektów podczas połączenia z debugerem. Jeśli na przykład debuger widzi działający wątek, powiązany z nim obiekt Thread nie jest usuwany do czasu, gdy debuger się rozłączy, nawet jeśli wątek został zakończony.

Zmiana typu debugera

Do debugowania kodu Java/Kotlin i C/C++ wymagane są różne narzędzia 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 Uruchom > Podłą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 kodu, który debugujesz. Jeśli na przykład w projekcie masz kod C lub C++, Android Studio automatycznie użyje typu debugowania Dual. 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. Debuger przeznaczony tylko do Java ignoruje wszystkie punkty kontrolne i punkty obserwacji ustawione w kodzie natywnym.
Tylko natywne (dostępne tylko z kodem C/C++)
Wybierz ten typ debugowania, jeśli chcesz debugować kod tylko za pomocą LLDB. Gdy używasz tego typu debugowania, widok sesji w debugerze Java jest niedostępny. Domyślnie LLDB sprawdza tylko kod natywny i ignoruje punkty przerwania w Javie w kodzie. Jeśli chcesz debugować kod Java, zmień typ debugowania na „Wykrywaj automatycznie” lub „Podwójne debugowanie”.

Debugowanie natywne działa tylko na urządzeniach spełniających te wymagania:

  • Urządzenie obsługuje run-as.

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

    run-as your-package-name pwd

    Zastąp your-package-name nazwą pakietu 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 funkcja 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 opcja ptrace nie jest włączona, zostanie wydrukowana wartość inna 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 Javy, jak i LLDB, aby umożliwić Ci sprawdzanie punktów przerwania w kodzie natywnym i w kodzie w Javie bez restartowania aplikacji ani zmiany konfiguracji debugowania.

Na ilustracji 2 zwróć uwagę na 2 karty po prawej stronie tytułu Okno debugowania. Aplikacja zawiera kod w językach Java i C++, więc jedna karta służy do debugowania kodu natywnego, a druga – do debugowania kodu Java, co jest oznaczone parametrem -java.

Rysunek 3. Karta do debugowania kodu natywnego i karty do debugowania kodu Java.

Uwaga: podczas debugowania kodu natywnego zoptymalizowanego przez kompilator możesz zobaczyć to ostrzeżenie:
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 będzie raportować nieoczekiwane lub nieprawidłowe informacje, ponieważ trudno jest mu przypisać zoptymalizowany skompilowany kod do pierwotnego kodu źródłowego. 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 debugować aplikację za pomocą dziennika systemowego, zadbaj o to, aby Twój kod zapisywał komunikaty dziennika i wyświetlał ślad stosu w przypadku wyjątków na etapie tworzenia aplikacji.

Pisanie komunikatów logowania w kodzie

Aby zapisać komunikaty logu w kodzie, użyj klasy Log. Komunikaty logowania pomagają zrozumieć przepływ wykonywania, ponieważ zbierają dane debugowania systemu podczas interakcji z aplikacją. Mogą też informować, która część aplikacji uległa awarii. Więcej informacji o rejestrowaniu znajdziesz w artykule Zapisywanie i wyświetlanie logów za pomocą narzędzia Logcat.

Ten przykład pokazuje, jak dodać komunikaty logowania, aby określić, czy informacje o poprzednim stanie są dostępne, gdy rozpoczyna się Twoja aktywność:

KotlinJava
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
    ...
  }
}
 
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 tworzenia kod może też przechwytywać wyjątki i zapisywać zrzuty stosu do dziennika systemu:

KotlinJava
fun someOtherMethod() {
    try {
        ...
    } catch (e : SomeException) {
        Log.d(TAG, "someOtherMethod()", e)
    }
}
 
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 flagę i umieszczać komunikaty dziennika debugowania w instrukcjach warunkowych.

Wyświetlanie dziennika systemowego

W oknie Logcat możesz wyświetlać i filtrować debugowanie oraz inne komunikaty systemowe (patrz rys. 4). Możesz na przykład zobaczyć komunikaty o zbieraniu pamięci podręcznej lub komunikaty dodane do aplikacji za pomocą klasy 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 linii
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 . W trybie pauzy możesz sprawdzać zmienne, oceniać wyrażenia, a następnie kontynuować wykonywanie kodu liniowo, aby określić przyczyny błędów w czasie wykonywania. 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. Odszukaj wiersz kodu, w którym chcesz wstrzymać wykonywanie kodu.
  2. Kliknij lewą krawędź pola po lewej stronie danej linii kodu lub umieść kursor na linii i naciśnij Control+F8 (w systemie macOS Command+F8).
  3. Jeśli aplikacja jest już uruchomiona, kliknij Załącz debuger do procesu Androida. W przeciwnym razie 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 wstrzyma wykonywanie aplikacji.

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

  • Aby sprawdzić, czy zmienna znajduje się w drzewie obiektów, rozwiń ją w widoku Zmienne. Jeśli widok Zmienne jest niewidoczny, kliknij Ustawienia układu i upewnij się, że zaznaczona jest opcja Zmienna.

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

  • 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 kontynuować normalne działanie aplikacji, kliknij Wznów program.

Jeśli Twój projekt używa kodu natywnego, domyślnie typ debugowania Wykrywanie automatycznie dołącza do aplikacji zarówno debuger Java, jak i LLDB jako 2 oddzielne procesy. Możesz przełączać się między punktami kontrolnymi w Javie i C/C++ bez restartowania aplikacji ani 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, otworzy się okno Debugowanie z kartą lub widokiem sesji debugowania dla każdego procesu debugera, jak pokazano na rysunku 6.

Rysunek 6. Debugowanie kodu natywnego za pomocą LLDB.
  1. Gdy debugger LLDB napotka punkt przerwania w kodzie C/C++, Android Studio przełączy się na kartę <your-module>. 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. Więcej informacji o tych panelach znajdziesz w sekcjach dotyczących debugowania ramek okna i sprawdzania zmiennych.

    Uwaga: podczas sprawdzania punktu przerwania w kodzie natywnym system Android zawiesza maszynę wirtualną, która wykonuje bajt kod Java aplikacji. Oznacza to, że podczas sprawdzania punktu przerwania w kodzie natywnym nie możesz wchodzić w interakcję z debugerem Java ani pobierać żadnych informacji o stanie z sesji debugera Java.

  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, zwane punktami obserwacji, które mogą zawiesić proces aplikacji, gdy aplikacja wchodzi w interakcję 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 graniczne, jak pokazano na rysunku 7.

Rysunek 7. W oknie Punkty graniczne wyświetla się lista wszystkich punktów granicznych wraz z ustawieniami zachowania dla każdego z nich.

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 wstrzymuje aplikacji, gdy osiągnie ten punkt.

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, w oknie debugowania kliknij Wyłącz punkty przerwania . 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 menu selektora wątku i wyświetl jego ramkę stosu. Klika elementy w ramce. aby otworzyć źródło w edytorze. Możesz też dostosować prezentację wątku i wyeksportować ramkę stosu zgodnie z opisem w przewodniku Examine Frames (w języku angielskim).

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. Drzewo obiektów i pole wprowadzania wyrażenia w oknie debugowania
  1. Wpisz wyrażenie, które chcesz oglądać lub wyświetlić
  2. Kliknij Dodaj do obserwowanych lub naciśnij klawisz Enter, aby przeanalizować wyrażenie raz.

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 i wybierz Usuń obserwowanie.

Dodawanie punktów kontrolnych

Podczas debugowania kodu C/C++ możesz ustawiać specjalne typy punktów przerwania, zwane punktami obserwacji, które mogą zawieszać proces aplikacji, gdy aplikacja wchodzi w interakcję 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 zakończy działanie funkcji i system zwolnił pamięć lokalną z tych zmiennych, musisz ponownie przypisać punkty kontrolne utworzone dla tych zmiennych.

Aby ustawić punkt kontrolny, musisz spełniać te wymagania:

  • Docelowe urządzenie fizyczne lub emulator ma procesor x86 lub x86_64. Jeśli Twoje urządzenie korzysta z procesora ARM, musisz dopasować granicę adresu zmiennej w pamięci 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, 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ż przypisane co najmniej 3 punkty kontrolne. 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 rozwiązany w kolejnej wersji Android 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ą, która zajmuje blok pamięci, który chcesz śledzić, i wybierz Dodaj punkt kontrolny.

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

  3. Pojawi się okno konfiguracji punktu obserwacji, jak pokazano na rysunku 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 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: wybierz, czy aplikacja ma wywoływać punkt kontrolny, gdy spróbuje odczytać lub zapisz do bloku pamięci przydzielonego przez system do zmiennej. Aby punkt obserwacji był uruchamiany przy odczycie lub zapisie, wybierz Dowolny.
  4. Kliknij Gotowe.

Aby wyświetlić wszystkie punkty kontrolne i skonfigurować ich ustawienia, w oknie debugowania kliknij Wyświetl punkty kontrolne . Pojawi się okno Punkty przerwania (jak na rysunku 10).

Rysunek 10. W oknie Punkty przerwania znajdziesz 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 wybierać inny format wyświetlania zmiennych w kodzie Java lub Kotlin. Gdy wyświetlona jest karta Zmienne i wybrany jest element, wykonaj te czynności:

  1. Aby wyświetlić listę, kliknij prawym przyciskiem myszy dowolne miejsce na liście Zmienne w miejscu, w którym znajduje się linia zasobu.
  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świetla definicję obiektu (wystąpienia klasy).
    • tablica: wyświetlanie w formacie tablicowym.
    • Znaczniki czasu: wyświetlanie daty i godziny w formacie rrrr-mm-dd gg:mm:ss.
    • Automatycznie: Android Studio wybiera najlepszy format na podstawie typu danych.
    • Binarne: wyświetlanie wartości binarnej za pomocą zer i jedynek.
    • MeasureSpec: wartość przekazywana z elementu nadrzędnego do wybranego elementu podrzędnego. Zobacz MeasureSpec.
    • Hex: wyświetlanie jako wartości szesnastkowej.
    • 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 Wyświetlacze typu danych Java. Postępuj zgodnie z instrukcjami podanymi w artykule Wyświetlacze typów danych Java.