O autorze (9)

Redaktorzy techniczni (11)

Podziękowania (13)

Wprowadzenie (15)

Rozdział 1. Optymalizowanie kodu w Javie (17)

• W jaki sposób Android wykonuje kod? (18)
  
• Optymalizowanie obliczania ciągu Fibonacciego (20)
  
  • Od rekurencji do iteracji (20)
  • Typ BigInteger (21)
• Zapisywanie wyników w pamięci podręcznej (25)
  
  • Klasa android.util.LruCache<K, V> (27)
• Wersje interfejsu API (28)
  
  • Fragmentacja rynku (30)
• Struktury danych (30)
  
• Reagowanie (33)
  
  • Leniwe inicjowanie (35)
  • Klasa StrictMode (35)
• SQLite (37)
  
  • Instrukcje bazy SQLite (37)
  • Transakcje (40)
  • Zapytania (41)
• Podsumowanie (42)

Rozdział 2. Wprowadzenie do pakietu NDK (43)

• Co znajduje się w pakiecie NDK? (44)
  
• Łączenie Javy oraz C i C++ (46)
  
  • Deklarowanie metody natywnej (47)
  • Implementowanie warstwy łączącej JNI (47)
  • Tworzenie plików makefile (49)
  • Implementowanie funkcji natywnej (50)
  • Kompilowanie biblioteki natywnej (52)
  • Wczytywanie biblioteki natywnej (52)
• Plik Application.mk (53)
  
  • Optymalizowanie pod kątem (prawie) wszystkich urządzeń (54)
  • Obsługa wszystkich urządzeń (56)
• Plik Android.mk (58)
  
• Usprawnianie wydajności za pomocą kodu w językach C lub C++ (60)
  
  • Więcej o JNI (64)
• Klasa NativeActivity (68)
  
  • Budowanie brakującej biblioteki (70)
  • Inne podejście (76)
• Podsumowanie (77)

Rozdział 3. Zaawansowane mechanizmy pakietu NDK (79)

• Asembler (79)
  
  • Największy wspólny dzielnik (80)
  • Przekształcanie zapisu kolorów (84)
  • Równoległe obliczanie średniej (88)
  • Instrukcje architektury ARM (91)
  • Rozszerzenie NEON (98)
  • Mechanizmy procesora (98)
• Rozszerzenia języka C (100)
  
  • Funkcje wbudowane (100)
  • Instrukcje dla wektorów (101)
• Wskazówki (105)
  
  • Rozwijanie funkcji (105)
  • Rozwijanie pętli (105)
  • Wstępne wczytywanie do pamięci (106)
  • Stosowanie instrukcji LDM i STM zamiast LDR i STD (107)
• Podsumowanie (107)

Rozdział 4. Wydajne korzystanie z pamięci (109)

• Krótko o pamięci (109)
  
• Typy danych (110)
  
  • Porównywanie wartości (112)
  • Inne algorytmy (114)
  • Sortowanie tablic (115)
  • Tworzenie własnych klas (116)
• Dostęp do pamięci (117)
  
  • Długość wiersza w pamięci podręcznej (118)
• Określanie struktury danych (118)
  
• Przywracanie pamięci (123)
  
  • Wyciekanie pamięci (123)
  • Referencje (124)
• Interfejsy API (128)
  
• Mała ilość pamięci (128)
  
• Podsumowanie (129)

Rozdział 5. Wielowątkowość i synchronizacja (131)

• Wątki (132)
  
• Klasa AsyncTask (134)
  
• Klasy Handler i Looper (137)
  
  • Obiekty Handler (137)
  • Obiekty Looper (139)
• Typy danych (139)
  
  • Model pamięci a słowa kluczowe synchronized i volatile (140)
• Współbieżność (143)
  
• Architektury wielordzeniowe (144)
  
  • Modyfikowanie algorytmu pod kątem architektury wielordzeniowej (145)
  • Stosowanie współbieżnej pamięci podręcznej (148)
• Cykl życia aktywności (150)
  
  • Przekazywanie informacji (151)
  • Zapamiętywanie stanu (153)
• Podsumowanie (156)

Rozdział 6. Testy szybkości i profilowanie (157)

• Pomiar czasu (157)
  
  • System.nanoTime() (158)
  • Debug.threadCpuTimeNanos() (159)
• Śledzenie (160)
  
  • Debug.startMethodTracing() (160)
  • Korzystanie z narzędzia Traceview (161)
  • Narzędzie Traceview w perspektywie DDMS (163)
  • Śledzenie kodu natywnego (164)
• Rejestrowanie komunikatów (166)
  
• Podsumowanie (168)

Rozdział 7. Maksymalizowanie czasu pracy na baterii (169)

• Baterie (169)
  
  • Pomiar zużycia baterii (171)
• Wyłączanie odbiorników rozgłoszeniowych (174)
  
  • Wyłączanie i włączanie odbiornika rozgłoszeniowego (176)
• Sieć (178)
  
  • Pobieranie danych w tle (178)
  • Transfer danych (179)
• Lokalizacja (181)
  
  • Wyrejestrowywanie odbiornika (182)
  • Częstotliwość aktualizacji (183)
  • Wielu dostawców (184)
  • Filtrowanie dostawców (185)
  • Ostatnia znana lokalizacja (187)
• Czujniki (188)
  
• Grafika (189)
  
• Alarmy (190)
  
  • Planowanie zgłaszania alarmów (191)
• Blokady WakeLock (192)
  
  • Zapobieganie problemom (193)
• Podsumowanie (194)

Rozdział 8. Grafika (195)

• Optymalizowanie układów (195)
  
  • Układ RelativeLayout (197)
  • Scalanie układów (200)
  • Ponowne wykorzystanie układów (201)
  • Namiastki widoków (203)
• Narzędzia wspomagające tworzenie układów (204)
  
  • Przeglądarka hierarchii (205)
  • Narzędzie layoutopt (205)
• Standard OpenGL ES (205)
  
  • Rozszerzenia (206)
  • Kompresja tekstur (207)
  • Mipmapy (212)
  • Różne pliki APK (213)
  • Programy cieniowania (213)
  • Złożoność sceny (214)
  • Odrzucanie (214)
  • Tryb renderowania (214)
  • Zużycie energii (214)
• Podsumowanie (215)

Rozdział 9. RenderScript (217)

• Wprowadzenie (217)
  
• Witaj, świecie (219)
  
• Witaj, renderingu (222)
  
  • Tworzenie skryptu renderującego (222)
  • Tworzenie kontekstu (obiektu RenderScriptGL) (223)
  • Rozszerzanie klasy RSSurfaceView (224)
  • Ustawianie widoku zawartości (224)
• Stosowanie zmiennych w skrypcie (225)
  
• Aplikacja HelloCompute (228)
  
  • Obiekty Allocation (229)
  • Funkcja rsForEach (229)
  • Wydajność (233)
• Natywne interfejsy API dla RenderScriptu (234)
  
  • Plik rs_types.rsh (234)
  • Plik rs_core.rsh (237)
  • Plik rs_cl.rsh (238)
  • Plik rs_math.rsh (241)
  • Plik rs_graphics.rsh (242)
  • Plik rs_time.rsh (243)
  • Plik rs_atomic.rsh (244)
• RenderScript a NDK (244)
  
• Podsumowanie (245)

Skorowidz (247)

• Tytuł: Optymalizacja wydajności aplikacji na Android
• Autor: Hervé Guihot
• Tytuł oryginału: Pro Android Apps Performance Optimization (Professional Apress)
• Tłumaczenie: Tomasz Walczak
• ISBN: 978-83-246-5556-4, 9788324655564
• Data wydania: 2013-07-02
• Format: Ebook
• Identyfikator pozycji: optwyd
• Wydawca: Helion