Podczas uruchamiania, debugowania lub testowania kodu Android Studio używa konfiguracji uruchamiania/debugowania, aby określić sposób wykonania operacji. Zwykle początkowo utworzona konfiguracja wystarcza do uruchomienia lub debugowania aplikacji. Możesz jednak modyfikować i tworzyć nowe konfiguracje oraz modyfikować szablony konfiguracji, aby dostosować je do procesu tworzenia aplikacji, zgodnie z opisem na tej stronie.
Więcej informacji znajdziesz w dokumentacji IntelliJ:
Informacje o konfiguracjach uruchamiania i debugowania
Konfiguracje uruchamiania i debugowania określają szczegóły, takie jak instalacja aplikacji, uruchamianie i opcje testowania. Możesz zdefiniować konfigurację do jednorazowego użycia lub zapisać ją na przyszłość. Po zapisaniu możesz wybrać konfigurację z listy Wybierz konfigurację uruchamiania/debugowania na pasku narzędzi. Android Studio zapisuje konfiguracje w ramach projektu.
Początkowo utworzona konfiguracja uruchamiania i debugowania
Gdy po raz pierwszy utworzysz projekt, Android Studio utworzy konfigurację uruchamiania/debugowania głównej aktywności na podstawie szablonu aplikacji na Androida. Aby uruchomić lub debugować projekt, musisz zawsze mieć zdefiniowaną co najmniej 1 konfigurację uruchamiania/debugowania. Z tego powodu nie zalecamy usuwania początkowo utworzonej konfiguracji.
Zakres projektu i kontrola wersji
Konfiguracje uruchamiania/debugowania i zmiany szablonów dotyczą tylko bieżącego projektu. Konfigurację uruchamiania/debugowania (ale nie szablon) możesz udostępnić za pomocą systemu kontroli wersji. Więcej informacji o udostępnianiu konfiguracji znajdziesz w sekcji Name and Share Configuration Options (Nazwij i udostępnij opcje konfiguracji).
Otwieranie okna konfiguracji uruchamiania i debugowania
Aby otworzyć okno Run/Debug Configurations (Konfiguracje uruchamiania/debugowania), wybierz Run (Uruchom) > Edit Configurations (Edytuj konfiguracje). Pojawi się okno Run/Debug Configurations (Konfiguracje uruchamiania/debugowania), jak pokazano na rysunku 1.
Rysunek 1. Okno Run/Debug Configurations (Konfiguracje uruchamiania i debugowania)
W panelu po lewej stronie okna zdefiniowane konfiguracje są pogrupowane według typu szablonu. U dołu możesz edytować szablony konfiguracji. Wybraną konfigurację możesz edytować w panelu po prawej stronie. Zmień rozmiar okna, aby zobaczyć ukryte elementy.
W tym oknie możesz:
- Tworzenie nowych konfiguracji uruchamiania i debugowania.
- Edytowanie konfiguracji uruchamiania i debugowania
- Edytowanie szablonów konfiguracji
- Sortuj i grupuj konfiguracje.
Tworzenie nowej konfiguracji uruchamiania i debugowania
Nowe konfiguracje uruchamiania i debugowania możesz zdefiniować w oknie Uruchamianie/debugowanie – konfiguracje, w oknie Projekt lub w edytorze kodu. Nowa konfiguracja musi być oparta na szablonie konfiguracji.
W oknie Run/Debug Configurations (Konfiguracje uruchamiania i debugowania) wyświetlają się konfiguracje uruchamiania i debugowania oraz dostępne szablony konfiguracji. Nową konfigurację możesz rozpocząć bezpośrednio od szablonu lub od kopii innej konfiguracji. W razie potrzeby możesz zmienić wartości pól.
Możesz też kliknąć prawym przyciskiem myszy element w oknie Project (Projekt), aby automatycznie utworzyć konfigurację specyficzną dla tego elementu. Jeśli na przykład chcesz uruchomić konkretne działanie, możesz kliknąć prawym przyciskiem myszy plik Java działania i wybrać Uruchom. W zależności od elementu Android Studio używa szablonu konfiguracji Android App (Aplikacja na Androida), Android Instrumented Tests (Testy instrumentowane na Androidzie) lub JUnit do utworzenia konfiguracji.
W Edytorze kodu możesz łatwo utworzyć konfigurację testu i uruchamiania/debugowania dla klasy lub metody, a następnie ją wykonać.
Jeśli utworzysz konfigurację poza oknem Uruchom/Debuguj konfiguracje, będzie ona tymczasowa, chyba że ją zapiszesz. Domyślnie w projekcie możesz mieć maksymalnie 5 konfiguracji tymczasowych, zanim Android Studio zacznie je usuwać. Aby zmienić to ustawienie domyślne, otwórz ustawienia Android Studio i zmień Ustawienia zaawansowane > Uruchom/Debuguj > Limit konfiguracji tymczasowych. Więcej informacji o konfiguracjach tymczasowych znajdziesz w artykule Tworzenie i zapisywanie tymczasowych konfiguracji uruchamiania/debugowania.
Rozpoczynanie konfiguracji na podstawie szablonu
Aby zdefiniować konfigurację uruchamiania/debugowania na podstawie szablonu, wykonaj te czynności:
- Otwórz okno dialogowe Uruchom/Debuguj konfiguracje.
- Kliknij Dodaj nową konfigurację
.
- Wybierz szablon konfiguracji.
- Wpisz nazwę w polu Nazwa.
- W razie potrzeby zmodyfikuj konfigurację.
- Kliknij Zastosuj lub OK.
Popraw wszystkie błędy wyświetlane u dołu okna.
Rozpoczynanie konfiguracji od kopii
Aby zdefiniować konfigurację uruchamiania/debugowania na podstawie kopii innej konfiguracji, wykonaj te czynności:
- Otwórz okno dialogowe Uruchom/Debuguj konfiguracje.
- W panelu po lewej stronie wybierz istniejącą konfigurację uruchamiania lub debugowania.
- Kliknij Kopiuj konfigurację
.
- Wpisz nazwę w polu Nazwa.
- W razie potrzeby zmodyfikuj konfigurację.
- Kliknij Zastosuj lub OK.
Popraw wszystkie błędy wyświetlane u dołu okna.
Określanie konfiguracji elementu w projekcie
Android Studio może utworzyć konfigurację uruchamiania/debugowania dla niektórych elementów wyświetlanych w oknie Projekt. Konfiguracja jest oparta na szablonie konfiguracji w ten sposób:
- Plik Java aktywności: szablon aplikacji na Androida.
- Pakiet: szablon Android Instrumented Tests lub Android JUnit w zależności od zestawu źródeł. Jeśli wybierzesz test z instrumentacją, zostanie użyty szablon testów z instrumentacją na Androidzie. Jeśli wybierzesz lokalny test jednostkowy, zostanie użyty szablon Androida JUnit. W przypadku lokalnego testu jednostkowego możesz opcjonalnie uruchomić test z pokryciem kodu. Więcej informacji znajdziesz w sekcji Pokrycie kodu.
Aby utworzyć konfigurację uruchamiania/debugowania elementu w projekcie:
- Otwórz projekt w widoku Androida lub projektu.
- W oknie Projekt kliknij prawym przyciskiem myszy element, który można przetestować, i wybierz Uruchomfilename lub Debugujfilename. Android Studio tworzy tymczasową konfigurację uruchamiania/debugowania i uruchamia aplikację.
- Otwórz menu Select Run/Debug Configuration (Wybierz konfigurację uruchamiania/debugowania) na pasku narzędzi.
- Wybierz Save Configuration (Zapisz konfigurację) z opcji obok konfiguracji, którą chcesz zapisać.
Rysunek 2. Zapisanie konfiguracji
Uwaga: jeśli klikniesz prawym przyciskiem myszy i uruchomisz lub debugujesz ten sam element (ale nie aktywność), Android Studio utworzy nową konfigurację.
Definiowanie konfiguracji testu dla klasy lub metody
Android Studio umożliwia zdefiniowanie konfiguracji uruchomienia testu dla klasy lub metody, a następnie jej wykonanie. Jeśli na przykład utworzysz nowe zajęcia, możesz utworzyć i przeprowadzić test. Jeśli test się powiedzie, możesz uruchomić testy dla pozostałej części projektu, aby upewnić się, że nowy kod nie powoduje problemów w innych miejscach.
Android Studio używa szablonu Android Instrumented Tests (Testy z instrumentacją na Androidzie) lub Android JUnit w zależności od zestawu źródeł. W przypadku lokalnego testu jednostkowego możesz opcjonalnie uruchomić sprawdzanie pokrycia kodu.
Aby utworzyć konfigurację uruchamiania lub debugowania klasy lub metody w kodzie Java:
- Otwórz projekt w widoku Androida lub projektu.
- Otwórz plik Java w edytorze kodu.
- Wybierz klasę lub metodę w kodzie, a następnie naciśnij Control+Shift+T (Command+Shift+T).
- W menu, które się pojawi, wybierz Utwórz nowy test.
- W oknie Utwórz test możesz zmienić lub ustawić wartości, a następnie kliknąć OK.
- W oknie Wybierz katalog docelowy wybierz miejsce w projekcie, w którym Android Studio ma umieścić test. Lokalizację możesz określić za pomocą struktury katalogów lub wybierając sąsiednią klasę.
- Kliknij OK.
Nowy test pojawi się w oknie Projekt w odpowiednim zestawie źródeł testowych.
- Aby przeprowadzić test, wykonaj jedną z tych czynności:
- W oknie Project (Projekt) kliknij prawym przyciskiem myszy test i wybierz Run (Uruchom) lub Debug (Debuguj).
- W edytorze kodu kliknij prawym przyciskiem myszy definicję klasy lub nazwę metody w pliku testowym i wybierz Uruchom lub Debuguj, aby przetestować wszystkie metody w klasie.
- Otwórz menu Select Run/Debug Configuration (Wybierz konfigurację uruchamiania/debugowania) na pasku narzędzi.
- Wybierz Save Configuration (Zapisz konfigurację) z opcji obok konfiguracji, którą chcesz zapisać.
Rysunek 3. Zapisanie konfiguracji
Uruchamianie aplikacji i jej debugowanie za pomocą zapisanej konfiguracji
Jeśli masz zapisaną konfigurację uruchamiania lub debugowania, możesz ją wybrać przed uruchomieniem lub debugowaniem aplikacji.
Aby użyć zapisanej konfiguracji uruchamiania lub debugowania, wykonaj te czynności:
- Wybierz konfigurację uruchamiania/debugowania z listy Wybierz konfigurację uruchamiania/debugowania na pasku narzędzi.
- Kliknij Uruchom > Uruchom lub Uruchom > Debuguj.
Lista jest po lewej stronie przycisków Uruchom
i Debuguj
, np. 
.
Możesz też kliknąć Uruchom lub Debuguj
.
Edytowanie konfiguracji uruchamiania i debugowania
Aby edytować konfigurację uruchamiania/debugowania, wykonaj te czynności:
- Otwórz okno dialogowe Uruchom/Debuguj konfiguracje.
- Wybierz konfigurację w panelu po lewej stronie.
- W razie potrzeby zmodyfikuj konfigurację.
- Kliknij Zastosuj lub OK.
Popraw wszystkie błędy wyświetlane u dołu okna.
Edytowanie szablonu konfiguracji uruchamiania i debugowania
Możesz edytować szablony konfiguracji udostępnione przez Androida Studio, aby dostosować je do procesu tworzenia aplikacji. Edytowanie szablonu nie ma wpływu na dotychczasowe konfiguracje, które go używają. Jeśli na przykład musisz utworzyć kilka konfiguracji określonego typu, możesz edytować szablon, a potem przywrócić go do poprzedniego stanu.
Nie możesz tworzyć nowych szablonów, ale możesz tworzyć konfiguracje, które działają podobnie do szablonów. Możesz skopiować konfigurację i edytować kopię, aby utworzyć nowe konfiguracje.
Aby edytować szablon:
- Otwórz okno dialogowe Uruchom/Debuguj konfiguracje.
- Kliknij Edytuj szablony konfiguracji....
- Wybierz szablon konfiguracji.
- W razie potrzeby zmodyfikuj konfigurację.
- Kliknij Zastosuj lub OK.
Popraw wszystkie błędy wyświetlane u dołu okna.
Sortowanie i grupowanie konfiguracji
W oknie Run/Debug Configurations (Konfiguracje uruchamiania/debugowania) możesz uporządkować konfiguracje, aby szybko je znajdować. Możesz sortować elementy w folderze alfabetycznie i tworzyć nowe foldery, aby grupować konfiguracje.
Aby posortować konfiguracje alfabetycznie, wykonaj te czynności:
- Otwórz okno dialogowe Uruchom/Debuguj konfiguracje.
- Wybierz folder zawierający konfiguracje.
- Kliknij Sort Configurations (Sortuj konfiguracje).
- Aby zamknąć okno, kliknij OK.
Aby pogrupować konfiguracje w folderach:
- Otwórz okno dialogowe Uruchom/Debuguj konfiguracje.
- Wybierz folder zawierający konfiguracje.
- Kliknij Utwórz nowy folder.
- Wpisz nazwę w polu Nazwa folderu.
- Aby zapisać nazwę, kliknij Zastosuj.
Określanie działań przed opublikowaniem
Możesz określić zadania do wykonania przed zastosowaniem konfiguracji uruchamiania/debugowania. Zadania są wykonywane w kolejności, w jakiej pojawiają się na liście.
Uwaga: definiowanie zadań przed opublikowaniem to funkcja zaawansowana. Zamiast korzystać z tej funkcji, zalecamy umieszczenie logiki przygotowania w postaci zadań w pliku build.gradle, aby były one wykonywane podczas kompilowania z wiersza poleceń.
Aby utworzyć listę zadań, wykonaj te czynności:
- U dołu okna Run/Debug Configurations (Konfiguracje uruchamiania/debugowania) w sekcji Before launch (Przed uruchomieniem) (może być konieczne przewinięcie w dół) kliknij Add i wybierz typ zadania. Jeśli otworzy się okno, wypełnij pola i kliknij OK.
- W razie potrzeby dodaj więcej zadań.
- Aby uporządkować zadania, przeciągnij je lub wybierz zadanie i kliknij W górę
i W dół
, aby przenieść je w górę lub w dół na liście. - Jeśli chcesz wyświetlić ustawienia konfiguracji uruchamiania/debugowania przed ich zastosowaniem, kliknij Show this page (Pokaż tę stronę).
Ta opcja jest domyślnie odznaczona.
- Wybierz Active tool window (Aktywne okno narzędzi), jeśli chcesz, aby okno narzędzi Uruchom lub Debuguj było aktywowane podczas uruchamiania lub debugowania aplikacji.
Ta opcja jest domyślnie wybrana.
Aby usunąć zadanie z listy, wykonaj te czynności:
- Wybierz zadanie.
- Kliknij Usuń
.
Aby edytować zadanie, wykonaj te czynności:
- Wybierz zadanie.
- Kliknij Edytuj
.
- W wyświetlonym oknie dialogowym zmień ustawienia zadania, a następnie kliknij OK.
W tabeli poniżej znajdziesz listę dostępnych zadań, które możesz dodać.
| Zadanie | Opis |
|---|---|
| Uruchom narzędzie zewnętrzne | Uruchom aplikację zewnętrzną w stosunku do Androida Studio. W oknie Narzędzia zewnętrzne wybierz co najmniej jedną aplikację, którą chcesz uruchomić, a następnie kliknij OK. Jeśli aplikacja nie jest jeszcze zdefiniowana w Android Studio, dodaj jej definicję w oknie Utwórz narzędzia. Więcej informacji znajdziesz w artykułach Konfigurowanie narzędzi innych firm i Narzędzia zewnętrzne. |
| Uruchamianie innej konfiguracji | Wykonaj jedną z istniejących konfiguracji uruchamiania i debugowania. W oknie dialogowym Choose Configuration to Execute (Wybierz konfigurację do wykonania) wybierz konfigurację do wykonania, a następnie kliknij OK. |
| Zrób | Skompiluj projekt lub moduł. Android Studio wykonuje polecenie Make Module, jeśli konfiguracja uruchamiania/debugowania określa konkretny moduł, lub polecenie Make Project, jeśli nie określono żadnych modułów. |
| Utwórz projekt | Skompiluj projekt. Android Studio wykonuje polecenie Make Project (Utwórz projekt). |
| Utwórz, bez sprawdzania błędów | Ta opcja działa tak samo jak Make, z tym że Android Studio wykonuje konfigurację uruchamiania/debugowania niezależnie od wyniku kompilacji. |
| Artefakty kompilacji | Nieobsługiwane w Android Studio. |
| Uruchamianie zadania Gradle | Uruchom zadanie Gradle. W wyświetlonym oknie podaj szczegóły, a potem kliknij OK. Więcej informacji znajdziesz w sekcji Gradle. |
| Make obsługujący Gradle | Skompiluj projekt i uruchom Gradle. |
| Kompilator Gradle App Engine | Zadanie narzędzia do kompilacji Gradle w App Engine synchronizuje projekt, a następnie kompiluje moduł. |
Szablony konfiguracji
Android Studio udostępnia szablony konfiguracji, które pomogą Ci szybko rozpocząć pracę. W sekcjach poniżej opisujemy szablony, które mają zastosowanie do tworzenia aplikacji na Androida w Android Studio:
- Aplikacja na Androida
- Testy na Androida
- App Engine DevAppServer
- Widżet, kafelek i tarcza zegarka Wear OS
Uwaga: w Androidzie Studio w wersji 2.1.x i starszych był dostępny szablon aplikacji natywnej, którego nie ma w nowszych wersjach. Jeśli w projekcie masz szablon aplikacji natywnej, Android Studio przekonwertuje go na aplikację na Androida po wczytaniu projektu. Okno Convert Project (Konwertuj projekt) przeprowadzi Cię przez ten proces.
Nieobsługiwane szablony
Poniższe nieobsługiwane szablony pochodzą z IntelliJ IDEA i nie są przeznaczone do programowania na Androida w Android Studio. Informacje o korzystaniu z tych szablonów znajdziesz w dokumentacji IntelliJ IDEA.
- Aplikacja
- Złożony
- Gradle
- Groovy
- JAR Application
- Java Scratch
- JUnit
- Kotlin
- Kotlin Script
- Zdalne debugowanie
- Shell Script
- TestNG
Typowe opcje konfiguracji
Opcje Nazwa, Zezwalaj na równoległe uruchamianie i Zapisz jako plik projektu są wspólne dla wielu szablonów konfiguracji. Więcej informacji znajdziesz w artykule Typowe ustawienia.
Android Studio przechowuje udostępnioną konfigurację uruchamiania/debugowania w osobnych plikach XML w folderze project_directory/.idea/runConfigurations/.
Więcej informacji znajdziesz w artykule Format oparty na katalogach w dokumentacji projektów IntelliJ.
Aplikacja na Androida
Możesz uruchamiać i debugować aplikacje oraz aktywności na Androida na urządzeniach wirtualnych lub sprzętowych, korzystając z konfiguracji opartych na tym szablonie.
Karta Ogólne
Na karcie Ogólne możesz określić opcje instalacji, uruchamiania i wdrażania. Karta Różne zawiera też opcje instalacji.
| Pole | Opis |
|---|---|
| Moduł | Wybierz moduł, do którego chcesz zastosować tę konfigurację. |
| Opcje instalacji: wdrażanie | Wybierz opcję:
|
| Opcje instalacji: wdróż jako aplikację błyskawiczną | Jeśli Twoja aplikacja obsługuje funkcje błyskawiczne, tzn. dodasz obsługę aplikacji błyskawicznych podczas tworzenia nowego projektu lub utworzysz 1 lub więcej modułów funkcji obsługujących funkcje błyskawiczne, możesz wdrożyć te moduły, zaznaczając pole obok opcji Wdróż jako aplikację błyskawiczną. |
| Opcje instalacji: funkcje do wdrożenia |
Jeśli Twoja aplikacja zawiera moduły funkcji, zaznacz pole obok każdej funkcji, którą chcesz uwzględnić podczas wdrażania aplikacji. Ta opcja jest widoczna tylko wtedy, gdy aplikacja zawiera moduły funkcji.
Uwaga: jeśli chcesz przetestować pobieranie i instalowanie modułów funkcji na żądanie, musisz to zrobić po opublikowaniu pakietu aplikacji, a następnie użyć wewnętrznej ścieżki testowej w Konsoli Play. Więcej informacji znajdziesz w artykule Przesyłanie pakietu aplikacji do Konsoli Play. |
| Opcje instalacji: flagi instalacji | Wpisz dowolne opcje adbpm
install, których chcesz użyć. Sformatuj opcje w taki sam sposób jak w wierszu poleceń, ale bez ścieżki. Oto przykłady:
i
Domyślnie: brak opcji. |
| Opcje uruchamiania: Uruchom | Wybierz opcję:
|
| Opcje uruchamiania: flagi uruchamiania | Wpisz dowolne opcje adbam
start, których chcesz użyć. Sformatuj opcje w taki sam sposób jak w wierszu poleceń, ale bez intencji. Na przykład:
Ta opcja nie jest widoczna, jeśli w przypadku opcji Uruchom wybrano wartość Nic. Domyślnie: brak opcji. |
| Opcje celu wdrożenia: cel | Wybierz opcję:
|
Opcje miejsca docelowego wdrożenia: użyj tego samego urządzenia do przyszłych wdrożeń |
Domyślnie ta opcja jest odznaczona, więc za każdym razem, gdy uruchamiasz aplikację, pojawia się okno Wybierz wdrożenie, w którym możesz wybrać urządzenie. Gdy wybierzesz tę opcję, a następnie uruchomisz aplikację, pojawi się okno Wybierz wdrożenie, w którym możesz wybrać urządzenie. Następnie za każdym razem, gdy uruchomisz aplikację, będzie ona włączać się na wybranym urządzeniu bez wyświetlania okna Wybierz wdrożenie. Aby uruchomić aplikację na innym urządzeniu, odznacz opcję Używaj tego samego urządzenia do przyszłych uruchomień lub zatrzymaj aplikację, wybierając Uruchom > Zatrzymaj app lub Zatrzymaj  , a następnie uruchom ją ponownie. Wyświetli się okno Wybierz wdrożenie, w którym możesz wybrać urządzenie.
|
| Przed uruchomieniem | Zobacz sekcję Określanie operacji przed uruchomieniem. |
Karta Różne
Na karcie Różne możesz określić opcje logcat, instalacji, uruchamiania i wdrażania. Na karcie Ogólne znajdują się też opcje instalacji.
| Pole | Opis |
|---|---|
| Logcat: automatyczne wyświetlanie dziennika | Gdy ta opcja jest zaznaczona, okno Logcat otwiera się za każdym razem, gdy uda Ci się wdrożyć i uruchomić aplikację przy użyciu tej konfiguracji. Domyślnie: zaznaczone. |
| Logcat: wyczyść dziennik przed uruchomieniem | Wybierz tę opcję, jeśli chcesz, aby Android Studio usuwał z pliku dziennika dane z poprzednich sesji przed uruchomieniem aplikacji. Domyślnie: odznaczona. |
| Opcje instalacji: pomiń instalację, jeśli pakiet APK nie uległ zmianie. | Jeśli ta opcja jest włączona, Android Studio nie wdraża ponownie pliku APK, jeśli wykryje, że nie został on zmieniony. Jeśli chcesz, aby Android Studio wymuszało instalację pliku APK, nawet jeśli nie uległ on zmianie, odznacz tę opcję. Domyślnie: zaznaczone |
| Opcje instalacji: wymuś zatrzymanie uruchomionej aplikacji przed uruchomieniem aktywności | Jeśli ta opcja jest włączona, gdy Android Studio wykryje, że nie musi ponownie instalować pliku APK, ponieważ nie został on zmieniony, wymusi zatrzymanie aplikacji, aby uruchomić ją z domyślnej aktywności programu uruchamiającego. Jeśli ta opcja nie jest zaznaczona, Android Studio nie wymusza zatrzymania aplikacji. Ta opcja działa z poprzednią opcją, która określa, czy pakiet APK ma być zainstalowany. W przypadku obu pól Opcje instalacji pozostaw domyślne ustawienia, chyba że chcesz wymusić instalację za każdym razem. W niektórych przypadkach możesz odznaczyć tę opcję. Jeśli na przykład piszesz silnik metody wprowadzania (IME), wymuszenie zatrzymania aplikacji spowoduje odznaczenie jej jako bieżącej klawiatury, co może być niepożądane. Domyślnie: zaznaczone |
| Przed uruchomieniem | Zobacz sekcję Określanie działań przed uruchomieniem. |
Karta Debuger
Określ opcje debugowania na karcie Debuger.
W przypadku kodu w językach C i C++ Android Studio używa debugera LLDB. Oprócz standardowego interfejsu Android Studio okno debugera ma kartę LLDB, która umożliwia wpisywanie poleceń LLDB podczas debugowania. Możesz wpisywać te same polecenia, których Android Studio używa do wyświetlania informacji w interfejsie debugera, a także wykonywać dodatkowe operacje.
W przypadku projektów w językach C i C++ możesz dodać katalogi symboli, a także polecenia uruchamiania LLDB i polecenia wykonywane po dołączeniu na karcie Debuger. Służą do tego przyciski podobne do tych:
- Dodaj
– dodaj katalog lub polecenie.
- Usuń – wybierz katalog lub polecenie, a następnie kliknij ten przycisk, aby usunąć element.
- W górę
– wybierz katalog lub polecenie, a następnie kliknij ten przycisk, aby przenieść element wyżej na liście.
- W dół
– wybierz katalog lub polecenie, a następnie kliknij ten przycisk, aby przenieść element w dół listy.
Więcej informacji o debugowaniu w Android Studio znajdziesz w artykule Debugowanie aplikacji.
| Pole | Opis |
|---|---|
| Typ debugowania | Wybierz jedną z tych opcji:
Zalecamy wybranie opcji Wykryj automatycznie, ponieważ wybiera ona odpowiedni typ debugowania dla Twojego projektu. |
| Katalogi symboli | Jeśli chcesz dodać pliki symboli, aby dostarczyć debugerowi informacje w języku C lub C++ wygenerowane poza Androidem Studio, możesz dodać tutaj co najmniej 1 katalog. Android Studio preferuje pliki znajdujące się w tych katalogach od plików wygenerowanych przez wtyczkę Androida do obsługi Gradle. Debuger przeszukuje katalogi od góry do dołu, w kolejności, aż znajdzie to, czego potrzebuje. Przeszukuje rekurencyjnie pliki w katalogu. Aby zoptymalizować listę i zaoszczędzić czas, umieść najczęściej używane katalogi na początku listy. Jeśli określisz katalog znajdujący się wysoko w drzewie, przeszukanie wszystkich podkatalogów może potrwać dłużej. Jeśli dodasz bardzo konkretny katalog, wyszukiwanie zajmie mniej czasu. Musisz znaleźć odpowiednią równowagę między szybkością a znajdowaniem plików potrzebnych do debugowania. Jeśli na przykład masz katalog zawierający podkatalogi dla różnych interfejsów binarnych Androida (ABI), możesz dodać katalog dla konkretnego interfejsu ABI lub dla wszystkich interfejsów ABI. Wyszukiwanie w katalogu wyższego poziomu może trwać dłużej, ale jest też bardziej niezawodne, jeśli zdecydujesz się na debugowanie na innym urządzeniu. Pamiętaj, że nie musisz dodawać katalogów zawierających pliki symboli Gradle, ponieważ debuger używa ich automatycznie. |
| Polecenia uruchamiania LLDB | Dodaj polecenia LLDB, które chcesz wykonać, zanim debuger przyłączy się do procesu. Możesz na przykład zdefiniować ustawienia środowiska, jak pokazano w tym poleceniu:
LLDB wykonuje polecenia w kolejności od góry do dołu. |
| Polecenia LLDB po podłączeniu | Dodaj polecenia LLDB, które chcesz wykonać od razu po podłączeniu debugera do procesu. Na przykład:
LLDB wykonuje polecenia w kolejności od góry do dołu. |
| Katalog roboczy hosta | Określ katalog roboczy LLDB. |
| Logowanie: kanały docelowe | Określ opcje dziennika LLDB. Android Studio ustawia opcje domyślne na podstawie doświadczenia zespołu, dzięki czemu nie jest zbyt wolny, ale zawiera potrzebne informacje do rozwiązywania problemów. Dziennik jest często wymagany w przypadku zgłaszania błędów w Android Studio. Wartość domyślna to
Możesz zmienić ustawienie domyślne, aby uzyskać więcej informacji. Na przykład te opcje dziennika zbierają informacje o konkretnym lldb process
platform:gdb-remote packets
Pełną listę poleceń log możesz wyświetlić, wpisując polecenie
Android Studio umieszcza logi urządzenia w tej lokalizacji, gdzie
Jeśli z urządzenia korzysta wielu użytkowników, dzienniki są umieszczane w tej lokalizacji, gdzie
Informacje o używaniu LLDB do debugowania zdalnego znajdziesz w artykule Debugowanie zdalne. |
| Przed uruchomieniem | Zobacz Definiowanie operacji przed uruchomieniem. |
Karta Profilowanie
Aby włączyć niektóre funkcje profilera Androida, gdy urządzenie działa na Androidzie 7.1 lub starszym, musisz zaznaczyć opcję Włącz zaawansowane profilowanie.
Testy na Androida
Szablon testu, którego należy użyć, zależy od zbioru źródłowego. Szablon Testy z instrumentacją na Androida jest przeznaczony do testów z instrumentacją. Szablon Android JUnit służy do lokalnego testu jednostkowego.
Uwaga: jeśli do testowania na różnych urządzeniach używasz Laboratorium Firebase, możesz zdefiniować testy z instrumentacją za pomocą szablonu Android JUnit. Więcej informacji znajdziesz w artykule Przeprowadzanie testów w Laboratorium Firebase.
Opisy kart poniżej obejmują karty i pola szablonu testu z instrumentacją na Androida. Informacje o kartach i polach szablonu testu JUnit w Androidzie znajdziesz na stronie IntelliJ Run/Debug Configuration: JUnit (Konfiguracja uruchamiania/debugowania: JUnit).
Karta Ogólne
Na karcie Ogólne możesz określić lokalizację testu, narzędzie do uruchamiania testów, powłokę adb i opcje wdrażania.
| Pole | Opis |
|---|---|
| Moduł | Wybierz moduł, do którego chcesz zastosować tę konfigurację. |
| Test | W tym obszarze określ lokalizację testów, które chcesz przeprowadzić:
|
| Określony program do uruchamiania testów (opcjonalnie) | Wpisz lokalizację instrumentation
runner. Aby użyć okna, kliknij Więcej. Plik
build.gradle określa lokalizację narzędzia do instrumentacji. Ta wartość ją zastępuje. Domyślnie jest to zwykle klasa AndroidJUnitRunner z biblioteki AndroidX Test.
|
| Dodatkowe opcje | Wpisz dowolne opcje adb Wartość domyślna: brak opcji |
| Opcje celu wdrożenia: cel | Wybierz opcję:
|
| Opcje miejsca docelowego wdrożenia: użyj tego samego urządzenia do przyszłych wdrożeń | Jeśli w przyszłości chcesz automatycznie używać urządzenia wybranego w oknie Wybierz miejsce wdrożenia, wybierz tę opcję. Jeśli urządzenie jest niedostępne, pojawi się okno dialogowe. Domyślnie: niezaznaczone |
| Przed uruchomieniem | Zobacz sekcję Określanie operacji przed uruchomieniem. |
Karta Różne
Karta Różne zawiera opcje logcat i instalacji.
| Pole | Opis |
|---|---|
| Logcat: wyczyść dziennik przed uruchomieniem | Wybierz tę opcję, jeśli chcesz, aby Android Studio usuwał z pliku dziennika dane z poprzednich sesji przed uruchomieniem aplikacji. Domyślnie: odznaczona. |
| Opcje instalacji: pomiń instalację, jeśli plik APK nie uległ zmianie | Gdy ta opcja jest włączona, Android Studio nie wdraża ponownie pliku APK, jeśli wykryje, że nie uległ on zmianie. Jeśli chcesz, aby Android Studio wymuszało instalację pliku APK, nawet jeśli nie uległ on zmianie, odznacz tę opcję. Domyślnie: zaznaczone |
| Opcje instalacji: wymuś zatrzymanie uruchomionej aplikacji przed uruchomieniem aktywności | Jeśli ta opcja jest włączona, gdy Android Studio wykryje, że nie musi ponownie instalować pliku APK, ponieważ nie uległ on zmianie, wymusi zatrzymanie aplikacji, aby uruchomić ją z domyślnej aktywności programu uruchamiającego. Jeśli ta opcja nie jest zaznaczona, Android Studio nie wymusza zatrzymania aplikacji. Ta opcja działa w połączeniu z poprzednią opcją, która określa, czy plik APK jest instalowany. W przypadku obu pól Opcje instalacji pozostaw domyślne ustawienia, chyba że chcesz wymusić instalację za każdym razem. W niektórych przypadkach możesz odznaczyć tę opcję. Jeśli na przykład piszesz silnik metody wprowadzania (IME), wymuszenie zatrzymania aplikacji spowoduje odznaczenie jej jako bieżącej klawiatury, co może być niepożądane. Domyślnie: zaznaczone |
| Przed uruchomieniem | Zobacz Definiowanie operacji przed uruchomieniem. |
Karta Debuger
Określ opcje debugowania na karcie Debuger.
W przypadku kodu w językach C i C++ Android Studio używa debugera LLDB. Oprócz standardowego interfejsu Android Studio okno debugera ma kartę LLDB, która umożliwia wpisywanie poleceń LLDB podczas debugowania. Możesz wpisywać te same polecenia, których Android Studio używa do wyświetlania informacji w interfejsie debugera, a także wykonywać dodatkowe operacje.
W przypadku projektów w językach C i C++ możesz dodać katalogi symboli, a także polecenia uruchamiania LLDB i polecenia wykonywane po dołączeniu na karcie Debuger. Służą do tego przyciski podobne do tych:
- Dodaj
– dodaj katalog lub polecenie.
- Usuń – wybierz katalog lub polecenie, a następnie kliknij ten przycisk, aby usunąć element.
- W górę
– wybierz katalog lub polecenie, a następnie kliknij ten przycisk, aby przenieść element wyżej na liście.
- W dół
– wybierz katalog lub polecenie, a następnie kliknij ten przycisk, aby przenieść element w dół listy.
Więcej informacji o debugowaniu w Android Studio znajdziesz w artykule Debugowanie aplikacji.
| Pole | Opis |
|---|---|
| Typ debugowania | Wybierz jedną z tych opcji:
Zalecamy wybranie opcji Wykryj automatycznie, ponieważ wybiera ona odpowiedni typ debugowania dla Twojego projektu. |
| Katalogi symboli | Jeśli chcesz dodać pliki symboli, aby dostarczyć debugerowi informacje w języku C lub C++ wygenerowane poza Androidem Studio, możesz dodać tutaj co najmniej 1 katalog. Android Studio preferuje pliki znajdujące się w tych katalogach od plików wygenerowanych przez wtyczkę Androida do obsługi Gradle. Debuger przeszukuje katalogi od góry do dołu, w kolejności, aż znajdzie to, czego potrzebuje. Przeszukuje rekurencyjnie pliki w katalogu. Aby zoptymalizować listę i zaoszczędzić czas, umieść najczęściej używane katalogi na początku listy. Jeśli określisz katalog znajdujący się wysoko w drzewie, przeszukanie wszystkich podkatalogów może potrwać dłużej. Jeśli dodasz bardzo konkretny katalog, wyszukiwanie zajmie mniej czasu. Musisz znaleźć odpowiednią równowagę między szybkością a znajdowaniem plików potrzebnych do debugowania. Jeśli na przykład masz katalog zawierający podkatalogi dla różnych interfejsów binarnych Androida (ABI), możesz dodać katalog dla konkretnego interfejsu ABI lub dla wszystkich interfejsów ABI. Wyszukiwanie w katalogu wyższego poziomu może trwać dłużej, ale jest też bardziej niezawodne, jeśli zdecydujesz się na debugowanie na innym urządzeniu. Pamiętaj, że nie musisz dodawać katalogów zawierających pliki symboli Gradle, ponieważ debuger używa ich automatycznie. |
| Polecenia uruchamiania LLDB | Dodaj polecenia LLDB, które chcesz wykonać, zanim debuger przyłączy się do procesu. Możesz na przykład zdefiniować ustawienia środowiska, jak pokazano w tym poleceniu:
LLDB wykonuje polecenia w kolejności od góry do dołu. |
| Polecenia LLDB po podłączeniu | Dodaj polecenia LLDB, które chcesz wykonać od razu po podłączeniu debugera do procesu. Na przykład:
LLDB wykonuje polecenia w kolejności od góry do dołu. |
| Katalog roboczy hosta | Określ katalog roboczy LLDB. |
| Logowanie: kanały docelowe | Określ opcje dziennika LLDB. Android Studio ustawia opcje domyślne na podstawie doświadczenia zespołu, dzięki czemu nie jest zbyt wolny, ale zawiera potrzebne informacje do rozwiązywania problemów. Dziennik jest często wymagany w przypadku zgłaszania błędów w Android Studio. Wartość domyślna to
Możesz zmienić ustawienie domyślne, aby uzyskać więcej informacji. Na przykład te opcje dziennika zbierają informacje o konkretnym lldb process
platform:gdb-remote packets
Pełną listę poleceń log możesz wyświetlić, wpisując polecenie
Android Studio umieszcza logi urządzenia w tej lokalizacji, gdzie
Jeśli z urządzenia korzysta wielu użytkowników, dzienniki są umieszczane w tej lokalizacji, gdzie
Informacje o używaniu LLDB do debugowania zdalnego znajdziesz w artykule Debugowanie zdalne. |
| Przed uruchomieniem | Zobacz sekcję Określanie operacji przed uruchomieniem. |
App Engine DevAppServer
Ta konfiguracja uruchamiania/debugowania dotyczy Google Cloud Platform. Gdy wykonasz te czynności i zsynchronizujesz projekt z plikiem build.gradle, Android Studio utworzy konfigurację serwera DevAppServer App Engine.
Pamiętaj, że szablon IntelliJ IDEA App Engine Server to inny szablon, który nie jest dostępny w Android Studio.
| Pole | Opis |
|---|---|
| Tylko jedna instancja | Jeśli chcesz mieć pewność, że w danym momencie jest wykonywana tylko jedna instancja konfiguracji uruchamiania/debugowania, wybierz tę opcję. Nie umożliwia jednoczesnego uruchamiania tej samej konfiguracji wiele razy. Domyślnie: zaznaczone |
| Moduł | Wybierz moduł, do którego chcesz zastosować tę konfigurację. |
| Synchronizacja z konfiguracją pliku build.gradle | Jeśli dodasz moduł App Engine i zsynchronizujesz go z build.gradle
plikiem, pola konfiguracji App Engine DevAppServer zostaną wypełnione automatycznie (zalecane).
Wybranie Plik > Synchronizuj projekt z plikami Gradle również synchronizuje projekt. Domyślnie: zaznaczone
|
| Pakiet SDK App Engine | Wpisz ścieżkę do pakietu Google App Engine SDK dla Javy na komputerze lokalnym. Kliknij …, aby wybrać go w oknie. |
| War Path | Wpisz ścieżkę do katalogu archiwum aplikacji internetowej (WAR) aplikacji, którą wdrażasz na lokalnym serwerze programistycznym. Kliknij …, aby wybrać go w oknie. |
| Argumenty maszyny wirtualnej | Określ opcje wiersza poleceń, które chcesz przekazać do maszyny wirtualnej w celu uruchomienia serwera DevAppServer. Podczas określania opcji:
Więcej informacji o opcjach maszyny wirtualnej znajdziesz w dokumentacji J2SE, np. Domyślnie: brak opcji |
| Adres serwera | Wpisz adres hosta, który ma być używany na serwerze. Może być konieczne podanie adresu, aby uzyskać dostęp do serwera programisty z innego komputera w sieci. Adres 0.0.0.0 umożliwia dostęp zarówno do hosta lokalnego, jak i do nazwy hosta. Domyślnie: localhost |
| Port serwera | Wpisz numer portu, którego chcesz używać na serwerze. Domyślnie: 8080 |
| Wyłącz sprawdzanie aktualizacji pakietu SDK App Engine | Jeśli zostanie podany, serwer deweloperski nie będzie kontaktować się z App Engine, aby sprawdzić dostępność nowej wersji pakietu SDK. Domyślnie serwer sprawdza, czy jest dostępna nowa wersja, i wyświetla komunikat, jeśli tak jest. |
| Przed uruchomieniem | Zobacz Definiowanie operacji przed uruchomieniem. |
Konfiguracje uruchamiania i debugowania Wear OS
Szablony widżetów, kafelków i tarcz zegarka Wear OS umożliwiają uruchamianie i debugowanie aplikacji Wear OS na urządzeniach wirtualnych lub fizycznych. Większość opcji konfiguracji szablonu jest taka sama jak opcje aplikacji na Androida. Oto opcje, które są bardziej specyficzne dla konfiguracji uruchamiania i debugowania Wear OS:
- W przypadku wszystkich konfiguracji uruchamiania/debugowania Wear musisz wybrać konkretne źródło danych komplikacji, kafelka lub tarczy zegarka (w zależności od szablonu), aby zastosować konfigurację. Zwykle każdy z tych elementów odpowiada klasie w Twoim kodzie.
- W przypadku konfiguracji uruchamiania/debugowania komplikacji Wear OS musisz wybrać miejsce, w którym chcesz umieścić dane komplikacji dostarczone przez źródło danych komplikacji. Możesz umieścić go u góry, po prawej, na dole, po lewej lub w tle tarczy zegarka.
- W przypadku konfiguracji uruchamiania/debugowania elementu Wear OS musisz też wybrać Typ danych elementu podanych przez źródło danych elementu. Typy, które możesz wybrać, są ograniczone do tych, które są udostępniane przez wybrane źródło danych widżetu i obsługiwane przez wybrane miejsce. Listę typów danych komplikacji znajdziesz w sekcji Typy i pola.
Możesz też uruchomić te interfejsy z poziomu ikony rynny, która znajduje się obok deklaracji interfejsu, jak pokazano na poniższym obrazie. Jeśli wystąpi błąd, np. „Error while setting the tile” (Błąd podczas ustawiania kafelka), sprawdź, czy powierzchnia jest prawidłowo skonfigurowana, w tym czy została zadeklarowana w pliku manifestu.
