Wprowadzenie (13)

Wprowadzenie do pierwszego wydania (15)

Podziękowania (17)

O książce (19)

O ilustracji na okładce (25)

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)

Skorowidz (609)

• Tytuł: Android w akcji. Wydanie II
• Autor: Frank Ableson, Robi Sen
• Tytuł oryginału: Android in Action 2nd edition
• Tłumaczenie: Paweł Gonera
• ISBN: 978-83-246-3957-1, 9788324639571
• Data wydania: 2012-02-22
• Format: Ebook
• Identyfikator pozycji: andrak
• Wydawca: Helion