Książki

informatyka

programowanie

Android. Programowanie aplikacji na urządzenia przenośne. Wydanie II

Opis książki Android. Programowanie aplikacji na urządzenia przenośne. Wydanie II:

Wyczerpujący przewodnik, gruntownie zaktualizowany w oparciu o najnowszą wersję Android SDK i najlepsze techniki programowania!

Gdy w 2008 roku Google opublikował Androida, rynkiem telefonów komórkowych wprawdzie nieco zatrzęsło, ale nikt nie spodziewał się, że ta platforma aż tak poważnie zagrozi takim gigantom mobilnych systemów operacyjnych, jak iOS Apple, Windows Mobile, Symbian czy RIM BlackBerry. Od tego czasu każde nowe urządzenie z Androidem miało coraz większe możliwości i było jeszcze bardziej ekscytujące od swoich poprzedników. Minęły zaledwie trzy lata od dnia, kiedy na rynku pojawił się pierwszy telefon z systemem Android - T-Mobile G1, stworzony przez firmę HTC - a system ten już okrzyknięty został najszybciej sprzedającą się platformą dla telefonów przenośnych. To oczywiście nie pozostaje bez echa: potrzeba coraz więcej ludzi specjalizujących się w programowaniu aplikacji na tę fascynującą, darmową i otwartą platformę mobilną.

Oto kompletny podręcznik, zawierający wszystko, co potrzebne do tworzenia, wdrażania i sprzedawania aplikacji na urządzenia przenośne działające pod kontrolą najnowszych wersji Androida. Autorzy - w oparciu o swoje wieloletnie doświadczenie w tworzeniu mobilnych aplikacji - wprowadzą Cię we wszystkie etapy tego procesu: pomysł, projektowanie, pisanie kodu, testowanie, pakowanie i rozpowszechnianie aplikacji. Poznasz doskonale specyfikację platformy Android, podstawowe zasady efektywnego projektowania aplikacji na nią przeznaczonych oraz najlepsze praktyki związane z tworzeniem wygodnych interfejsów użytkownika. Znajdziesz tu także wyczerpujące opisy wszystkich kluczowych interfejsów programistycznych: do obsługi składowania danych, komunikacji sieciowej, obsługi rozmów telefonicznych, usług lokalizacyjnych, multimediów, grafiki 3D oraz opcjonalnych komponentów sprzętowych. Oprócz tego książka została uzupełniona praktycznymi sztuczkami, które pozwolą Ci zaoszczędzić sporo cennego czasu i uniknąć wielu niepotrzebnych pułapek!

Ponadto znajdziesz tu:

kilka rozdziałów opisujących interfejs API do obsługi technologii związanych z WWW, a także Android NDK, poszerzanie zasięgu aplikacji, zarządzanie użytkownikami, synchronizację danych, tworzenie kopii bezpieczeństwa, zaawansowane metody wprowadzania danych
wyczerpujące informacje na temat plików manifestu, dostawców treści, projektowania i testowania aplikacji
prezentację najbardziej aktualnych i interesujących zagadnień, takich jak obsługa komunikacji Bluetooth i gestów, rozpoznawanie mowy, widgety, technologie Live Folders, Live Wallpapers oraz globalne wyszukiwanie
aktualne informacje na temat generowania grafiki 3D przy użyciu OpenGL ES 2.0
zagadnienia związane z zapewnianiem zgodności pomiędzy różnymi urządzeniami

Spis treści: Rozwiń >>

O autorach (23)
Wprowadzenie (25)

Kto powinien przeczytać tę książkę (25)
Kluczowe pytania, na jakie odpowiada ta książka (26)
Struktura książki (27)
Opis zmian wprowadzonych w tym wydaniu książki (28)
Stosowane środowisko programistyczne (30)
Dostępne materiały dodatkowe (30)
Gdzie szukać dodatkowych informacji (30)
Konwencje stosowane w książce (31)
Kontakt z autorami (32)

Część I: Ogólne informacje o platformie Android (33)
Rozdział 1. Prezentacja systemu Android (35)

Krótka historia tworzenia aplikacji dla urządzeń przenośnych (35)
Dawno, dawno temu (35)
"Cegła" (38)
Wireless Application Protocol (WAP) (39)
Zastrzeżone platformy mobilne (42)
Open Handset Alliance (44)
Google staje się bezprzewodowy (44)
Tworzenie Open Handset Alliance (45)
Producenci - projektowanie telefonów dla Androida (46)
Operatorzy - dostarczanie wrażeń (47)
Dostawcy treści - tworzenie aplikacji na Androida (47)
Wykorzystanie wszystkich możliwości Androida (48)
Co wyróżnia platformę Android? (48)
Android - platforma następnej generacji (49)
Darmowy i otwarty (50)
Znane i niedrogie narzędzia programistyczne (51)
Rozsądny stopień trudności nauki programowania (51)
Umożliwianie tworzenia potężnych aplikacji (51)
Bogate i bezpieczne możliwości integracji aplikacji (52)
Brak kosztownych przeszkód utrudniających publikację (52)
"Otwarty rynek" aplikacji (53)
Nowa, rozwijająca się platforma (54)
Platforma Android (54)
Architektura Androida (55)
Bezpieczeństwo i uprawnienia (56)
Pisanie aplikacji na Androida (58)
Podsumowanie (60)
Odwołania i inne źródła informacji (60)

Rozdział 2. Przygotowywanie środowiska programistycznego (61)

Konfiguracja środowiska programistycznego (61)
Konfiguracja własnego systemu do debugowania urządzenia (62)
Konfiguracja urządzenia do testowania (63)
Aktualizacja Android SDK (64)
Problemy z Android SDK (64)
Poznajemy Android SDK (65)
Zrozumienie postanowień licencji (65)
Korzystanie z dokumentacji Android SDK (66)
Prezentacja szkieletu programowania aplikacji (68)
Poznawanie narzędzi Android SDK (69)
Poznawanie aplikacji przykładowych (74)
Podsumowanie (75)
Odwołania i inne źródła informacji (75)

Rozdział 3. Pierwsza aplikacja na Androida (77)

Testowanie środowiska programistycznego (77)
Dodawanie aplikacji Snake do projektu w przestrzeni roboczej Eclipse (78)
Tworzenie wirtualnego urządzenia (AVD) na potrzeby projektu Snake (80)
Tworzenie konfiguracji uruchomieniowej projektu Snake (82)
Uruchamianie aplikacji Snake w emulatorze (84)
Budowanie pierwszej aplikacji na Androida (85)
Tworzenie i konfiguracja nowego projektu aplikacji (86)
Podstawowe pliki i katalogi aplikacji na Androida (88)
Tworzenie AVD na potrzeby projektu (89)
Tworzenie konfiguracji uruchomieniowych dla projektu (90)
Uruchamianie aplikacji w emulatorze (91)
Debugowanie aplikacji w emulatorze (93)
Dodawanie mechanizmów rejestracji do aplikacji (97)
Dodawanie obsługi multimediów do aplikacji (99)
Dodawanie do aplikacji usług lokalizacyjnych (100)
Debugowanie aplikacji na fizycznym urządzeniu (103)
Podsumowanie (105)
Zasoby i inne źródła informacji (106)

Część II: Kluczowe informacje o konstrukcji aplikacji na Androida (107)
Rozdział 4. Anatomia aplikacji na Androida (109)

Opanowanie najważniejszej terminologii (109)
Stosowanie kontekstu aplikacji (110)
Pobieranie kontekstu aplikacji (110)
Stosowanie kontekstu aplikacji (110)
Realizacja działań przy użyciu aktywności (111)
Cykl życia aktywności (112)
Zarządzanie zmianami aktywności przy użyciu intencji (117)
Praca z usługami (120)
Odbieranie oraz rozgłaszanie intencji (121)
Podsumowanie (122)
Odwołania i inne źródła informacji (123)

Rozdział 5. Definiowanie aplikacji przy użyciu pliku manifestu (125)

Konfiguracja pliku manifestu (125)
Edycja pliku manifestu (126)
Zarządzanie tożsamością aplikacji (131)
Określanie wersji aplikacji (131)
Określanie nazwy oraz ikony aplikacji (131)
Określanie wymagań systemowych aplikacji (132)
Określanie konkretnych wersji SDK (132)
Ograniczenia związane z platformą (135)
Korzystanie z zewnętrznych bibliotek (137)
Rejestracja aktywności oraz innych komponentów aplikacji (138)
Określanie aktywności będącej głównym punktem wejścia aplikacji przy użyciu filtra intencji (138)
Konfiguracja innych filtrów intencji (139)
Stosowanie uprawnień (140)
Rejestracja uprawnień wymaganych przez aplikację (140)
Rejestracja uprawnień przydzielanych innym aplikacjom (141)
Poznawanie innych ustawień podawanych w manifeście (142)
Podsumowanie (142)
Odwołania i inne źródła informacji (143)

Rozdział 6. Zarządzanie zasobami aplikacji (145)

Czym są zasoby? (145)
Przechowywanie zasobów aplikacji (146)
Zrozumienie hierarchii katalogów zasobów (146)
Typy wartości zasobów (147)
Przechowywanie zasobów różnych typów (149)
Programowy dostęp do zasobów (152)
Określanie wartości prostych zasobów w Eclipse (152)
Praca z zasobami (156)
Łańcuchy znaków (156)
Stosowanie łańcuchów z zasobów do formatowania tekstów (157)
Praca z tablicami łańcuchów znaków (159)
Praca z wartościami logicznymi (159)
Praca z liczbami całkowitymi (160)
Praca z kolorami (161)
Praca z wymiarami (162)
Praca z prostymi zasobami graficznymi (163)
Praca z obrazami (164)
Praca z animacjami (166)
Praca z menu (168)
Praca z plikami XML (170)
Praca z nieprzetworzonymi plikami (171)
Odwołania do zasobów (171)
Praca z układami (173)
Praca ze stylami (178)
Praca z tematami (181)
Odwołania do zasobów systemowych (181)
Podsumowanie (182)
Odwołania i inne źródła informacji (183)

Część III: Kluczowe zagadnienia projektowania interfejsów użytkownika (185)
Rozdział 7. Prezentacja wizualnych elementów interfejsu użytkownika (187)

Prezentacja widoków i układów (187)
Prezentacja widoków (187)
Prezentacja kontrolek (188)
Prezentacja układów (188)
Wyświetlanie tekstów przy użyciu TextView (189)
Konfiguracja układu oraz określanie wymiarów (190)
Umieszczanie w tekście kontekstowych odnośników (191)
Pobieranie danych od użytkowników (192)
Pobieranie danych przy użyciu kontrolek EditText (193)
Kontrolka Spinner - zapewnianie możliwości wyboru (199)
Stosowanie przycisków, pól wyboru oraz pól opcji (200)
Stosowanie zwyczajnych przycisków (201)
Stosowanie pól wyboru i przełączników (203)
Stosowanie kontrolek RadioGroup oraz RadioButton (204)
Pobieranie daty i godziny (206)
Prezentacja danych przy użyciu wskaźników (208)
Prezentacja postępów przy użyciu paska postępu (208)
Modyfikacja postępu przy użyciu kontrolki SeekBar (211)
Wyświetlanie oceny przy użyciu kontrolki RatingBar (212)
Prezentacja upływu czasu przy użyciu minutnika (213)
Wyświetlanie czasu (213)
Prezentowanie menu opcji oraz menu kontekstowego (214)
Edycja menu opcji (215)
Obsługa zdarzeń generowanych przez użytkownika (219)
Odbieranie informacji o zmianach trybu dotyku (219)
Odbieranie zdarzeń dotyczących całego ekranu (221)
Obsługa zdarzeń naciśnięcia i przytrzymania (222)
Reagowanie na zmiany wybranej kontrolki (223)
Stosowanie okien dialogowych (224)
Różne typy okien dialogowych (224)
Śledzenie cyklu życia okna dialogowego (225)
Tworzenie własnych okien dialogowych (227)
Stosowanie stylów (227)
Stosowanie tematów (229)
Podsumowanie (231)

Rozdział 8. Projektowanie interfejsów użytkownika z użyciem układów (233)

Tworzenie interfejsów użytkownika w systemie Android (233)
Definiowanie układów w zasobach aplikacji (233)
Programowe tworzenie układów (235)
Organizacja interfejsu użytkownika aplikacji (238)
Zrozumienie różnic między View i ViewGroup (238)
Stosowanie wbudowanych układów (243)
Układ FrameLayout (244)
Układ LinearLayout (247)
Układ RelativeLayout (247)
Układ TableLayout (251)
Stosowanie wielu układów jednocześnie (254)
Stosowanie wbudowanych klas pojemników (255)
Pojemniki działające w oparciu o dane (255)
Organizacja interfejsu użytkownika przy wykorzystaniu zakładek (260)
Dodawanie możliwości przewijania (264)
Prezentacja innych rodzajów pojemników (265)
Podsumowanie (266)

Rozdział 9. Rysowanie i korzystanie z animacji (267)

Rysowanie na ekranie (267)
Stosowanie obiektów Canvas oraz Paint (267)
Wyświetlanie tekstów (272)
Stosowanie domyślnych czcionek i ich krojów (272)
Stosowanie własnych czcionek (273)
Określanie wymiarów tekstu na ekranie (275)
Wyświetlanie i operacje na grafice rastrowej (275)
Wyświetlanie grafiki rastrowej (275)
Skalowanie grafiki rastrowej (275)
Macierzowe przekształcenia grafiki rastrowej (275)
Wyświetlanie i operacje na kształtach (277)
Definiowanie kształtów w postaci zasobów XML (277)
Programowe definiowanie kształtów (278)
Rysowanie różnych kształtów (279)
Stosowanie animacji (285)
Stosowanie animacji poklatkowych (286)
Stosowanie animacji przejść (288)
Podsumowanie (294)

Część IV: Najczęściej stosowane interfejsy programowania aplikacji na Androida (295)
Rozdział 10. Obsługa danych i składowanie (297)

Korzystanie z preferencji aplikacji (297)
Tworzenie właściwości prywatnych i wspólnych (298)
Przeszukiwanie i odczyt preferencji (299)
Dodawanie, aktualizacja oraz usuwanie preferencji (299)
Odnajdywanie danych preferencji w systemie plików Androida (300)
Obsługa plików i katalogów (301)
Poznawanie zawartości katalogów aplikacji (301)
Korzystanie z innych katalogów i plików w systemie Android (304)
Przechowywanie danych strukturalnych w bazach danych SQLite (305)
Tworzenie baz danych SQLite (307)
Tworzenie, aktualizacja oraz usuwanie rekordów z baz danych (309)
Wykonywanie zapytań w bazach danych SQLite (312)
Zamykanie i usuwanie baz danych SQLite (317)
Projektowanie trwałych baz danych (318)
Kojarzenie danych z interfejsem użytkownika aplikacji (320)
Podsumowanie (325)
Odwołania oraz dodatkowe źródła informacji (326)

Rozdział 11. Udostępnianie danych pomiędzy aplikacjami przy użyciu dostawców treści (327)

Prezentacja dostawców treści (327)
Stosowanie dostawcy treści MediaStore (328)
Stosowanie dostawcy danych CallLog (329)
Stosowanie dostawcy treści Browser (331)
Stosowanie dostawcy treści Contacts (332)
Stosowanie dostawcy treści UserDictionary (335)
Stosowanie dostawcy treści Settings (336)
Modyfikacja danych dostawców treści (336)
Dodawanie rekordów (336)
Aktualizacja rekordów (337)
Usuwanie rekordów (338)
Wzbogacanie możliwości aplikacji przy użyciu dostawców treści (338)
Dostęp do zgromadzonych obrazów (339)
Działanie jako dostawca treści (344)
Implementacja interfejsu dostawcy treści (344)
Definiowanie identyfikatora URI danych (345)
Definiowanie kolumn danych (345)
Implementacja metod dostawcy treści (346)
Modyfikacja pliku manifestu (351)
Aktywne foldery (352)
Podsumowanie (355)
Odwołania i inne źródła informacji (355)

Rozdział 12. Obsługa operacji sieciowych (357)

Podstawy operacji sieciowych na urządzeniach przenośnych (357)
Dostęp do internetu (HTTP) (358)
Odczytywanie danych z sieci (358)
Stosowanie klasy HttpUrlConnection (359)
Przetwarzanie kodu XML pobieranego z sieci (360)
Przetwarzanie asynchroniczne (362)
Stosowanie klasy AsyncTask (362)
Zastosowanie wątków do obsługi operacji sieciowych (364)
Wyświetlanie obrazów pobieranych z internetu (365)
Pobieranie statusu połączenia sieciowego (367)
Podsumowanie (369)
Odwołania i inne źródła informacji (369)

Rozdział 13. Obsługa WWW (371)

Przeglądanie WWW przy użyciu WebView (371)
Projektowanie układu z kontrolką WebView (372)
Wyświetlanie treści w kontrolce WebView (372)
Wzbogacanie możliwości kontrolki WebView (374)
Tworzenie rozszerzeń przy użyciu WebKit (378)
Przegląd interfejsów mechanizmu WebKit (378)
Tworzenie aplikacji internetowych w systemie Android (378)
Stosowanie technologii Flash (383)
Korzystanie z aplikacji napisanych w technologii Flash (384)
Tworzenie aplikacji na Androida w technologii AIR (384)
Podsumowanie (385)
Odwołania i dodatkowe źródła informacji (386)

Rozdział 14. Korzystanie z usług lokalizacyjnych (387)

Stosowanie usług GPS (387)
Korzystanie z możliwości GPS w aplikacji (388)
Określanie położenia (388)
Określanie położenia w emulatorze (390)
Geokodowanie lokalizacji (391)
Prezentacja lokalizacji na mapie (394)
Intencje wykorzystujące mapy (394)
Kontrolka mapy (396)
Pobieranie testowego klucza API (397)
Przesuwanie mapy (399)
Powiększanie mapy (400)
Zaznaczanie miejsc (401)
Inne możliwości, jakie zapewniają usługi lokalizacyjne (406)
Podsumowanie (407)
Odwołania i inne źródła informacji (407)

Rozdział 15. Obsługa multimediów (409)

Korzystanie z multimediów (409)
Korzystanie ze zdjęć (410)
Rejestracja zdjęć przy użyciu aparatu fotograficznego (410)
Konfiguracja trybu działania aparatu (415)
Współdzielenie zdjęć (416)
Stosowanie obrazów jako tapet (417)
Korzystanie z wideo (418)
Rejestracja wideo (418)
Odtwarzanie obrazu wideo (419)
Rejestracja i odtwarzanie dźwięków (421)
Rejestracja dźwięków (421)
Odtwarzanie plików dźwiękowych (423)
Współdzielenie plików dźwiękowych (424)
Poszukiwanie multimediów (425)
Korzystanie z dzwonków (425)
Podsumowanie (426)
Odwołania i inne źródła informacji (426)

Rozdział 16. Obsługa telefonii (427)

Korzystanie z narzędzi telefonii (427)
Uzyskiwanie uprawnień do pobierania statusu telefonu (428)
Pobieranie informacji o stanie rozmowy (428)
Pobieranie informacji o usłudze (430)
Monitorowanie siły sygnału i szybkości połączenia (431)
Obsługa numerów telefonicznych (431)
Korzystanie z krótkich wiadomości tekstowych (432)
Uzyskiwanie uprawnień do wysyłania SMS-ów (433)
Wysyłanie wiadomości tekstowych (433)
Odbieranie SMS-ów (435)
Nawiązywanie i odbieranie połączeń telefonicznych (437)
Nawiązywanie połączeń telefonicznych (437)
Odbieranie połączeń telefonicznych (438)
Podsumowanie (439)
Odwołania i inne źródła informacji (440)

Rozdział 17. Obsługa grafiki 3D przy użyciu OpenGL ES (441)

Stosowanie OpenGL ES (441)
Stosowanie OpenGL ES w Androidzie (442)
Zapewnianie zgodności urządzeń (443)
Korzystanie z biblioteki OpenGL ES w Androidzie (443)
Ręczna obsługa OpenGL ES (444)
Tworzenie obiektu SurfaceView (445)
Uruchamianie wątku dla operacji OpenGL ES (446)
Inicjalizacja biblioteki EGL (448)
Inicjalizacja biblioteki GL (450)
Rysowanie na ekranie (450)
Rysowanie obiektów trójwymiarowych (452)
Rysowanie wierzchołków (452)
Kolorowanie wierzchołków (453)
Rysowanie bardziej złożonych obiektów (453)
Oświetlanie sceny (455)
Dodawanie tekstur do obiektów (457)
Interakcja z kontrolkami i zdarzeniami systemu Android (459)
Zapewnianie komunikacji pomiędzy wątkiem OpenGL i wątkiem aplikacji (460)
Zapewnianie możliwości przesyłania danych z wątku aplikacji do wątku OpenGL (461)
Zwalnianie zasobów OpenGL ES (464)
Stosowanie klasy GLSurfaceView (prosty sposób na OpenGL ES) (464)
Stosowanie OpenGL ES 2.0 (467)
Konfiguracja aplikacji w celu korzystania z OpenGL 2.0 (468)
Pobieranie powierzchni OpenGL ES 2.0 (468)
Podsumowanie (472)
Odwołania i inne źródła informacji (473)

Rozdział 18. Stosowanie Android NDK (475)

Określanie, kiedy warto użyć NDK (475)
Instalacja Android NDK (476)
Prezentacja Android NDK (477)
Uruchamianie aplikacji przykładowej (477)
Tworzenie własnego projektu NDK (478)
Wywoływanie kodu rodzimego z poziomu Javy (478)
Obsługa parametrów i wartości wynikowych (480)
Stosowanie wyjątków w kodzie rodzimym (480)
Poprawa wydajności generowania grafiki (482)
Podsumowanie (483)
Odwołania i inne źródła informacji (484)

Rozdział 19. Korzystanie z opcjonalnych komponentów sprzętowych (485)

Interakcja z komponentami sprzętowymi urządzenia (485)
Korzystanie z czujników (486)
Korzystanie z różnych czujników (487)
Uzyskiwanie dostępu do czujnika (488)
Odczyt danych z czujnika (488)
Kalibracja czujników (490)
Określanie położenia (490)
Odnajdywanie północy (491)
Korzystanie z Wi-Fi (491)
Korzystanie z technologii Bluetooth (494)
Sprawdzanie dostępności komponentów sprzętowych (495)
Włączanie komunikacji Bluetooth (495)
Poszukiwanie sparowanych urządzeń (495)
Odkrywanie urządzeń (496)
Nawiązywanie połączenia pomiędzy dwoma urządzeniami (496)
Monitorowanie stanu baterii (497)
Podsumowanie (500)
Odwołania i inne źródła informacji (501)

Część V: Dodatkowe zasady projektowania aplikacji na Androida (503)
Rozdział 20. Stosowanie powiadomień (505)

Powiadamianie użytkownika (505)
Powiadomienia na pasku stanu (506)
Stosowanie usługi NotificationManager (507)
Tworzenie prostego powiadomienia z ikoną (507)
Obsługa kolejki powiadomień (508)
Aktualizacja powiadomień (510)
Usuwanie powiadomień (511)
Stosowanie wibracji (511)
Błyskanie (512)
Stosowanie dźwięków (514)
Określanie postaci powiadomień (515)
Projektowanie użytecznych powiadomień (517)
Podsumowanie (517)
Odwołania i inne źródła informacji (518)

Rozdział 21. Stosowanie usług (519)

Określanie, kiedy należy użyć usługi (519)
Prezentacja cyklu życia usługi (520)
Tworzenie usługi (521)
Kontrola działania usługi (526)
Implementacja zdalnego interfejsu (527)
Implementacja klasy Parcelable (529)
Podsumowanie (532)
Odwołania i inne źródła informacji (532)

Rozdział 22. Poszerzanie zasięgu aplikacji (533)

Wzbogacanie aplikacji (533)
Tworzenie widżetów aplikacji (534)
Tworzenie widżetu aplikacji (535)
Instalacja widżetu (543)
Hosty widżetów (544)
Animowane tapety (545)
Tworzenie animowanej tapety (545)
Instalacja animowanej tapety (549)
Obsługa konkretnego typu danych (549)
Określanie akcji intencji oraz typów MIME (551)
Implementacja aktywności do obsługi intencji (551)
Rejestracja filtra intencji (552)
Zapewnianie możliwości przeszukiwania treści aplikacji (553)
Zapewnianie możliwości przeszukiwania wewnątrz aplikacji (555)
Zapewnianie możliwości korzystania z wyszukiwania globalnego (562)
Korzystanie z aktywnych folderów (565)
Tworzenie aktywnego folderu (566)
Instalacja aktywnego folderu (570)
Podsumowanie (571)
Odwołania i inne źródła informacji (572)

Rozdział 23. Zarządzanie kontami użytkownika oraz synchronizacja jego danych (573)

Zarządzanie kontami przy użyciu menedżera kont (573)
Synchronizacja danych przy użyciu adapterów synchronizacji (575)
Korzystanie z usług tworzenia kopii zapasowych (576)
Wybór zdalnej usługi tworzenia kopii (576)
Implementacja agenta archiwizacji (577)
Tworzenie kopii i odtwarzanie danych aplikacji (581)
Podsumowanie (582)
Odwołania i inne źródła informacji (582)

Rozdział 24. Zaawansowane sposoby obsługi wprowadzania danych (585)

Stosowanie różnych metod wprowadzania tekstów (585)
Stosowanie klawiatur programowych (586)
Korzystanie z przewidywania tekstu i słowników użytkownika (589)
Przedstawienie szkieletu ułatwień dostępu (589)
Korzystanie z usług rozpoznawania mowy (591)
Korzystanie z usług odczytywania tekstów (593)
Korzystanie z gestów (596)
Wykrywanie ruchów w widokach (596)
Obsługa popularnych gestów wykonywanych jednym palcem (597)
Obsługa gestów wielodotyku (604)
Zapewnianie bardziej naturalnego wyglądu gestów (607)
Korzystanie z manipulatora kulowego (607)
Obsługa zmian orientacji ekranu (607)
Podsumowanie (610)
Odwołania i inne źródła informacji (611)

Rozdział 25. Przygotowywanie aplikacji dla różnych konfiguracji sprzętowych i języków (613)

Maksymalizowanie zgodności aplikacji (613)
Projektowanie interfejsu użytkownika pod kątem zachowania zgodności (615)
Obsługa konkretnych typów ekranów (617)
Korzystanie z grafiki typu Nine-Patch Stretchable Graphics (617)
Stosowanie zasady kwadratu roboczego (621)
Stosowanie zasobów alternatywnych (622)
Kwalifikatory zasobów alternatywnych (622)
Tworzenie zasobów na potrzeby działania przy różnej orientacji ekranu (628)
Programowe stosowanie zasobów alternatywnych (629)
Określanie efektywnej organizacji zasobów (630)
Umiędzynarodawianie aplikacji (632)
Umiędzynarodawianie przy wykorzystaniu zasobów alternatywnych (632)
Programowa obsługa ustawień lokalnych (637)
Obsługa różnych konfiguracji urządzeń (638)
Obsługa konfiguracji sprzętowych (639)
Określanie wersji Android SDK, na jakich działa aplikacja (640)
Podsumowanie (643)
Odwołania i inne źródła informacji (643)

Część VI: Wdrażanie aplikacji (645)
Rozdział 26. Proces tworzenia oprogramowania mobilnego (647)

Prezentacja procesu tworzenia oprogramowania mobilnego (647)
Wybór metodologii tworzenia oprogramowania (648)
Zrozumienie niebezpieczeństw metody kaskadowej (648)
Zrozumienie znaczenia powtarzania (649)
Gromadzenie wymagań aplikacji (649)
Określanie wymagań projektowych (650)
Tworzenie przypadków użycia oprogramowania mobilnego (652)
Dołączanie wymagań innych podmiotów (652)
Zarządzanie bazą danych urządzeń (653)
Szacowanie ryzyka związanego z projektem (656)
Określanie urządzeń docelowych (656)
Pozyskiwanie urządzeń docelowych (658)
Określanie możliwości zaspokojenia wymagań aplikacji (659)
Rozumienie ryzyka związanego z zapewnianiem jakości (659)
Pisanie ważnej dokumentacji projektowej (661)
Tworzenie planów testowania na potrzeby kontroli jakości (662)
Dostarczanie dokumentacji wymaganej przez inne podmioty (662)
Dokumentacja na potrzeby utrzymania i przenoszenia (662)
Korzystanie z systemów zarządzania konfiguracjami (663)
Wybór systemu zarządzania kodem źródłowym (663)
Implementacja działającego systemu numeracji wersji aplikacji (663)
Projektowanie aplikacji mobilnych (664)
Znajomość ograniczeń urządzeń przenośnych (664)
Poznawanie wspólnych architektur aplikacji mobilnych (664)
Projektowanie aplikacji pod kątem jej rozszerzania i pielęgnacji (665)
Projektowanie pod kątem możliwości współdziałania aplikacji (667)
Tworzenie aplikacji na urządzenia przenośne (667)
Testowanie aplikacji na urządzenia przenośne (668)
Wdrażanie aplikacji mobilnych (668)
Określanie rynków docelowych (669)
Wsparcie i pielęgnacja oprogramowania mobilnego (669)
Śledzenie i weryfikacja informacji o awariach (669)
Testowanie aktualizacji oprogramowania układowego (670)
Prowadzenie odpowiedniej dokumentacji aplikacji (670)
Wprowadzanie zmian na działającym serwerze (670)
Określanie możliwości przenoszenia aplikacji obciążonego niewielkim ryzykiem (670)
Podsumowanie (671)
Odwołania i dodatkowe źródła informacji (671)

Rozdział 27. Projektowanie i tworzenie niezawodnych aplikacji na Androida (673)

Najlepsze praktyki projektowania niezawodnych aplikacji mobilnych (673)
Zaspokajanie wymagań użytkowników urządzeń przenośnych (674)
Projektowanie interfejsu użytkownika aplikacji mobilnych (675)
Projektowanie stabilnych i szybko reagujących aplikacji mobilnych (676)
Projektowanie bezpiecznych aplikacji mobilnych (678)
Projektowanie aplikacji w celu maksymalizacji zysków (679)
Korzystanie ze standardów projektowania aplikacji opracowanych przez innych (680)
Projektowanie aplikacji pod kątem prostoty ich utrzymania i aktualizacji (680)
Projektowanie aplikacji przy wykorzystaniu narzędzi Androida (682)
Unikanie głupich błędów podczas projektowania aplikacji na Androida (683)
Najlepsze praktyki stosowane przy tworzeniu niezawodnego oprogramowania mobilnego (683)
Określanie procesu produkcyjnego dostosowanego do tworzenia oprogramowania mobilnego (684)
Wczesne i częste testowanie możliwości wykonania projektu (684)
Stosowanie standardów kodowania, weryfikacji i testów jednostkowych w celu poprawienia jakości kodu (685)
Obsługa usterek występujących na jednym urządzeniu (688)
Korzystanie z narzędzi Androida przy pisaniu aplikacji (689)
Unikanie głupich błędów podczas tworzenia aplikacji na Androida (689)
Podsumowanie (689)
Odwołania i inne źródła informacji (690)

Rozdział 28. Testowanie aplikacji na Androida (691)

Najlepsze praktyki testowania oprogramowania na urządzenia przenośne (691)
Projektowanie systemu rejestracji defektów na potrzeby tworzenia oprogramowania mobilnego (691)
Zarządzanie środowiskiem testowym (693)
Maksymalizacja pokrycia testów (696)
Stosowanie narzędzi do testowania aplikacji na Androida (704)
Unikanie głupich błędów podczas testowania aplikacji na Androida (705)
Korzystanie z usług testowania aplikacji (706)
Podsumowanie (706)
Odwołania i inne źródła informacji (706)

Rozdział 29. Sprzedawanie aplikacji na Androida (709)

Wybór odpowiedniego modelu dystrybucji (709)
Przygotowywanie aplikacji do publikacji (710)
Przygotowanie kodu do utworzenia pakietu instalacyjnego (711)
Tworzenie pakietu aplikacji i jego podpisywanie (713)
Testowanie publikowanej wersji pakietu aplikacji (716)
Certyfikacja aplikacji na Androida (716)
Dystrybucja aplikacji (717)
Sprzedawanie aplikacji w Android Market (717)
Sprzedawanie aplikacji na własnym serwerze (724)
Korzystanie z innych sposobów sprzedawania aplikacji (725)
Ochrona własności intelektualnej (726)
Pobieranie opłat od użytkowników (727)
Podsumowanie (727)
Odwołania i inne źródła informacji (728)

Dodatki (729)
Dodatek A: Krótki przewodnik po emulatorze Androida (731)

Symulacja rzeczywistości - przeznaczenie emulatora (731)
Korzystanie z różnych urządzeń wirtualnych (AVD) (733)
Stosowanie narzędzia Android SDK and AVD Manager (734)
Tworzenie AVD (735)
Uruchamianie emulatora z użyciem konkretnego AVD (740)
Konfiguracja opcji uruchomieniowych emulatora (741)
Uruchamianie emulatora w celu wykonania aplikacji (741)
Uruchamianie emulatora z poziomu programu Android SDK and AVD Manager (743)
Konfiguracja położenia GPS w emulatorze (744)
Nawiązywanie połączeń telefonicznych pomiędzy dwoma egzemplarzami emulatora (745)
Przesyłanie SMS-ów pomiędzy dwoma egzemplarzami emulatora (747)
Interakcja z emulatorem z poziomu konsoli (749)
Wykorzystanie konsoli do symulowania odbieranych połączeń (750)
Stosowanie konsoli do symulowania wiadomości SMS (751)
Stosowanie konsoli do przesyłania współrzędnych GPS (752)
Stosowanie konsoli do monitorowania transmisji sieciowych (752)
Stosowanie konsoli do modyfikowania ustawień zasilania (752)
Inne polecenia konsoli emulatora (753)
Korzystanie z emulatora dla zabawy (754)
Ograniczenia emulatora (755)

Dodatek B: Krótki przewodnik po DDMS (757)

Korzystanie z DDMS jako niezależnej aplikacji oraz w Eclipse (757)
Szybka prezentacja kluczowych możliwości DDMS (758)
Obsługa procesów (760)
Dołączanie debugera do aplikacji (760)
Monitorowanie aktywności wątku aplikacji (761)
Żądanie oczyszczenia pamięci (762)
Monitorowanie operacji wykonywanych na stercie (762)
Monitorowanie przydzielanej pamięci (763)
Zatrzymywanie procesu (763)
Zarządzanie plikami (764)
Przeglądanie systemu plików w emulatorze lub na urządzeniu (764)
Kopiowanie plików z emulatora lub urządzenia (765)
Kopiowanie plików do emulatora lub urządzenia (765)
Usuwanie plików na emulatorze lub urządzeniu (765)
Stosowanie zakładki Emulator Control (766)
Symulowanie przychodzących połączeń telefonicznych (766)
Symulowanie nadsyłanych wiadomości SMS (766)
Przesyłanie współrzędnych geograficznych (767)
Korzystanie z mechanizmów rejestracji komunikatów (767)
Wykonywanie zrzutów ekranu z emulatora lub urządzenia (768)

Dodatek C: Krótki przewodnik po ADB (771)

Wyświetlanie listy podłączonych urządzeń i uruchomionych emulatorów (771)
Kierowanie poleceń ADB do konkretnych urządzeń (772)
Uruchamianie i zatrzymywanie serwera ADB (772)
Zatrzymywanie procesu serwera ADB (773)
Uruchamianie i sprawdzanie procesu serwera ADB (773)
Wykonywanie poleceń powłoki (773)
Wydawanie pojedynczych poleceń powłoki (773)
Stosowanie sesji (773)
Zastosowanie powłoki do uruchamiania i zatrzymywania emulatora (774)
Kopiowanie plików (774)
Wysyłanie plików do urządzenia lub emulatora (775)
Pobieranie plików z urządzenia lub emulatora (775)
Instalowanie i usuwanie aplikacji (775)
Instalowanie aplikacji (776)
Ponowna instalacja aplikacji (776)
Deinstalacja aplikacji (776)
Korzystanie z narzędzia LogCat (776)
Wyświetlanie wszystkich zarejestrowanych komunikatów (777)
Prezentowanie daty i godziny (777)
Filtrowanie prezentowanych informacji (777)
Czyszczenie listy komunikatów (779)
Przekierowywanie prezentowanych informacji do pliku (779)
Dostęp do innych dzienników (779)
Kontrola usługi kopii zapasowej (779)
Wymuszanie sporządzenia kopii zapasowej (780)
Wymuszanie odtworzenia danych (780)
Usuwanie kopii zapasowej (781)
Generacja raportu o błędach (781)
Korzystanie z powłoki do wykonywania operacji na bazach danych SQLite (781)
Korzystanie z powłoki do testowania aplikacji w warunkach zwiększonego obciążenia (781)
Małpia zabawa z aplikacją (782)
Odbieranie informacji o działaniach programu monkey (782)
Określanie czynności symulowanych przez program monkey (782)
Powtarzanie tych samych operacji (784)
Kontrola działania programu (784)
Dokładniejsze poznanie programu monkey (785)
Instalowanie niestandardowych programów binarnych (785)
Poznawanie innych poleceń ADB (786)

Dodatek D: Sztuczki i triki podczas korzystania z Eclipse IDE (787)

Organizacja przestrzeni roboczej (787)
Integracja z usługami kontroli wersji (787)
Zmiana położenia zakładek w perspektywie (788)
Maksymalizacja okien (788)
Minimalizacja okien (788)
Umieszczanie okien obok siebie (789)
Wyświetlanie dwóch fragmentów tego samego pliku (789)
Zamykanie niepotrzebnych zakładek (789)
Zachowanie kontroli nad oknami (789)
Tworzenie własnych filtrów dziennika (790)
Pisanie kodu w języku Java (790)
Automatyczne uzupełnianie (790)
Formatowanie kodu (791)
Tworzenie nowych klas (791)
Tworzenie nowych metod (791)
Organizacja instrukcji import (792)
Modyfikacja niemal wszystkich nazw (792)
Refaktoryzacja kodu (793)
Stosowanie narzędzia Extract Local Variable (793)
Reorganizacja kodu (794)
Tworzenie dokumentacji Javadoc (795)
Wyjaśnianie tajemniczych błędów (795)

Dodatek E: Przewodnik po SQLite dla początkujących (797)

Podstawowe czynności obsługi baz SQLite (797)
Stosowanie programu sqlite3 (798)
Uruchamianie powłoki ADB (798)
Nawiązywanie połączenia z bazą danych SQLite (799)
Przeglądanie baz danych (799)
Importowanie oraz eksportowanie baz danych i ich zawartości (800)
Wykonywanie poleceń SQL w wierszu poleceń (802)
Stosowanie innych poleceń sqlite3 (803)
Znajomość ograniczeń baz danych SQLite (803)
Nauka na przykładach - baza ocen uczniów (804)
Projektowanie struktury bazy danych ocen (805)
Tworzenie prostej tabeli z kolumną AUTOINCREMENT (805)
Zapisywanie danych w tabelach (806)
Pobieranie informacji z tabel przy użyciu polecenia SELECT (806)
Stosowanie kluczy obcych oraz złożonych kluczy głównych (807)
Modyfikowanie i aktualizacja danych (808)
Pobieranie danych z kilku tabel przy użyciu złączeń (809)
Stosowanie kolumn o obliczanych wartościach (810)
Wyliczanie wartości kolumn przy użyciu podzapytań (811)
Usuwanie tabel (811)

Skorowidz (813)

Fragment książki: Rozwiń >>

1. Z poziomu Eclipse uruchomić program Android Virtual Device, klikając
umieszczony na pasku narzędzi przycisk z niewielką ikoną Androida i strzałką
skierowana w dół — . Jeśli nie można znaleźć tej ikony, to program menedżera
można także uruchomić za pośrednictwem opcji dostępnych w menu Window
środowiska Eclipse.
2. W menu Virtual Devices kliknąć przycisk New.
3. Podać nazwę tworzonego AVD. Ponieważ mamy zamiar wykorzystać wszystkie
domyślne ustawienia, nadamy mu nazwę Android_Vanilla2.2.
4. Wybrać urządzenie docelowe. Ponieważ chcemy stworzyć zwyczajne urządzenie
z Androidem 2.2, z rozwijalnej listy należy wybrać opcję Android 2.2.
5. Określić pojemność karty SD. Można ją podać w kilobajtach lub megabajtach.
Obszar ten jest przydzielany z dostępnej przestrzeni na dysku twardym
komputera. Warto wybrać jakąś rozsądną wartość, na przykład 1 GB (1024 MB).
Jeśli Czytelnikowi brakuje wolnego miejsca na dysku bądź jeśli wiadomo, że nie
trzeba będzie testować przechowywania danych aplikacji na karcie SD, to można
utworzyć kartę o znacznie mniejszej pojemności, na przykład 64 MB.
6. Wybrać wygląd symulowanego urządzenia, tak zwaną „skórkę” (ang. skin). Ta
opcja pozwala określać różne rozdzielczości ekranu symulowanego urządzenia.
W naszym przypadku zastosujemy skórkę WVGA800. Chyba najdokładniej
odpowiada ona najbardziej popularnym telefonom z Androidem, takim jak
HTC Negus One lub Evo 4G, które właśnie leżą przede mną na biurku.