Podziękowania Jestem wdzięczny redaktor naczelnej Laurze Lewin za to, że uwierzyła we mnie i umożliwiła napisanie tej książki. Moja wdzięczność należy się Songlin Qiu, redaktor prowadzącej, która przekazała mi wiele opinii, a one pomogły ukształtować wszystkie rozdziały. To właśnie ona odegrała kluczową rolę w poprawie struktury książki oraz jakości informacji w niej zawartych. Muszę też podziękować korektorom, Jamesowi Becwarowi, Rominowi Iraniemu i Prashantowi Thakkarowi (Pandhi), za ich doskonały i szczegółowy przegląd książki oraz wiele przydatnych komentarzy i sugestii. Specjalne podziękowania należą się Karen Gill za jej najwyższej klasy redakcję językową i strukturalną tekstu. Doceniam jej starania w zakresie poszerzenia zawartości książki i jej wygładzenia. Wielkie i nieustające podziękowania dla Olivii Basegio, asystentki redakcji, za świetną robotę. Wyrazy wdzięczności dla całego zespołu za wydanie książki na czas. Specjalne podziękowania dla redakcji i całego zespołu w Pearson Technology Group, który pracował bez wytchnienia, aby wydać tę książkę. Bardzo podobała mi się współpraca z każdym z was. Jestem również wdzięczny rodzinie, która jest moim małym światem: mojej żonie Anuszce i moim wspaniałym dzieciom Chiragowi i Namanowi, za inspirację i motywowanie mnie do pracy. Proszę ich o wybaczenie za to, że spędzałem tyle czasu przy komputerze. Muszę wspomnieć też o moich studentach, którzy byli dla mnie dobrymi nauczycielami. Ich interesujące pytania pomogły zrozumieć oczekiwania czytelnika i zainspirowały mnie do napisania książki, w której skupiłem się na praktycznym podejściu.
Spis treści
O autorze . .........................................................................11 Wstęp . .............................................................................13
Część I
Techniki interfejsu użytkownika ..........................21
Rozdział 1
Przegląd aplikacji na tablety z systemem Android . .............23 Receptura: wprowadzenie do tabletów z systemem Android ..............23 Receptura: różnice pomiędzy telefonami Android a tabletami Android .....................................................................25 Receptura: zapewnianie kompatybilności aplikacji z telefonami i tabletami z systemem Android ...................................................26 Receptura: tworzenie urządzeń AVD ................................................27 Receptura: struktura katalogów projektu Android .............................32 Receptura: konwersja aplikacji z telefonu Android w aplikację na tablet Android ........................................................................37 Receptura: wymuszanie, aby aplikacja działała jedynie na tabletach ...48 Receptura: aktywności ...................................................................49 Receptura: cykl życia aktywności w systemie Android .......................49 Receptura: rozpoczynanie korzystania z intencji ...............................53 Receptura: przekazywanie danych z jednej aktywności do drugiej ......58 Podsumowanie .............................................................................64
Rozdział 2
Fragmenty . .......................................................................67
Receptura: wprowadzenie do fragmentów .............................................................68 Receptura: cykl życia fragmentu ..........................................................................68 Receptura: tworzenie fragmentów pierwszego planu oraz różnice pomiędzy fragmentami pierwszego planu a fragmentami w tle ...............................70 Receptura: dodawanie i usuwanie fragmentów w przypadku zmiany orientacji urządzenia .............................................................78 Receptura: rola klas FragmentManager i FragmentTransaction w obsłudze fragmentów ......................................................................................83 Receptura: tworzenie fragmentów dynamicznie w trakcie wykonywania aplikacji ....................................................86
6
Android na tablecie. Receptury Receptura: implementowanie komunikacji pomiędzy fragmentami .....92 Receptura: wyświetlanie opcji za pomocą klasy ListFragment ............98 Receptura: wyświetlanie okien dialogowych za pomocą klasy DialogFragment ...............................................102 Receptura: konfigurowanie preferencji użytkownika za pomocą klasy PreferenceFragment .........................................109 Podsumowanie ...........................................................................117
Rozdział 3
Paski akcji w działaniu . ...................................................119 Receptura: różnice pomiędzy menu i paskiem akcji ........................119 Receptura: przełączanie widoczności paska akcji ...........................120 Receptura: komponenty paska akcji .............................................121 Receptura: wyświetlanie elementów akcji w pasku akcji .................121 Receptura: nawigowanie do strony głównej po wybraniu ikony aplikacji .........................................................126 Receptura: wyświetlanie widoków akcji w pasku akcji .....................127 Receptura: wyświetlanie podmenu w pasku akcji ...........................132 Receptura: tworzenie paska zadań z zakładkami ............................139 Receptura: tworzenie paska akcji z rozwijaną listą .........................145 Podsumowanie ...........................................................................149
Rozdział 4
Nowe widżety . ................................................................151
Receptura: wyświetlanie kalendarza w aplikacji Android .......................................151 Receptura: wyświetlanie i wybieranie liczb za pomocą widżetu NumberPicker .....................................................................154 Receptura: tworzenie stosu obrazów za pomocą widżetu StackView ...........................................................................160 Receptura: wyświetlanie listy opcji za pomocą widżetu ListPopupWindow .........................................165 Receptura: sugerowanie opcji za pomocą widżetu PopupMenu ........170 Podsumowanie ...........................................................................172
Część II Rozdział 5
Zarządzanie zawartością ..................................175 Schowek systemowy oraz operacja przeciągnij i upuść ......177 Receptura: operacja przeciągnij i upuść ........................................177 Receptura: przeciąganie i upuszczanie tekstu ................................179 Receptura: przeciąganie i upuszczanie obrazów .............................188 Receptura: wycinanie, kopiowanie i wklejanie tekstu przy wykorzystaniu schowka systemowego ..................................198 Podsumowanie ...........................................................................202
Rozdział 6
Powiadomienia oraz intencje oczekujące . ........................205 Receptura: intencje oczekujące ....................................................205 Receptura: rozgłaszanie intencji ...................................................207 Receptura: system powiadomień systemu Android .........................214 Receptura: tworzenie powiadomień ...............................................215
Spis treści Receptura: wykorzystanie klasy Notification.Builder .......................216 Receptura: pozyskiwanie obiektu klasy NotificationManager ...........218 Receptura: tworzenie powiadomienia i wykorzystywanie intencji oczekującej w celu rozpoczęcia aktywności .................................218 Podsumowanie ...........................................................................222
Rozdział 7
Ładowarki . ......................................................................225
Receptura: ładowarki ........................................................................................225 Receptura: dostawca treści ...............................................................................226 Receptura: zastosowanie klasy CursorLoader w celu uzyskania dostępu do informacji przechowywanych przez dostawcę treści Contacts .........................................................................228 Receptura: Tworzenie niestandardowego dostawcy treści ....................................233 Receptura: wyświetlanie informacji z niestandardowego dostawcy treści ..................................................................243 Receptura: aktualizowanie i usuwanie informacji przechowywanych w niestandardowym dostawcy treści Podsumowanie ...........................................................................252
Część III Techniki multimedialne ....................................255 Rozdział 8
Animacje . .......................................................................257 Receptura: typy animacji ..............................................................257 Receptura: korzystanie z klasy ValueAnimator ...............................259 Receptura: wykorzystanie klasy ObjectAnimator do animowania widoków ............................................................267 Receptura: uruchamianie wielu animacji za pomocą klasy AnimatorSet ....................................................273 Receptura: animacja poklatkowa ..................................................279 Receptura: animacja generująca klatki pośrednie ..........................283 Korzystanie z klasy AlphaAnimation .........................................287 Korzystanie z klasy TranslateAnimation ...................................287 Korzystanie z klasy RotateAnimation .......................................288 Korzystanie z klasy ScaleAnimation .........................................289 Receptura: zastosowanie animacji układu .....................................293 Receptura: gromadzenie i wyświetlanie sekwencji animacji za pomocą klasy AnimationSet ...................................................301 Podsumowanie ...........................................................................306
Rozdział 9
Sprzętowa akceleracja grafiki 2D . ...................................309 Receptura: akceleracja sprzętowa ................................................309 Receptura: korzystanie z warstw widoku ........................................313 Receptura: poprawa wydajności aplikacji opartych na grafice przy wykorzystaniu klasy SurfaceView .........................................317 Receptura: zastosowanie transformacji z wykorzystaniem klasy TextureView ...........................................323 Podsumowanie ...........................................................................326
7
8
Android na tablecie. Receptury
Rozdział 10 Tworzenie i renderowanie grafiki . .....................................327 Receptura: interfejsy API wymagane dla grafiki ..............................327 Receptura: tworzenie i renderowanie prostokąta przy użyciu OpenGL ...................................................................328 Receptura: zastosowanie kolorów wieloodcieniowych .....................334 Receptura: rotacja grafiki .............................................................337 Receptura: skalowanie grafiki ......................................................342 Receptura: przesuwanie grafiki .....................................................346 Podsumowanie ...........................................................................349
Rozdział 11 Przechwytywanie audio, wideo i obrazów . ........................351 Receptura: przechwytywanie obrazu z wykorzystaniem wbudowanej intencji ........................................351 Receptura: przechwytywanie obrazu za pomocą kodu Java . .................................................356 Receptura: nagrywanie audio z wykorzystaniem wbudowanej intencji ........................................362 Receptura: klasa CamcorderProfile ...............................................365 Receptura: klasa MediaRecorder i jej metody ................................372 Receptura: nagrywanie audio z wykorzystaniem kodu Java ..............373 Receptura: nagrywanie wideo za pomocą wbudowanej intencji ........379 Receptura: nagrywanie wideo z użyciem kodu Java .........................382 Podsumowanie ...........................................................................389
Część IV Interfejs sieciowy i sprzętowy ...........................391 Rozdział 12 Łączność bezprzewodowa . ...............................................393 Receptura: wiązanie ze sobą dwóch urządzeń Bluetooth .................393 Receptura: ręczne przesyłanie plików z jednego urządzenia na drugie z wykorzystaniem technologii Bluetooth ........................397 Receptura: łączenie w parę urządzenia Bluetooth z komputerem z systemem Windows ..........................................399 Receptura: włączanie lokalnego urządzenia Bluetooth ....................400 Receptura: wyświetlanie listy powiązanych urządzeń ......................405 Receptura: przesyłanie plików za pomocą technologii Bluetooth ......410 Receptura: standard Wi-Fi ............................................................412 Receptura: włączanie i wyłączanie Wi-Fi .........................................414 Receptura: Wi-Fi Direct ................................................................418 Podsumowanie ...........................................................................423
Rozdział 13 Rdzenie i wątki . ..............................................................425 Receptura: użyteczność architektury procesorów wielordzeniowych ...425 Receptura: użyteczność procesów odzyskiwania pamięci ................426 Receptura: wątki .........................................................................429 Receptura: używanie wielu wątków ...............................................432 Receptura: korzystanie z klasy AsyncTask .....................................437 Podsumowanie ...........................................................................442
Spis treści
Rozdział 14 Klawiatury i sensory . .......................................................443 Receptura: zmiana klawiatury i metody wprowadzania danych w systemie Android ...................................................................443 Receptura: sensory .....................................................................445 Receptura: lista sensorów obsługiwanych przez urządzenie ............448 Receptura: korzystanie z akcelerometru ........................................450 Receptura: korzystanie z czujnika zbliżeniowego ............................455 Receptura: korzystanie z żyroskopu ..............................................458 Podsumowanie ...........................................................................461
Część V
Eksploracja sieci WWW ....................................463
Rozdział 15 JSON . .............................................................................465 Receptura: JSON .........................................................................465 Receptura: wykorzystywanie obiektu JSONObject do przechowywania informacji ....................................................468 Receptura: zagnieżdżanie obiektów JSONObject ............................471 Receptura: korzystanie z tablicy JSONArray ...................................473 Receptura: korzystanie z klas JsonReader oraz JsonWriter .............478 Receptura: wykorzystywanie usług sieciowych JSON w aplikacjach Android ................................................................483 Podsumowanie ...........................................................................488
Rozdział 16 Klasa WebView . ..............................................................489 Receptura: klasa WebView i jej metody ..............................................................489 Receptura: wyświetlanie stron WWW za pomocą kontrolki WebView ....................................................491 Receptura: korzystanie z klasy WebViewClient ...............................496 Receptura: korzystanie z klasy WebViewFragment ..........................499 Podsumowanie ...........................................................................507
Część VI Zaawansowane techniki systemu Android .........509 Rozdział 17 Obsługa małych ekranów . ................................................511 Receptura: czynniki decydujące o obsłudze różnych ekranów i gęstości .......................................511 Receptura: zapewnianie obsługi dla różnych wersji platformy ...............................513 Receptura: wykorzystanie pakietu Android Support Library do zapewnienia obsługi starszych wersji systemu ...............................................518 Receptura: dostosowywanie aplikacji do orientacji ekranu za pomocą kotwiczenia kontrolek ......................................................................524 Receptura: obsługa orientacji ekranu przy użyciu alternatywnych układów ............................................528 Podsumowanie ...........................................................................532
9
10
Android na tablecie. Receptury
Rozdział 18 Widżety ekranu głównego . ...............................................535 Receptura: widżety aplikacji oraz widżety ekranu głównego .............535 Receptura: metody cyklu życia widżetu aplikacji .............................538 Receptura: tworzenie widżetów ekranu głównego ...........................539 Receptura: aktualizowanie widżetu ekranu głównego za pomocą kontrolki Button .......................................................547 Receptura: zastosowanie klasy AlarmManager do częstej aktualizacji widżetu ekranu głównego ..........................551 Podsumowanie ...........................................................................554
Rozdział 19 Android Beam . ................................................................555 Receptura: standard NFC .............................................................555 Receptura: znaczniki NFC .............................................................556 Receptura: struktura wykorzystywana do wymiany informacji za pomocą znaczników NFC ........................557 Receptura: odczytywanie danych ze znaczników NFC ......................560 Receptura: zapisywanie danych do znacznika NFC ............................566 Receptura: korzystanie z funkcji Android Beam ..............................570 Receptura: przesyłanie danych za pomocą funkcji Android Beam .....571 Podsumowanie ...........................................................................575
Rozdział 20 Analityka i śledzenie aplikacji . .........................................577 Receptura: analizowanie i śledzenie aplikacji .................................577 Receptura: wykorzystanie biblioteki EasyTracker do śledzenia aplikacji Android ....................................................578 Receptura: wykorzystanie narzędzia GoogleAnalytics do śledzenia aplikacji Android ....................................................587 Podsumowanie ...........................................................................589
Skorowidz. .......................................................................591
O autorze B.
M. Harwani jest założycielem i właścicielem uczelni Microchip Computer Education (MCE), której siedziba mieści się w mieście Ajmer, w Indiach. Uczelnia prowadzi szkolenia komputerowe z zakresu programowania oraz projektowania stron WWW. Ukończył Uniwersytet w Pune z tytułem magistra inżyniera i uzyskał dyplom magistra technologii komputerowych na wydziale Elektroniki i Akredytacji Kursów Komputerowych (DOEACC), katedrze podległej indyjskiemu ministerstwu ds. komunikacji i technologii. Autor działa na polu edukacji od ponad dziewiętnastu lat, dzięki czemu mógł rozwinąć sztukę tłumaczenia nawet najbardziej skomplikowanych tematów w prosty i zrozumiały sposób. Napisał kilka książek, wśród nich Android Programming Unleashed (Sams Publishing), i od siedemnastu lat prowadzi kursy programowania. Aby dowiedzieć się więcej o autorze, odwiedź jego blog: http://bmharwani.com/blog.
12
Android na tablecie. Receptury
Wstęp A
ndroid jest dostarczoną przez firmę Google bezpłatną platformą na licencji open source, opartą na języku Java, która przeznaczona jest dla urządzeń mobilnych. Tablety z dnia na dzień zyskują coraz większą popularność. Gadżety te plasują się pomiędzy smartfonami i komputerami osobistymi. Mają procesory szybsze niż smartfony, ale mniejszą moc obliczeniową niż komputery. Są lekkie i poręczne. Na tablecie możesz oglądać filmy, słuchać muzyki, surfować w Internecie, wykonywać połączenia telefoniczne przez sieć Wi-Fi, czytać dokumenty elektroniczne, grać i uruchamiać różne aplikacje. Tablet Android jest posiadającym ekran dotykowy urządzeniem mobilnym, które jest obsługiwane przez system operacyjny Android. Google przyczyniła się do rozwoju tabletów z systemem Android, wydając pakiet Android 3.0 SDK. W rzeczywistości pakiet Android 3.0 SDK został zaprojektowany ze specjalnym uwzględnieniem tabletów (czyli urządzeń o większych ekranach). Wydanie pakietu Android 3.0 SDK zmusiło producentów na całym świecie do produkcji tabletów Android. W miarę zapełniania rynku tabletami Android, programiści coraz chętniej zajmują się przygotowywaniem aplikacji przeznaczonych na te urządzenia. Duży nacisk na rozwój aplikacji na tablety z systemem Android zainspirował mnie do napisania tej książki.
Kto powinien przeczytać tę książkę? Jak każda dobra książka, również ta pozycja dostarcza łatwych do ponownego wykorzystania kodów przeznaczonych do rozwiązywania rzeczywistych problemów i skierowanych do średnio zaawansowanych i zaawansowanych użytkowników. Zakres tematyczny tej książki obejmuje podstawowe i złożone problemy, które zazwyczaj napotykają na swojej drodze programiści. Książka ta będzie przydatna zarówno dla programistów, jak i instruktorów, którzy chcą nauczyć się programowania aplikacji na tablety Android lub przekazać tę wiedzę innym. Mówiąc w skrócie, jest to podręcznik przydatny dla każdego, kto chce zrozumieć wszystkie kluczowe aspekty programowania aplikacji na tablety Android i znaleźć szybkie rozwiązania różnych krytycznych problemów, które pojawiają się podczas przygotowywania aplikacji Android.
14
Android na tablecie. Receptury
Kluczowe tematy omówione w tej książce Książka jest kompleksowym opracowaniem, w którym każdy temat został omówiony bardzo szczegółowo. Oto tematy kluczowe. Aktywności i cykl życia aktywności w systemie Android. Uruchamianie aktywności za pomocą intencji oraz przekazywanie danych
z jednej aktywności do drugiej. Wyświetlanie i używanie fragmentów ListFragment, DialogFragment
oraz PreferenceFragment. Tworzenie paska akcji z zakładkami i rozwijanymi listami opcji. Tworzenie niestandardowych dostawców treści. Korzystanie z animacji poklatkowej oraz animacji generującej klatki pośrednie. Korzystanie z sensorów, takich jak akcelerometr, czujnik zbliżeniowy i żyroskop. Zastosowanie formatu JSON do zarządzania formatami wymiany danych. Włączanie i wyłączanie modułu Wi-Fi oraz korzystanie z Wi-Fi Direct. Korzystanie z klasy RemoteViews oraz tworzenie i aktualizacja widżetów ekranu
głównego. Tworzenie i renderowanie grafiki za pomocą OpenGL. Wycinanie, kopiowanie i wklejanie tekstu z wykorzystaniem schowka
systemowego. Czytanie i zapisywanie znaczników NFC. Przesyłanie danych za pomocą funkcji Android Beam. Stosowanie do grafiki kolorów wieloodcieniowych oraz rotacji, skalowania
i przesunięcia. Przechwytywanie obrazu, audio i wideo za pomocą wbudowanej intencji
oraz kodu Java. Wykorzystywanie narzędzi EasyTracker Library oraz Google Analytics
Singleton do śledzenia aplikacji Android. Książka ta jest w całości zaktualizowana pod kątem najnowszego systemu Jelly Bean 4.2.
Główne korzyści oferowane przez tę książkę Po lekturze tej książki będziesz dobrze znał wymienione niżej pojęcia. Dodawanie i usuwanie fragmentów podczas zmiany orientacji urządzenia. Implementowanie komunikacji pomiędzy fragmentami. Wyświetlanie w pasku akcji elementów akcji, widoków akcji oraz podmenu. Tworzenie stosu obrazów za pomocą klasy StackView.
Jak podzielona jest książka? Wyświetlanie listy opcji za pomocą klas ListPopupWindow i PopupMenu. Przeciąganie i upuszczanie tekstu oraz obrazów. Tworzenie i używanie powiadomień. Tworzenie intencji oczekującej i używanie jej do uruchamiania aktywności. Wykorzystywanie ładowarek w celu uzyskiwania dostępu do informacji. Używanie klas ValueAnimator i ObjectAnimator do animowania widoków. Implementowanie wielu animacji za pomocą klasy AnimatorSet. Stosowanie animacji układu. Stosowanie przyspieszenia sprzętowego w celu zwiększenia wydajności
graficznej systemu. Wykorzystywanie warstw widoku oraz klasy SurfaceView w celu zwiększenia
wydajności graficznej aplikacji. Stosowanie transformacji za pomocą klasy TextureView. Przesyłanie plików za pomocą technologii Bluetooth. Używanie wątków i wielu wątków jednocześnie. Wykorzystywanie klas WebView, WebViewClient oraz WebViewFragment
do wyświetlania stron WWW. Obsługa różnych wersji platformy. Obsługa starszych wersji systemu Android. Dostosowywanie aplikacji do różnych orientacji ekranu. Różnice pomiędzy aplikacjami przeznaczonymi na tablety Android i telefony
Android. Przenoszenie aplikacji pomiędzy telefonami z niewielkimi ekranami a tabletami.
Jak podzielona jest książka? Książka jest podzielona na sześć części. Część I: Techniki interfejsu użytkownika
W rozdziale 1., „Przegląd aplikacji na tablety z systemem Android”, przeczytasz o rozmiarach i funkcjach różnych tabletów Android. Nauczysz się także tworzyć wirtualne urządzenia Android i poznasz strukturę katalogową projektów Android. Ponadto dowiesz się, czym są aktywności i cykl życia aktywności w systemie Android. Nauczysz się uruchamiać aktywność za pomocą intencji oraz przekazywać dane z jednej aktywności do drugiej. Rozdział 2., „Fragmenty”, koncentruje się na koncepcji fragmentów. Podczas jego lektury zapoznasz się z cyklem życia fragmentu oraz procedurą tworzenia
15
16
Android na tablecie. Receptury
fragmentów pierwszego planu. Poznasz również różnicę pomiędzy fragmentami pierwszego planu oraz fragmentami w tle oraz dowiesz się, jak dodawać i usuwać fragmenty przy zmianie orientacji urządzenia. Zobaczysz, w jaki sposób fragmenty są obsługiwane przez klasy FragmentManager i FragmentTransaction. Ponadto nauczysz się tworzyć fragmenty dynamicznie w trakcie działania aplikacji oraz implementować komunikację pomiędzy fragmentami. Na koniec prześledzisz procedury wyświetlania opcji za pomocą fragmentu ListFragment, wyświetlania okien dialogowych przy użyciu fragmentu DialogFragment oraz ustawiania preferencji użytkownika z wykorzystaniem fragmentu PreferenceFragment. Rozdział 3., „Paski akcji w działaniu”, poświęcony jest zastosowaniu pasków akcji w aplikacjach Android. Czytając go, dowiesz się, jaka jest różnica pomiędzy menu a paskiem akcji. Nauczysz się przełączać widoczność paska akcji, poznasz jego różne komponenty oraz prześledzisz procedurę wyświetlania elementów akcji w pasku akcji. Nauczysz się wyświetlać w pasku akcji widoki akcji oraz podmenu. Na koniec zobaczysz, jak w pasku akcji tworzy się zakładki oraz rozwijaną listę opcji. Rozdział 4., „Nowe widżety”, to omówienie działania nowych widżetów. Nauczysz się, jak wyświetlić kalendarz w aplikacji Android, wyświetlać i wybierać liczby za pomocą widżetu NumberPicker i tworzyć stos obrazów przy użyciu widżetu StackView. Ponadto dowiesz się, jak wyświetlać listę opcji, wykorzystując widżety ListPopupWindow i PopupMenu. Część II: Zarządzanie zawartością
W rozdziale 5., „Schowek systemowy oraz operacja przeciągnij i upuść”, nauczysz się, jak przeciągać i upuszczać tekst oraz obrazy. Ponadto dowiesz się, jak wycinać, kopiować i wklejać tekst, wykorzystując schowek systemowy. Czytając rozdział 6., „Powiadomienia oraz intencje oczekujące”, dowiesz się, czym są intencje oczekujące oraz jak intencje są rozgłaszane. Poznasz także system powiadomień Androida. Nauczysz się tworzyć powiadomienia, korzystać z klasy Notification.Builder oraz uzyskiwać obiekt klasy NotificationManager. Na koniec będziesz tworzył powiadomienia i wykorzystywał intencję oczekującą w celu uruchomienia aktywności. Rozdział 7., „Ładowarki”, poświęcony jest koncepcji ładowarek. Tu dowiesz się również, czym są dostawcy treści i jak korzystać z ładowarki CursorLoader w celu uzyskania dostępu do informacji zawartych w dostawcy treści kontaktów. Na koniec nauczysz się tworzyć własnych niestandardowych dostawców treści. Część III: Techniki multimedialne
W rozdziale 8., „Animacje”, poznasz różne typy animacji. Nauczysz się korzystać z klas ValueAnimator i ObjectAnimator przy animowaniu widoków. Dowiesz się, jak implementować wiele animacji za pomocą klasy AnimatorSet. Ponadto zapoznasz się z animacją poklatkową i animacją generującą klatki
Jak podzielona jest książka?
pośrednie. Nauczysz się stosować animację układu oraz poznasz procedurę gromadzenia i sekwencyjnego uruchamiania aplikacji za pomocą klasy AnimationSet. W rozdziale 9., „Sprzętowa akceleracja grafiki 2D”, nauczysz się korzystać z przyspieszenia sprzętowego. Dowiesz się, jak używać warstw widoku i zwiększać wydajność aplikacji opartych na grafice, wykorzystując klasę SurfaceView. Na koniec nauczysz się stosować transformacje za pomocą klasy TextureView. Rozdział 10., „Tworzenie i renderowanie grafiki”, to objaśnienie różnych interfejsów API, które są wymagane do wyświetlania grafiki. Nauczysz się tworzyć i renderować prostokąt, wykorzystując OpenGL. Poznasz także różnicę pomiędzy kolorowaniem wierzchołka i oświetleniem. Ponadto nauczysz się stosować w grafice kolory wieloodcieniowe oraz rotację, skalowanie i przesunięcie. Rozdział 11., „Przechwytywanie audio, wideo i obrazów”, poświęcony jest technice przechwytywania obrazu za pomocą wbudowanej intencji oraz kodu Java. Podczas jego lektury nauczysz się nagrywać dźwięk i wideo, wykorzystując intencję i kod Java, oraz poznasz klasy CamcorderProfile i MediaRecorder wraz z ich metodami. Część IV: Interfejs sieciowy i sprzętowy
Rozdział 12., „Łączność bezprzewodowa”, koncentruje się na ustanawianiu bezprzewodowych połączeń pomiędzy urządzeniami. Nauczysz się, w jaki sposób powiązać dwa urządzenia z obsługą Bluetooth, ręcznie przesyłać pliki z jednego urządzenia na drugie z wykorzystaniem technologii Bluetooth oraz powiązać urządzenie z obsługą Bluetooth z komputerem na platformie Windows. Dowiesz się także, jak włączyć lokalne urządzenie Bluetooth, wyświetlić listę powiązanych urządzeń oraz przesyłać pliki za pomocą technologii Bluetooth. Na koniec zapoznasz się z koncepcją Wi-Fi, dowiesz się, jak włączyć i wyłączyć moduł Wi-Fi oraz poznasz zastosowanie Wi-Fi Direct. Z rozdziału 13., „Rdzenie i wątki”, dowiesz się, jaka jest użyteczność architektury procesorów wielordzeniowych. Poznasz zastosowanie mechanizmu odzyskiwania pamięci. Przeczytasz także o wątkach oraz wielu równoczesnych wątkach. Na koniec nauczysz się stosować klasę AsyncTask. W rozdziale 14., „Klawiatury i sensory”, dowiesz się, jak zmienić w systemie Android klawiatury i metody wprowadzania danych. Nauczysz się, czym są sensory i jak wyświetlać listę sensorów obsługiwanych przez dane urządzenie. Na koniec poznasz sposób korzystania z sensorów, takich jak akcelerometr, czujnik zbliżeniowy oraz żyroskop. Część V: Eksploracja sieci WWW
W rozdziale 15., „JSON”, poznasz koncepcję formatu JSON. Nauczysz się korzystać z obiektu JSONObject, zagnieżdżać obiekty JSONObject oraz stosować tablicę JSONArray do przechowywania informacji. Ponadto nauczysz się używać klas JsonReader i JsonWriter.
17
18
Android na tablecie. Receptury
W rozdziale 16., „Klasa WebView”, nauczysz się, jak wyświetlać strony WWW za pomocą klasy WebView. Ponadto skorzystasz z klasy WebViewClient oraz fragmentu WebViewFragment. Część VI: Zaawansowane techniki systemu Android
W rozdziale 17., „Obsługa małych ekranów”, przeczytasz o czynnikach związanych z obsługą różnych ekranów i gęstości. Dowiesz się, w jaki sposób w aplikacjach Android obsługiwane są różne wersje platformy oraz jak pakiet Support Library jest wykorzystywany do obsługi starszych wersji systemu Android. Nauczysz się adaptować aplikacje do orientacji ekranu za pomocą kotwiczenia kontrolek. Ponadto nauczysz się definiować alternatywne układy dla obsługi orientacji ekranu. W rozdziale 18., „Widżety ekranu głównego”, poznasz klasę RemoteViews, widżety aplikacji oraz widżety ekranu głównego. Przeczytasz o metodach cyklu życia widżetów aplikacji. Ponadto nauczysz się tworzyć widżety ekranu głównego i aktualizować je za pomocą kontrolki Button. Na koniec dowiesz się, jak aktualizować widżety ekranu głównego za pomocą klasy AlarmManager. W rozdziale 19., „Android Beam”, przeczytasz o standardzie NFC (ang. Near Field Communication) i roli znaczników NFC. Poznasz także struktury wykorzystywane przy wymianie danych za pomocą znaczników NFC oraz dowiesz się, jak odczytywać i pisać znaczniki NFC. Na koniec zapoznasz się z funkcją Android beam i nauczysz się przesyłać pliki z jej wykorzystaniem. W rozdziale 20., „Analityka i śledzenie aplikacji”, zapoznasz się z koncepcją analizowania i śledzenia aplikacji. Nauczysz się wykorzystywać narzędzia EasyTracker Library i Google Analytics Singleton do śledzenia aplikacji Android.
Przykłady kodu dla tej książki Wszystkie receptury Android omówione w tej książce możesz pobrać ze strony wydawnictwa Helion, pod adresem www.helion.pl/ksiazki/antare.htm. Po pobraniu rozpakuj paczkę z kodami i wykonaj wymienione poniżej czynności, aby wykorzystać dostarczone kody. Uruchom środowisko Eclipse. Wybierz z menu opcję File/Import (plik/importuj). W wyświetlonym oknie
dialogowym Import wybierz Existing Android Code Into Workspace (istniejący kod Android do przestrzeni roboczej) i kliknij przycisk Next (dalej). W kolejnym oknie dialogowym kliknij przycisk Browse (przeglądaj), aby
zlokalizować i wybrać folder, do którego rozpakowałeś paczkę z kodami.
Założenia
Po wybraniu paczki z kodami wszystkie zawarte w niej projekty Android
pojawią się na liście w oknie Import Projects (importuj projekty). Domyślnie wszystkie projekty będą zaznaczone. Możesz usunąć zaznaczenie projektu lub projektów, których nie chcesz importować. Następnie kliknij przycisk Finish (zakończ) i gotowe. Projekty zostaną zaimportowane do środowiska Eclipse i będą gotowe do uruchomienia.
Założenia We wszystkich recepturach przedstawionych w tej książce przyjęto trzy następujące założenia. Jeśli nie określono inaczej, atrybuty android:minSdkVersion
i android:targetSdkVersion wszystkich aplikacji z tej książki mają odpowiednio wartości 11 i 17. Interfejsy API poziomu 11. i 17. odnoszą się odpowiednio do systemów Android 3.0 (Honeycomb) i Android 4.2 (Jelly Bean). Oznacza to również, że aplikacje z tej książki wymagają do uruchomienia co najmniej API poziomu 11. Ponadto aplikacje te zostały skompilowane i przeznaczone do uruchomienia na API poziomu 17. Założono, że w folderze res/values utworzony został plik XML dimens.xml
zawierający następujący kod:
14sp
Założono, że w folderze res utworzone zostały dwa foldery: values-sw600dp
i values-sw720dp. Ponadto do tych dwóch folderów powinien zostać skopiowany plik dimens.xml z folderu res/values. W celu dopasowania aplikacji do ekranów tabletów 7-calowych i 10-calowych zasób wymiarów text_size w pliku dimens.xml z folderów values-sw600dp i values-sw720dp powinien zostać zmodyfikowany odpowiednio wartościami 24sp i 32sp. Więcej informacji na ten temat znajdziesz w podrozdziale „Receptura: zapewnianie kompatybilności aplikacji z telefonami i tabletami z systemem Android”, w rozdziale 1.
19
20
Android na tablecie. Receptury
Część I Techniki interfejsu użytkownika
1 Przegląd aplikacji na tablety z systemem Android P
akiet Android 3.0 SDK został zaprojektowany i opublikowany z myślą o tabletach. To SDK wprowadza kilka nowych funkcji oferujących obsługę urządzeń z panoramicznym ekranem. Do tych funkcji należą zoptymalizowany pod kątem tabletów interfejs użytkownika, obsługa procesorów wielordzeniowych, usprawniona wielozadaniowość oraz zaawansowane opcje przeglądarki internetowej. Ten rozdział poświęcony jest funkcjom tabletów z systemem Android, omówione w nim zostaną różnice pomiędzy telefonami Android i tabletami Android oraz procedury implementowania w aplikacjach telefonicznych kompatybilności z tabletami Android. W trakcie lektury tego rozdziału zapoznasz się ze strukturą projektu Android. Ponadto przygotujesz aktywności i zapoznasz się z cyklem życia aktywności w systemie Android. Na koniec dowiesz się, jak rozpocząć aktywność, wykorzystując intencję, oraz jak przekazywać dane z jednej aktywności do drugiej.
Receptura: wprowadzenie do tabletów z systemem Android Rozmiary tabletów zazwyczaj wahają się od 7 do 12 cali przekątnej ekranu. Na rynku dostępnych jest wiele różnych tabletów, takich jak Google Nexus 7, Google Nexus 10, Samsung Galaxy Note 10.1, Toshiba AT300, Amazon Kindle Fire HD, Asus Transformer Pad 300 oraz Samsung Galaxy Tab 8.9. W naszej dyskusji skupimy się na tabletach produkowanych przez Google, czyli Google Nexus 7 oraz Google Nexus 10. Google Nexus 7 (patrz rysunek 1.1) to tablet firmy Google. Wyprodukowany został we współpracy z firmą Asus, dostawcą sprzętu komputerowego klasy ekonomicznej. Jest to tablet o przekątnej 7 cali oraz interfejsie użytkownika zorganizowanym na wzór telefonu. Tablet ten wykorzystuje nowy układ zaprojektowany dla 7-calowych urządzeń tego typu. Oto kilka jego cech.
24
Rozdział 1. Przegląd aplikacji na tablety z systemem Android
Rysunek 1.1. Google Nexus 7 (po lewej) oraz Google Nexus 10 (po prawej) Wymiary 198,5×120×10,5 mm. Rozdzielczość 800×1200 pikseli. Wielodotykowy wyświetlacz chroniony taflą Corning Glass. Wydajny i niezawodny system operacyjny Android 4.1 Jelly Bean. Cena waha się od 800 do 900 zł (w zależności od wybranego modelu),
co znaczy, że tablet ten to niedrogie urządzenie. Ekran ma gęstość tvdpi, zatem otrzymujemy oczekiwany rozmiar interfejsu
użytkownika (ang. user interface — UI) w odpowiedniej odległości. Ponadto bitmapy mogą być z łatwością skalowane bez zwracania uwagi użytkownika. Oznaczenie tvdpi reprezentuje charakterystyczną dla telewizorów gęstość pikseli i umożliwia podgląd aplikacji androidowych na telewizorze bez efektu rozmazania obrazu. Aplikacje prezentują się znacznie lepiej na ekranach z gęstością tvdpi niż na ekranach innych 7-calowych tabletów z gęstością mdpi. Potężny, czterordzeniowy procesor Tegra, który zapewnia doskonałe efekty
wizualne w grach. Obsługa sieci 2G i 3G oraz zapewniona łączność w standardach Wi-Fi 802.11 b/g/n,
Bluetooth i NFC. Wersje o pojemności pamięci trwałej 8 GB i 16 GB.
Google Nexus 10 został wyprodukowany przez firmę Google we współpracy z Samsungiem (patrz rysunek 1.1). Jak sugeruje nazwa, tablet ten wyposażony został w 10-calowy wyświetlacz. Oto kilka cech tabletu Google Nexus 10. Czterordzeniowy procesor zapewniający wysoką wydajność. Wysoka rozdzielczość ekranu oraz format 16:9. Najnowsza wersja systemu operacyjnego Android 4.2 Jelly Bean.
Receptura: różnice pomiędzy telefonami Android a tabletami Android
Obsługa Wi-Fi oraz do wyboru 16 GB lub 32 GB pamięci trwałej (w zależności
od modelu). Cena około 1800 zł dla modelu 16 GB lub około 2000 zł dla modelu 32 GB.
Więcej informacji na temat tabletów z serii Google Nexus znajdziesz na stronie www.google.com/nexus/#/features.
Receptura: różnice pomiędzy telefonami Android a tabletami Android Pierwszą różnicą pomiędzy telefonami a tabletami z systemem Android jest rozmiar ekranu. Większość ekranów telefonicznych mierzy od 3 do 5 cali, podczas gdy w przypadku tabletów rozpiętość ta sięga od 7 do 12 cali. Drugą różnicę stanowi rozdzielczość ekranu wyrażona w pikselach. Rozdzielczość pikselowa (ang. pixel resolution) to całkowita liczba pikseli wyświetlana na ekranie. Oto rozdzielczości pikselowe telefonów i tabletów. Telefony mają zazwyczaj rozdzielczość 800×400. Tablety 7-calowe mają zazwyczaj rozdzielczość 1024×600. Tablety 10-calowe mają zazwyczaj rozdzielczość 1280×800.
Gęstość (ang. density), czyli inaczej liczba pikseli w określonym obszarze ekranu, stanowi trzecią różnicę pomiędzy tabletami a telefonami. Rozmiar pozostaje ten sam, kiedy liczba pikseli oraz gęstość rosną jednocześnie. Załóżmy, że ekran 1. ma rozmiar 100×100 pikseli, a ekran 2. ma rozmiar 150×150 pikseli. Rozmiary te będą równe, jeśli gęstość ekranu 2. będzie stanowiła 1,5 gęstości ekranu 1. Ponadto grafika wyświetlana na urządzeniu o podwójnej gęstości będzie sprawiała wrażenie o połowę mniejszej niż na urządzeniu, którego współczynnik gęstości wynosi 1. Urządzenia mogą oferować niską, średnią, wysoką lub ekstrawysoką gęstość. W urządzeniu o średniej gęstości (ang. medium-density — mdpi) mamy 160 pikseli na cal. W urządzeniach o wysokiej gęstości (ang. high-density — hdpi) oraz ekstrawysokiej gęstości (ang. extra-high-density — xhdpi) mamy odpowiednio 240 oraz 320 pikseli na cal. Aby znormalizować rozmiary ekranu, w Androidzie potraktowano mdpi jako gęstość bazową. Oznacza to, że dla urządzeń mdpi 1 dp = 1 piksel, gdzie dp oznacza piksel niezależny od urządzenia (ang. device-independent pixel). Gęstość wszystkich innych urządzeń konwertowana jest na mdpi dla ujednolicenia. Objaśnimy to na następujących przykładach. Rozmiarowi ekranu telefonu Android (mdpi) wynoszącemu 320×480 pikseli
odpowiada 320 dp×480 dp (ponieważ w przypadku urządzeń mdpi 1 piksel = 1 dp). Rozmiarowi ekranu telefonu Android (hdpi) wynoszącemu 480×800 pikseli
odpowiada (480×160/240)×(800×160/240), czyli 320 dp×533 dp.
25
26
Rozdział 1. Przegląd aplikacji na tablety z systemem Android
Rozmiarowi ekranu tabletu Android (xdpi) wynoszącemu 1600×2560 pikseli
odpowiada (1600×160/320)×(2560×160/320), czyli 800 dp×1280 dp. Poniżej zamieszczono formułę przeliczania liczby rzeczywistych pikseli fizycznych (px) na jednostki niezależne od urządzenia (dp): dp = px×(gęstość/160) Android kategoryzuje ekrany według następujących rozmiarów: mały, normalny, duży i ekstraduży. Rozmiarom tym odpowiadają następujące wielkości: ekstraduże ekrany mają co najmniej 960 dp×720 dp, duże ekrany mają co najmniej 640 dp×480 dp, normalne ekrany mają co najmniej 470 dp×320 dp, małe ekrany mają co najmniej 426 dp×320 dp.
Rozmiary ekranu telefonu, 7-calowego tabletu i 10-calowego tabletu są określane odpowiednio jako normalny, duży i ekstraduży. Podczas tworzenia aplikacji brana jest pod uwagę szerokość ekranu w celu odpowiedniego rozmieszczenia przycisków kontrolnych interfejsu użytkownika. Oto standardowe szerokości dla telefonów i tabletów: szerokość ekranu telefonu wynosi 320 dp, szerokość ekranu 7-calowego tabletu wynosi 600 dp, szerokość ekranu 10-calowego tabletu wynosi 720 dp.
Receptura: zapewnianie kompatybilności aplikacji z telefonami i tabletami z systemem Android System Android ułatwia tworzenie aplikacji, które działają równie dobrze na szeregu urządzeń o różnych rozmiarach ekranów. Pozwala to przygotować pojedynczą aplikację, która może być szeroko dystrybuowana na wszystkie wymagane urządzenia docelowe. Trzeba jedynie zoptymalizować układy i inne komponenty interfejsu użytkownika dla każdej z docelowych konfiguracji ekranu. Tworząc aplikacje, które mają działać zarówno na telefonach Android, jak i na tabletach Android, zadbaj o następujące rzeczy. Kontrolki interfejsu użytkownika (ang. UI controls) nie powinny być
niepotrzebnie rozciągnięte w celu wypełnienia pustej przestrzeni. Kontrolki układaj w bloki, aby zredukować ich szerokość. Korzystaj z wieloekranowych układów, aby lepiej wykorzystać szersze ekrany.
Używaj fragmentów, tylko wtedy, kiedy jest to konieczne. Definiuj osobne układy dla normalnych, dużych i ekstradużych ekranów.
Receptura: tworzenie urządzeń AVD
Modyfikuj rozmiar czcionki i inne wymiary kontrolek interfejsu użytkownika
według konkretnych układów. Elementy graficzne, ikony oraz inne bitmapy wykorzystywane w danej aplikacji
muszą odpowiadać gęstościom ekranów telefonów i tabletów. Definiując wymiary w plikach XML układu, używaj atrybutów wrap_content,
match_parent lub jednostek dp. Nie definiuj stałych rozmiarów dla kontrolek interfejsu użytkownika. Jeśli trzeba, w pliku AndroidManifest.xml deklaruj element
dp, reprezentuje krótszy z boków ekranu, bez względu na aktualną orientację urządzenia. 14sp 24sp 32sp 14sp , aby określić minimalną szerokość urządzenia, na którym uruchamiana ma być aplikacja. Za pomocą atrybutu android:requiresSmallestWidthDp możesz definiować minimalne następującą instrukcję: 14sp arrayAdpt= new ArrayAdapter (c, R.layout.list_item, products); productsList.setAdapter(arrayAdpt); productsList.setOnItemClickListener(new OnItemClickListener(){ @Override public void onItemClick(AdapterView parent, View v, int position, long id){ myListener.onOptionSelected(((TextView) v).getText().toString()); } }); return vw; } public interface OnOptionSelectedListener { public void onOptionSelected(String message); } @Override public void onAttach(Activity activity) { super.onAttach(activity); try { myListener = (OnOptionSelectedListener) activity; } catch (ClassCastException e) { throw new ClassCastException(activity.toString() + " musisz zaimplementować interfejs OnItemClickListener"); } } } . Fragmentom tym przypisane zostały odpowiednio identyfikatory fragment1 i fragment2. Fragmenty skonfigurowano tak, by odwoływały się do swoich właściwych klas Java za pomocą atrybutu android:name. Pierwszy fragment odwołuje się do swojego pliku klasy Java Fragment1Activity, który został umieszczony w paczce com.androidtablet.foregroundfragmentapp. Orientacja kontenera LinearLayout została ustawiona horyzontalnie (horizontal), więc fragmenty będą wyświetlane obok siebie. Plik aktywności Java musi implementować interfejs OnOptionSelectedListener, dlatego zdefiniuj metodę onOptionSelected(). Przypominamy, że zdefiniowałeś interfejs OnOptionSelectedListener w pliku Fragment1Activity.java. Kod wpisany w pliku aktywności Java ForegroundFragmentAppActivity.java został przedstawiony w listingu 2.6. Listing 2.6. Kod wpisany w pliku aktywności Java ForegroundFragmentAppActivity.java package com.androidtablet.foregroundfragmentapp; import android.app.Activity; import android.os.Bundle; import com.androidtablet.foregroundfragmentapp. Fragment1Activity.OnOptionSelectedListener; public class ForegroundFragmentAppActivity extends Activity implements OnOptionSelectedListener { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_foreground_fragment_app); } arrayAdpt= new ArrayAdapter (c, R.layout.list_item, products); productsList.setAdapter(arrayAdpt); productsList.setOnItemClickListener(new OnItemClickListener(){ @Override public void onItemClick(AdapterView parent, View v, int position, long id){ if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE || large || xlarge){ myListener.onOptionSelected(((TextView) v).getText().toString()); } else { Intent intent = new Intent(getActivity(). getApplicationContext(), DisplayItemActivity.class); intent.putExtra("item", ((TextView) v).getText().toString()); startActivity(intent); } } }); return vw; } public interface OnOptionSelectedListener { public void onOptionSelected(String message); } @Override public void onAttach(Activity activity) { super.onAttach(activity); try { myListener = (OnOptionSelectedListener) activity; } catch (ClassCastException e) { throw new ClassCastException(activity.toString() + " musisz zaimplementować interfejs OnItemClickListener"); } } } w pliku układu aplikacji. Można też definiować je za pomocą kodu w trakcie wykonywania aplikacji. Do tworzenia, dodawania i zastępowania fragmentów dynamicznie wykorzystywana jest klasa FragmentManager. Koncepcję definiowania fragmentów dynamicznie łatwiej można zrozumieć na działającym przykładzie. Utwórz projekt Android o nazwie FragmentsByCodeApp. W tej aplikacji zbudujesz dynamicznie dwa fragmenty: Fragment1 i Fragment2. Fragment o nazwie Fragment1 będzie zawierał widżet wyboru ListView wyświetlający kilka produktów, spośród których należy wybrać. Fragment2 będzie zawierał kontrolkę TextView wyświetlającą produkt wybrany z ListView fragmentu Fragment1. Aby pomieścić oba fragmenty w danej aplikacji, musisz zdefiniować ich odpowiednie kontenery. Zdefiniuj dwa układy FrameLayout jako kontenery obu fragmentów w pliku układu activity_fragments_by_code_app.xml w sposób przedstawiony w listingu 2.11. arrayAdpt= new ArrayAdapter (c, R.layout.list_item, products); productsList.setAdapter(arrayAdpt); productsList.setOnItemClickListener(new OnItemClickListener(){ @Override public void onItemClick(AdapterView parent, View v, int position, long id){ myListener.onOptionSelected(((TextView) v).getText().toString()); } }); return vw; } public interface OnOptionSelectedListener { public void onOptionSelected(String message); } @Override public void onAttach(Activity activity) { super.onAttach(activity); try { myListener = (OnOptionSelectedListener) activity; } catch (ClassCastException e) { throw new ClassCastException(activity.toString() + " musisz zaimplementować interfejs OnItemClickListener"); } } } arrayAdpt = new ArrayAdapter (getActivity(),R.layout.list_item, products); setListAdapter(arrayAdpt); } @Override public void onListItemClick(ListView l, View v, int position, long id) { Fragment2Activity frag = (Fragment2Activity) getFragmentManager().findFragmentById( R.id.fragment2); frag.dispOption(((TextView) v).getText().toString()); } }. Fragmenty zostały ustawione tak, aby odwoływać się do swoich właściwych klas Java za pomocą atrybutu android:name. W pliku aktywności Java ListFragmentAppActivity.java danej aplikacji nie musisz wpisywać żadnego kodu. W tym pliku aktywności pozostawiasz bez zmian domyślny kod, co zostało przedstawione w listingu 2.23. Listing 2.23. Domyślny kod w pliku aktywności Java ListFragmentAppActivity.java package com.androidtablet.listfragmentapp; import android.app.Activity; import android.os.Bundle; public class ListFragmentAppActivity extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_list_fragment_app); } } wyświetlają w PreferenceFragment przycisk Wyślij, który użytkownik klika po wybraniu żądanej preferencji z preferencji widoku, w celu zapisania preferencji lub wykonania innej czynności. Przycisk Wyślij ma przydzielony klucz submitPref, który będzie go identyfikował w kodzie Java. Następnym krokiem jest zdefiniowanie w pliku zasobów strings.xml dwóch tablic, jednej dla wyświetlania tekstu dla przycisków opcji w ListPreference, a drugiej dla przechowywania wartości odpowiednich elementów pierwszej tablicy. Wygląd pliku strings.xml po zdefiniowaniu tych dwóch tablic przedstawiono w listingu 2.30. Listing 2.30. Plik zasobu ciągów strings.xml po zdefiniowaniu dwóch tablic Aplikacja z użyciem klasy PreferenceFragment Ustawienia - Aparat
- Laptop
- Zegarek
- Smartfon
- Telewizor
- Wybrałeś Aparat
- Wybrałeś Laptop
- Wybrałeś Zegarek
- Wybrałeś Smartfon
- Wybrałeś Telewizor
uzyskiwany jest dostęp do przycisku Wyślij zdefiniowanego w pliku preferences.xml, a sam przycisk jest mapowany na obiekt Preference o nazwie submitPref. Procedura obsługi zdarzeń OnPreferenceClickListener jest dodawana do obiektu submitPref. Implementowana jest jego metoda wywołania zwrotnego onPreferenceClick(), która jest wykonywana, kiedy kliknięty zostanie obiekt submitPref. Na koniec w metodzie onPreferenceClick() zamykasz obiekt PreferenceFragment i powracasz do pliku PreferenceFragActivity.java, aby wykonać odpowiednie działania na wybranych preferencjach. Za pomocą pliku aktywności PrefFragmentAppActivity.java będziesz wyświetlał preferencje wybrane przez użytkownika, korzystając z kontrolki TextView. Aby wyświetlić opcje wybrane z widoków preferencji pokazanych we fragmencie PreferenceFragment, musisz zdefiniować w pliku układu activity_pref_fragment.xml cztery kontrolki TextView. Po zdefiniowaniu tych kontrolek plik activity_pref_fragment_app.xml będzie wyglądał tak, jak przedstawiono w listingu 2.32. Listing 2.32. Plik układu activity_pref_fragment_app.xml po dodaniu czterech kontrolek TextView i zagnieździć go wewnątrz elementu akcji, który chcesz powiązać z tym podmenu. Rozważmy sytuację, w której chcesz utworzyć dwa elementy akcji, Utwórz i Zaktualizuj. Kiedy użytkownik kliknie element akcji Utwórz, rozwinięte zostanie podmenu wyświetlające trzy elementy menu: Utwórz fakturę, Utwórz klienta oraz Utwórz produkt. Aby zrozumieć, w jaki sposób definiuje się podmenu dla elementu akcji, utwórz projekt Android o nazwie ActionBarSubmenu. W celu zdefiniowania elementów akcji Utwórz i Zaktualizuj oraz podmenu dla elementu Utwórz w pliku activity_action_bar_submenu.xml znajdującym się w folderze /res/menu wpisz kod przedstawiony w listingu 3.6. Listing 3.6. Kod wpisany w pliku menu activity_action_bar_submenu.xml -
zdefiniowany wewnątrz elementu akcji Utwórz definiuje podmenu składające się z trzech elementów menu: Utwórz fakturę, Utwórz klienta oraz Utwórz produkt. Aby po wybraniu któregoś elementu akcji lub menu wyświetlić odpowiedź, musisz zdefiniować kontrolkę TextView w pliku układu o nazwie activity_action_bar_submenu.xml. Kontrolka TextView będzie wyświetlać tekst wskazujący, które menu akcji lub jaki element akcji zostały wybrane. Po zdefiniowaniu tej kontrolki plik układu activity_action_bar_submenu.xml będzie wyglądał tak, jak przedstawiono w listingu 3.7. -
-
, a atrybut android:checkableBehavior=single jest powiązany z daną grupą, aby zapewnić, że wybrany będzie mógł być tylko jeden element menu w grupie. Z tego względu elementy menu adapter = new ArrayAdapter(this, android.R.layout. simple_spinner_dropdown_item, items); ActionBar actionBar = getActionBar(); actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_LIST); actionBar.setListNavigationCallbacks(adapter, onNavigationItemSelected); adapter = new ArrayAdapter( this, android.R.layout.simple_spinner_dropdown_ item, items); ActionBar actionBar = getActionBar(); actionBar.setNavigationMode(ActionBar.NAVIGATION_ MODE_LIST); actionBar.setListNavigationCallbacks(adapter, onNavigationItemSelected); } OnNavigationListener onNavigationItemSelected = new OnNavigationListener() { @Override public boolean onNavigationItemSelected(int itemPosition, long itemId) { Log.d("Opcja ", String.valueOf(itemId) + " wybrałeś"); return true; } }; } 100dp 200dp 200dp 300dp 300dp 400dp targetArrayList; ArrayAdapter targetAdapter; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_drag_drop_list_app); sourceListView = (ListView)findViewById( R.id.sourcelist); targetListView = (ListView)findViewById( R.id.targetlist); targetLayout = (LinearLayout)findViewById( R.id.targetlayout); sourceListView.setTag("Źródłowa kontrolka ListView"); targetListView.setTag("Docelowa kontrolka ListView"); targetLayout.setTag("Docelowy układ"); sourceListView.setAdapter(new ArrayAdapter( this, R.layout.list_item, food)); sourceListView.setOnItemLongClickListener( sourceListItemLongClickListener); targetArrayList = new ArrayList();(this, R.layout.list_item, targetArrayList); targetListView.setAdapter(targetAdapter); sourceListView.setOnDragListener(dragEventListener); targetLayout.setOnDragListener(dragEventListener); 14sp 100dp 120dp 24sp 140dp 160dp 32sp 180dp 200dp drawables; private ArrayList targetdrawables = new ArrayList (); DragEventListener dragEventListener = new DragEventListener(); TargetAdapter targetAdapter; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_drag_and_drop_image); drawables = new ArrayList(); drawables.add(R.drawable.image1); drawables.add(R.drawable.image2); drawables.add(R.drawable.image3); drawables.add(R.drawable.image4); drawables.add(R.drawable.image5); drawables.add(R.drawable.image6); drawables.add(R.drawable.image7); sourceGridView = (GridView) findViewById( R.id.sourcegrid_view); targetGridView = (GridView) findViewById( R.id.targetgrid_view); sourceGridView.setAdapter(new ImageAdapter()); sourceGridView.setOnItemLongClickListener( sourceGridLongClickListener); sourceGridView.setOnDragListener(dragEventListener); targetGridView.setOnDragListener(dragEventListener); targetAdapter=new TargetAdapter(); targetGridView.setAdapter(targetAdapter); sourceGridView.setTag("Źródłowa kontrolka GridView"); targetGridView.setTag("Docelowa kontrolka GridView"); } OnItemLongClickListener sourceGridLongClickListener = new OnItemLongClickListener() { @Override public boolean onItemLongClick(AdapterView l, View v, int position, long id) { ClipData.Item item = new ClipData.Item(drawables. get(position).toString()); String[] clipDescription = {ClipDescription.MIMETYPE_TEXT_PLAIN}; ClipData dragData = new ClipData((CharSequence) v.getTag(), clipDescription,item); DragShadowBuilder itemShadow = new ShadowBuilder(v); v.startDrag(dragData, itemShadow, drawables. get(position), 0); jest wykorzystywany w pliku manifestu do zarejestrowania danego odbiornika rozgłaszania. Znacznik ten również wyznacza jako odbiorcę intencji klasę ReceiveBroadcastActivity.class, której akcją jest com.androidtablet. broadcastintent. W listingu 6.4 przedstawiono kod z pliku AndroidManifest.xml. Dodane zostały tylko fragmenty kodu zaznaczone pogrubioną czcionką. Reszta to domyślny kod generowany automatycznie przez SDK Androida. Listing 6.4. Kod wpisany w pliku AndroidManifest.xml File pliku AndroidManifest.xml. Nie zapomnij także ustawić wartości atrybutu android:minSdkVersion na 16, ponieważ metoda build() klasy Notification.Builder działa tylko z API poziomu 16. We wcześniejszych poziomach API zamiast metody build() wykorzystywana była metoda getNotification(). Metoda ta została dodana w API poziomu 11. i jest już przestarzała. Poniższa instrukcja zastosowana w pliku AndroidManifest.xml potwierdza, że minimalnym wymaganym poziomem API dla uruchomienia tej aplikacji jest poziom 16., a preferowanym poziomem API, dla którego aplikacja została zaprojektowana jest poziom 17.: loaderCallback = new LoaderManager.LoaderCallbacks()://<ścieżka_danych>/ contactRows=new ArrayList(); final String[] nocontact={"Nie masz żadnych kontaktów w urządzeniu"}; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_access_contacts_app); final ListView contactsList=(ListView) findViewById( R.id.contactslist); Uri contactsUri = Uri.parse("content:// contacts/people"); String[] projection = new String[] {ContactsContract.Contacts._ID, ContactsContract.Contacts.DISPLAY_NAME }; Cursor c; CursorLoader cursorLoader = new CursorLoader(this, contactsUri, projection, null, null, null); c = cursorLoader.loadInBackground(); contactRows.clear(); c.moveToFirst(); while(c.isAfterLast()==false){ String contactID = c.getString(c.getColumnIndex( ContactsContract.Contacts._ID)); String contactDisplayName = c.getString( c.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME)); contactRows.add(contactID+ " "+contactDisplayName); c.moveToNext(); } if (c != null && !c.isClosed()) { c.close(); } if(contactRows.isEmpty()) { ArrayAdapter arrayAdpt=new ArrayAdapter (this, R.layout.list_item, nocontact); contactsList.setAdapter(arrayAdpt); } else { ArrayAdapter arrayAdpt=new ArrayAdapter (this, R.layout.list_item, contactRows); contactsList.setAdapter(arrayAdpt); } } } 18sp 14sp 250dp 100dp 28sp 24sp 400dp 150dp 36sp 32sp 500dp 200dp oraz jego atrybuty android:name i android:authorities są wykorzystywane do zarejestrowania dostawcy treści. Atrybut android:name jest nazwą klasy dostawcy treści, a atrybut android:authorities definiuje bazowy adres URI upoważnienia dostawcy treści. W Twojej aplikacji nazwą klasy dostawcy jest ProductsProvider. Format wykorzystywany do definiowania upoważnienia dostawcy treści jest następujący: com..provider.: { private SimpleCursorAdapter adapter; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.showproduct); String[] columns = new String[] { ProductsProvider.PRODUCT}; int[] toIds = new int[] {R.id.product_name}; getLoaderManager().initLoader(0, null,this); adapter = new SimpleCursorAdapter(this, R.layout.list_item, null, columns, toIds, 0); setListAdapter(adapter); } @Override public Loader onCreateLoader(int id, Bundle args) { String[] projection = new String[] {ProductsProvider.ID, ProductsProvider.PRODUCT, ProductsProvider.PRICE} ; CursorLoader cursorLoader = new CursorLoader(this, ProductsProvider.CONTENT_URI, projection, null, null, null); return cursorLoader; } @Override public void onLoadFinished(Loader loader, Cursor data) { adapter.swapCursor(data); } loader) { adapter.swapCursor(null); } @Override protected void onListItemClick(ListView l, View v, int position, long id) { super.onListItemClick(l, v, position, id); Intent intent = new Intent(this, MaintainProductActivity.class); Uri uri = Uri.parse(ProductsProvider.CONTENT_URI + "/" + id); intent.putExtra(ProductsProvider.CONTENT_ITEM_TYPE, uri); startActivity(intent); } poniższą instrukcję: następującą instrukcję: animacje, aby wskazać listę animacji do odtworzenia. animacje, aby określić zbiór animacji do odtworzenia. 14sp 100dp 120dp 24sp 140dp 160dp 32sp 180dp 200dp 14sp 100dp 120dp 24sp 140dp 160dp 32sp 180dp 200dp 14sp 100dp 120dp 24sp 140dp 160dp 32sp 180dp 200dp arrayAdpt= new ArrayAdapter (getBaseContext(),R.layout.list_item, products); listView.setAdapter(arrayAdpt); } } 14sp 100dp 120dp 24sp 140dp 160dp 32sp 180dp 200dp w pliku AndroidManifest.xml w następujący sposób: w sposób pokazany niżej: w pliku w pliku AndroidManifest.xml po dodaniu atrybutu android:hardwareAccelerated będzie wyglądał następująco: 14sp 100dp 120dp 24sp 140dp 160dp 32sp 180dp 200dp , tak jak pokazano w poniższych instrukcjach. devices = bluetoothAdapter. getBondedDevices(); for (BluetoothDevice device : devices) { textView.append("\n\nWykryto urządzenie: " + device.getName() + "\nAdres MAC: " + device.getAddress()); } } } { @Override protected void onPreExecute() { seqNums.setText("Sekwencja liczb rozpoczęta"); } @Override protected Void doInBackground(Integer... args) { sensorsList = sensorManager.getSensorList(Sensor.TYPE_ALL); accelerometersList = sensorManager.getSensorList(Sensor.TYPE_ACCELEROMETER); listOfSensors = sensorManager. getSensorList(Sensor.TYPE_ALL); ArrayList arrayListSensors = new ArrayList(); for(int i=0; i arrayAdpt= new ArrayAdapter (this, R.layout.list_item, arrayListSensors); sensorsList.setAdapter(arrayAdpt); } } { protected void onPreExecute() {} @Override protected String doInBackground(String... urls) { HttpClient httpclient = new DefaultHttpClient(); StringBuilder builder = new StringBuilder(); HttpPost httppost = new HttpPost(urls[0]); try { HttpResponse response = httpclient.execute(httppost); StatusLine statusLine = response.getStatusLine(); int statusCode = statusLine.getStatusCode(); if (statusCode == 200) { HttpEntity entity = response.getEntity(); InputStream content = entity.getContent(); BufferedReader reader = new BufferedReader(new InputStreamReader(content)); String line; while ((line = reader.readLine()) != null) { builder.append(line); } } } catch (Exception e) { e.printStackTrace(); } return builder.toString(); } protected void onPostExecute(String result) { String state="";0 ) resp.setText(stateInfo); else resp.setText("Niestety, nie znaleziono dopasowania"); } } } zagnieźdź następującą instrukcję: 14sp 200dp 24sp 400dp 32sp 600dp 14sp 200dp 24sp 400dp 32sp 600dp identyfikują najniższy poziom API, z którym kompatybilna jest aplikacja, oraz poziom API, na jakim aplikacja została zaprojektowana, skompilowana i przetestowana. Poniżej zamieszczono przykładowe atrybuty minSdkVersion i targetSdkVersion sugerujące poziomy API wymagane przez aplikację do jej uruchomienia: w pliku AndroidManifest.xml w następujący sposób: w pliku AndroidManifest.xml zostały zmodyfikowane w następujący sposób: w pliku AndroidManifest.xml w następujący sposób: . W definicji widżetu określane są następujące rzeczy. Minimalna szerokość i wysokość widżetu (czyli minimalny obszar, którego wskazuje, że klasą odbiornika jest TimeWidgetProvider. Klasa ta wykorzystuje wewnętrzną klasę usługi UpdateService do aktualizacji widżetu. jest umieszczany w Twojej aktywności, ponieważ właśnie filtry intencji pomagają „systemowi rozsyłania znaczników” określić aplikacje, które mogą obsłużyć dane znaczniki. Na podstawie danych zawartych w znaczniku NFC „system rozsyłania znaczników” określa i wyszukuje aplikacje, które są w stanie obsłużyć zeskanowany znacznik NFC. Aplikacje deklarują filtry intencji, aby poinformować, że będą obsługiwać zeskanowany znacznik i jego dane. Poniżej zamieszczono filtry intencji dla różnych typów danych znacznika. Filtr intencji dla znacznika NFC z typem MIME: , który odwołuje się do kolejnego pliku umieszczonego w folderze /res/xml Twojej aplikacji. Plik tech_filter.xml będzie zawierał listę wszystkich technologii, których szuka Twoja aktywność. Filtr intencji dla znacznika NFC z typem "unknown": UA-xxxxxxxx-y true true true 
