• Android SDK i programowanie aplikacji WWW
• Komunikacja Bluetooth i przetwarzanie danych z czujników
• Grafika, animacja i multimedia w Androidzie
• Techniki pisania natywnych aplikacji w języku C

Skoro zwróciłeś uwagę właśnie na tę książkę, zapewne dobrze wiesz, czym jest Android i co potrafi — teraz przyszła pora, abyś sprawdził go także w akcji! Oto doskonała książka dla wszystkich programistów, którym marzy się tworzenie własnych aplikacji dla robiącego oszałamiającą karierę systemu. Choć ta książka nie jest przeznaczona dla początkujących, zawiera wszystkie informacje potrzebne osobom, dla których Android jest całkowicie nowym środowiskiem. Można w niej znaleźć instrukcje niezbędne do szybkiego zorientowania się w architekturze tej platformy oraz sposobie jej działania, co pozwoli sprawnie rozpocząć pracę w tym środowisku. Pozostałe rozdziały to już czysta frajda programowania!

Od czego zaczniesz zabawę z Androidem? Dowiesz się, jak budować aplikacje dla tego systemu od najmniejszych cegiełek aż po ekrany, dodawać funkcje telefoniczne i wykorzystywać bibliotekę OpenGL ES do tworzenia złożonej grafiki 2D oraz 3D. Następnie poznasz zasady tworzenia większych aplikacji oraz techniki pisania aplikacji w języku C, także z użyciem Android Native Development Kit. Opanujesz potężne narzędzie Android SDK oraz budowanie aplikacji dla WebKit z użyciem HTML 5, a nawet nauczysz się rozszerzać lub zastępować wbudowane funkcje Androida na podstawie użytecznych i intrygujących przykładów.

• Wprowadzenie do systemu Android
• Środowisko programowania
• Komponenty interfejsu użytkownika, w tym View i Layout
• Metody przechowywania i odczytywania lokalnych danych
• Sieci oraz usługi sieciowe
• Przegląd podstawowych zagadnień związanych z telefonią
• Powiadomienia i alarmy
• Grafika i animacja w Androidzie
• Korzystanie z funkcji multimedialnych Androida
• Usługi oparte na lokalizacji
• Integracja kontaktów z platformy społecznościowej
• Aplikacja wspomagająca serwisantów
• Budowanie aplikacji Android w języku C
• Bluetooth, sensory i widżety aplikacji
• Tworzenie stron WWW dla systemu Android
• Strategie lokalizowania aplikacji
• Android Native Development Kit
• Korzystanie z SDK oraz AVD Manager

Wkrocz wreszcie do akcji i zacznij tworzyć własne aplikacje dla Androida.

Spis treści:

Część I. Czym jest Android? Zarys ogólny (27)
1. Wprowadzenie do systemu Android (29)

• 1.1. Platforma Android (30)
• 1.2. Omówienie rynku Androida (32)
  • 1.2.1. Operatorzy telefonii komórkowej (32)
  • 1.2.2. Android kontra zaawansowane telefony (32)
  • 1.2.3. Android kontra smartfony (34)
  • 1.2.4. Android kontra Android (35)
  • 1.2.5. Licencjonowanie Androida (35)
• 1.3. Warstwy systemu Android (36)
  • 1.3.1. Budowanie na bazie jądra Linux (38)
  • 1.3.2. Praca w maszynie wirtualnej Dalvik (39)
• 1.4. Intencje w programowaniu dla Androida (39)
  • 1.4.1. Wykorzystywanie intuicyjnego interfejsu użytkownika (40)
  • 1.4.2. Sposób działania intencji (40)
• 1.5. Cztery rodzaje komponentów Androida (43)
  • 1.5.1. Klasa Activity (44)
  • 1.5.2. Klasa Service (45)
  • 1.5.3. Klasa BroadcastReceiver (46)
  • 1.5.4. Klasa ContentProvider (49)
• 1.6. Budowa pliku AndroidManifest.xml (50)
• 1.7. Odwzorowanie aplikacji na procesy (52)
• 1.8. Tworzenie aplikacji dla systemu Android (53)
• 1.9. Podsumowanie (57)

2. Środowisko programowania dla systemu Android (59)

• 2.1. Wprowadzenie do Android SDK (60)
  • 2.1.1. Podstawowe pakiety systemu Android (61)
  • 2.1.2. Pakiety opcjonalne (62)
• 2.2. Przegląd środowiska programowania (62)
  • 2.2.1. Perspektywa Java (64)
  • 2.2.2. Perspektywa DDMS (65)
  • 2.2.3. Narzędzia wiersza poleceń (68)
• 2.3. Budowanie aplikacji dla systemu Android w Eclipse (71)
  • 2.3.1. Kreator projektu aplikacji Android (72)
  • 2.3.2. Kod źródłowy przykładowej aplikacji Android (72)
  • 2.3.3. Pakowanie aplikacji (79)
• 2.4. Użycie emulatora systemu Android (80)
  • 2.4.1. Konfiguracja środowiska emulowanego (81)
  • 2.4.2. Testowanie aplikacji w emulatorze (85)
• 2.5. Debugowanie aplikacji (86)
• 2.6. Podsumowanie (88)

Część II. Ćwiczenia z Android SDK (89)
3. Interfejs użytkownika (91)

• 3.1. Tworzenie aktywności (93)
  • 3.1.1. Tworzenie klasy Activity (94)
  • 3.1.2. Przedstawiamy cykl życia aktywności (99)
• 3.2. Praca z widokami (103)
  • 3.2.1. Przegląd wspólnych widoków (103)
  • 3.2.2. Korzystanie z ListView (105)
  • 3.2.3. Wielowątkowość z użyciem klas Handler i Message (109)
  • 3.2.4. Tworzenie własnych widoków (111)
  • 3.2.5. Przedstawiamy układy (113)
  • 3.2.6. Obsługa fokusu (115)
  • 3.2.7. Przechwytywanie zdarzeń (116)
• 3.3. Użycie zasobów (117)
  • 3.3.1. Obsługiwane typy zasobów (117)
  • 3.3.2. Odwoływanie się do zasobów w kodzie Java (118)
  • 3.3.3. Definiowanie widoków i układów w zasobach XML (120)
  • 3.3.4. Wartości zewnętrzne (122)
  • 3.3.5. Tworzenie animacji (125)
• 3.4. Przedstawiamy plik AndroidManifest.xml (126)
• 3.5. Podsumowanie (128)

4. Intencje i usługi (129)

• 4.1. Obsługa aplikacji Wyszukiwarka restauracji z użyciem intencji (130)
  • 4.1.1. Definiowanie intencji (131)
  • 4.1.2. Wywołania jawne i niejawne (131)
  • 4.1.3. Dodawanie łączy zewnętrznych do aplikacji Wyszukiwarka restauracji (132)
  • 4.1.4. Wyszukiwanie celu dla intencji (135)
  • 4.1.5. Wykorzystanie aktywności dostępnych w Androidzie (137)
• 4.2. Sprawdzanie pogody z użyciem własnych URI (138)
  • 4.2.1. Oferowanie własnych URI (138)
  • 4.2.2. Użycie niestandardowego URI (140)
• 4.3. Sprawdzanie pogody za pomocą obiektu BroadcastReceiver (142)
  • 4.3.1. Rozgłaszanie intencji (142)
  • 4.3.2. Tworzenie odbiornika (143)
• 4.4. Budowanie usługi prognozy pogody (144)
• 4.5. Komunikacja WeatherAlertService z innymi aplikacjami (148)
  • 4.5.1. Język definicji interfejsu (148)
  • 4.5.2. Binder oraz Parcelable (150)
  • 4.5.3. Udostępnianie zdalnego interfejsu (151)
  • 4.5.4. Łączenie z usługą (152)
  • 4.5.5. Uruchamianie i dołączanie usługi (155)
  • 4.5.6. Cykl życia usługi (156)
• 4.6. Podsumowanie (157)

5. Zapisywanie i odczytywanie danych (159)

• 5.1. Użycie właściwości (160)
  • 5.1.1. Wykorzystanie obiektu SharedPreferences (160)
  • 5.1.2. Uprawnienia dostępu do właściwości (163)
• 5.2. Użycie systemu plików (166)
  • 5.2.1. Tworzenie plików (166)
  • 5.2.2. Odczyt z plików (167)
  • 5.2.3. Pliki jako surowe zasoby (168)
  • 5.2.4. Zasoby plików XML (169)
  • 5.2.5. Zapis na karcie SD (171)
• 5.3. Zapisywanie danych w bazie danych (174)
  • 5.3.1. Budowanie i wykorzystanie bazy danych (175)
  • 5.3.2. Wykorzystanie programu sqlite3 (179)
• 5.4. Użycie klas ContentProvider (180)
  • 5.4.1. Użycie istniejącej klasy ContentProvider (181)
  • 5.4.2. Tworzenie dostawcy treści (182)
• 5.5. Podsumowanie (188)

6. Sieci oraz usługi sieciowe (189)

• 6.1. Przegląd zagadnień sieciowych (191)
  • 6.1.1. Podstawy sieci (191)
  • 6.1.2. Serwery i klienty (194)
• 6.2. Sprawdzanie stanu sieci (195)
• 6.3. Komunikacja poprzez gniazdo serwera (196)
• 6.4. Wykorzystanie HTTP (199)
  • 6.4.1. Proste żądania HTTP i java.net (199)
  • 6.4.2. Zaawansowana obsługa HTTP za pomocą HttpClient (201)
  • 6.4.3. Tworzenie klasy pomocniczej dla wywołań HTTP i HTTPS (203)
• 6.5. Usługi sieciowe (209)
  • 6.5.1. POX - połączenie HTTP i XML (209)
  • 6.5.2. REST (211)
  • 6.5.3. SOAP czy nie SOAP - oto jest pytanie (215)
• 6.6. Podsumowanie (216)

7. Telefonia (217)

• 7.1. Przegląd podstawowych zagadnień związanych z telefonią (218)
  • 7.1.1. Poznajemy GSM (219)
  • 7.1.2. Poznajemy CDMA (220)
• 7.2. Dostęp do danych telefonii (221)
  • 7.2.1. Odczyt właściwości telefonu (222)
  • 7.2.2. Pozyskiwanie informacji o stanie telefonu (224)
• 7.3. Interakcja z telefonem (226)
  • 7.3.1. Użycie intencji do nawiązywania połączeń (226)
  • 7.3.2. Użycie narzędzi związanych z numerami telefonicznymi (227)
  • 7.3.3. Przechwytywanie połączeń wychodzących (229)
• 7.4. Obsługa wiadomości - SMS (230)
  • 7.4.1. Wysyłanie wiadomości SMS (231)
  • 7.4.2. Odbieranie wiadomości SMS (233)
• 7.5. Podsumowanie (235)

8. Powiadomienia i alarmy (237)

• 8.1. Korzystanie z Toast (238)
  • 8.1.1. Tworzenie aplikacji SMS korzystającej z klasy Toast (238)
  • 8.1.2. Odbieranie wiadomości SMS (239)
• 8.2. Wprowadzenie do powiadomień (242)
  • 8.2.1. Klasa Notification (243)
  • 8.2.2. Powiadamianie użytkownika o wiadomości SMS (244)
• 8.3. Wprowadzenie do alarmów (247)
  • 8.3.1. Przykład użycia alarmu (248)
  • 8.3.2. Użycie powiadomień z alarmami (252)
• 8.4. Podsumowanie (253)

9. Grafika i animacja (255)

• 9.1. Rysowanie grafiki w systemie Android (256)
  • 9.1.1. Rysowanie przy użyciu XML (257)
  • 9.1.2. Przegląd figur rysowanych za pomocą XML (259)
• 9.2. Tworzenie animacji za pomocą API graficznego (261)
  • 9.2.1. Animacja poklatkowa w Androidzie (261)
  • 9.2.2. Programowe tworzenie animacji (263)
• 9.3. Wprowadzenie do OpenGL dla systemów wbudowanych (267)
  • 9.3.1. Tworzenie kontekstu OpenGL (268)
  • 9.3.2. Rysowanie prostokąta za pomocą OpenGL ES (272)
  • 9.3.3. Tworzenie trójwymiarowych kształtów i powierzchni za pomocą OpenGL ES (275)
• 9.4. Podsumowanie (279)

10. Multimedia (281)

• 10.1. Wprowadzenie do multimediów oraz OpenCORE (282)
• 10.2. Odtwarzanie dźwięków (283)
• 10.3. Odtwarzanie wideo (285)
• 10.4. Przechwytywanie mediów (287)
  • 10.4.1. Obsługa kamery (287)
  • 10.4.2. Zapisywanie dźwięku (292)
• 10.5. Zapisywanie wideo (295)
• 10.6. Podsumowanie (301)

11. Lokalizacja (303)

• 11.1. Symulowanie położenia w emulatorze (305)
  • 11.1.1. Wysyłanie współrzędnych z perspektywy DDMS (305)
  • 11.1.2. Format GPS Exchange (307)
  • 11.1.3. Keyhole Markup Language z Google Earth (309)
• 11.2. Użycie klas LocationManager i LocationProvider (311)
  • 11.2.1. Dostęp do danych lokalizacji za pomocą LocationManager (312)
  • 11.2.2. Użycie klasy LocationProvider (314)
  • 11.2.3. Odbieranie informacji o lokalizacji za pomocą klasy LocationListener (315)
• 11.3. Korzystanie z map (318)
  • 11.3.1. Dziedziczenie po MapActivity (318)
  • 11.3.2. Użycie MapView (319)
  • 11.3.3. Umieszczanie danych na mapie za pomocą Overlay (322)
• 11.4. Zamiana miejsc na adresy za pomocą klasy Geocoder (325)
• 11.5. Podsumowanie (327)

Część III. Aplikacje dla systemu Android (329)
12. Aplikacja wspomagająca serwisantów (331)

• 12.1. Projektowanie rzeczywistej aplikacji Android (333)
  • 12.1.1. Podstawowe wymagania aplikacji (333)
  • 12.1.2. Zarządzanie danymi (334)
  • 12.1.3. Architektura aplikacji i integracji (335)
• 12.2. Określanie przebiegów w aplikacji (336)
  • 12.2.1. Określanie procesów w aplikacji (337)
  • 12.2.2. Lista plików źródłowych (338)
  • 12.2.3. Plik AndroidManifest.xml aplikacji serwisanta mobilnego (340)
• 12.3. Kod źródłowy aplikacji (341)
  • 12.3.1. Aktywność Splash (341)
  • 12.3.2. Właściwości używane przez aktywność FieldService (343)
  • 12.3.3. Implementacja aktywności FieldService (344)
  • 12.3.4. Ustawienia (346)
  • 12.3.5. Zarządzanie danymi zleceń (348)
• 12.4. Kod źródłowy dla zarządzania zleceniami (355)
  • 12.4.1. Aktywność RefreshJobs (355)
  • 12.4.2. Zarządzanie zleceniami - aktywność ManageJobs (359)
  • 12.4.3. Obsługa zlecenia w aktywności ShowJob (362)
  • 12.4.4. Przechwytywanie podpisu w aktywności CloseJob (366)
• 12.5. Kod serwera (372)
  • 12.5.1. Interfejs użytkownika dyspozytora (372)
  • 12.5.2. Baza danych (373)
  • 12.5.3. Kod PHP aplikacji dyspozytora (374)
  • 12.5.4. Kod PHP do integracji z aplikacją mobilną (375)
• 12.6. Podsumowanie (376)

13. Budowanie aplikacji Android w języku C (377)

• 13.1. Budowanie aplikacji Android bez SDK (378)
  • 13.1.1. Kompilator i linker języka C (379)
  • 13.1.2. Budowanie aplikacji Witaj, świecie (380)
  • 13.1.3. Instalowanie i uruchamianie aplikacji (381)
  • 13.1.4. Skrypt budujący aplikację w języku C (383)
• 13.2. Rozwiązywanie problemu z łączeniem dynamicznym (384)
  • 13.2.1. Biblioteki systemu Android (384)
  • 13.2.2. Budowanie aplikacji łączonej dynamicznie (386)
  • 13.2.3. exit() oraz return() (389)
  • 13.2.4. Kod uruchamiający (390)
• 13.3. Która godzina? Serwer DayTime (392)
  • 13.3.1. Aplikacja serwera DayTime (392)
  • 13.3.2. Plik daytime.c (393)
  • 13.3.3. Baza danych SQLite (395)
  • 13.3.4. Budowanie i uruchamianie serwera DayTime (397)
• 13.4. Klient DayTime (399)
  • 13.4.1. Aktywność (399)
  • 13.4.2. Klient DayTime (401)
  • 13.4.3. Testowanie klienta DayTime (402)
• 13.5. Podsumowanie (402)

Część IV. Dojrzewająca platforma (405)
14. Bluetooth i sensory (407)

• 14.1. Przegląd możliwości Bluetooth w systemie Android (409)
  • 14.1.1. Zastępowanie kabli (409)
  • 14.1.2. Rola podstawowa i podrzędna oraz gniazda (410)
  • 14.1.3. Urządzenia zaufane (411)
  • 14.1.4. Podłączanie się do zdalnego urządzenia (413)
  • 14.1.5. Przechwytywanie zdarzeń Bluetooth (414)
  • 14.1.6. Uprawnienia Bluetooth (416)
• 14.2. Interakcja z obiektem SensorManager (416)
  • 14.2.1. Typy czujników (417)
  • 14.2.2. Odczyt wartości czujnika (418)
  • 14.2.3. Włączanie i wyłączanie czujników (419)
• 14.3. Budowanie aplikacji SenseBot (420)
  • 14.3.1. Interfejs użytkownika (420)
  • 14.3.2. Interpretowanie wartości czujnika (423)
  • 14.3.3. Jazda robotem (424)
  • 14.3.4. Komunikacja z robotem (425)
• 14.4. Podsumowanie (426)

15. Integracja (429)

• 15.1. Poznajemy model kontaktów Androida (430)
  • 15.1.1. Wybór otwartych rekordów (431)
  • 15.1.2. Obsługa wielu kont (433)
  • 15.1.3. Unifikowanie widoku lokalnego z różnych zdalnych magazynów (434)
  • 15.1.4. Wspólny plac zabaw (436)
• 15.2. Zaczynamy korzystać z LinkedIn (436)
• 15.3. Zarządzanie kontaktami (438)
  • 15.3.1. Wykorzystanie wbudowanej aplikacji kontaktów (438)
  • 15.3.2. Żądanie wykonania operacji z naszej aplikacji (441)
  • 15.3.3. Bezpośredni odczyt i modyfikowanie bazy danych kontaktów (443)
  • 15.3.4. Dodawanie kontaktów (444)
• 15.4. Łączenie wszystkiego (446)
  • 15.4.1. Marzenia o synchronizacji (446)
  • 15.4.2. Definiowanie kont (447)
  • 15.4.3. Usługa AccountManager (449)
• 15.5. Tworzenie konta LinkedIn (450)
  • 15.5.1. Brak obsługi urządzeń mobilnych (450)
  • 15.5.2. Uwierzytelnianie w LinkedIn (450)
• 15.6. Synchronizacja w tle z użyciem SyncAdapter (458)
  • 15.6.1. Cykl życia synchronizacji (458)
  • 15.6.2. Synchronizowanie danych LinkedIn (458)
• 15.7. Kończymy - LinkedIn w akcji (461)
  • 15.7.1. Kończenie projektu LinkedIn (461)
  • 15.7.2. Rozwiązywanie problemów (462)
  • 15.7.3. Kontynuacja (463)
• 15.8. Podsumowanie (464)

16. Tworzenie stron WWW dla systemu Android (465)

• 16.1. Czym jest programowanie WWW dla Androida (466)
  • 16.1.1. Wprowadzenie do WebKit (467)
  • 16.1.2. Analiza opcji architektury (467)
• 16.2. Optymalizacja aplikacji WWW dla Androida (468)
  • 16.2.1. Projektowanie z zachowaniem mobilności stron (469)
  • 16.2.2. Dodawanie znacznika viewport (470)
  • 16.2.3. Selektywne ładowanie treści (472)
  • 16.2.4. Analiza parametru user agent (473)
  • 16.2.5. Zapytanie media (474)
  • 16.2.6. Aplikacja tylko dla urządzeń mobilnych (476)
• 16.3. Przechowywanie danych w przeglądarce (477)
  • 16.3.1. Konfiguracja (477)
  • 16.3.2. Analiza kodu (479)
  • 16.3.3. Interfejs użytkownika (480)
  • 16.3.4. Otwieranie bazy danych (481)
  • 16.3.5. Analiza funkcji transaction() (482)
  • 16.3.6. Wstawianie i usuwanie wierszy (484)
  • 16.3.7. Testowanie aplikacji za pomocą narzędzi WebKit (485)
• 16.4. Budowanie aplikacji hybrydowej (486)
  • 16.4.1. Poznajemy kontrolkę przeglądarki (487)
  • 16.4.2. Konfigurowanie kontrolki (487)
  • 16.4.3. Implementowanie obiektu obsługi JavaScript (489)
  • 16.4.4. Użycie kodu z JavaScript (491)
  • 16.4.5. Spotkanie z JavaScript (492)
  • 16.4.6. Przede wszystkim bezpieczeństwo (494)
  • 16.4.7. Implementacja WebViewClient (496)
  • 16.4.8. Rozszerzanie przeglądarki (496)
  • 16.4.9. Wykrywanie zdarzeń nawigacyjnych (497)
  • 16.4.10. Implementacja klasy WebChromeClient (500)
• 16.5. Podsumowanie (501)

17. Widżety aplikacji (503)

• 17.1. Wprowadzenie do widżetów aplikacji (504)
  • 17.1.1. Co to jest widżet aplikacji? (504)
  • 17.1.2. Strategie instalowania widżetów (507)
• 17.2. Wprowadzenie do aplikacji SiteMonitor (509)
  • 17.2.1. Korzyści z aplikacji SiteMonitor (509)
  • 17.2.2. Interfejs użytkownika (509)
• 17.3. Architektura aplikacji SiteMonitor (513)
  • 17.3.1. Schemat projektu aplikacji (513)
  • 17.3.2. Plik po pliku (515)
• 17.4. Obsługa danych w widżetach (515)
• 17.5. Implementacja klasy AppWidgetProvider (519)
  • 17.5.1. Katalog metod klasy AppWidgetProvider (520)
  • 17.5.2. Implementowanie klasy SiteMonitorWidgetImpl (520)
  • 17.5.3. Obsługa widżetów zombie (523)
• 17.6. Wyświetlanie widżetów za pomocą RemoteViews (524)
  • 17.6.1. Korzystanie z RemoteViews (524)
  • 17.6.2. Metoda UpdateOneWidget() (525)
• 17.7. Konfigurowanie instancji widżetu (527)
  • 17.7.1. Metadane widżetu (527)
  • 17.7.2. Operacje na danych intencji (528)
  • 17.7.3. Potwierdzenie utworzenia widżetu (529)
• 17.8. Aktualizacja widżetu (531)
  • 17.8.1. Porównanie usługi z alarmem (531)
  • 17.8.2. Uruchamianie aktualizacji (532)
  • 17.8.3. Aktualizowanie widżetów (534)
• 17.9. Łączenie wszystkich elementów w pliku AndroidManifest.xml (538)
• 17.10. Podsumowanie (539)

18. Lokalizowanie aplikacji (541)

• 18.1. Potrzeba lokalizowania (542)
• 18.2. Ustawienia regionalne (543)
• 18.3. Strategie lokalizowania aplikacji (545)
  • 18.3.1. Identyfikowanie docelowych języków i danych (545)
  • 18.3.2. Identyfikowanie tekstów i zarządzanie nimi (546)
  • 18.3.3. Rysunki i układy (548)
  • 18.3.4. Data, czas, liczby i waluty (549)
  • 18.3.5. Praca z zespołem tłumaczy (550)
• 18.4. Wykorzystanie możliwości zasobów Androida (550)
  • 18.4.1. Więcej niż ustawienia regionalne (551)
  • 18.4.2. Przypisywanie tekstów z zasobów (551)
• 18.5. Lokalizowanie kodu Java (553)
• 18.6. Formatowanie lokalizowanych napisów (554)
• 18.7. Problemy z lokalizowaniem (556)
• 18.8. Podsumowanie (557)

19. Android Native Development Kit (559)

• 19.1. Wprowadzenie do NDK (560)
  • 19.1.1. Zastosowania NDK (561)
  • 19.1.2. Przegląd NDK (561)
• 19.2. Budowanie aplikacji za pomocą NDK (563)
  • 19.2.1. Demonstracja gotowej aplikacji (563)
  • 19.2.2. Struktura projektu (565)
• 19.3. Budowanie biblioteki JNI (565)
  • 19.3.1. Poznajemy JNI (566)
  • 19.3.2. Implementacja biblioteki (567)
  • 19.3.3. Kompilowanie biblioteki JNI (571)
• 19.4. Budowanie interfejsu użytkownika (572)
  • 19.4.1. Układ interfejsu użytkownika (572)
  • 19.4.2. Wykonanie zdjęcia (574)
  • 19.4.3. Wyszukiwanie krawędzi (576)
• 19.5. Integracja NDK w Eclipse (577)
• 19.6. Podsumowanie (578)

Część V. Dodatki (581)
A Instalowanie Android SDK (583)

• A.1. Wymagania środowiska programistycznego (584)
• A.2. Pobieranie i instalowanie Eclipse (584)
• A.3. Pobieranie i instalowanie Android SDK (587)
• A.4. Korzystanie z SDK oraz AVD Manager (587)
• A.5. Pobieranie i instalowanie wtyczki Eclipse (590)
• A.6. Konfigurowanie wtyczki Eclipse (592)

B Publikowanie aplikacji (595)

• B.1. Przygotowanie aplikacji do dystrybucji (596)
  • B.1.1. Rejestrowanie (596)
  • B.1.2. Powiadomienia debugowania (596)
  • B.1.3. Przykładowe dane (596)
  • B.1.4. Plik AndroidManifest.xml (597)
  • B.1.5. Licencja użytkownika (597)
  • B.1.6. Testowanie (598)
  • B.1.7. Operacje końcowe (598)
• B.2. Podpisywanie cyfrowe aplikacji (599)
  • B.2.1. Magazyny kluczy (599)
  • B.2.2. keytool (599)
  • B.2.3. jarsigner (600)
• B.3. Publikowanie w Android Market (602)
  • B.3.1. Zasady Android Market (602)
  • B.3.2. Umieszczanie aplikacji w Android Market (603)
  • B.3.3. Android Market - właściwe rozwiązanie (603)
• B.4. Inne sposoby dystrybucji (604)
• B.5. Podsumowanie Android Debug Bridge (606)