Programowanie aplikacji na iPhone 4. Poznaj platformę iOS SDK3 od podstaw - ebook

• Jak przygotować środowisko pracy?
• Jak zaprojektować atrakcyjny interfejs użytkownika?
• Jak wykorzystać potencjał ekranów dotykowych i gestów?

iPhone, iPad, iPod Touch - kto nie zna tych urządzeń? Zmieniły one sposób, w jaki korzystamy z telefonii komórkowej, internetu, oraz to, jak słuchamy muzyki. Perfekcyjny interfejs użytkownika oraz nowoczesny, choć elegancki design sprawiły, że urządzenia te podbiły serca ludzi w każdym wieku. Używają ich nastolatkowie oraz stateczni biznesmeni. Dzięki tej popularności ich użytkownicy są łakomym kąskiem dla producentów oprogramowania. Udostępniając atrakcyjną aplikację, błyskawicznie możesz zyskać dziesiątki tysięcy potencjalnych klientów. Na aplikacjach na te urządzenia naprawdę można zarobić konkretne pieniądze!

Dzięki tej książce błyskawicznie opanujesz niuanse tworzenia oprogramowania dla systemu iOS. Na początek poznasz jego charakterystyczne cechy oraz skonfigurujesz swoje środowisko pracy. Jesteś gotowy do nauki? Zaczynamy. Obsługa interakcji, projektowanie interfejsu użytkownika, obsługa wirtualnej klawiatury to tylko niektóre z elementów, które opanujesz na wstępie. Potem z każdym rozdziałem jest coraz ciekawiej! Nauczysz się zarządzać pamięcią, przechowywać dane użytkownika oraz tworzyć zaawansowane obiekty graficzne za pomocą bibliotek Quartz i OpenGL.
Ponadto dowiesz się, jak maksymalnie wykorzystać potencjał ekranów dotykowych, usług geolokalizacyjnych oraz czujników położenia i przyśpieszenia. Na sam koniec zobaczysz, jak tworzyć aplikacje obsługujące wiele języków, tak żeby Twoje dzieło mogło zdobyć popularność na rynku międzynarodowym. Książka ta jest idealną i wymarzoną pozycją dla wszystkich osób tworzących rozwiązania dla platformy spod znaku ugryzionego jabłka. Sprawdzi się ona również wyśmienicie w rękach nowicjusza, dla którego będzie stanowiła przewodnik programisty po systemie iOS.

• Cechy charakterystyczne platformy iOS
• Obsługa interakcji
• Akcje
• Uruchamianie aplikacji
• Projektowanie i tworzenie interfejsu użytkownika
• Automatyczna rotacja i zmiana rozmiaru interfejsu
• Korzystanie z wielu widoków
• Wykorzystanie paska zakładek
• Obsługiwane czcionki
• Zastosowanie TableView
• Nawigacja w tabelach
• Ustawienia aplikacji i użytkownika
• Przechowywanie danych
• Technologia Grand Central Dispatch
• Cykl życia aplikacji
• Quartz i OpenGL - rysowanie na ekranie
• Obsługa ekranów dotykowych i gestów
• Usługi geolokalizacyjne
• Wykorzystanie informacji z żyroskopu i akcelerometru
• Korzystanie z aparatu
• Tworzenie aplikacji wielojęzycznych

O autorach (13)

O recenzencie (15)

Wstęp (17)

Rozdział 1. Witamy w dżungli (19)

• Dla kogo jest przeznaczona ta książka? (19)
  
• Co będzie potrzebne? (20)
  
  • Programy oferowane programistom (21)
  • Co trzeba wiedzieć? (22)
• Czym się wyróżnia programowanie na platformę iOS? (23)
  
  • Tylko jedna aktywna aplikacja (23)
  • Tylko jedno okno (23)
  • Ograniczony dostęp (23)
  • Ograniczony czas udzielenia odpowiedzi (24)
  • Ekran o ograniczonej wielkości (24)
  • Ograniczone zasoby systemowe (24)
  • Brak mechanizmu Garbage Collection (25)
  • Niektóre z nowych funkcji (25)
  • Inne podejście (25)
• Co nowego w tej książce? (25)
  
• Co nowego w tym wydaniu? (27)
  
• Czy jesteś gotowy? (27)

Rozdział 2. Udobruchanie bogów (29)

• Konfiguracja projektu w Xcode (29)
  
  • Okno projektu w Xcode (32)
• Wprowadzenie do programu Interface Builder (34)
  
  • Czym jest plik nib? (35)
  • Dodanie etykiety do widoku (36)
  • Zmiana atrybutów (39)
• Dopracowanie zbudowanej aplikacji (40)
  
  • Gotowość do kompilacji i uruchomienia (42)
• Podsumowanie (44)

Rozdział 3. Obsługa podstawowej interakcji (45)

• Architektura Model-View-Controller (46)
  
• Utworzenie projektu (46)
  
• Utworzenie kontrolera widoku (47)
  
  • Outlety (48)
  • Akcje (48)
  • Dodanie akcji i outletów do kontrolera widoku (49)
  • Dodanie akcji i outletów do pliku implementacji (52)
• Używanie delegata aplikacji (56)
  
• Edycja pliku MainWindow.xib (59)
  
• Edycja pliku Button_FunViewController.xib (60)
  
  • Utworzenie widoku w programie Interface Builder (60)
  • Połączenie elementów w całość (62)
  • Wypróbowanie aplikacji (66)
• Podsumowanie (66)

Rozdział 4. Dalsza praca z interfejsem użytkownika (67)

• Ekran pełen kontrolek (67)
  
• Kontrolki aktywne i pasywne (68)
  
• Tworzenie aplikacji (71)
  
• Implementacja pola obrazu i pól tekstowych (71)
  
  • Określenie outletów (71)
  • Określenie akcji (72)
  • Dodanie elementu Image View (73)
  • Dodanie pól tekstowych (77)
  • Ustawienie atrybutów drugiego pola tekstowego (81)
  • Połączenie outletów (82)
• Zamknięcie klawiatury (82)
  
  • Zamknięcie klawiatury po zakończeniu wprowadzania danych (82)
  • Dotknięcie tła w celu zamknięcia klawiatury (83)
• Implementacja suwaka i etykiety (86)
  
  • Określenie outletów i akcji (86)
  • Dodanie outletów i akcji (87)
  • Dodanie suwaka i etykiety (88)
  • Połączenie akcji i outletu (89)
• Implementacja przełączników, przycisku i kontrolki segmentowej (89)
  
  • Dodanie outletów i akcji (90)
  • Dodanie przełączników, przycisku oraz kontrolki segmentowanej (92)
  • Połączenie outletów przełączników i akcji (93)
  • Dodanie przycisku (94)
• Implementacja panelu Action Sheet oraz komunikatu (95)
  
  • Spełnienie wymagań metody delegata Action Sheet (96)
  • Wyświetlenie elementu Action Sheet (96)
  • Używanie delegata Action Sheet (98)
• Uatrakcyjnienie przycisku (99)
  
  • Używanie metody viewDidLoad (100)
  • Stany kontrolki (100)
  • Rozciągane obrazy (101)
• Prawidłowe zachowanie podczas zarządzania pamięcią (101)
  
• Podsumowanie (102)

Rozdział 5. Automatyczna rotacja i zmiana wielkości (103)

• Automatyczna rotacja (104)
  
• Obsługa rotacji za pomocą atrybutów Autosize (105)
  
  • Włączenie obsługi rotacji (105)
  • Projektowanie interfejsu z użyciem atrybutów Autosize (107)
  • Używanie atrybutów Autosize w oknie inspektora (108)
  • Ustawienie atrybutów Autosize dla przycisków (110)
• Rekonstrukcja widoku podczas rotacji (111)
  
  • Zdefiniowanie i połączenie outletów (112)
  • Przenoszenie przycisków po rotacji (112)
• Zamiana widoków (114)
  
  • Określenie outletów i akcji (116)
  • Zdefiniowanie outletów i akcji (116)
  • Zaprojektowanie dwóch widoków (117)
  • Implementacja zamiany widoków i akcji (118)
• Podsumowanie (120)

Rozdział 6. Aplikacje z wieloma widokami (121)

• Najczęściej spotykane typy aplikacji z wieloma widokami (121)
  
• Architektura aplikacji z wieloma widokami (124)
  
  • Kontroler główny (127)
  • Anatomia widoku z treścią (127)
  • Budowa aplikacji View Switcher (128)
  • Utworzenie kontrolera widoku oraz plików nib (129)
  • Modyfikacja delegata aplikacji (130)
  • SwitchViewController.h (132)
  • Dodanie kontrolera widoku (132)
  • Budowanie widoku z paskiem narzędzi (135)
  • Utworzenie głównego kontrolera widoku (137)
  • Implementacja widoków z treścią (140)
  • Animacja przełączania widoków (143)
• Podsumowanie (146)

Rozdział 7. Pasek zakładek i kontrolka Picker (147)

• Aplikacja Pickers (147)
  
• Delegaci i źródła danych (149)
  
• Konfiguracja struktury paska zakładek (152)
  
  • Utworzenie plików (152)
  • Dodanie kontrolera głównego (152)
  • Edycja pliku MainWindow.xib (154)
  • Połączenie outletu, a następnie uruchomienie (159)
• Implementacja kontrolki Picker do wyboru daty (159)
  
• Implementacja kontrolki Picker z pojedynczym komponentem (162)
  
  • Zdefiniowanie outletów i akcji (162)
  • Utworzenie widoku (162)
  • Implementacja kontrolera jako źródła danych i delegata (163)
• Implementacja kontrolki Picker z wieloma komponentami (167)
  
  • Zdefiniowanie outletów i akcji (167)
  • Utworzenie widoku (168)
  • Implementacja kontrolera (168)
• Implementacja kontrolki Picker z komponentami zależnymi od siebie (171)
  
• Utworzenie prostej gry z użyciem kontrolki Picker (177)
  
  • Zapis pliku nagłówkowego kontrolera (177)
  • Utworzenie widoku (178)
  • Dodanie grafiki do zasobów aplikacji (179)
  • Implementacja kontrolera (179)
  • Ostatnie szczegóły (184)
  • Dołączenie struktury Audio Toolbox do projektu (189)
• Podsumowanie (190)

Rozdział 8. Wprowadzenie do Table View (191)

• Podstawy Table View (191)
  
  • Kontrolki Table View i Table View Cell (191)
  • Tabele zwykłe i grupowane (193)
• Implementacja prostej tabeli (194)
  
  • Tworzenie widoku (194)
  • Utworzenie kontrolera (195)
  • Dodanie grafiki (198)
  • Stosowanie stylów komórki tabeli (200)
  • Określenie poziomu wcięcia (201)
  • Obsługa wyboru rekordu (202)
  • Zmiana wielkości czcionki i wysokości rekordu (203)
• Dostosowanie komórki tabeli do własnych potrzeb (206)
  
  • Dodawanie podwidoków do komórki tabeli (206)
  • Wczytanie UITableViewCell z pliku nib (210)
• Tabele grupowane i indeksowane (215)
  
  • Utworzenie widoku (215)
  • Import danych (215)
  • Implementacja kontrolera (215)
  • Dodanie indeksu (218)
• Implementacja paska wyszukiwania (220)
  
  • Ponowne przemyślenie projektu (220)
  • Pełna, modyfikowalna kopia (221)
  • Uaktualnienie pliku nagłówkowego kontrolera (223)
  • Modyfikacja widoku (224)
  • Modyfikacja implementacji kontrolera (226)
• Podsumowanie (237)

Rozdział 9. Kontrolery nawigacyjne i tabele (239)

• Kontrolery nawigacyjne (239)
  
  • Koncepcja stosu (240)
  • Stos kontrolerów (240)
• Aplikacja hierarchiczna Nav w sześciu odsłonach (241)
  
  • Podkontrolery (241)
  • Szkielet aplikacji Nav (245)
  • Pierwszy podkontroler: przycisk Filmy (254)
  • Drugi podkontroler: widok listy (262)
  • Trzeci podkontroler: kontrolki w rekordzie tabeli (266)
  • Czwarty podkontroler: ruchome rekordy (273)
  • Piąty podkontroler: rekordy do usunięcia (279)
  • Szósty podkontroler: edytowalny widok szczegółów (284)
  • Jest coś jeszcze... (303)
• Podsumowanie (306)

Rozdział 10. iPad (307)

• Widoki podzielone i Popover (307)
  
  • Utworzenie projektu SplitView (308)
  • Plik xib definiuje strukturę (310)
  • Kod definiuje funkcjonalność (312)
• Aplikacja Presidents (319)
  
  • Utworzenie własnego widoku Popover (323)
• Podsumowanie (329)

Rozdział 11. Ustawienia aplikacji i ustawienia domyślne użytkownika (331)

• Poznajemy systemową aplikację Ustawienia (331)
  
• Aplikacja AppSettings (332)
  
  • Utworzenie projektu (337)
  • Praca z grupą Settings Bundle (337)
  • Odczyt preferencji w aplikacji (348)
  • Zmiana ustawień domyślnych aplikacji (353)
  • Ostatnie zmiany (356)
• Podsumowanie (359)

Rozdział 12. Podstawy przechowywania danych (361)

• Aplikacje są odseparowane od siebie (362)
  
  • Pobieranie ścieżki dostępu do katalogu dokumentów (362)
  • Pobranie ścieżki dostępu do katalogu tmp (363)
• Strategie zapisu plików (363)
  
  • Przechowywanie danych w pojedynczym pliku (364)
  • Przechowywanie danych w wielu plikach (364)
• Używanie plików typu property list (364)
  
  • Serializacja plików typu property list (364)
  • Pierwsza wersja aplikacji trwale przechowującej dane (365)
• Archiwizacja obiektów modelu (371)
  
  • Spełnienie wymagań protokołu NSCoding (371)
  • Implementacja protokołu NSCopying (372)
  • Archiwizacja i dearchiwizacja obiektów danych (373)
  • Archiwizacja w aplikacji (374)
• Używanie bazy danych SQLite3 wbudowanej w iOS (378)
  
  • Utworzenie lub otworzenie bazy danych (379)
  • Używanie zmiennych dołączanych (380)
  • Aplikacja używająca SQLite3 (381)
• Używanie Core Data (387)
  
  • Encje i obiekty zarządzane (388)
  • Aplikacja wykorzystująca Core Data (392)
• Podsumowanie (401)

Rozdział 13. Technologia Grand Central Dispatch, przetwarzanie w tle i programista (403)

• Technologia Grand Central Dispatch (403)
  
• Aplikacja SlowWorker (404)
  
• Podstawy wątków (407)
  
• Jednostki pracy (408)
  
• GDC - kolejkowanie niskiego poziomu (408)
  
  • Rozpoczęcie pracy z blokami (409)
  • Usprawnienie aplikacji SlowWorker (410)
• Przetwarzanie w tle (415)
  
  • Cykl życiowy aplikacji (416)
  • Powiadomienia o zmianie stanu (416)
  • Utworzenie aplikacji State Lab (418)
  • Stan wykonywania aplikacji (418)
  • Wykorzystanie zmian stanu działania aplikacji (420)
  • Obsługa stanu nieaktywnego (421)
  • Obsługa stanu działania w tle (425)
• Podsumowanie (433)

Rozdział 14. Rysowanie za pomocą Quartz i OpenGL (435)

• Dwie strony świata grafiki (435)
  
• Rysowanie za pomocą Quartz (436)
  
  • Kontekst graficzny w Quartz 2D (436)
  • System współrzędnych (437)
  • Określenie koloru (438)
  • Rysowanie obrazów w kontekście (440)
  • Rysowanie kształtów - wielokąty, linie i krzywe (441)
  • Próbka możliwości Quartz 2D - wzorce, przejścia barw i różne wzorce linii (441)
• Aplikacja QuartzFun (441)
  
  • Konfiguracja aplikacji QuartzFun (441)
  • Dodanie kodu Quartz odpowiedzialnego za rysowanie (453)
  • Optymalizacja aplikacji QuartzFun (457)
• Aplikacja GLFun (461)
  
  • Konfiguracja aplikacji GLFun (461)
  • Rysowanie za pomocą OpenGL (463)
  • Ukończenie aplikacji GLFun (469)
• Podsumowanie (470)

Rozdział 15. Obsługa ekranu dotykowego i gestów (471)

• Terminologia Multitouch (471)
  
  • Łańcuch odpowiedzi (472)
  • Przekazywanie zdarzenia: utrzymywanie łańcucha odpowiedzi (473)
• Architektura Multitouch (474)
  
  • Gdzie należy umieścić kod? (474)
  • Cztery metody informujące o dotknięciu (474)
• Wykrywanie dotknięcia ekranu (475)
  
  • Budowa aplikacji TouchExplorer (476)
  • Uruchomienie TouchExplorer (479)
• Wykrywanie machnięcia (479)
  
  • Budowa aplikacji Swipes (479)
  • Stosowanie automatycznego rozpoznawania gestów (482)
  • Implementacja gestu machnięcia wieloma palcami (483)
• Wykrywanie wielu naciśnięć (485)
  
• Wykrywanie uszczypnięć (490)
  
• Tworzenie i używanie własnych gestów (492)
  
  • Zdefiniowanie gestu "ptaszka" (493)
  • Dołączenie nowego gestu do widoku (496)
• Podsumowanie (497)

Rozdział 16. Gdzie jestem? Wyszukiwanie drogi za pomocą Core Location (499)

• Menedżer lokalizacji (500)
  
  • Ustawienie żądanej dokładności (500)
  • Ustawienie filtru odległości (500)
  • Uruchomienie menedżera lokalizacji (501)
  • Rozsądne używanie menedżera lokalizacji (501)
• Delegat menedżera lokalizacji (501)
  
  • Pobieranie uaktualnień określających położenie (501)
  • Pobieranie współrzędnych geograficznych za pomocą CLLocation (501)
  • Powiadamianie o błędach (503)
• Wypróbowanie Core Location (504)
  
  • Uaktualnianie menedżera lokalizacji (508)
  • Obliczenie pokonanej odległości (509)
• Podsumowanie (509)

Rozdział 17. Żyroskop i przyspieszeniomierz (511)

• Zasada działania przyspieszeniomierza (511)
  
• Nie wolno zapomnieć o rotacji (512)
  
• Core Motion i menedżer ruchu (513)
  
  • Ruch na bazie zdarzeń (513)
  • Proaktywny dostęp do wartości dotyczących ruchu (518)
  • Wyniki przyspieszeniomierza (520)
• Wykrywanie wstrząsów (521)
  
  • Wbudowane wykrywanie wstrząsów (522)
  • Aplikacja ShakeAndBreak (523)
• Przyspieszeniomierz jako kontroler kierunkowy (528)
  
  • Tocząca się kula (528)
  • Utworzenie klasy BallView (530)
  • Obliczanie ruchu kuli (533)
• Podsumowanie (535)

Rozdział 18. Aparat fotograficzny w iPhonie i biblioteka zdjęć (537)

• Używanie Image Picker i UIImagePickerController (537)
  
• Implementacja delegata Image Picker Controller (539)
  
• Praktyczny test aparatu fotograficznego i biblioteki treści multimedialnych (540)
  
  • Utworzenie interfejsu użytkownika (542)
  • Implementacja kontrolera (542)
• Podsumowanie (546)

Rozdział 19. Tłumaczenie aplikacji na inny język (547)

• Architektura przeznaczona do tłumaczenia aplikacji (547)
  
• Pliki ciągów tekstowych (548)
  
  • Czym jest plik ciągu tekstowego? (549)
  • Makro LocalizedString (549)
• Lokalizacja aplikacji w praktyce (550)
  
  • Konfiguracja aplikacji LocalizeMe (550)
  • Wypróbowanie aplikacji LocalizeMe (554)
  • Tłumaczenie pliku nib (555)
  • Użycie odpowiedniej wersji obrazu (559)
  • Generowanie i tłumaczenie pliku ciągów tekstowych (559)
  • Lokalizacja wyświetlanej nazwy aplikacji (562)
• Do widzenia (563)

Rozdział 20. Co dalej? (565)

• Gdzie szukać pomocy? (565)
  
  • Dokumentacja Apple (565)
  • Listy dyskusyjne (566)
  • Fora dyskusyjne (566)
  • Witryny internetowe (567)
  • Blogi (567)
  • Konferencje (568)
  • Obserwuj poczynania autorów (569)
• Pożegnanie (569)

Skorowidz (571)