Uruchamianie aplikacji na Androida z telefonu. Testowanie na prawdziwym urządzeniu. Uzyskiwanie źródeł z pakietu aplikacji
Wcześniej pisałem . Możesz radykalnie rozwiązać problem, nie używaj emulatora, ale od razu przetestuj urządzenie przenośne z systemem Android. Mam wspaniały HTC i skonfigurowałem go do tego. Aby więc uruchamiać aplikacje na fizycznym urządzeniu, potrzebujesz:
- Włącz debugowanie USB w telefonie. Możesz to zrobić, przechodząc do Ustawienia -> Aplikacje -> Rozwój i zaznaczając pole "Debugowanie USB"
- Poczekaj, aż sterownik się zainstaluje
- Odłącz i ponownie podłącz telefon do komputera.
Aby sprawdzić, czy telefon jest widoczny dla komputera, musisz wykonać następujące czynności:
Jeśli tak jest w Twoim przypadku, możesz użyć program specjalny: PdaNet. () Zwykle służy do korzystania z Internetu z telefonu z komputera, ale tak się składa, że zawiera ogromną liczbę sterowników do telefonów. Podczas instalacji zostałem poproszony o model urządzenia, a potem wyskoczył piękny czerwony balun z ostrzeżeniem, że sterownik nie był testowany i wszystko może się źle skończyć, ale nie - wszystko w porządku, został zainstalowany. Następnie ponownie uruchomiłem sprawdzanie (polecenie powyżej) i mój telefon pojawił się na liście urządzeń.
A jak pracować z Eclipse? Właściwie wszystko już zostało zrobione - wystarczy uruchomić projekt i otwiera się na telefonie.
Celem tego rozdziału jest napisanie minimalnej aplikacji na Androida. Ale nigdy nie dowiemy się na pewno, czy moglibyśmy napisać coś działającego bez próby uruchomienia go na prawdziwym urządzeniu. To właśnie zrobimy w tym artykule.
Możliwość testowania na smartfonie zapewnia ADB (Android Debug Bridge). W tym artykule skonfigurujemy i uruchomimy naszą aplikację na prawdziwym smartfonie.
Co to jest adb
Android Debug Bridge (ADB) to uniwersalne narzędzie wiersz poleceń ułatwiający komunikację między środowiskiem programistycznym, w naszym przypadku Android Studio, a emulatorami AVD lub fizycznymi urządzeniami z Androidem w celu umożliwienia uruchamiania i debugowania aplikacji.
ADB składa się z klienta, serwera działającego jako proces w tle na komputerze dewelopera oraz demona działającego jako proces w tle na każdym wystąpieniu emulatora lub rzeczywistego urządzenia.
Konfigurowanie urządzenia z systemem Android do pracy z ADB
Aby korzystać z ADB z urządzeniem podłączonym przez USB, musisz włączyć debugowanie USB w Ustawienia systemowe telefon lub tablet w Opcjach programisty (nazwa może się różnić). Na niektórych urządzeniach ta sekcja jest domyślnie ukryta. Rozważ kroki w przypadku, gdy nie ma pożądana sekcja ustawienia.
- Przejdź do ustawień, sekcja „O urządzeniu”
- Znajdź element „Numer kompilacji” i kliknij go 7 razy. Powinno pojawić się okno informujące o aktywowaniu trybu programisty. Sekcja opcji programisty powinna teraz pojawić się w ustawieniach.
- Włącz w nim opcję „Debugowanie USB”.
Teraz po podłączeniu urządzenia do komputera, w zależności od modelu, możesz mieć nową opcję połączenia.
Konfigurowanie ADB w systemie Windows
Na Konfiguracja systemu Windows Najpierw upewnij się, że masz zainstalowany sterownik Google USB. Przejdź do Menedżera SDK w sekcji Dodatki i znajdź sterownik Google USB, w razie potrzeby zainstaluj go.
Teraz powinieneś zaktualizować sterownik. Podłącz urządzenie do komputera, przejdź do Panel sterowania -> Sprzęt i dźwięk -> Menedżer urządzeń, znajdź swoje urządzenie. Kliknij prawy klawisz na urządzeniu, aby otworzyć menu kontekstowe i wybierz "Aktualizuj sterowniki...". Sterownik można znaleźć w katalogu sdk pod \(katalog sdk)\extras\google\usb_driver.
Jak sprawdzić, czy ustawienia ADB są prawidłowe?
Aby sprawdzić, czy ADB działa, podłącz urządzenie do komputera, uruchom wiersz poleceń w folderze \(sdk directory)\platform-tools i wpisz w nim polecenie:
urządzenia adb
Powinna pojawić się taka lista:
Lista podłączonych urządzeń Urządzenie 5cdb2ced
Uruchamianie aplikacji na prawdziwym urządzeniu
Wszystko jest takie samo jak w przypadku uruchomienia na emulatorze. Otwórz nasz projekt w Android Studio, kliknij zielony trójkąt, ale w wyświetlonym oknie wyboru urządzenia wybierz swoje urządzenie.
Jeśli mówi, że urządzenie jest w trybie offline, podłącz ponownie USB i włącz debugowanie USB na komputerze:
Dzięki temu nasza aplikacja pojawi się na ekranie Twojego telefonu lub tabletu.
Wniosek
Na tym kończy się rozdział. Odnieśliśmy sukces: udało nam się skonfigurować nasz system do tworzenia aplikacji na Androida, a nawet uruchomić jedną z nich na prawdziwym urządzeniu.
Jeśli coś Ci się nie udaje lub jesteś zdezorientowany, wypisz się z komentarzy, a pomogę Ci rozwiązać Twój problem.
Piaskownica
bóg serwera 18 września 2011 o 15:55Przegląd narzędzi do uruchamiania i debugowania aplikacji w systemie Android
- Rupieciarnia *
Podczas tworzenia mojej pierwszej aplikacji na Androida natknąłem się na problem z uruchomieniem aplikacji do testowania i debugowania. Ten artykuł powinien pomóc początkującemu użytkownikowi wybrać narzędzie do emulacji.
Urządzenie wirtualne z Androidem (AVD)
Instalacja:Ten emulator jest wbudowany w Android SDK.
Dostosowywanie:
(na przykładzie użycia w Eclipse)
Okno > Android SDK i Menedżer AVD > Nowe
Wpisujemy nazwę urządzenia wirtualnego, platformę, wielkość karty pamięci, rodzaj wyświetlacza...
Kliknij Utwórz AVD.
Początek:
Pierwsze uruchomienie emulatora trwa bardzo długo, zwłaszcza na słabych urządzeniach. Na przykład nie mogłem się doczekać pierwszego uruchomienia na moim netbooku, a gdy uruchomiłem go po raz pierwszy na komputerze, byłem pewien, że emulator wszedł w wieczną pętlę.
Kolejne uruchomienia emulatora będą nieco szybsze.
Czas między naciśnięciem przycisku „Uruchom” a pojawieniem się głównej aktywności aplikacji testowej na emulatorze zajmuje średnio 11 sekund. Pomiary przeprowadzono na wystarczająco wydajnym komputerze.
Zalety i wady:
+ możliwość przetestowania aplikacji na różne wersje Android OS na urządzeniach z różne rodzaje wyświetlacz...
+ różne ustawienia potrzebne do testowania, np. zmiana orientacji ekranu
+ emulacja karty SD
- długi czas pomiędzy naciśnięciem przycisku „Uruchom” a uruchomieniem aplikacji na emulatorze
- emulator działa bardzo wolno np. to co telefon przetworzył w 1-2 sekundy, emulator zrobił w 8-10 sekund
VirtualBox + Android x86
Instalacja i konfiguracja:- Pobierz i zainstaluj VirtualBox.
- Pobieranie obrazu.
- „Tworzenie maszyny wirtualnej Linux 2.6/Inne Linux, 512 Mb RAM, Bridged Network, HD 2 Gb, Wyłącz integrację myszy. Podłączamy plik ISO i uruchamiamy jedną z opcji LiveCD (istnieje opcja HDPI i MDPI) ”lub postępuj zgodnie z tą instrukcją.
- Naciśnij Alt-F1, aby wyjść do konsoli i wpisz netcfg i zapamiętaj adres IP emulatora. Aby wrócić do GUI, naciśnij Alt-F7.
- połączenie adb
Początek:
Czas między naciśnięciem przycisku „Uruchom” a pojawieniem się głównej aktywności aplikacji testowej na emulatorze nie został wykryty, ale według subiektywnych odczuć dzieje się to prawie natychmiast.
Zalety i wady:
+ mały odstęp czasu pomiędzy naciśnięciem przycisku „Uruchom” a uruchomieniem aplikacji na emulatorze
+ czasem zwinna praca
- dość długa i czasami problematyczna instalacja
- emulator miejscami działa wolno, występują problemy z obrazem (szczególnie na MDPI)
- problemy z emulacją karty SD, zmianą orientacji ekranu,…
- tylko dwie (trzy) dostępne wersje systemu operacyjnego Android i tylko dwa dostępne typy wyświetlania
Telefon z Androidem podłączony przez USB
Instalacja i konfiguracja:- Włącz tryb debugowania w telefonie. (Ustawienia > Aplikacje > Programowanie > Debugowanie USB).
- Pobierz sterownik na swój telefon.
- Podłączamy telefon do komputera.
- Instalowanie sterowników. Sekcja Interfejs ADB powinna pojawić się w Menedżerze urządzeń.
- urządzenia adb. Jeśli Twój telefon nie pojawia się na liście, zainstaluj ponownie sterownik ADB.
Początek:
Pomiędzy naciśnięciem przycisku „Uruchom” a pojawieniem się na telefonie głównej aktywności aplikacji testowej mija około 5 sekund.
Zalety i wady:
+ możliwość zobaczenia aplikacji tak, jak zobaczy ją użytkownik (bardzo ważny punkt, zwłaszcza podczas tworzenia interfejsu i projektowania aplikacji)
+ multitouch (jeśli jest dostępny w telefonie)
+ zmiana orientacji ekranu, akcelerometru (jeśli jest w telefonie)
- tylko jedna wersja systemu operacyjnego i jeden typ wyświetlacza
- na fizycznym pulpicie pojawi się inny obiekt
Wnioski:
Wypróbowałem każde z tych narzędzi do emulacji i zdecydowałem się na tę opcję:1. pisanie i testowanie aplikacji za pomocą telefonu;
2. Testowanie aplikacji na wielu urządzeniach wirtualnych z systemem Android z różnymi kombinacjami wersji systemu operacyjnego i typu wyświetlacza.
Mam nadzieję, że czytelnik dokonał wyboru emulatora lub nauczył się czegoś nowego dla siebie.
Powodzenia w testach!
Dekompilacja i debugowanie aplikacji na Androida
Aleksander Antipow
W tym artykule dowiesz się, jak dołączyć debuger do aplikacji systemu Android i przejść przez metody, które są wywoływane przy użyciu informacji uzyskanych po dekompilacji aplikacji.
W tym artykule dowiesz się, jak dołączyć debuger do aplikacji systemu Android i przejść przez metody, które są wywoływane przy użyciu informacji uzyskanych po dekompilacji aplikacji. Dobrą wiadomością jest to, że debugowanie nie wymaga uprawnień superużytkownika. Opisane techniki mogą być bardzo przydatne podczas pentestów. aplikacje mobilne, ponieważ możemy „penetrować” kod podczas działania programu, pobieramy i zapisujemy informacje, do których zwykle nie mamy dostępu. Na przykład możesz przechwytywać ruch przed szyfrowaniem i uzyskiwać klucze, hasła i inne cenne informacje w locie. Artykuł przyda się pentesterom i twórcom aplikacji mobilnych, którzy chcą pogłębić wiedzę na temat możliwych ataków na platformę Android.
Wymagania dotyczące środowiska testowego:
- System operacyjny: Windows/Mac OS X/Linux
- Java (zalecana wersja 1.7)
- IDE (Eclipse, IntelliJ IDEA, Android Studio)
- Android SDK (https://developer.android.com/sdk/index.html?hl=i)
- APKTool (https://code.google.com/p/android-apktool/)/APK Studio (http://apkstudio.codeplex.com)
- Urządzenie/emulator z Androidem
W tym artykule wykorzystamy następującą konfigurację: Windows 8, Android Studio i IntelliJ IDEA. Urządzenie: Nexus 4s wersja na Androida 4.4.4. Zalecam dodanie wszystkich narzędzi do zmiennej środowiskowej PATH w celu ułatwienia i przyspieszenia dostępu do tych narzędzi.
Pakiet aplikacji na Androida (APK) użyty w tym artykule można pobrać stąd: com.netspi.egruber.test.apk .
Konfiguracja urządzenia
Poniższe instrukcje pomogą przygotować urządzenie do eksperymentów.
Aktywacja sekcji Opcje programisty
Na początek na urządzeniu z Androidem musi być włączone debugowanie przez USB (opcja debugowania USB), co pozwoli na „komunikowanie się” z urządzeniem za pomocą narzędzi z Android SDK. Jednak wcześniej musisz aktywować sekcję Opcje programisty. Na urządzeniu przejdź do sekcji Ustawienia> Informacje o telefonie i kliknij kilka razy element Numer kompilacji, po czym powinien pojawić się komunikat z informacją, że sekcja Opcje programisty jest aktywna.
Rysunek 1: Aby aktywować sekcję Opcje programisty, musisz kilka razy kliknąć Numer kompilacji
Włącz debugowanie przez USB
Aby włączyć debugowanie USB, przejdź do Ustawienia> Opcje programisty i zaznacz pole obok debugowania USB.
Rysunek 2: Włączanie opcji debugowania USB
Podłączanie urządzenia i uruchamianie ADB
Po podłączeniu urządzenia do komputera przez port USB powinien pojawić się komunikat „Debugowanie USB podłączone na urządzeniu”. Należy również sprawdzić, czy można połączyć się z urządzeniem za pomocą aplikacji Android Debug Bridge (ADB) dołączonej do pakietu Android SDK (pakiet Android SDK Platform-tools). W wierszu polecenia wprowadź następujące polecenie:
Urządzenie powinno pojawić się na liście.
Rysunek 3: Lista podłączonych urządzeń
Jeśli urządzenie nie pojawia się na liście, to najbardziej prawdopodobna przyczyna w niepoprawnie zainstalowane sterowniki(w systemie Windows). W zależności od urządzenia sterownik można znaleźć w Android SDK lub na stronie producenta.
Sprawdzanie aplikacji pod kątem debugowania
Przed debugowaniem aplikacji na Androida musisz najpierw sprawdzić, czy jest to możliwe. Weryfikację można przeprowadzić na kilka sposobów.
Pierwszym sposobem jest bieganie Monitor urządzenia z systemem Android, który jest częścią Android SDK (w folderze narzędzia). W plik windows o nazwie monitor.bat. Po otwarciu Android Device Monitor urządzenie pojawi się w sekcji Urządzenia.
Rysunek 4: Aplikacja Android Device Monitor
Jeśli jakakolwiek aplikacja na urządzeniu może być debugowana, ta aplikacja również pojawi się na liście. Utworzyłem program testowy, ale lista jest pusta, ponieważ programu nie można debugować.
Drugim sposobem przetestowania aplikacji pod kątem debugowania jest sprawdzenie pliku AndroidManifest.xml z pakietu aplikacji (APK, pakiet aplikacji Android). APK to archiwum zip zawierające wszystkie informacje potrzebne do uruchomienia aplikacji na urządzeniu z Androidem.
Za każdym razem, gdy aplikacja jest ładowana z Google Play Sklep, pakiet aplikacji jest również pobierany. Wszystkie pobrane pliki APK są zwykle przechowywane na urządzeniu w folderze /data/app. Jeśli nie masz uprawnień administratora, nie będziesz w stanie uzyskać listy plików z katalogu /data/app. Chociaż, jeśli znasz nazwę pliku APK, możesz go skopiować za pomocą narzędzia adb. Aby poznać nazwę pliku APK, wprowadź następujące polecenie:
pojawi się wiersz poleceń urządzenia. Następnie wprowadź następujące polecenie:
pm lista pakietów -f
Wyświetlona zostanie lista wszystkich pakietów na urządzeniu.
Rysunek 5: Lista pakietów na urządzeniu
Patrząc na listę, znajdujemy aplikację testową.
Rysunek 6: Pakiet utworzonej aplikacji testowej (podświetlony na biało)
Teraz musisz skopiować plik pakietu. Otwórz powłokę i wprowadź następujące polecenie:
adb pull /data/app/[plik apk]
Rysunek 7: Skopiuj plik APK z urządzenia do systemu
Teraz musimy otworzyć plik pakietu i sprawdzić zawartość AndroidManifest.xml. Niestety nie możemy po prostu rozpakować archiwum, ponieważ plik APK jest zakodowany w formacie binarnym. Do dekodowania najczęściej używanym narzędziem jest narzędzie apk chociaż używam Studio APK ponieważ ta aplikacja ma przyjazną GUI. W dalszej części artykułu omówimy APK Studio.
W APK Studio kliknij małą zieloną ikonę, nadaj projektowi nazwę i ścieżkę do Plik APK. Następnie określ ścieżkę do zapisania projektu.
Rysunek 8: Tworzenie nowego projektu w APK Studio
Po otwarciu APK wybierz plik AndroidManifest.xml i spójrz na ustawienia tagu aplikacji. Jeśli flaga android:debuggable nie jest obecna (lub jest obecna, ale ustawiona na wartość false), nie można debugować aplikacji.
Rysunek 9: Zawartość pliku AndroidManifest.xml
Modyfikowanie pliku AndroidManifest.xml
Korzystając z narzędzia apktool lub APK Studio, możemy modyfikować pliki i pakować zawartość z powrotem do pakietu. Zmodyfikujemy teraz plik AndroidManifest.xml, aby można było debugować aplikację. Dodaj wiersz android:debuggable="true" wewnątrz tagu aplikacji.
Rysunek 10: Zmiana zawartości znacznika aplikacji
Po dodaniu flagi kliknij ikonę "młotka" i ponownie złóż paczkę. Przebudowany pakiet będzie znajdować się w katalogu build/apk.
Rysunek 11: Odbudowa pakietu zakończona pomyślnie
Po przebudowaniu pakiet jest podpisany i można go ponownie zainstalować na urządzeniu (wszystkie aplikacje na Androida muszą być podpisane). Większość aplikacji nie weryfikuje certyfikatu użytego do podpisania. W przeciwnym razie musisz zmienić kod wykonujący to sprawdzenie.
Teraz musisz zainstalować przebudowany pakiet. Najpierw usuń starą aplikację za pomocą następującego polecenia:
adb pm odinstalować
Następnie zainstaluj nowy pakiet:
instalacja adb [plik .apk]
Możesz także usunąć i zainstalować pakiet jednym poleceniem:
adb zainstalować -r [plik .apk]
Rysunek 12: Instalowanie przebudowanego pakietu
Sprawdź, czy ponownie zainstalowana aplikacja działa poprawnie na urządzeniu. Jeśli wszystko działa, wróć do Android Device Monitor, gdzie powinna pojawić się testowa aplikacja.
Rysunek 13: Teraz przebudowaną aplikację można debugować
Konfigurowanie środowiska programistycznego (IDE)
Teraz możesz podłączyć debugger do przebudowanej aplikacji, ale najpierw musisz stworzyć projekt w środowisku deweloperskim (ten artykuł wykorzystuje IntelliJ IDEA). Tworzymy nowy projekt. Podaj dowolną nazwę w polu Nazwa aplikacji. W polu Nazwa pakietu określ nazwę, która dokładnie odpowiada hierarchii folderów przebudowanego pakietu.
Rysunek 14: Tworzenie nowego projektu w IntelliJ IDEA
Zwykle nazwa pliku APK odpowiada strukturze folderów, chociaż jeśli nie masz pewności, w APK Studio sprawdź hierarchię katalogów do folderu, w którym znajdują się pliki aplikacji. W moim przypadku nazwa i struktura folderów są dokładnie takie same (com.netspi.egruber.test).
Rysunek 15: Hierarchia katalogów aplikacji testowych
Odznacz „Utwórz aktywność Hello World” i zakończ tworzenie projektu (wszystkie pozostałe opcje pozostają domyślne). Nowy projekt powinien wyglądać mniej więcej tak:
Rysunek 16: Hierarchia folderów i plików nowego projektu
Po utworzeniu projektu musisz dodać źródło z pliku APK, aby debugger „znał” nazwy symboli, metod, zmiennych itp. Dobrą wiadomością jest to, że aplikacje na Androida można dekompilować prawie bez utraty jakości (kod źródłowy będzie taki sam jak oryginał). Po dekompilacji kod źródłowy jest importowany do środowiska programistycznego (IDE).
Uzyskiwanie źródeł z pakietu aplikacji
Najpierw musisz przekonwertować APK na plik jar. Następnie za pomocą dekompilatora java otrzymamy kod źródłowy aplikacji. Zrobimy konwersję do jar za pomocą narzędzia dex2jar. dex2jar ma plik d2j-dex2jar.bat używany do konwersji APK na jar. Składnia polecenia jest dość prosta:
d2j-dex2jar.bat [plik .apk]
Rysunek 17: Konwersja APK do jar
Następnie otwieramy lub przeciągamy wynikowy plik do JD-GUI (jest to dekompilator java).
Rysunek 18: Struktura pliku jar
Plik jar powinien być wyświetlany jako struktura hierarchiczna, wewnątrz której znajdują się pliki java z czytelnym kodem źródłowym. Przejdź do Plik> Zapisz wszystkie źródła, aby spakować wszystkie źródła do archiwum zip.
Rysunek 19: Zapisywanie źródeł zdekompilowanego pliku
Po zapisaniu tekstów źródłowych rozpakuj archiwum do osobnego katalogu.
Rysunek 20: Rozpakowane archiwum
Teraz musisz zaimportować oba katalogi do projektu utworzonego wcześniej w IDE. W IntelliJ przejdź do folderu src i skopiuj tam zawartość rozpakowanego archiwum (dwa katalogi).
Rysunek 21: Oba foldery skopiowane do katalogu src
Wracając do Intellij, widzimy zaktualizowany projekt.
Rysunek 22: Teksty źródłowe pojawiły się w projekcie
Jeśli klikniemy na dowolny element z listy, zobaczymy oryginalny tekst. Jak widać na poniższym zrzucie ekranu (kod źródłowy klasy LoginActivity), kod źródłowy został zaciemniony przy użyciu ProGuard.
Rysunek 23: Zaciemniony kod źródłowy dla klasy LoginActivity
Podłączanie debuggera
Teraz, gdy projekt ma kod źródłowy, możemy zacząć ustawiać punkty przerwania w metodach i zmiennych. Po osiągnięciu punktów przerwania aplikacja zostanie zatrzymana. Jako przykład ustawiłem punkt przerwania w metodzie (wprost w zaciemnionym kodzie) odpowiedzialnej za przetwarzanie informacji wprowadzonych w polu tekstowym.
Rysunek 24: Ustaw punkt przerwania w zaciemnionej metodzie
Gdy tylko pojawi się punkt przerwania, podłączamy debugger do procesu na urządzeniu, klikając ikonę z ekranem w prawym górnym rogu (ikona może się różnić w twoim IDE).
Rysunek 25: Dołączanie debugera do procesu
Rysunek 26: Lista procesów dołączania debuggera
Po wybraniu procesu debugger połączy się z urządzeniem.
Rysunek 27: Debuger podłączony do procesu uruchomionego na urządzeniu
W polu tekstowym wpiszę liczbę 42 (jeśli pamiętasz, w odpowiedniej metodzie jest punkt przerwania).
Rysunek 28: Wprowadź liczbę 42 w polu tekstowym
Po naciśnięciu przycisku „Enter Code” wykonanie aplikacji zostanie przerwane w punkcie przerwania, ponieważ debugger „wie”, która metoda jest wywoływana na urządzeniu. Skompilowana aplikacja dla systemu Android zawiera informacje debugowania (takie jak nazwy zmiennych) dostępne dla dowolnego debugera zgodnego z protokołem Java Debug Wire Protocol (JDWP). Jeśli debugowanie jest włączone w aplikacji, debuger zgodny z JDWP (większość debugerów dostarczanych ze środowiskami programistycznymi Java należy do tej kategorii) będzie mógł podłączyć się do maszyna wirtualna Aplikacje na Androida, a następnie odczytywanie i wykonywanie poleceń debugowania.
Rysunek 29: Trafienie w punkt przerwania
Poniższy zrzut ekranu pokazuje numer, który wcześniej wpisaliśmy w polu tekstowym.
Rysunek 30: Lista zmiennych bieżącej instancji klasy
Wniosek
Możemy nie tylko odczytać dane w aplikacji, ale również wstawić własne. Może to być przydatne, jeśli na przykład chcemy przerwać przepływ wykonywania kodu i ominąć niektóre części algorytmu. Za pomocą debuggera możemy lepiej zrozumieć logikę aplikacji i przeanalizować to, co nie jest dostępne dla zwykłego użytkownika. Na przykład bardzo przydatne może być przeglądanie używanych funkcji szyfrowania i kluczy dynamicznych. Ponadto czasami podczas debugowania warto wiedzieć, w jaki sposób współdziałają funkcje system plików lub bazę danych, aby zrozumieć, jakie informacje są przechowywane przez aplikację. Takie manipulacje są dostępne na dowolnym urządzeniu z Androidem bez uprawnień superużytkownika.
Podczas tworzenia aplikacji na Androida większość programistów korzysta z różnych emulatorów. Jest to wygodne, ponieważ nie ma potrzeby przechowywania wielu różnych urządzeń w szufladach biurka, nie ma bólu głowy z podłączaniem urządzeń do komputera, nie ma sterty przewodów na stole. Klikamy myszą i widzimy pracę naszego programu na ekranie komputera. Prosty i elegancki. Emulator nie jest jednak telefonem. Ma ograniczone możliwości. Jeśli aplikacja korzysta z funkcji specyficznych dla sprzętu, takich jak aparat, Bluetooth lub Połączenie USB, pracując podczas odbierania telefonu, z dużym prawdopodobieństwem możemy powiedzieć, że nie można obejść się bez debugowania na prawdziwym urządzeniu. Na szczęście Eclipse zawiera wszystko, czego potrzebujesz do wykonania tego zadania.
Podłączanie telefonu i uruchamianie programu
Przed podłączeniem telefonu do komputera za pomocą przez USB kabel do transmisji danych, należy wykonać kilka czynności przygotowawczych. Faktem jest, że środowisko Eclipse jest domyślnie skonfigurowane do pracy z emulatorem i musimy poprawić konfigurację trybu debugowania. To proste. Wybierz pozycję menu Uruchom > Konfiguracja debugowania, a następnie DroidDebug. Na karcie Cel, w sekcji Tryb wyboru miejsca docelowego wdrożenia ustaw przełącznik na Ręczny i kliknij Zastosuj. W ten sposób włączony jest tryb ręcznego wyboru platformy. Teraz po uruchomieniu aplikacji pojawi się okno dialogowe, w którym możesz wybrać emulator lub jeden z podłączonych telefonów.
Aby telefon działał w trybie debugowania, należy go również odpowiednio skonfigurować. Na ekranie głównym musisz kliknąć przycisk Menu i znaleźć aplikację Ustawienia. W tej aplikacji otwórz sekcję „Aplikacje”, a następnie element „Rozwój”. Na ekranie, który się otworzy, zaznacz pole obok „Debugowanie USB” (Debugowanie USD). Ta sekwencja działań działa na większości telefonów, ale jest całkiem możliwe, że tryb debugowania UBS jest włączony na twoim urządzeniu w innym miejscu.
Podłącz telefon do komputera i kliknij przycisk Debuguj w Eclipse. W wyświetlonym oknie dialogowym zobaczysz dwie listy: „Wybierz działające urządzenie z Androidem” i „Uruchom nowe urządzenie wirtualne z Androidem”. Pierwsza z nich wymienia telefony podłączone do komputera, druga - emulatory. Wybierz swój telefon z pierwszej listy. Eclipse zainstaluje debugowaną aplikację w telefonie i uruchomi ją. Możesz debugować swój program.
Monitorowanie stanu telefonu DDMS (Dalvik Debug Monitor Service)
Wszystkie informacje o stanie telefonu są dostępne za pośrednictwem specjalnego narzędzia o nazwie usługa monitorowania debugowania DDMS (Dalvik Debug Monitor Service). Aby go uruchomić, kliknij przycisk Androida w prawym górnym rogu Eclipse.
Okno DDMS składa się z kilku paneli. Panel Urządzenia wyświetla listę dostępnych emulatorów i podłączonych telefonów. Oto lista biegania ten moment procesy. Każdy proces działa na własnej maszynie wirtualnej. Strumienie są wyświetlane na oddzielna zakładka wątki. Karta Eksplorator plików jest przeznaczona do pracy z systemem plików telefonu. Dzięki niemu możesz kopiować pliki z komputera na telefon i odwrotnie. Za pomocą przycisku Zrzut ekranu możesz zrobić zrzut ekranu telefonu. Przycisk zielonego żuka umożliwia dołączenie debuggera do wybranego procesu. Aby skorzystać z tej funkcji, musisz mieć kod open source dla tego procesu.
Warto również zwrócić uwagę na narzędzie do rejestrowania LogCat i powiązany z nim panel, który może być bardzo pomocny w rozwiązywaniu problemów. Praca z dziennikiem odbywa się poprzez specjalną klasę android.util.Log. Najczęściej stosowane metody to:
Log.e() - do logowania błędów,
Log.w() - do logowania ostrzeżeń,
Log.i() - do logowania komunikaty informacyjne,
Log.d() - do logowania debugowania,
Log.v() - do rejestrowania pełnych rekordów,
Do tych metod należy przekazać dwa ciągi znaków jako parametry. Pierwszym z nich jest tag, który można następnie wykorzystać do wyszukiwania i filtrowania w LogCat. Drugi to rzeczywiste informacje, które są rejestrowane.