Platforma Android dynamicznie powiększa swój udział w rynku. Jej niewątpliwymi zaletami są modułowa architektura, wysoka elastyczność i otwarty charakter systemu. Na świecie działają miliardy urządzeń pracujących pod kontrolą Androida i z pewnością będzie ich coraz więcej. A programiści, którzy zdobędą umiejętność efektywnego pisania atrakcyjnych aplikacji w tym systemie, będą mogli spokojnie patrzeć w świetlaną przyszłość.
Niniejsza książka stanowi wyczerpujący podręcznik do nauki obsługi środowiska Android Studio — efektywnego, intuicyjnego, potężnego i niezwykle wygodnego
IDE . Opisano tu m.in. wszystkie istotne narzędzia tego środowiska, system kontroli wersji Git i skrypty Gradle oraz ich integrację z IDE. Dodatkowo przedstawiono techniki tworzenia i rozwijania aplikacji w Androidzie. Książka zawiera cztery pełne przykładowe projekty, udostępnione do pobrania z publicznego repozytorium Git.
Dzięki tej książce:
płynnie i bezproblemowo rozpoczniesz pisanie aplikacji w Android Studio
zaczniesz korzystać z systemu kontroli wersji Git
nauczysz się stosować skrypty Gradle
będziesz używać frameworka Android Wear
nauczysz się testować aplikacje i debugować kod za pomocą Android Studio
dowiesz się, jak najskuteczniej zarządzać wieloma podprojektami
poznasz zasady analizy i refaktoryzowania kodu
Android Studio — prawdziwe atelier sztuki programowania!
Adam Gerber — pracuje na Uniwersytecie Illinois. Jest członkiem Chicago Innovation Exchange. Był jednym z pierwszych użytkowników Android Studio i — jak twierdzi — od razu odkrył jego zalety. Używa go zarówno w celu tworzenia profesjonalnych aplikacji, jak i w celu nauczenia studentów programowania.
Clifton Craig — od kilkunastu lat pracuje jako inżynier oprogramowania. Zajmował się systemami mobilnymi J2ME/BlackBerry, Android oraz iOS, a także systemami serwerowymi opartymi na JEE. Pracował przy wielu wysokoprofilowych projektach, takich jak portal MapQuest Gas Prices, MapQuest for Mobile dla platform J2ME i Android, a także Skype dla platform iOS i Android.
Darmowy fragment publikacji:
Tytuł oryginału: Learn Android Studio: Build Android Apps Quickly and Effectively
Tłumaczenie: Rafał Jońca
ISBN: 978-83-283-2009-3
Original edition copyright © 2015 by Adam Gerber and Clifton Craig.
All rights reserved.
Polish edition copyright © 2016 by HELION SA.
All rights reserved.
All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means,
electronic or mechanical, including photocopying, recording or by any information storage retrieval system,
without permission from the Publisher.
Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej
publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich
właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były
kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane
z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie
ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji
zawartych w książce.
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Pliki z przykładami omawianymi w książce można znaleźć pod adresem:
ftp://ftp.helion.pl/przyklady/answyg.zip
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/answyg
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Printed in Poland.
• Kup książkę
• Poleć książkę
• Oceń książkę
• Księgarnia internetowa
• Lubię to! » Nasza społeczność
Spis tre(cid:258)ci
O autorach .............................................................................................................13
O redaktorze technicznym .....................................................................................15
Podzi(cid:218)kowania ......................................................................................................17
Wprowadzenie ......................................................................................................19
Rozdzia(cid:239) 1. Wprowadzenie do Android Studio ........................................................................23
Instalacja JDK w systemie Windows .................................................................................................23
Pobieranie JDK w systemie Windows ........................................................................................23
Uruchomienie instalacji w systemie Windows .........................................................................24
Konfiguracja zmiennych środowiskowych ................................................................................24
Instalacja JDK w systemie Mac OS ....................................................................................................29
Pobieranie JDK w systemie Mac OS ...........................................................................................29
Uruchomienie instalacji w systemie Mac OS ............................................................................30
Konfiguracja JDK w systemie Mac OS .......................................................................................32
Instalacja Android Studio ...................................................................................................................32
Tworzenie pierwszego projektu — HelloWorld ..............................................................................35
Użycie Android Virtual Device Manager .........................................................................................37
Uruchomienie aplikacji HelloWorld w AVD ..................................................................................39
Uruchamianie aplikacji HelloWorld na urządzeniu .......................................................................41
Podsumowanie ......................................................................................................................................43
Rozdzia(cid:239) 2. Poruszanie si(cid:218) po Android Studio ..........................................................................45
Edytor .....................................................................................................................................................46
Zakładki edytora ............................................................................................................................46
Margines .........................................................................................................................................47
Pasek znaczników ..........................................................................................................................48
Przyciski narzędzi ..........................................................................................................................48
Wygląd domyślny ..........................................................................................................................48
Okna narzędzi nawigacyjnych ............................................................................................................49
Okno narzędzia Project ................................................................................................................49
Okno narzędzia Structure ............................................................................................................49
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Okno narzędzia Favorities ...........................................................................................................50
Okno narzędzia TODO ................................................................................................................51
Pasek głównego menu .........................................................................................................................51
Pasek narzędziowy ...............................................................................................................................52
Pasek nawigacyjny ................................................................................................................................52
Pasek statusu .........................................................................................................................................52
Typowe operacje ...................................................................................................................................53
Zaznaczanie tekstu ........................................................................................................................53
Polecenia cofania i przywracania ................................................................................................53
Znajdowanie ostatnio otwieranych plików ...............................................................................54
Przemieszczanie się po ostatnich operacjach nawigacyjnych .................................................54
Kopiowanie, wycinanie i wklejanie .............................................................................................54
Menu kontekstowe ...............................................................................................................................55
Uzyskiwanie pomocy ...........................................................................................................................55
Poruszanie się po IDE przy użyciu klawiatury .................................................................................56
Polecenie Select In .........................................................................................................................56
Polecenie Class ...............................................................................................................................56
Polecenie File .................................................................................................................................57
Polecenie Line ................................................................................................................................57
Polecenie Related File ...................................................................................................................57
Polecenie Last Edit Location ........................................................................................................57
Polecenie Type Hierarchy ............................................................................................................57
Polecenie Declaration ...................................................................................................................57
Znajdowanie i zastępowanie tekstu ...................................................................................................58
Polecenie Find ................................................................................................................................58
Polecenie Find in Path ..................................................................................................................58
Polecenie Replace ..........................................................................................................................58
Polecenie Replace in Path .............................................................................................................58
Podsumowanie ......................................................................................................................................59
Rozdzia(cid:239) 3. Programowanie w Android Studio ........................................................................61
Zawijanie kodu .....................................................................................................................................61
Uzupełnianie kodu ...............................................................................................................................63
Komentowanie kodu ............................................................................................................................66
Wykorzystanie generowania kodu .....................................................................................................66
Konstruktor ....................................................................................................................................66
Metody ustawiające i pobierające ................................................................................................68
Przesłanianie metod ......................................................................................................................68
Metoda toString() ..........................................................................................................................70
Delegowanie metod .......................................................................................................................70
Wstawianie szablonów działających na żywo ..................................................................................70
Przenoszenie kodu ...............................................................................................................................73
Odpowiedni styl kodu .........................................................................................................................74
Polecenie Auto-Indent Lines .......................................................................................................74
Polecenie Rearrange Code ...........................................................................................................75
Polecenie Reformat Code .............................................................................................................76
Polecenie Surround With .............................................................................................................76
Podsumowanie ......................................................................................................................................77
6
Poleć książkęKup książkę SPIS TRE(cid:165)CI
Rozdzia(cid:239) 5.
Rozdzia(cid:239) 4. Refaktoryzacja kodu ..............................................................................................79
Operacja Rename .................................................................................................................................80
Operacja Change Signature ................................................................................................................81
Operacja Type Migration ....................................................................................................................82
Operacja Move ......................................................................................................................................82
Operacja Copy ......................................................................................................................................84
Operacja Safe Delete ............................................................................................................................84
Operacje wydobywania ........................................................................................................................84
Operacja Extract Variable ............................................................................................................85
Operacja Extract Constant ...........................................................................................................85
Operacja Extract Field ..................................................................................................................86
Operacja Extract Parameter .........................................................................................................86
Operacja Extract Method .............................................................................................................87
Zaawansowana refaktoryzacja ............................................................................................................89
Operacje Push Members Down i Pull Members Up ................................................................89
Operacja Replace Inheritance with Delegation .........................................................................89
Operacja Encapsulate Fields ........................................................................................................91
Operacja Wrap Method Return Value .......................................................................................92
Operacja Replace Constructor with Factory Method ..............................................................92
Operacja Convert Anonymous to Inner ....................................................................................93
Podsumowanie ......................................................................................................................................94
Laboratorium — przypomnienia, cz(cid:218)(cid:258)(cid:202) I ...............................................................95
Tworzenie nowego projektu ...............................................................................................................96
Inicjalizacja repozytorium Git ............................................................................................................97
Tworzenie interfejsu użytkownika ...................................................................................................101
Korzystanie z edytora wizualnego ............................................................................................101
Edycja pliku XML zawierającego układ graficzny ..................................................................102
Dodanie usprawnień wizualnych ..............................................................................................106
Dodanie elementów do ListView ..............................................................................................108
Utworzenie menu paska akcji ....................................................................................................109
Zapewnienie trwałości przypomnień ..............................................................................................110
Model danych ..............................................................................................................................111
Niskopoziomowe API SQLite ....................................................................................................112
Podsumowanie ....................................................................................................................................117
Laboratorium — przypomnienia, cz(cid:218)(cid:258)(cid:202) II ............................................................119
Dodawanie i usuwanie przypomnień ..............................................................................................119
Reagowanie na interakcję użytkownika ..........................................................................................121
Własne okna dialogowe ..............................................................................................................122
Utworzenie menu kontekstowego z wyborem wielu elementów ................................................123
Obsługa wcześniejszych wersji API ..........................................................................................125
Dodanie kontekstowego trybu akcji .........................................................................................126
Implementacja dodawania, edycji i usuwania przypomnień .......................................................128
Planowanie własnego okna dialogowego .................................................................................129
Od planów do kodu .....................................................................................................................130
Rozdzia(cid:239) 6.
7
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Utworzenie własnego okna dialogowego .................................................................................132
Dodanie własnej ikony ...............................................................................................................134
Podsumowanie ....................................................................................................................................135
Rozdzia(cid:239) 7. Wprowadzenie do narz(cid:218)dzia Git ..........................................................................139
Instalacja Git .......................................................................................................................................139
Ignorowanie plików ...........................................................................................................................141
Dodawanie plików ..............................................................................................................................142
Klonowanie przykładowej aplikacji Przypomnienia .....................................................................142
Klonowanie i rozwidlanie ...........................................................................................................143
Przeglądanie historii zmian repozytorium ..............................................................................145
Odgałęzienia .................................................................................................................................146
Programowanie w osobnej gałęzi .....................................................................................................146
Tworzenie rewizji i rozgałęzień w Git ......................................................................................152
Gdzie jest polecenie cofnięcia? ..................................................................................................153
Łączenie gałęzi .............................................................................................................................157
Zmiana historii poleceniem Reset .............................................................................................159
Operacja Git Rebase ....................................................................................................................163
Odłączenie od gałęzi ...................................................................................................................163
Referencje względne ....................................................................................................................166
Rozwiązywanie konfliktów w trakcie operacji zmiany bazy .................................................167
Zdalne repozytoria Git ................................................................................................................172
Podsumowanie ....................................................................................................................................173
Rozdzia(cid:239) 8. Projektowanie uk(cid:239)adu komponentów aplikacji ....................................................175
Klasa Activity ......................................................................................................................................175
Klasy View i ViewGroup ...................................................................................................................176
Okno podglądu ............................................................................................................................177
Wysokość i szerokość .................................................................................................................178
Tryb projektowania .....................................................................................................................180
Komponent FrameLayout ..........................................................................................................181
Komponent LinearLayout ..........................................................................................................184
Komponent RelativeLayout .......................................................................................................185
Zagnieżdżanie komponentów ...................................................................................................188
Komponent ListView ..................................................................................................................192
Wskazówki dotyczące projektowania układu graficznego aplikacji ...........................................198
Obsługa różnych wielkości ekranu ...........................................................................................199
Łączymy wszystko razem ...........................................................................................................199
Fragmenty ............................................................................................................................................208
Podsumowanie ....................................................................................................................................215
Laboratorium — waluty, cz(cid:218)(cid:258)(cid:202) I ..........................................................................217
Specyfikacja aplikacji .........................................................................................................................217
Inicjalizacja repozytorium Git ..........................................................................................................221
Modyfikacja układu aktywności MainActivity ..............................................................................223
Definiowanie kolorów .......................................................................................................................226
Zastosowanie kolorów w układzie graficznym ..............................................................................227
Tworzenie i stosowanie stylów .........................................................................................................228
Rozdzia(cid:239) 9.
8
Poleć książkęKup książkę SPIS TRE(cid:165)CI
Utworzenie klasy JSONParser ..........................................................................................................231
Utworzenie aktywności ekranu powitalnego .................................................................................232
Pobieranie kodów walut w formacie JSON ....................................................................................234
Uruchamianie MainActivity .............................................................................................................236
Podsumowanie ....................................................................................................................................238
Rozdzia(cid:239) 10. Laboratorium — waluty, cz(cid:218)(cid:258)(cid:202) II .........................................................................239
Definicja składowych klasy MainActivity .......................................................................................239
Rozpakowanie kodów walut z paczki ..............................................................................................240
Utworzenie menu opcji .....................................................................................................................241
Implementacja zachowania dla elementów menu .........................................................................242
Utworzenie układu spinner_closed .................................................................................................243
Powiązanie mCurrencies z listami ...................................................................................................244
Przeniesienie zachowania list rozwijanych do MainActivity .......................................................244
Utworzenie menedżera ustawień .....................................................................................................246
Znalezienie pozycji na podstawie kodu ...........................................................................................247
Wydobycie kodu waluty z całego tekstu .........................................................................................247
Implementacja współdzielonych ustawień .....................................................................................249
Obsługa naciśnięcia przycisku ..........................................................................................................250
Przechowywanie klucza API .............................................................................................................251
Pobranie klucza API ...........................................................................................................................252
Klasa CurrencyConverterTask .........................................................................................................252
Metoda onPreExecute() ..............................................................................................................256
Metoda doInBackground() ........................................................................................................256
Metoda onPostExecute() ............................................................................................................256
Selektor przycisku ..............................................................................................................................257
Ikona aplikacji i jej tytuł ....................................................................................................................258
Podsumowanie ....................................................................................................................................259
Rozdzia(cid:239) 11. Testowanie i analiza ............................................................................................261
Utworzenie nowego testu instrumentacyjnego .............................................................................262
Definicja metod setUp() i tearDown() .....................................................................................262
Definicja wywołania zwrotnego w MainActivity ....................................................................264
Definicja metod testujących .......................................................................................................265
Uruchomienie testu instrumentacji ..........................................................................................266
Naprawa błędu .............................................................................................................................267
Użycie narzędzia Monkey .................................................................................................................268
Korzystanie z narzędzi analitycznych .............................................................................................269
Inspekcja kodu .............................................................................................................................269
Analiza zależności .......................................................................................................................270
Analiza stosu wywołań ...............................................................................................................270
Podsumowanie ....................................................................................................................................273
Rozdzia(cid:239) 12. Debugowanie ......................................................................................................275
Dziennik zdarzeń ................................................................................................................................275
Użycie narzędzia logcat ..............................................................................................................276
Zapis danych w dzienniku .........................................................................................................278
9
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Polowanie na błędy! ...........................................................................................................................278
Korzystanie z debugera interaktywnego ..................................................................................282
Obliczanie wyrażenia ..................................................................................................................284
Wykorzystanie stosu wywołań ..................................................................................................286
Elementy narzędzia interaktywnego debugera .......................................................................289
Przeglądarka punktów wstrzymania ........................................................................................289
Warunkowe punkty wstrzymania .............................................................................................292
Podsumowanie ....................................................................................................................................295
Rozdzia(cid:239) 13. Narz(cid:218)dzie Gradle .................................................................................................297
Składnia Gradle ...................................................................................................................................298
System budowania aplikacji IntelliJ .................................................................................................299
Podstawowe zagadnienia systemu budowania Gradle .................................................................299
Struktura skryptu Gradle dla Androida ...................................................................................300
Zależności projektu .....................................................................................................................301
Laboratorium — projekt prognozy pogody ...................................................................................302
Zależności od bibliotek systemu Android ......................................................................................307
Zależność od bibliotek Javy ........................................................................................................312
Biblioteki zewnętrzne ..................................................................................................................320
Otwieranie starszych projektów .......................................................................................................322
Podsumowanie ....................................................................................................................................323
Rozdzia(cid:239) 14. Dodatkowe narz(cid:218)dzia Android SDK .....................................................................325
Android Device Monitor ...................................................................................................................325
Zakładka Threads ........................................................................................................................325
Zakładka Heap .............................................................................................................................326
Zakładka Allocation Tracker .....................................................................................................328
Zakładka Network Statistics ......................................................................................................329
Przeglądarka hierarchii ...............................................................................................................329
Integracja monitora Androida .........................................................................................................332
Zakładka Memory .......................................................................................................................332
Narzędzie Method Trace ............................................................................................................333
Narzędzie Allocation Tracker ....................................................................................................334
Wykonywanie zrzutów ekranu ..................................................................................................335
Edytor nawigacji .................................................................................................................................336
Projektowanie interfejsu użytkownika .....................................................................................337
Pierwsze kroki w edytorze nawigacji ........................................................................................337
Łączenie aktywności ....................................................................................................................337
Terminal ..............................................................................................................................................340
Uzyskanie listy urządzeń ............................................................................................................340
Instalacja APK ..............................................................................................................................340
Pobranie pliku ..............................................................................................................................340
Wysłanie pliku .............................................................................................................................340
Przekazywanie portów ................................................................................................................340
Narzędzia chmury Google ................................................................................................................341
Utworzenie części klienckiej ......................................................................................................342
Utworzenie modułu serwerowego ............................................................................................343
10
Poleć książkęKup książkę SPIS TRE(cid:165)CI
Połączenie wszystkich elementów ............................................................................................343
Wdrożenie na serwerach Google App Engine ........................................................................349
Podsumowanie ....................................................................................................................................352
Rozdzia(cid:239) 15. Laboratorium — Android Wear ...........................................................................353
Konfiguracja środowiska ...................................................................................................................353
Instalacja sterowników urządzenia ...........................................................................................353
Konfiguracja narzędzi SDK ........................................................................................................354
Konfiguracja urządzenia wirtualnego Wear ............................................................................354
Konfiguracja sprzętu Android Wear ........................................................................................355
Tworzenie projektu MegaDroid .......................................................................................................357
Optymalizacja związana z technologią ekranu .......................................................................358
Tworzenie usługi WatchFace .....................................................................................................360
Inicjalizacja zasobów i stylów ....................................................................................................362
Zarządzanie aktualizacjami zegara ...........................................................................................362
Rysowanie tarczy i wskazówek ..................................................................................................366
Podsumowanie ....................................................................................................................................369
Rozdzia(cid:239) 16. Dostosowywanie Android Studio do w(cid:239)asnych potrzeb ......................................371
Style kodu ............................................................................................................................................371
Wygląd, kolory i czcionki ..................................................................................................................374
Skróty klawiaturowe ..........................................................................................................................376
Makra ...................................................................................................................................................376
Szablony kodu i plików ......................................................................................................................377
Menu i paski narzędziowe .................................................................................................................377
Moduły dodatkowe ............................................................................................................................380
Podsumowanie ....................................................................................................................................381
Skorowidz ...........................................................................................................383
11
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
12
Poleć książkęKup książkę R O Z D Z I A (cid:146) 1 5
(cid:132) (cid:132) (cid:132)
Laboratorium — Android Wear
Android Wear, jedna z najnowszych technologii firmy Google, daje szansę na bardziej osobisty i intymny
kontakt z urządzeniem. Obecnie nie ma jeszcze zbyt wielu urządzeń obsługujących Android Wear, ale ich lista
stale rośnie. W zasadzie dostępne urządzenia to głównie zegarki, ale gdy technologia bardziej się rozwinie,
w zasadzie urządzeniem obsługującym Android Wear będzie mogło być cokolwiek, na przykład naszyjnik
lub ubranie. Obecnie zegarki z systemem Android są produkowane przez trzy firmy znane z produkcji urządzeń
z systemem Android: Samsung, Motorola i Sony. W tym rozdziale wykonamy aplikację, która może działać
zarówno przewodowo, jak i bezprzewodowo.
(cid:132) Uwaga Zach(cid:218)camy do sklonowania tego projektu za pomoc(cid:200) narz(cid:218)dzia Git, aby(cid:258) móg(cid:239) przyjrze(cid:202) si(cid:218) ca(cid:239)emu
przyk(cid:239)adowi. Z drugiej strony w poszczególnych podrozdzia(cid:239)ach b(cid:218)dziemy krok po kroku tworzy(cid:202) ten projekt od
podstaw. Je(cid:258)li narz(cid:218)dzie Git nie jest zainstalowane na Twoim komputerze, zajrzyj do rozdzia(cid:239)u 7. Otwórz sesj(cid:218) Git-bash
w systemie Windows (lub terminal w systemie Mac albo Linux) i przejd(cid:283) do folderu C:\androidBook\reference (utwórz
folder, je(cid:258)li nie istnieje). W systemach Linux i Mac folder mo(cid:285)e znajdowa(cid:202) si(cid:218) w innym miejscu. Wykonaj nast(cid:218)puj(cid:200)ce
polecenie: git clone https://bitbucket.org/gluwer/megadroid.git MegaDroid.
Konfiguracja (cid:258)rodowiska
Przed rozpoczęciem prac nad aplikacją musimy poświęcić nieco czasu na konfigurację środowiska. Choć
można wykonać całą pracę, posiłkując się tylko emulatorem, zawsze najlepiej mieć rzeczywiste urządzenie
Wear. Upewnij się, że Twoje urządzenie korzysta z najnowszej wersji systemu operacyjnego. Pobierz i zainstaluj
wszystkie wymagane sterowniki. Podłącz urządzenie do komputera i poszukaj go na liście urządzeń okna
narzędzia Android Monitor.
Instalacja sterowników urządzenia
W systemie Windows konieczna może okazać się instalacja sterowników niezbędna do uzyskania komunikacji
za pomocą USB. Pamiętaj o tym, aby instalować sterownik tylko wtedy, gdy urządzenie nie jest rozpoznane.
Punkt ten możesz pominąć, jeśli planujesz przesyłanie aplikacji za pomocą połączenia Bluetooth. Przy pierwszej
próbie podłączenia urządzenia system Windows automatycznie rozpocznie wyszukiwanie sterowników.
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Otwórz Menedżer urządzeń i znajdź urządzenie na liście wewnątrz grupy Inne urządzenia. Kliknij je prawym
klawiszem myszy i wybierz polecenie Aktualizuj oprogramowanie sterownika. W oknie, które się pojawi,
wybierz drugą opcję (Przeglądaj mój komputer w poszukiwaniu oprogramowania sterownika), a następnie
opcję Pozwól mi wybrać z listy sterowników urządzeń ma moim komputerze. Z listy wybierz Android Device.
Jeśli na następnej liście nie znajdziesz sterownika firmy produkującej zegarek, wybierz ogólny sterownik ADB
Interface, który również zadziała prawidłowo.
Konfiguracja narzędzi SDK
Przed rozpoczęciem prac programistycznych pobierz i zainstaluj SDK w wersji przynajmniej 5.0.1 lub nowszej
i uaktualnij narzędzia SDK do wersji 24.0.2 lub nowszej. Obsługa Android Wear pojawiła się w wersji 4.4W.2
i narzędziach SDK 23.0, ale przykłady użyte w dalszej części wymagają nowszego SDK. Warto również
zainstalować przykłady z SDK oraz biblioteki Google znajdujące się w pakiecie Extras.
Konfiguracja urządzenia wirtualnego Wear
Uruchom narzędzie AVD Manager z poziomu paska narzędziowego lub poleceniem Tools/Android/AVD
Manager. Kliknij przycisk Create Virtual Device. Z listy kategorii po lewej wybierz Wear. Jako profile
sprzętowe po prawej stronie pojawią się profile typu Android Wear Square i Android Wear Round
(patrz rysunek 15.1). Wybierz API 5.0.1 lub nowsze, ponieważ prezentowane przykłady wymagają funkcji
dostępnych w wersji 5.0.1. W zależności od szybkości komputera można wybrać obraz systemu w wersji x86.
Tego rodzaju obrazy działają szybciej, ponieważ nie muszą emulować procesora. Z drugiej strony ich
dostępność uzależniona jest od systemu HAXM (Hardware Accelerated Execution Manager) firmy Intel.
HAXM również instaluje się z poziomu narzędzia AVD Manager. Do działania wymaga on dostępności
technologii wirtualizacji (VT) firmy Intel, która nie jest dostępna na każdym sprzęcie. Kliknij przycisk Next,
aby pozostawić wartości domyślne, i przejdź do następnego ekranu kreatora. By uzyskać optymalną szybkość
działania, włącz opcję Use Host CPU.
Rysunek 15.1. Wybór kategorii Wear
354
Poleć książkęKup książkę Wybierz najnowszy dostępny poziom API (obecnie jest to Lollipop). Następnie kliknij przycisk Next
(patrz rysunek 15.2).
ROZDZIA(cid:146) 15. (cid:132) LABORATORIUM — ANDROID WEAR
Rysunek 15.2. Wybór obrazu systemu w wersji Lollipop
Nadaj AVD nazwę Android Wear Square API 22 na ekranie przedstawionym na rysunku 15.3.
Kliknij przycisk Finish, aby utworzyć AVD. Następnie kliknij strzałkę w dół na końcu wpisu dotyczącego
Wear AVD i wybierz polecenie Duplicate (patrz rysunek 15.4). Jeśli pierwszy utworzony AVD był typu
Square, zmień go na wersję Round, i odwrotnie. Warto utworzyć dwa obrazy, aby móc testować aplikację
w obu wariantach.
Konfiguracja sprzętu Android Wear
Osoby posiadające urządzenie Android Wear muszą je odpowiednio skonfigurować, aby móc go używać
do testowania aplikacji. Aplikacje przekazuje się na urządzenia Wear za pomocą telefonu komórkowego
lub tabletu, więc one również będą potrzebne. Na komórce z systemem Android zainstaluj aplikację Android
Wear ze sklepu Google Play. Uruchom aplikację i sparuj ją z urządzeniem Wear (na przykład zegarkiem).
Istnieją dwa sposoby wdrażania aplikacji na zegarku — przewodowy i bezprzewodowy (Bluetooth).
Rozwiązanie przewodowe jest prostsze, ale rozwiązanie Bluetooth jest wygodniejsze, szczególnie jeśli portów
USB w komputerze jest mało i nie chcesz zajmować się sterownikami. Brak portów USB jest szczególnie
uciążliwy, gdy jednocześnie testuje się aplikację na smartfonie, tablecie i zegarku.
355
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Rysunek 15.3. Nadaj obrazowi nazwę Android Wear Square API 22
Rysunek 15.4. Zduplikuj AVD Android Wear Square API 22
W(cid:239)(cid:200)czenie trybu programisty
Jeśli nigdy wcześniej nie był włączany tryb programisty (lub urządzenie jest całkowicie nowe), wykonaj
poniższe kroki, aby móc włączyć na urządzeniu tryb pozwalający na ciągłą pracę urządzenia, testowanie
poprzez Bluetooth, sprawdzanie układu aplikacji itp.
1. Otwórz aplikację ustawienia na urządzeniu, naciskając i przytrzymując przez dwie sekundy przycisk
na boku.
2. Przejdź na sam dół listy i wybierz ostatni element (informacje o urządzeniu).
356
Poleć książkęKup książkę ROZDZIA(cid:146) 15. (cid:132) LABORATORIUM — ANDROID WEAR
3. Wewnątrz nowego ekranu kliknij siedmiokrotnie element numer kompilacji. Po powrocie do głównej
listy ustawień dostępny będzie nowy element z opcjami programisty.
4. Wejdź do nowego elementu i włącz opcję debugowania.
W(cid:239)(cid:200)czenie debugowania Bluetooth
Na ekranie opcji programisty włącz debugowanie Bluetooth, aby móc korzystać z bezprzewodowego
testowania aplikacji. Następnie otwórz narzędzie Terminal i wpisz następujące polecenia ADB:
adb forward tcp:4444 localabstract:/adb-hub
adb connect localhost:4444
Sprawdź status aplikacji Android Wear na urządzeniu mobilnym. Powinny pojawić się wartości:
Host: pod(cid:239)(cid:200)czone
Cel: pod(cid:239)(cid:200)czone
Od tego momentu aplikacja i zegarek są gotowe do instalacji aplikacji.
Tworzenie projektu MegaDroid
W tym podrozdziale wykonamy aplikację tarczy zegarka z fikcyjną postacią o nazwie MegaDroid. MegaDroid
to połączenie postaci z dwóch gier wideo z lat 80. (nie będziemy podawali ich nazw). Tło zegarka będzie
stanowiła postać wojownika, który walczy z wrogami za pomocą dwóch mieczy. Aplikacja może stanowić
dodatek do prawdziwej gry. Rysunek 15.5 przedstawia finalny wynik. Przykład można wykorzystać jako
podstawę do napisania własnej aplikacji zegara z własną marką. Tworzenie własnych aplikacji zegara to
nowość wprowadzona w wersji Lollipop. Tego rodzaju rozwiązanie działa jako rzeczywista tarcza zegarka
(urządzenia), więc otwiera przed programistą nowe możliwości. Aplikacja może wyświetlać informacje
z różnych źródeł, na przykład internetu, GPS, kalendarza powiązanego urządzenia itp. Ponieważ aplikacja
zegara działa cały czas, może posłużyć jako rozszerzenie aplikacji. W przykładzie omówimy tylko
najważniejsze aspekty związane z interfejsem użytkownika i jego aktualizacją wraz z upływem czasu.
Rysunek 15.5. Finalna wersja zegara z postacią MegaDroid
Użyj kreatora nowego projektu opisanego w rozdziale 1., aby utworzyć projekt Android Wear. Na drugim
ekranie kreatora wybierz opcję Wear i SDK w wersji przynajmniej 5.0 (patrz rysunek 15.6). Na pozostałych
ekranach pozostaw wartości domyślne. Na ekranie wyboru szablonów wybierz Blank Activity dla aplikacji
mobilnej i Blank Wear Activity dla komponentu Wear. Zakończ konfigurację projektu przyciskiem Finish.
Zbuduj i uruchom projekt, aby sprawdzić go na rzeczywistym urządzeniu lub emulatorze.
357
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Rysunek 15.6. Włączenie opcji Wear w kreatorze nowego projektu
Wykonanie jak najlepszego projektu układu aplikacji to jedno z najważniejszych zadań stojących przed
twórcami aplikacji typu Wear. Aby produkt stał się optymalny, na początku większość czasu należy poświęcić
na dopracowywanie układu elementów, ich kolorów, wyrazistości, czytelności itp. Każde tło zegarka jest
unikatowe, więc dostosowanie się do wymogów urządzenia bywa trudne. Oczywiście znacznie łatwiej
wykonać proste tło z cyfrowym zegarem (bo są to tylko cyfry) niż z wersją imitującą zegar analogowy.
Dokumentacja dostępna na stronach internetowych projektu Android może onieśmielić wiele osób
niezaznajomionych ze sztuką projektowania. Na stronie zamieszczono sugestię, by zastanowić się nad
wykonaniem zarówno wersji kwadratowej, jak i okrągłej, a także nad dodatkowymi danymi, elementami
interfejsu użytkownika i obsługą różnych rozdzielczości. Można także zastanowić się nad ekranem
konfiguracji. Ponieważ prezentowany przykład ma przedstawić jedynie podstawy, wiele z wymienionych
aspektów zostało pominiętych.
Optymalizacja związana z technologią ekranu
System wykonawczy Wear uruchamia aplikację w dwóch trybach wyświetlania: w trybie tła i w trybie
interaktywnym. Zegarek przełącza się między tymi trybami w zależności od tego, czy aplikacja jest przeglądana,
czy używana. Tryb tła ma za zadanie oszczędzać baterię. Aplikacja powinna taki tryb wykryć i na przykład
przyciemnić ekran. Ponieważ aktualizacje w tym trybie są wysyłane raz na minutę, warto zmniejszyć
częstotliwość odświeżania ekranu. Tworzona aplikacja usunie w tym trybie wygładzanie jednej ze wskazówek
i zmieni częstotliwość odświeżania ekranu z jednej sekundy na jedną minutę.
Niektóre urządzenia w trybie tła obsługują jedynie niższą rozdzielczość, a samo urządzenie stosuje
ograniczoną paletę kolorów. To redukuje zużycie energii i zapobiega wypaleniu ekranu. Wejście w tryb
ograniczonych kolorów można wykryć i ograniczyć wykorzystane barwy tylko do czerni, bieli, zielonego,
niebieskiego, czerwonego, karmazynowego, żółtego i cyjanowego. Warto czasem zastosować zamiast całego
358
Poleć książkęKup książkę ROZDZIA(cid:146) 15. (cid:132) LABORATORIUM — ANDROID WEAR
obrazu jedynie jego otoczkę. W trybie ograniczonych kolorów tło powinno pozostawać prawie czarne. Piksele
w kolorze innym niż czerń nie powinny zajmować więcej niż 10 ekranu, a intensywne kolory więcej niż 5 .
W tym trybie warto również wyłączyć korzystanie z wygładzania krawędzi. Wygładzanie krawędzi to technika,
po której zastosowaniu krawędzie rysunku wydają się mniej poszarpane (porównaj rysunku 15.7 i 15.8).
Rysunek 15.7. Obraz bez wygładzania
Rysunek 15.8. Obraz z wygładzaniem
Aplikacja w trybie działania w tle wykorzysta wersję grafiki w odcieniach szarości (patrz rysunek 15.9).
Skopiuj wszystkie obrazy z folderu gotowego projektu do folderu nowego projektu. W systemie Windows
przeciągnij prawym klawiszem myszy folder res z folderu
C:\androidBook\reference\MegaDroid\wear\src\main do folderu C:\androidBook\MegaDroid\wear\src\main
i wybierz z menu kontekstowego polecenie Kopiuj tutaj. W systemie Mac OS lub Linux z poziomu konsoli
wykonaj polecenie:
cp -R ~/androidBook/reference/MegaDroid/wear/src/main/res
~/androidBook/MegaDroid/wear/src/main/
Rysunek 15.9. Grafika w odcieniach szarości
359
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Tworzenie usługi WatchFace
Usługa tarczy zegarka odpowiada za utworzenie WatchFaceService.Engine, czyli głównego mechanizmu
obsługującego tarczę zegarka. Klasa WatchFaceService.Engine odpowiada na wywołania zwrotne systemu,
aktualizuje czas i rysuje obraz tła (tarczy zegarka). Utwórz nową klasę MegaDroidWatchFaceService
dziedziczącą po klasie CanvasWatchFaceService. Umieść w klasie kod z listingu 15.1.
Listing 15.1. Klasa MegaDroidWatchFaceService
public class MegaDroidWatchFaceService extends CanvasWatchFaceService {
private static final String TAG = MegaDroidWatchSvc ;
@Override
public Engine onCreateEngine() {
// utworzenie i zwrócenie klasy Engine dla obrazu tła
return new MegaDroidEngine(this);
}
/* implementacja metod wywołań zwrotnych */
private class MegaDroidEngine extends CanvasWatchFaceService.Engine {
private final Service service;
public MegaDroidEngine(Service service) {
this.service = service;
}
/**
* inicjalizacja tła zegarka
*/
@Override
public void onCreate(SurfaceHolder holder) {
super.onCreate(holder);
}
/**
* wywoływana w momencie zmiany właściwości,
* co pozwala włączyć tryb szarości
*/
@Override
public void onPropertiesChanged(Bundle properties) {
super.onPropertiesChanged(properties);
}
/**
* wywoływana przez system wykonawczy co minutę
*/
@Override
public void onTimeTick() {
super.onTimeTick();
}
/**
* wywoływana w trybie wejścia do trybu tła i wyjścia z tego trybu
*/
@Override
public void onAmbientModeChanged(boolean inAmbientMode) {
super.onAmbientModeChanged(inAmbientMode);
360
Poleć książkęKup książkę ROZDZIA(cid:146) 15. (cid:132) LABORATORIUM — ANDROID WEAR
}
@Override
public void onDraw(Canvas canvas, Rect bounds) {
// rysowanie tła
}
/**
* wywoływana, gdy tło staje się widoczne lub niewidoczne
*/
@Override
public void onVisibilityChanged(boolean visible) {
super.onVisibilityChanged(visible);
}
}
}
Rejestracja us(cid:239)ugi
Dodaj poniższy fragment do pliku manifestu aplikacji Android tuż przed znacznikiem zamykającym
application:
service
android:name= .MegaDroidWatchFaceService
android:label= @string/mega_droid_service_name
android:allowEmbedded= true
android:taskAffinity=
android:permission= android.permission.BIND_WALLPAPER
meta-data
android:name= android.service.wallpaper
android:resource= @xml/watch_face /
meta-data
android:name= com.google.android.wearable.watchface.preview
android:resource= @drawable/preview_analog /
meta-data
android:name= com.google.android.wearable.watchface.preview_circular
android:resource= @drawable/preview_analog_circular /
intent-filter
action android:name= android.service.wallpaper.WallpaperService /
category android:name=
com.google.android.wearable.watchface.category.WATCH_FACE /
/intent-filter
/service
Po umieszczeniu kodu w manifeście pojawi się kilka błędów. Użyj klawisza F2 i kombinacji Alt+Enter, aby
wyświetlić sugestie i rozwiązać problemy. Pierwsza sugestia dotyczy wygenerowania nazwy dla nowej usługi,
która pojawi się na liście zawierającej nazwy i rodzaje tła. Następna sugestia dotyczy kodu XML deskryptora
określającego tapetę. Utwórz plik xml/watch_face.xml i umieść w nim poniższy kod:
?xml version= 1.0 encoding= utf-8 ?
wallpaper xmlns:android= http://schemas.android.com/apk/res/android /
Dwa następne błędy nie mogą być łatwo naprawione na poziomie sugestii IntelliJ. Stanowią referencję
do zasobów rysowania, które odpowiadają za podgląd tarczy na ekranie wyboru tła. Można niezbędne pliki
utworzyć w dowolnym edytorze graficznym. Alternatywą jest wykonanie zrzutu ekranu działającej aplikacji,
ale przypomina to stawianie wszystkiego na głowie. Jeśli nie chcesz zajmować się edytorem grafiki rastrowej,
361
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
pobierz dwa dowolne obrazy, nadaj im odpowiednie nazwy i wstaw do projektu. Gdy aplikacja będzie gotowa,
wykonaj zrzuty ekranu i wstaw je w miejsce wcześniejszych, tymczasowych obrazów.
Inicjalizacja zasobów i stylów
W metodzie onCreate() dodaj następujący kod, który zainicjalizuje style i zasoby rysowania:
public void onCreate(SurfaceHolder holder) {
super.onCreate(holder);
setWatchFaceStyle(new WatchFaceStyle.Builder(service)
.setCardPeekMode(WatchFaceStyle.PEEK_MODE_SHORT)
.setStatusBarGravity(Gravity.RIGHT | Gravity.TOP)
.setHotwordIndicatorGravity(Gravity.LEFT | Gravity.TOP)
.setBackgroundVisibility(WatchFaceStyle.BACKGROUND_VISIBILITY_INTERRUPTIVE)
.setShowSystemUiTime(false)
.build());
Resources resources = service.getResources();
Drawable backgroundDrawable = resources.getDrawable(R.drawable.bg);
this.backgroundBitmap = ((BitmapDrawable) backgroundDrawable).getBitmap();
this.character = ((BitmapDrawable) resources.getDrawable(
R.drawable.character_standing)).getBitmap();
this.logo = ((BitmapDrawable) resources.getDrawable(
R.drawable.megadroid_logo)).getBitmap();
this.minuteHand = ((BitmapDrawable) resources.getDrawable(
R.drawable.minute_hand)).getBitmap();
this.hourHand = ((BitmapDrawable) resources.getDrawable(
R.drawable.hour_hand)).getBitmap();
this.secondPaint = new Paint();
secondPaint.setARGB(255, 255, 0, 0);
secondPaint.setStrokeWidth(2.f);
secondPaint.setAntiAlias(true);
secondPaint.setStrokeCap(Paint.Cap.ROUND);
this.time = new Time();
}
Zarządzanie aktualizacjami zegara
Dodaj dwa poniższe pola do głównej klasy:
private static final long INTERACTIVE_UPDATE_RATE_MS =
TimeUnit.SECONDS.toMillis(1);
private static final int MSG_UPDATE_TIME = 0;
Utworzymy procedurę aktualizacji, która wymusi aktualizację zegara na podstawie zdefiniowanej
wcześniej stałej INTERACTIVE_UPDATE_RATE_MS:
/** aktualizacja czasu co sekundę w trybie interaktywnym */
final Handler mUpdateTimeHandler = new Handler() {
@Override
public void handleMessage(Message message) {
switch (message.what) {
case MSG_UPDATE_TIME:
362
Poleć książkęKup książkę ROZDZIA(cid:146) 15. (cid:132) LABORATORIUM — ANDROID WEAR
if (Log.isLoggable(TAG, Log.VERBOSE)) {
Log.v(TAG, aktualizacja czasu );
}
invalidate();
if (shouldTimerBeRunning()) {
long timeMs = System.currentTimeMillis();
long delayMs = INTERACTIVE_UPDATE_RATE_MS
- (timeMs INTERACTIVE_UPDATE_RATE_MS);
mUpdateTimeHandler.sendEmptyMessageDelayed(MSG_UPDATE_TIME, delayMs);
}
break;
}
}
};
private boolean shouldTimerBeRunning() {
return isVisible() !isInAmbientMode();
}
Kod procedury aktualizacyjnej ponownie umieści się na liście zadań do wykonania (z odpowiednim
opóźnieniem) po pierwszym uruchomieniu. Kod niczego nie rysuje — wywołuje tylko unieważnienie zawartości
ekranu, co wymusza niejawnie wywołanie metody onDraw(). Przed następnym uruchomieniem z zadanym
opóźnieniem sprawdza jeszcze, czy zegarek nie znajduje się w trybie tła i czy samo tło jest w ogóle widoczne.
Dodaj metodę onDestroy(), aby zwolnić zasoby, gdy usługa będzie czyszczona przez system:
@Override
public void onDestroy() {
mUpdateTimeHandler.removeMessages(MSG_UPDATE_TIME);
super.onDestroy();
}
Zaimplementuj metodę onPropertiesChanged(), aby śledzić włączenie trybu lowBitAmbient.
Dodaj składową typu boolean, by zapamiętać aktualny tryb działania. W ten sposób będziemy decydować,
czy ograniczyć szybkość wyświetlania. Umieść w metodzie poniższy kod:
public void onPropertiesChanged(Bundle properties) {
super.onPropertiesChanged(properties);
this.lowBitAmbient = properties.getBoolean(PROPERTY_LOW_BIT_AMBIENT, false);
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, onPropertiesChanged: w tle z szaro(cid:258)ci(cid:200) = + lowBitAmbient);
}
}
Składowa lowBitAmbient powinna mieć postać:
private boolean lowBitAmbient;
Dodaj w metodzie onTimeTick() wywołanie metody invalidate(), co spowoduje wymuszanie ponownego
rysowania ekranu:
@Override
public void onTimeTick() {
super.onTimeTick();
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, onTimeTick: tryb t(cid:239)a = + isInAmbientMode());
}
invalidate();
}
363
Poleć książkęKup książkę ANDROID STUDIO. WYGODNE I EFEKTYWNE TWORZENIE APLIKACJI
Następnie zaimplementuj wywołanie zwrotne onAmbientModeChanged(). W zależności od trybu użyjemy
grafiki w kolorach szarości lub grafiki kolorowej i dla jednej ze wskazówek wyłączymy wygładzanie
(patrz wcześniejszy opis).
public void onAmbientModeChanged(boolean inAmbientMode) {
super.onAmbientModeChanged(inAmbientMode);
if (Log.isLoggable(TAG, Log.DEBUG)) {
Log.d(TAG, onAmbientModeChanged: + inAmbientMode);
}
if(inAmbientMode) {
character = ((BitmapDrawable) service.getResources().getDrawable(
R.drawable.character_standing_greyscale)).getBitmap();
logo = ((BitmapDrawable) service.getResources().getDrawable(
R.drawable.megadroid_logo_bw)).getBitmap();
hourHand = ((BitmapDrawable) service.getResources().getDrawable(
R.drawable.hour_hand_bw)).getBitmap();
minuteHand = ((BitmapDrawable) service.getResources()
.getDrawable(R.drawable.minute_hand_bw)).getBitmap();
} else {
character = ((BitmapDrawable) service.getResources()
.getDrawable(R.drawable.character_standing)).getBitmap();
logo = ((BitmapDrawable) service.getResources()
.getDrawable(R.drawable.megadroid_logo)).getBitmap();
hourHand = ((BitmapDrawable) service.getResources()
.getDrawable(R.drawable.hour_hand)).getBitmap();
minuteHand = ((BitmapDrawable) service.getResources()
.getDrawable(R.drawable.minute_hand)).getBitmap();
}
if (lowBitAmbient) {
boolean antiAlias = !inAmbientMode;
secondPaint.setAntiAlias(antiAlias);
}
invalidate();
// To, czy kod ponawiający odświeżanie powinien działać, zależy od
// trybu działania (i tego, czy tło jest widoczne), więc
// kod odpowiedzialny za ponowienie odświeżenia wywołujemy
// za każdym razem.
updateTimer();
}
Kod wywołuje metodę updateTimer(), którą dopiero musimy zdefiniować. Metoda ta wysyła do
mUpdateTimeHandler pusty ko
Pobierz darmowy fragment (pdf)
