Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00251 001500 12927645 na godz. na dobę w sumie
Objective-C. Podstawy - książka
Objective-C. Podstawy - książka
Autor: , , Liczba stron: 392
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-4144-4 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> c - programowanie
Porównaj ceny (książka, ebook, audiobook).

Wejdź pewnym krokiem w świat programowania Apple!

Jeszcze parę lat temu nie do pomyślenia było, że aplikacje na urządzenia mobilne mogą stanowić tak intratny interes. Jednak urządzenia te podbiły rynek w mgnieniu oka i dziś trudno wyobrazić sobie życie bez nich. Co więcej, dały one jeszcze większe możliwości działania różnym projektantom - praktycznie wszystkie wyposażone są w aparat fotograficzny, odbiornik GPS oraz czujniki położenia. To peryferia, o których programiści tworzący aplikacje na standardowe komputery mogą tylko pomarzyć. Zastanawiasz się, jak wykorzystać ten potencjał?

Ta książka dostarczy Ci odpowiedzi. W trakcie lektury nauczysz się tworzyć atrakcyjne aplikacje na platformę iOS. Jest ona wykorzystywana w urządzeniach firmy Apple, których nikomu nie trzeba przedstawiać. Podczas tworzenia aplikacji dla tej platformy będziesz korzystał z języka Objective-C oraz środowiska XCode 4. Zawarta tu wiedza i liczne przykłady krok-po-kroku pozwolą Ci błyskawicznie opanować trudniejsze partie materiału. Książka ta jest idealną pozycją dla wszystkich programistów chcących rozpocząć przygodę z platformą iOS.

Sprawdź:

Twój przewodnik do pierwszej aplikacji na system iOS!


Christopher Fairbairn, Johannes Fahrenkrug i Collin Ruffenach są profesjonalnymi twórcami oprogramowania działającego na platformach mobilnych. Każdy z nich ma więcej niż dziesięcioletnie doświadczenie w używaniu różnych systemów, takich jak iOS, Palm, Windows Mobile i Java.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Objective-C Fundamentals, ISBN: 1935182536 Tłumaczenie: Robert Górczyński ISBN: 978-83-246-4144-4 Original edition copyright © 2012 by Manning Publications Co. All rights reserved. Polish edition copyright © 2012 by HELION S.A. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: helion@helion.pl WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie?objecp Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/objecp.zip Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis treĂci WstÚp PodziÚkowania O ksiÈĝce Forum Author Online Informacje na temat ilustracji umieszczonej na okïadce 11 13 15 19 20 CzÚĂÊ I. RozpoczÚcie pracy z Objective-C 1. Twoja pierwsza aplikacja iOS 21 23 1.1. Wprowadzenie do narzÚdzi programistycznych na platformÚ iOS ........................................ 24 1.1.1. Dostosowanie struktur Cocoa do potrzeb urzÈdzeñ mobilnych ...................................... 25 1.2. Dostosowanie swoich oczekiwañ ................................................................................................ 26 1.2.1. Specyfikacja sprzÚtowa na koniec 2011 roku ..................................................................... 26 1.2.2. Spodziewaj siÚ zawodnego poïÈczenia z internetem ........................................................ 27 1.3. Przygotowanie prostej gry Coin Toss w Xcode ......................................................................... 28 1.3.1. Wprowadzenie do Ărodowiska IDE firmy Apple — Xcode ............................................. 29 1.3.2. ’atwe uruchamianie Xcode ................................................................................................ 29 1.3.3. Utworzenie projektu ........................................................................................................... 30 1.3.4. Tworzenie kodu ěródïowego .............................................................................................. 33 1.4. Przygotowanie interfejsu uĝytkownika ...................................................................................... 37 1.4.1. Dodanie kontrolek do widoku ............................................................................................ 38 1.4.2. PoïÈczenie kontrolek z kodem ěródïowym ........................................................................ 39 4 Spis treĂci 2. Typy danych, zmienne i staïe 1.5. Kompilacja gry ............................................................................................................................. 43 1.6. Uruchomienie gry ........................................................................................................................ 44 1.6.1. Wybór urzÈdzenia docelowego .......................................................................................... 44 1.6.2. Uĝywanie punktów kontrolnych do Ăledzenia stanu dziaïajÈcej aplikacji ....................... 45 1.6.3. Uruchomienie gry Coin Toss w symulatorze .................................................................... 46 1.6.4. Uĝywanie moduïu usuwania bïÚdów ................................................................................. 47 1.7. Podsumowanie .............................................................................................................................. 49 51 2.1. Wprowadzenie do aplikacji Rental Manager ........................................................................... 52 2.1.1. Podstawy aplikacji ............................................................................................................... 53 2.2. Podstawowe typy danych ............................................................................................................. 55 2.2.1. Liczenie na palcach — liczby caïkowite ............................................................................ 56 2.2.2. Liczby zmiennoprzecinkowe .............................................................................................. 59 2.2.3. Znaki i ciÈgi tekstowe .......................................................................................................... 61 2.2.4. WartoĂci boolowskie ........................................................................................................... 63 2.3. WyĂwietlanie i konwersja wartoĂci ............................................................................................ 65 2.3.1. Funkcja NSLog() i specyfikatory formatu .......................................................................... 65 2.3.2. Rzutowanie typów i konwersja typów ................................................................................ 67 2.4. Tworzenie wïasnych typów danych ............................................................................................ 69 2.4.1. Typy wyliczeniowe .............................................................................................................. 69 2.4.2. Struktury .............................................................................................................................. 71 2.4.3. Tablice ................................................................................................................................. 73 2.4.4. Waga odpowiednich nazw .................................................................................................. 75 2.5. Ukoñczenie aplikacji Rental Manager 1.0, czyli kierujemy siÚ do App Store! ...................... 77 2.6. Podsumowanie .............................................................................................................................. 79 81 3.1. Krótkie wprowadzenie do koncepcji programowania zorientowanego obiektowo .............. 82 3.1.1. Co zïego jest w jÚzyku proceduralnym, takim jak C? ....................................................... 82 3.1.2. Czym jest obiekt? ................................................................................................................ 83 3.1.3. Czym jest klasa? .................................................................................................................. 83 3.1.4. Dziedziczenie i polimorfizm .............................................................................................. 83 3.2. BrakujÈcy typ danych — id ......................................................................................................... 84 3.3. Wskaěniki i róĝnice pomiÚdzy odniesieniem i wartoĂciÈ typu ................................................ 85 3.3.1. Mapowanie pamiÚci ............................................................................................................ 86 3.3.2. Pobieranie adresu zmiennej ............................................................................................... 86 3.3.3. PodÈĝanie za wskaěnikiem .................................................................................................. 87 3.3.4. Porównywanie wartoĂci wskaěników ................................................................................. 88 3.4. Komunikacja z obiektami ............................................................................................................ 89 3.4.1. Wysyïanie wiadomoĂci obiektowi ...................................................................................... 89 3.4.2. Wysyïanie wiadomoĂci klasie ............................................................................................. 90 3.4.3. Wysyïanie nieistniejÈcych wiadomoĂci .............................................................................. 90 3.4.4. Wysïanie wiadomoĂci do nil ............................................................................................... 92 3.5. CiÈgi tekstowe .............................................................................................................................. 93 3.5.1. Tworzenie ciÈgu tekstowego .............................................................................................. 93 3.5.2. WyodrÚbnianie znaków z ciÈgu tekstowego ...................................................................... 94 3.5.3. Modyfikacja ciÈgu tekstowego ............................................................................................ 95 3.5.4. Porównywanie ciÈgów tekstowych ..................................................................................... 96 3.6. Przykïadowa aplikacja ................................................................................................................. 97 3.7. Podsumowanie ............................................................................................................................ 100 3. Wprowadzenie do obiektów 4. Spis treĂci 5 Przechowywanie danych w kolekcjach 101 4.1. Tablice ......................................................................................................................................... 102 4.1.1. Budowa tablicy .................................................................................................................. 102 4.1.2. Uzyskanie dostÚpu do elementów tablicy ........................................................................ 104 4.1.3. Wyszukiwanie elementów tablicy .................................................................................... 105 4.1.4. Iteracja przez tablice ......................................................................................................... 106 4.1.5. Dodawanie elementów do tablicy .................................................................................... 108 4.2. Sïowniki ....................................................................................................................................... 110 4.2.1. Tworzenie sïownika .......................................................................................................... 110 4.2.2. Uzyskanie dostÚpu do par przechowywanych w sïowniku ............................................. 112 4.2.3. Dodawanie par klucz-wartoĂÊ .......................................................................................... 113 4.2.4. WyĂwietlenie wszystkich kluczy i wartoĂci ..................................................................... 114 4.3. Boxing .......................................................................................................................................... 116 4.3.1. Klasa NSNumber .............................................................................................................. 117 4.3.2. Klasa NSValue ................................................................................................................... 118 4.3.3. nil kontra NULL kontra NSNull ...................................................................................... 118 4.4. Aplikacja Rental Manager zaczyna uĝywaÊ danych ..................................................................... 119 4.5. Podsumowanie ............................................................................................................................ 122 CzÚĂÊ II. Tworzenie wïasnych obiektów 5. Tworzenie klas 123 125 5.1. Tworzenie wïasnej klasy ............................................................................................................ 126 5.1.1. Dodanie nowej klasy do projektu ..................................................................................... 126 5.2. Deklaracja interfejsu klasy ....................................................................................................... 127 5.2.1. Zmienne egzemplarza ....................................................................................................... 129 5.2.2. Deklarowanie metod ......................................................................................................... 130 5.2.3. Przygotowanie pliku nagïówkowego dla klasy CTRentalProperty ................................. 133 5.3. Utworzenie implementacji klasy .............................................................................................. 135 5.3.1. Zdefiniowanie implementacji metody ............................................................................. 135 5.3.2. Uzyskanie dostÚpu do zmiennych egzemplarza .............................................................. 135 5.3.3. Wysyïanie wiadomoĂci do self .......................................................................................... 136 5.3.4. Uzupeïnienie pliku metody klasy CTRentalProperty ..................................................... 137 5.4. Zdefiniowane wïaĂciwoĂci ......................................................................................................... 138 5.4.1. Skïadnia @property .......................................................................................................... 138 5.4.2. Automatyczne wygenerowanie metod typu getter i setter ............................................. 141 5.4.3. Skïadnia z uĝyciem kropki ................................................................................................ 143 5.5. Tworzenie i usuwanie obiektów ............................................................................................... 144 5.5.1. Tworzenie i inicjalizacja obiektów ................................................................................... 145 5.5.2. Metoda init nie jest najsprytniejsza ................................................................................. 146 5.5.3. PoïÈczenie alokacji i inicjalizacji ...................................................................................... 148 5.5.4. Usuwanie obiektów ........................................................................................................... 149 5.6. Uĝywanie klasy w aplikacji Rental Manager .......................................................................... 150 5.7. Podsumowanie ............................................................................................................................ 153 155 6.1. Tworzenie podklas ..................................................................................................................... 156 6.1.1. Dlaczego tworzymy podklasy? ......................................................................................... 156 6.2. Dodawanie nowych zmiennych egzemplarza ......................................................................... 158 6. Rozszerzanie klas 6 Spis treĂci 7. 9. ZarzÈdzanie pamiÚciÈ 6.3. Uzyskiwanie dostÚpu do istniejÈcych zmiennych egzemplarza ............................................ 161 6.3.1. PodejĂcie polegajÈce na rÚcznym utworzeniu metod typu getter i setter ..................... 162 6.4. Nadpisywanie metod .................................................................................................................. 163 6.4.1. Nadpisywanie metody description ................................................................................... 164 6.5. Klastry klas ................................................................................................................................. 166 6.5.1. Dlaczego stosowane sÈ klastry klas? ................................................................................ 167 6.5.2. Wiele klastrów publicznych ............................................................................................. 167 6.6. Kategorie ..................................................................................................................................... 168 6.6.1. Rozszerzenie klasy bez uĝycia podklasy .......................................................................... 168 6.6.2. Uĝywanie kategorii ............................................................................................................ 169 6.6.3. Rozwaĝania dotyczÈce uĝywania kategorii ...................................................................... 170 6.7. Zastosowanie podklas w aplikacji Rental Manager ................................................................ 171 6.7.1. Utworzenie klasy CTLease i jej podklas .......................................................................... 172 6.7.2. Utworzenie podklasy CTPeriodicLease jako podklasy CTLease ................................... 173 6.7.3. Utworzenie podklasy CTFixedLease jako podklasy CTLease ....................................... 174 6.8. Podsumowanie ............................................................................................................................ 176 Protokoïy 177 7.1. Definiowanie protokoïu ............................................................................................................. 179 Implementacja protokoïu .......................................................................................................... 180 7.2. 7.2.1. Tworzenie funkcji wywoïywania metod protokoïu ......................................................... 180 7.2.2. Zapewnienie klasie zgodnoĂci z protokoïem ................................................................... 182 7.3. Waĝne protokoïy ........................................................................................................................ 185 7.3.1. Protokóï UITableViewDataSource .................................................................................. 185 7.3.2. Protokóï UITableViewDelegate ....................................................................................... 188 7.3.3. Protokóï UIActionSheetDelegate .................................................................................... 192 7.3.4. Protokóï NSXMLParser .................................................................................................... 193 7.4. Podsumowanie ............................................................................................................................ 198 199 8.1. Typy statyczne kontra dynamiczne .......................................................................................... 200 8.1.1. Przyjmowanie zaïoĝeñ dotyczÈcych typu ustalanego w trakcie dziaïania aplikacji ....... 201 8.2. ’Èczenie dynamiczne ................................................................................................................ 202 Jak dziaïajÈ wiadomoĂci? ........................................................................................................... 203 8.3. 8.3.1. Metody, selektory i implementacje .................................................................................. 204 8.3.2. Obsïuga nieznanych selektorów ....................................................................................... 205 8.3.3. Wysyïanie wiadomoĂci do nil ........................................................................................... 207 Informacje o typie dostarczane w trakcie dziaïania aplikacji ............................................... 208 8.4.1. Ustalenie, czy wiadomoĂÊ odpowie na wiadomoĂÊ ......................................................... 208 8.4.2. Wysyïanie wiadomoĂci wygenerowanej w trakcie dziaïania aplikacji ........................... 208 8.4.3. Dodawanie nowych metod do klasy podczas dziaïania aplikacji .................................... 210 8.5. Praktyczne wykorzystanie introspekcji typu podczas dziaïania aplikacji ........................... 212 8.6. Podsumowanie ............................................................................................................................ 213 215 9.1. WïasnoĂÊ obiektu ....................................................................................................................... 216 9.2. Licznik uĝycia obiektu ............................................................................................................... 218 9.2.1. Zwolnienie obiektu ........................................................................................................... 219 9.2.2. Przytrzymanie obiektu ...................................................................................................... 220 9.2.3. OkreĂlenie bieĝÈcej wartoĂci licznika uĝycia ................................................................... 221 8.4. 8. Dynamiczne okreĂlanie typu i ustalanie typu w trakcie dziaïania aplikacji Spis treĂci 7 9.3. Pule autorelease ......................................................................................................................... 223 9.3.1. Czym jest pula autorelease? ............................................................................................. 224 9.3.2. Dodawanie obiektów do puli autorelease ........................................................................ 224 9.3.3. Utworzenie nowej puli autorelease .................................................................................. 224 9.3.4. Usuwanie obiektów z puli ................................................................................................. 226 9.3.5. Dlaczego puli autorelease nie moĝna wykorzystywaÊ w kaĝdej sytuacji? ..................... 226 9.4. Strefy pamiÚci ............................................................................................................................. 229 9.5. Reguïy wïasnoĂci ........................................................................................................................ 231 9.6. Ostrzeĝenie o maïej iloĂci dostÚpnej pamiÚci ......................................................................... 232 9.6.1. Implementacja protokoïu UIApplicationDelegate .............................................................233 9.6.2. Nadpisanie metody didReceiveMemoryWarning ..............................................................234 9.6.3. Obserwacja powiadomienia UIApplicationDidReceiveMemoryWarningNotification ............................................237 9.7. Podsumowanie ............................................................................................................................ 239 11. Key-Value Coding i NSPredicate CzÚĂÊ III. Maksymalne wykorzystanie funkcji struktur 10. Obsïuga bïÚdów i wyjÈtków 241 243 10.1. NSError — obsïuga bïÚdów w sposób zgodny z Cocoa ......................................................... 244 10.1.1. Komunikacja z NSError ................................................................................................. 245 10.1.2. Analiza sïownika userInfo klasy NSError ...................................................................... 245 10.2. Tworzenie obiektu NSError ..................................................................................................... 247 10.2.1. Wprowadzenie RentalManagerAPI ............................................................................... 247 10.2.2. Obsïuga i wyĂwietlanie bïÚdów w aplikacji RentalManagerAPI .................................. 250 10.3. WyjÈtki ........................................................................................................................................ 251 10.3.1. Zgïaszanie wyjÈtku .......................................................................................................... 251 10.3.2. Przechwytywanie wyjÈtku .............................................................................................. 252 10.4. Podsumowanie ............................................................................................................................ 253 255 11.1. Zapewnienie obiektom zgodnoĂci z KVC ................................................................................ 257 11.1.1. Uzyskanie dostÚpu do wïaĂciwoĂci za pomocÈ KVC ..................................................... 258 11.1.2. Tworzenie Ăcieĝek kluczy ............................................................................................... 258 11.1.3. Zwracanie wielu wartoĂci ............................................................................................... 259 11.1.4. Agregacja i zbieranie wartoĂci ........................................................................................ 259 11.2. Obsïuga przypadków specjalnych ............................................................................................ 261 11.2.1. Obsïuga nieznanych kluczy ............................................................................................ 261 11.2.2. Obsïuga wartoĂci nil ........................................................................................................ 262 11.3. Filtrowanie i dopasowywanie za pomocÈ predykatów ........................................................... 263 11.3.1. Obliczenie predykatu ...................................................................................................... 263 11.3.2. Filtrowanie kolekcji ........................................................................................................ 264 11.3.3. Wyraĝenie warunku predykatu ...................................................................................... 264 11.3.4. Bardziej skomplikowane wyraĝenia ............................................................................... 265 11.3.5. Uĝywanie Ăcieĝek kluczy w wyraĝeniu predykatu ........................................................ 266 11.3.6. Parametryzowanie i stosowanie szablonu wyraĝenia predykatu .................................. 267 11.4. Przykïadowa aplikacja ............................................................................................................... 268 11.5. Podsumowanie ............................................................................................................................ 271 8 Spis treĂci 12. Odczyt i zapis danych aplikacji 14. Techniki usuwania bïÚdów 273 12.1. Historia Core Data .................................................................................................................... 275 12.1.1. Do czego sïuĝy Core Data? ............................................................................................ 275 12.2. Obiekty Core Data ..................................................................................................................... 276 12.2.1. Kontekst obiektów zarzÈdzanych ................................................................................... 277 12.2.2. Koordynator trwaïego magazynu danych ...................................................................... 277 12.2.3. Model obiektu zarzÈdzanego .......................................................................................... 277 12.2.4. Magazyn trwaïych obiektów ........................................................................................... 278 12.3. Zasoby Core Data ...................................................................................................................... 278 12.3.1. Encje Core Data ............................................................................................................. 278 12.3.2. Atrybuty Core Data ......................................................................................................... 279 12.3.3. ZwiÈzki w Core Data ...................................................................................................... 280 12.4. Utworzenie aplikacji PocketTasks ........................................................................................... 281 12.4.1. Analiza szablonu Xcode z obsïugÈ Core Data ............................................................... 281 12.4.2. Budowa modelu danych ................................................................................................. 281 12.4.3. Definicje zwiÈzków ......................................................................................................... 282 12.4.4. Tworzenie encji Person .................................................................................................. 284 12.4.5. Pobieranie encji Person .................................................................................................. 286 12.4.6. Dodanie TableView ........................................................................................................ 287 12.4.7. Dodawanie i usuwanie osób ........................................................................................... 290 12.4.8. ZarzÈdzanie zadaniami .................................................................................................... 294 12.4.9. Uĝywanie obiektów modelu ........................................................................................... 297 12.5. WykraczajÈc poza podstawy ..................................................................................................... 299 12.5.1. Zmiana modelu danych ................................................................................................... 299 12.5.2. WydajnoĂÊ ....................................................................................................................... 301 12.5.3. Obsïuga bïÚdów i weryfikacja ........................................................................................ 302 12.6. Podsumowanie .............................................................................................................................. 304 305 13.1. Skïadnia bloków ......................................................................................................................... 306 13.1.1. Blok stanowi zamkniÚtÈ caïoĂÊ ....................................................................................... 309 13.1.2. Bloki i zarzÈdzanie pamiÚciÈ .......................................................................................... 310 13.1.3. API bazujÈce na blokach w strukturach iOS dostarczanych przez Apple ................... 313 13.2. Asynchroniczne wykonywanie zadañ ....................................................................................... 314 13.2.1. Poznaj technologiÚ GCD ................................................................................................ 315 13.2.2. Podstawy technologii GCD ............................................................................................ 315 13.2.3. Budowa aplikacji RealEstateViewer .............................................................................. 316 13.2.4. Asynchroniczne przeprowadzanie wyszukiwania obrazów .......................................... 321 13.2.5. Asynchroniczne wczytywanie obrazów .......................................................................... 322 13.3. Podsumowanie ............................................................................................................................ 324 325 14.1. Utworzenie aplikacji zawierajÈcej bïÚdy ................................................................................. 326 14.2. Zrozumienie funkcji NSLog() ................................................................................................... 327 14.3. Kontrola wycieków pamiÚci za pomocÈ narzÚdzia Instruments ........................................... 331 14.4. Wykrywanie zombie .................................................................................................................. 333 14.5. Podsumowanie ............................................................................................................................ 336 13. Bloki i technologia Grand Central Dispatch Spis treĂci 9 B Podstawy jÚzyka C C Alternatywy dla Objective-C Dodatki A Instalacja iOS SDK 337 339 Instalacja iOS SDK .................................................................................................................... 340 A.1. A.2. Przygotowanie urzÈdzenia iOS ................................................................................................. 341 345 B.1. Konwencje nazw zmiennych ..................................................................................................... 346 B.2. Wyraĝenia ................................................................................................................................... 349 B.3. Polecenia warunkowe ................................................................................................................ 353 B.4. Polecenia pÚtli ............................................................................................................................ 358 B.5. Podsumowanie ............................................................................................................................ 364 365 C.1. Krótka historia Objective-C ...................................................................................................... 366 C.2. Alternatywy dla Objective-C i Cocoa ...................................................................................... 368 iPhone SDK — Safari ................................................................................................................ 369 C.3. C.4. JÚzyki skryptowe — Lua i Ruby ............................................................................................... 374 C.5. Waga ciÚĝka — Adobe Flash .................................................................................................... 376 C.6. Mono (.NET) ............................................................................................................................... 378 C.7. Podsumowanie ............................................................................................................................ 380 381 Skorowidz 10 Spis treĂci Twoja pierwsza aplikacja iOS W tym rozdziale: i Zrozumienie Ğrodowiska programistycznego iOS. i Poznanie narzĊdzi Xcode i moduáu Interface Builder. i Zbudowanie pierwszej aplikacji. 24 ROZDZIAà 1 Twoja pierwsza aplikacja iOS Jako poczÈtkujÈcy programista na platformie iOS w stosunkowo krótkim czasie bÚ- dziesz musiaï poznaÊ wiele nowych technologii i koncepcji. ObejmujÈ one przede wszystkim zestaw narzÚdzi programistycznych, których moĝesz nie znaÊ, oraz jÚzyk programowania opracowany przez kilka firm i uksztaïtowany przez seriÚ historycz- nych zdarzeñ. Aplikacje na platformÚ iOS sÈ zwykle budowane za pomocÈ jÚzyka programowania o nazwie Objective-C oraz zestawu bibliotek Cocoa Touch. Jeĝeli wczeĂniej tworzyïeĂ aplikacje dla systemu Mac OS X, to prawdopodobnie znasz wymienione technologie, ale w wersji biurkowej. W tym miejscu trzeba koniecznie powiedzieÊ, ĝe wersje iOS tych narzÚdzi nie dostarczajÈ dokïadnie takich samych moĝliwoĂci; konieczne jest po- znanie pewnych ograniczeñ i usprawnieñ wystÚpujÈcych w urzÈdzeniach mobilnych. W niektórych przypadkach bÚdziesz musiaï nawet zapomnieÊ o pewnych praktykach stosowanych podczas tworzenia aplikacji biurkowych. W czasie tworzenia aplikacji iOS wiÚkszoĂÊ pracy odbywa siÚ w narzÚdziu o nazwie Xcode. Xcode 4 to najnowsza wersja zintegrowanego Ărodowiska programistycznego (ang. Integrated Development Environment, IDE) firmy Apple. Zawiera ona wbudo- wany moduï Interface Builder, sïuĝÈcy do tworze nia interfejsu uĝytkownika. Xcode 4 pozwala na tworzenie aplikacji, zarzÈdzanie nimi, wdraĝanie ich i usuwanie bïÚdów w trakcie caïego ich cyklu ĝyciowego. Przy tworzeniu aplikacji przeznaczonej do dziaïania w wiÚcej niĝ tylko jednym rodzaju urzÈdzenia iOS moĝe wystÈpiÊ potrzeba uĝycia nieco innego interfejsu uĝytkownika dla poszczególnych urzÈdzeñ, ale przy zachowaniu tej samej, podstawowej logiki aplikacji. To zadanie stanie siÚ ïatwiejsze po zastosowaniu koncepcji MVC (ang. Model-View- -Controller, model-widok-kontroler), w czym pomaga Xcode 4. W tym rozdziale zostanÈ omówione podstawowe kroki, jakie naleĝy podjÈÊ, w celu wykorzystania wymienionych narzÚdzi do utworzenia prostej gry dla telefonu iPhone. Jednak zanim przejdziemy do zagadnieñ technicznych, w pierwszej kolejnoĂci warto ogólnie poznaÊ narzÚdzia programistyczne na platformie iOS oraz róĝnice pomiÚdzy tworzeniem aplikacji na urzÈdzenia mobilne i aplikacji biurkowych bÈdě sieciowych. 1.1. Wprowadzenie do narzĊdzi programistycznych na platformĊ iOS Objective-C to rozszerzenie proceduralnego jÚzyka programowania C. Zatem kaĝdy pra- widïowy program w jÚzyku C jest równoczeĂnie poprawnym programem w Objective-C (aczkolwiek nie bÚdzie wykorzystywaï ĝadnych usprawnieñ wprowadzonych w Ob- jective-C). JÚzyk Objective-C rozszerza moĝliwoĂci C poprzez dostarczenie funkcji zoriento- wanych obiektowo. Zastosowany tutaj model programowania zorientowanego obiek- towo polega na wysyïaniu wiadomoĂci obiektom, co odróĝnia go od modelu uĝywanego przez jÚzyki C++ i Java, w których metody sÈ wywoïywane bezpoĂrednio wzglÚdem obiektów. Wymieniona róĝnica jest subtelna, ale równoczeĂnie wskazuje na jednÈ z funkcji jÚzyka Objective-C, która jest znana z jÚzyków dynamicznych, takich jak Ruby i Python. 1.1. Wprowadzenie do narzÚdzi programistycznych na platformÚ iOS 25 Jednak jÚzyk programowania jest dobry na tyle, na ile sprawne sÈ funkcje ofero- wane przez biblioteki go wspomagajÈce. Objective-C zapewnia skïadniÚ pozwalajÈcÈ na wykonywanie operacji logicznych i tworzenie konstrukcji pÚtli, ale nie obsïuguje dziedziczenia w kontekĂcie interakcji z uĝytkownikiem, dostÚpu do zasobów siecio- wych i odczytu plików. Aby zapewniÊ obsïugÚ tych funkcji bez zmuszania programisty do tworzenia odpowiednich procedur caïkowicie od poczÈtku w kaĝdej aplikacji, firma Apple doïÈczyïa do SDK zbiór bibliotek wspomagajÈcych o nazwie Cocoa Touch. Jeĝeli wczeĂniej zajmowaïeĂ siÚ programowaniem na platformie Java lub .NET, biblioteki Cocoa Touch moĝesz porównaÊ do Java Class Library lub .NET Base Class Library (BCL). 1.1.1. Dostosowanie struktur Cocoa do potrzeb urządzeĔ mobilnych Cocoa Touch skïada siÚ z pewnej liczby struktur (ang. framework), które najczÚĂciej sÈ okreĂlane mianem kit. Wspomniana struktura to zbiór klas przeznaczonych do wyko- nywania powiÈzanych ze sobÈ zadañ. Dwie podstawowe struktury uĝywane w aplika- cjach iOS to Foundation Kit i UIKit. Pierwsza z wymienionych to zbiór niegraficznych klas zawierajÈcych struktury danych, obsïugÚ sieci, operacji wejĂcia-wyjĂcia na plikach, daty i godziny oraz ciÈgów tekstowych. Natomiast druga ma na celu pomoc w przy- gotowaniu graficznego interfejsu uĝytkownika wraz z animacjami. Cocoa Touch bazuje na istniejÈcych strukturach Cocoa uĝywanych podczas budowy aplikacji na platformÚ Mac OS X. Jednak zamiast po prostu przenieĂÊ Cocoa Touch na platformÚ iOS, firma Apple dodatkowo wïoĝyïa sporo wysiïku w jej optymalizacjÚ. Niektóre struktury zostaïy nawet caïkowicie zastÈpione przez nowe, co umoĝliwiïo wprowadzenie usprawnieñ w ich funkcjonowaniu, wydajnoĂci i ogólnym dziaïaniu. Przykïadowo struktura UIKit zastÈpiïa AppKit, stosowanÈ podczas tworzenia aplikacji biurkowych. Programowe Ărodowisko dziaïania rodzimych aplikacji iOS zostaïo pokazane na rysunku 1.1. Po zastÈpieniu iOS przez Mac OS X na najniĝszym poziomie oraz po wprowadzeniu kilku zmian na poziomie Cocoa otrzymujemy niemal taki sam ukïad jak przedstawiajÈcy Ărodowisko dla aplikacji biurkowych. Rysunek 1.1. Programowe Ğrodowisko dziaáania aplikacji iOS obejmuje system operacyjny, Ğrodowisko uruchomieniowe Objective-C oraz warstwĊ struktur Cocoa Touch 26 ROZDZIAà 1 Twoja pierwsza aplikacja iOS Chociaĝ struktury Cocoa Touch to po prostu API bazujÈce na Objective-C, plat- forma programistyczna iOS pozwala równieĝ na uĝywanie standardowych API bazujÈ- cych na jÚzyku C. MoĝliwoĂÊ wykorzystania bibliotek C (lub C++) w aplikacjach Objective-C jest niezwykle uĝytecznÈ funkcjÈ. W ten sposób moĝna wykorzystaÊ ist- niejÈcy kod ěródïowy poczÈtkowo opracowany na inne platformy mobilne oraz uĝywaÊ wielu bibliotek open source o potÚĝnych moĝliwoĂciach (o ile pozwalajÈ na to zapisy licencji). DziÚki temu nie musisz wywaĝaÊ otwartych drzwi. Przykïadowo proste wy- szukanie w Google pozwala na znalezienie bazujÈcego na jÚzyku C kodu ěródïowego przeznaczonego do obsïugi miÚdzy innymi rozszerzonej rzeczywistoĂci, analizy obrazów, kodów paskowych itd. Wymieniony kod ěródïowy moĝna bez problemu wykorzystaÊ w tworzonych aplikacjach Objective-C. 1.2. Dostosowanie swoich oczekiwaĔ Poniewaĝ Ărodowisko programistyczne jest podobne do stosowanego przez obecnych programistów na platformie Mac OS X, moĝesz pomyĂleÊ, ĝe iPhone to po prostu mi- niaturowa wersja urzÈdzenia podobnego do starego laptopa, tabletu lub netbooka. To caïkowicie bïÚdne zaïoĝenie. iPhone ma znacznie wiÚksze moĝliwoĂci od zwykïego telefonu komórkowego, ale mniejsze od standardowego, biurkowego komputera PC. Pod wzglÚdem mocy obliczeniowej plasuje siÚ obok netbooków; jest zaprojektowany do okazyjnego uĝywania w ciÈgu dnia w róĝnych sytuacjach i miejscach, a nie przez dïuĝszy czas w trakcie pojedynczej sesji. 1.2.1. Specyfikacja sprzĊtowa na koniec 2011 roku Kiedy spojrzysz na telefon iPhone 4(S), niewÈtpliwie od razu zauwaĝysz ekran o prze- kÈtnej 3,5 cala i rozdzielczoĂci 960 na 640 pikseli, który wrÚcz dominuje na przedniej stronie urzÈdzenia. Wspomniany duĝy ekran dotykowy to jedyny sposób pozwalajÈcy uĝytkownikom na interakcjÚ z urzÈdzeniem; jego wielkoĂÊ ma niewÈtpliwie waĝny wpïyw na projekt aplikacji. Wprawdzie rozdzielczoĂÊ 960 na 640 punktów jest znacznie wiÚksza niĝ w wiÚkszoĂci telefonów komórkowych, jednak nie bÚdzie wystarczajÈca do wyĂwietlenia arkusza kalkulacyjnego o wielkoĂci 300 kolumn i 900 wierszy. W tabeli 1.1 przedstawiono specyfikacje techniczne róĝnych urzÈdzeñ dziaïajÈ- cych pod kontrolÈ systemu iOS (iPhone, iPod touch i iPad), które byïy dostÚpne pod koniec 2011 roku. Ogólnie rzecz biorÈc, specyfikacja techniczna znacznie ustÚpuje oferowanym obecnie komputerom PC, ale aplikacje majÈ dostÚp do duĝo wiÚkszej liczby wbudowanych akcesoriów, takich jak kamera, Bluetooth i GPS. Wprawdzie miïo jest znaÊ dokïadnÈ specyfikacjÚ sprzÚtowÈ danego urzÈdzenia i jego moĝliwoĂci, jednak programiĂci aplikacji nie muszÈ przejmowaÊ siÚ tymi szczegóïami. WciÈĝ bÚdÈ siÚ pojawiaÊ nowe modele urzÈdzeñ, platforma iOS jest nieustannie ulep- szana i ewoluuje, wiÚc Ăledzenie wszystkich moĝliwych wariantów poïÈczenia sprzÚtu i oprogramowania jest po prostu trudne. 1.2. Dostosowanie swoich oczekiwañ 27 Tabela 1.1. Porównanie specyfikacji sprzĊtowej róĪnych urządzeĔ dziaáających pod kontrolą systemu iOS Funkcja RAM Pami¤ø masowa Procesor iPod touch iPhone 3GS 256 MB 8 – 64 GB 800 MHz Apple A4 256 MB 16 – 32 GB 600 MHz ARM Cortex iPhone 4 iPhone 4S 512 MB 8 – 32 GB 800 MHz Apple A4 Sieø komórkowa Brak 7,2 Mbps 7,2 Mbps Wi-Fi Kamera Tak 3 MP AF Tak 0,7 MP (z ty¨u) 0,3 MP (z przodu) Bluetooth GPS Tak Brak Tak Tak Tak 5 MP AF (z ty¨u) 0,3 MP (z przodu) Tak Tak 512 MB 16 – 64 GB 1 GHz dwurdzeniowy Apple A5 7,2 Mbps i 14,4 Mbps Tak 8 MP AF (z ty¨u) 0,3 MP (z przodu) Tak Tak iPad 256 MB 16 – 64 GB 1 GHz Apple A4 7,2 Mbps (opcjonalnie) Tak Brak Tak Tak (tylko modele 3G) iPad 2 512 MB 16 – 64 GB 1 GHz dwurdzeniowy Apple A5 7,2 Mbps (opcjonalnie) Tak 0,92 MP (z ty¨u) 0,3 MP (z przodu) Tak Tak (tylko modele 3G) Warto dÈĝyÊ do utworzenia aplikacji, która bÚdzie siÚ staraïa dostosowaÊ do okreĂlo- nego urzÈdzenia, na jakim jest uruchamiana. Kiedy zachodzi potrzeba uĝycia funkcji do- stÚpnej jedynie w wybranych urzÈdzeniach, trzeba wyraěnie sprawdziÊ jej dostÚpnoĂÊ i zapewniÊ programowÈ obsïugÚ w sytuacji, gdy aplikacja zostanie uruchomiona w urzÈ- dzeniu nieposiadajÈcym danej funkcji. Przykïadowo zamiast sprawdzaÊ, czy dana apli- kacja jest uruchomiona w iPhonie — na przykïad celem okreĂlenia dostÚpnoĂci kamery — lepszym rozwiÈzaniem bÚdzie sprawdzenie, czy dostÚpna jest kamera. W ten sposób dana funkcja bÚdzie dziaïaïa takĝe w urzÈdzeniach iPad, które sÈ wyposaĝone w kamerÚ. 1.2.2. Spodziewaj siĊ zawodnego poáączenia z internetem W erze „przetwarzania w chmurze” spora grupa aplikacji iOS wymaga do dziaïania poïÈczenia z internetem. Platforma iOS zapewnia dwie podstawowe formy poïÈczenia bezprzewodowego: lokalne w postaci Wi-Fi (standard 802.11) oraz globalne za pomo- cÈ sieci komórkowej1. DostÚpne poïÈczenia oferujÈ róĝnÈ szybkoĂÊ — aĝ do 300 me- gabitów (Wi-Fi 802.11n). Istnieje jednak moĝliwoĂÊ zaniku poïÈczenia z internetem, na przykïad po wïÈczeniu trybu samolotowego, wyïÈczeniu obsïugi sieci komórkowej po opuszczeniu granic kraju lub po wejĂciu do windy bÈdě wjechaniu do tunelu. W przeciwieñstwie do aplikacji biurkowych, w których wiÚkszoĂÊ programistów zakïada nieustannÈ dostÚpnoĂÊ poïÈczenia sieciowego, dobra aplikacja iOS musi pora- dziÊ sobie z sytuacjÈ, gdy poïÈczenie sieciowe stanie siÚ niedostÚpne przez dïuĝszy czas lub nagle zaniknie. Z punktu widzenia uĝytkownika komunikat bïÚdu w stylu: „Przepraszamy, nie moĝna nawiÈzaÊ poïÈczenia z serwerem” sprawia okropne wraĝenie, 1 Tylko urzÈdzenia oferujÈce obsïugÚ sieci komórkowych, czyli obecnie (koniec roku 2011) dowolny model telefonu iPhone i iPad w wersji 3G — przyp. tïum. 28 ROZDZIAà 1 Twoja pierwsza aplikacja iOS w szczególnoĂci gdy jest on spóěniony na spotkanie i chce uzyskaÊ dostÚp do waĝnych informacji, których przedstawienie nie powinno wymagaÊ poïÈczenia z internetem. Ogólnie rzecz biorÈc, aplikacja iOS powinna byÊ przygotowana na zmienne wa- runki, w jakich przyjdzie jej dziaïaÊ. Zastosowane techniki programistyczne nie mogÈ ograniczaÊ siÚ jedynie do kwestii zwiÈzanych z dostÚpnÈ iloĂciÈ pamiÚci i mocy obli- czeniowej urzÈdzenia, powinny takĝe braÊ pod uwagÚ sposób interakcji aplikacji z uĝytkownikiem. Wystarczy juĝ tych informacji teoretycznych. Teraz przejdziemy do konkretów i utworzymy pierwszÈ aplikacjÚ na platformÚ iOS! 1.3. Przygotowanie prostej gry Coin Toss w Xcode ByÊ moĝe masz pomysïy na Ăwietne aplikacje, które mogÈ zrobiÊ furorÚ w sklepie iTunes App Store, ale na poczÈtek zajmiemy siÚ utworzeniem wzglÚdnie prostej aplikacji. Jej przygotowanie nie bÚdzie wymagaïo zbytniego zagïÚbiania siÚ w szczegóïy techniczne, ale pozwoli na wykorzystanie wspaniaïych moĝliwoĂci oferowanych przez narzÚdzia programistyczne. Na kolejnych stronach ksiÈĝki aplikacja i jej wszystkie aspekty zo- stanÈ dokïadnie omówione. Jednak teraz skoncentrujemy siÚ jedynie na zrozumie- niu ogólnego procesu, zamiast zajmowaÊ siÚ wszystkimi aspektami uĝytych technik. TworzonÈ aplikacjÈ bÚdzie prosta gra symulujÈca rzut monetÈ, który w zawodach sportowych (np. meczach) bardzo czÚsto decyduje o tym, kto rozpocznie rozgrywkÚ. Interfejs uĝytkownika gry zostaï pokazany na rysunku 1.2; skïada siÚ z dwóch przycisków: Orzeï i Reszka. KlikajÈc wybrany przycisk, uĝytkownik ĝÈda wykonania nowego rzutu monetÈ i jednoczeĂnie wskazuje oczekiwany wynik. Aplikacja symuluje rzut monetÈ i uaktualnia ekran, wyĂwietlajÈc informacjÚ o wyniku tego rzutu (orzeï lub reszka). Rysunek 1.2. Gra Coin Toss w dziaáaniu W celu przygotowania omówionej tutaj gry w pierwszej kolejnoĂci trzeba nieco poznaÊ Xcode. 1.3. Przygotowanie prostej gry Coin Toss w Xcode 29 1.3.1. Wprowadzenie do Ğrodowiska IDE firmy Apple — Xcode Jak juĝ wspomniano we wczeĂniejszej czÚĂci rozdziaïu, Xcode to zintegrowane Ăro- dowisko programistyczne (IDE) dostarczajÈce funkcji pozwalajÈcych na zarzÈdzanie caïym cyklem ĝyciowym projektu aplikacji. Utworzenie projektu, zdefiniowanie klas lub modelu danych, edycja kodu ěródïowego, kompilacja aplikacji, usuwanie bïÚdów i optymalizacja wydajnoĂci zbudowanej aplikacji to przykïady zadañ wykonywanych w Xcode. Oprogramowanie Xcode zostaïo stworzone na bazie kilku narzÚdzi typu open source, takich jak: kompilator LLVM (ang. Low-Level Virtual Machine), GCC2 (kompilator GNU), GDB (debuger GNU) i DTrace (opracowane przez firmÚ Sun Microsystems narzÚdzie do instrumentowania i profilowania). 1.3.2. àatwe uruchamianie Xcode Po instalacji iOS SDK (ang. Software Development Kit) pierwszym wyzwaniem dla poczÈtkujÈcych programistów moĝe byÊ znalezienie Xcode. W przeciwieñstwie do wiÚk- szoĂci aplikacji instalowanych w katalogu /Programy, dla narzÚdzi programistycznych Apple przygotowaïo oddzielny katalog: /Developer/Applications. Najïatwiejszym sposobem znalezienia Xcode jest uĝycie Findera i przejĂcie do katalogu gïównego dysku (zobacz rysunek 1.3). NastÚpnie trzeba przejĂÊ do katalogu Developer i dalej do podkatalogu Applications. Poniewaĝ jako programista bÚdziesz spÚdzaï duĝo czasu w Xcode, jego ikonÚ warto umieĂciÊ w Docku lub pasku bocznym okna Findera w celu ïatwego dostÚpu do programu. Rysunek 1.3. W oknie Findera pokazano poáoĪenie katalogu Developer, w którym znajdują siĊ wszystkie narzĊdzia związane z programowaniem oraz dokumentacja Po przejĂciu do katalogu /Developer/Applications znajdziesz tam program Xcode. 2 PoczÈwszy od Xcode w wersji 4.2, firma Apple zrezygnowaïa z kompilatora GCC i oferuje jedynie LLVM — przyp. tïum. 30 ROZDZIAà 1 Twoja pierwsza aplikacja iOS Warto w tym miejscu wspomnieÊ, ĝe uĝycie Xcode to nie jedyny sposób tworzenia apli- kacji na platformÚ iOS. NarzÚdzie Xcode dostarcza peïne Ărodowisko wraz z wszystkimi funkcjami potrzebnymi do tworzenia aplikacji, ale do programowania moĝna wykorzy- staÊ takĝe inne narzÚdzia. Przykïadowo jeĂli masz ulubiony edytor tekstowy, dziÚki któremu pracujesz znacznie wydajniej, to narzÚdzie Xcode moĝesz skonfigurowaÊ w taki sposób, aby do edycji kodu ěródïowego uĝywaÊ zewnÚtrznego edytora teksto- wego zamiast wbudowanego. Prawdziwi masochiĂci posuwajÈ siÚ nawet do uĝywania plików Makefile i powïoki. Pomocy! Nie widzĊ aplikacji Xcode! JeĪeli na dysku nie masz katalogu /Developer lub po uruchomieniu aplikacji Xcode nie widzisz Īadnych szablonów projektów dla platformy iOS, przejdĨ do dodatku A, aby dowiedzieü siĊ, w jaki sposób pobraü i zainstalowaü wymagane oprogramowanie. 1.3.3. Utworzenie projektu W celu utworzenia pierwszego projektu z menu File wybierz opcjÚ New Project (lub naciĂnij klawisze Shift+Command+N). Xcode wyĂwietli okno dialogowe podobne do pokazanego na rysunku 1.4. Rysunek 1.4. Okno dialogowe New Project w Xcode pozwala na wybór szablonu dla tworzonego projektu 1.3. Przygotowanie prostej gry Coin Toss w Xcode 31 TwojÈ pierwszÈ decyzjÈ jest typ projektu, który ma zostaÊ utworzony. W tym celu wybierasz szablon projektu, który bÚdzie zawieraï odpowiedni kod ěródïowy i usta- wienia automatycznie dodane przez Xcode po utworzeniu projektu. Tworzona w tej czÚĂci ksiÈĝki gra Coin Toss powstanie na bazie szablonu View-based Application. W pierwszej kolejnoĂci wybierz opcjÚ Application w lewym panelu (w grupie iOS), a nastÚpnie View-based Application. Po naciĂniÚciu przycisku Next znajdujÈcego w prawym dolnym rogu okna dialogowego bÚdziesz mógï podaÊ nazwÚ projektu oraz zdefiniowaÊ identyfikator firmy wymagany do powiÈzania aplikacji z kontem programisty iOS. Na potrzeby tworzonego tutaj projektu uĝyj nazwy CoinToss oraz dowolnego identyfikatora firmy. Xcode uĝywa nazwy produktu i identyfikatora firmy do wygenerowania tak zwa- nego identyfikatora aplikacji (ang. bundle identifier). DziÚki temu wygenerowanemu ciÈgowi tekstowemu system iOS unikalnie identyfikuje kaĝdÈ aplikacjÚ. Aby system operacyjny pozwoliï na uruchomienie gry Coin Toss, wspomniany identyfikator apli- kacji musi odpowiadaÊ identyfikatorowi znajdujÈcemu siÚ w profilu zainstalowanym w urzÈdzeniu iOS. Jeĝeli urzÈdzenie nie znajdzie odpowiedniego profilu, wówczas odmówi uruchomienia aplikacji. W ten sposób firma Apple decyduje o tym, które aplikacje mogÈ byÊ uruchamiane w utworzonym przez niÈ ekosystemie. JeĂli nie po- siadasz odpowiedniego identyfikatora firmy lub nie jesteĂ pewny, w którym miejscu powinien zostaÊ wprowadzony, nie pozostaje Ci nic innego, jak koniecznie zapoznaÊ siÚ z informacjami zamieszczonymi w dodatku A przed lekturÈ dalszej czÚĂci rozdziaïu. Po wprowadzeniu wszystkich danych odznacz pole wyboru Include Unit Tests i naci- Ănij przycisk Next. Zostaniesz poproszony o wskazanie miejsca zapisu projektu, a Xcode wygeneruje odpowiedni plik kodu ěródïowego. Pomocy! Nie widzĊ Īadnych opcji dotyczących platformy iOS! JeĪeli w oknie dialogowym New Project nie widzisz Īadnych szablonów przeznaczonych dla platformy iOS, to prawdopodobnie nie zainstalowaáeĞ iOS SDK. UĪywane przez Ciebie narzĊ- dzie Xcode prawdopodobnie pochodzi wiĊc z páyty instalacyjnej Mac OS X Install DVD lub zo- staáo pobrane bezpoĞrednio z witryny ADC (ang. Apple Developer Connection) w wersji prze- znaczonej do tworzenia aplikacji na platformĊ Mac OS X. Omówiony w dodatku A proces instalacji iOS SDK powinien pomóc Ci zastąpiü uĪywaną przez Ciebie wersjĊ Xcode wersją uaktualnioną, która zawiera obsáugĊ oprogramowania tworzonego na platformĊ iOS. ByÊ moĝe zastanawiasz siÚ, jakie inne typy projektów moĝna utworzyÊ w Xcode. W tabeli 1.2 wymieniono szablony projektów iOS oferowanych przez Xcode w wersji 4.2. Wybór konkretnego szablonu zaleĝy od rodzaju interfejsu uĝytkownika dla two- rzonej aplikacji. Nie przykïadaj zbyt duĝej wagi do wyboru szablonu projektu, ta de- cyzja nie ma aĝ tak duĝego znaczenia, jak moĝna by sÈdziÊ. Po utworzeniu projektu zawsze moĝesz zmieniÊ styl aplikacji. To zadanie nie bÚdzie jednak ïatwe, poniewaĝ szablon projektu automatycznie nie wstawi za Ciebie wszystkich wymaganych plików kodu ěródïowego — bÚdziesz musiaï to zrobiÊ samodzielnie. 32 ROZDZIAà 1 Twoja pierwsza aplikacja iOS Tabela 1.2. Szablony projektów dostĊpne w Xcode do tworzenia nowych projektów iOS Rodzaj projektu Navigation-based Application OpenGL ES Application Split View-based Application Tab Bar Application Utility Application View-based Application Window-based Application Opis Ten szablon pozwala na utworzenie projektu w stylu podobnym do wbudowanej aplikacji Kontakty, czyli wraz z paskiem nawigacyjnym znajduj cym si¤ u góry ekranu. Ten szablon to punkt wyjĿciowy dla aplikacji bazuj cej na grafice w technologii OpenGL ES, na przyk¨ad dla gry itd. Ten szablon to punkt wyjĿciowy dla projektu w stylu podobnym do wbudowanej aplikacji Poczta w tablecie iPad. Jest zaprojektowany do wyĿwietlania informacji w stylu master-detail na pojedynczym ekranie. Ten szablon pozwala na utworzenie projektu w stylu podobnym do wbudowanej aplikacji Zegar, wraz z paskiem kart umieszczonym na dole ekranu. Ten szablon pozwala na utworzenie projektu w stylu podobnym do wbudowanych aplikacji Gie¨da i Pogoda, których ekran obraca si¤, pokazuj c drug  stron¤. Ten szablon pozwala na utworzenie aplikacji sk¨adaj cej si¤ z pojedynczego widoku. Istnieje moŞliwoĿø tworzenia i odpowiadania na zdarzenia we w¨asnym widoku. Ten szablon pozwala na utworzenie aplikacji z pojedynczym widokiem, w którym s  umieszczane kontrolki. Po zamkniÚciu okna dialogowego tworzenia nowego projektu na ekranie zostanie wyĂwietlone okno gïówne Xcode, podobne do pokazanego na rysunku 1.5. Pokazane tutaj okno gïówne Xcode zawiera po lewej stronie panel Project Navigator, natomiast prawÈ stronÚ wypeïnia panel edycyjny. Panel widoczny po lewej stronie okna zawiera wszystkie pliki tworzÈce aplikacjÚ. Grupa o nazwie CoinToss przedstawia caïÈ grÚ. Po rozwiniÚciu tego wÚzïa uzyskujesz dostÚp do mniejszych podgrup oraz plików skïadajÈcych siÚ na dany projekt. Oczywi- Ăcie moĝesz tworzyÊ wïasne dowolne grupy w celu uporzÈdkowania plików w odpo- wiadajÈcy Ci sposób. Po klikniÚciu pliku w lewym panelu panel w prawej czÚĂci okna bÚdzie wyĂwietlaï edytor wraz z kodem ěródïowym zaznaczonego pliku. W przypadku plików .h i .m uĝyty zostanie tradycyjny edytor tekstów dla kodu ěródïowego, natomiast inne typy plików (np. zasoby .xib) bÚdÈ wyĂwietlane za pomocÈ znacznie bardziej skomplikowa- nych edytorów graficznych. Niektóre grupy znajdujÈce siÚ w lewym panelu majÈ przypisany im specjalny spo- sób zachowania lub w ogóle nie przedstawiajÈ ĝadnych plików. Przykïadowo elementy wymienione w grupie Frameworks to prekompilowane biblioteki kodu uĝywane przez dany projekt. Kiedy zyskasz wiÚksze doĂwiadczenie w tworzeniu aplikacji za pomocÈ Xcode, osiÈgniesz wiÚkszÈ biegïoĂÊ w uĝywaniu sekcji znajdujÈcych siÚ w panelu Project Navigator. Aby pomóc Ci w rozpoczÚciu podróĝy, przystÈpimy teraz do utworzenia kodu ěródïowego pierwszej klasy. 1.3. Przygotowanie prostej gry Coin Toss w Xcode 33 Rysunek 1.5. Okno gáówne Xcode, zawierające w peáni rozwiniĊte katalogi projektu CoinToss z róĪnymi plikami kodu Ĩródáowego 1.3.4. Tworzenie kodu Ĩródáowego Szablon View-based Application dostarcza wystarczajÈcÈ iloĂÊ kodu ěródïowego, aby prosta gra zostaïa wyĂwietlona na ekranie iPhone’a. W rzeczywistoĂci szablon jest tak prosty, ĝe jeĂli zdecydujesz siÚ na uruchomienie gry na tym etapie, ekran bÚdzie wy- peïniony jedynie kolorem szarym. Rozpocznijmy implementacjÚ gry poprzez wyĂwietlenie pliku CoinTossView- Controller.h w oknie edytora Xcode. NastÚpnie jego zawartoĂÊ zastÚpujemy kodem przedstawionym na listingu 1.1. 34 ROZDZIAà 1 Twoja pierwsza aplikacja iOS Listing 1.1. Plik CoinTossViewController.h #import UIKit/UIKit.h @interface CoinTossViewController : UIViewController { UILabel *status; UILabel *result; } @property (nonatomic, retain) IBOutlet UILabel *status; @property (nonatomic, retain) IBOutlet UILabel *result; - (IBAction)callHeads; - (IBAction)callTails; @end Nie przejmuj siÚ, jeĂli zawartoĂÊ listingu 1.1 nie ma dla Ciebie sensu. Na obecnym etapie peïne zrozumienie przedstawionego tutaj kodu ěródïowego nie jest konieczne. Niniejsza ksiÈĝka zostaïa napisana wïaĂnie po to, aby omówiÊ wszystkie szczegóïy zwiÈzane z tworzeniem aplikacji. CierpliwoĂci! Obecnie skoncentrujemy siÚ na zrozumieniu ogólnej struktury projektu bazujÈcego na Objective-C. Objective-C to jÚzyk zorientowany obiektowo, co oznacza, ĝe znaczna czÚĂÊ wysiïku programisty polega na definiowaniu nowych klas (typów obiektów). W listingu 1.1 zostaïa zdefiniowana nowa klasa o nazwie CoinTossViewController. Zgodnie z konwencjÈ definicja klasy znajduje siÚ w pliku nagïówkowym z rozsze- rzeniem .h. W pliku nagïówkowym pierwsze dwa wiersze deklarujÈ klasy przechowujÈce in- formacje szczegóïowe dotyczÈce dwóch kontrolek UILabel uĝytych w interfejsie uĝyt- kownika tworzonej aplikacji. Kontrolki UILabel bÚdÈ wyĂwietlaïy pojedyncze wiersze tekstu i sÈ uĝyte w celu poinformowania uĝytkownika o wyniku rzutu monetÈ. Drugi zestaw poleceñ pozwala kodowi zewnÚtrznemu wzglÚdem tej klasy na po- informowanie, która kontrolka UILabel ma zostaÊ uĝyta. Wreszcie w listingu zdefinio- wano, ĝe klasa ma odpowiadaÊ na dwie wiadomoĂci — o nazwach callHeads i callTails. Wymienione wiadomoĂci informujÈ, kiedy uĝytkownik postawiï na orïa lub reszkÚ oraz o koniecznoĂci zainicjowania nowego rzutu monetÈ. Plik nagïówkowy (*.h) okreĂla to, czego moĝna oczekiwaÊ od klasy oraz w jaki spo- sób inny kod ma wspóïpracowaÊ z danÈ klasÈ. Po uaktualnieniu pliku nagïówkowego trzeba dodaÊ kod faktycznej implementacji funkcji w nim wymienionych. Po wyĂwie- tleniu pliku CoinTossViewController.m jego zawartoĂÊ naleĝy zastÈpiÊ kodem przed- stawionym na listingu 1.2. Listing 1.2. Plik CoinTossViewController.m #import CoinTossViewController.h #import QuartzCore/QuartzCore.h @implementation CoinTossViewController @synthesize status, result; Odpowiada dyrektywie @property 1.3. Przygotowanie prostej gry Coin Toss w Xcode 35 - (void) simulateCoinToss:(BOOL)userCalledHeads { BOOL coinLandedOnHeads = (arc4random() 2) == 0; result.text = coinLandedOnHeads ? @ Orzeđ : @ Reszka ; if (coinLandedOnHeads == userCalledHeads) status.text = @ Prawidđowo! ; else status.text = @ Nieprawidđowo! ; Konfiguracja dwóch obiektów CABasicAnimation *rotation = [CABasicAnimation animationWithKeyPath:@ transform.rotation ]; rotation.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut]; rotation.fromValue = [NSNumber numberWithFloat:0.0f]; rotation.toValue = [NSNumber numberWithFloat:720 * M_PI / 180.0f]; rotation.duration = 2.0f; [status.layer addAnimation:rotation forKey:@ rotate ]; Wpáywa na etykietĊ CABasicAnimation *fade = [CABasicAnimation animationWithKeyPath:@ opacity ]; fade.timingFunction = [CAMediaTimingFunction functionWithName:kCAMediaTimingFunctionEaseInEaseOut]; fade.fromValue = [NSNumber numberWithFloat:0.0f]; fade.toValue = [NSNumber numberWithFloat:1.0f]; fade.duration = 3.5f; [status.layer addAnimation:fade forKey:@ fade ]; } - (IBAction) callHeads { [self simulateCoinToss:YES]; } - (IBAction) callTails { [self simulateCoinToss:NO]; } - (void) viewDidUnload { [super viewDidUnload]; self.status = nil; self.result = nil; } - (void) dealloc { [status release]; [result release]; [super dealloc]; } @end Zarządzanie pamiĊcią Na pierwszy rzut okna listing 1.2 wydaje siÚ dïugi i przeraĝajÈcy, ale po jego po- dziale na kilka czÚĂci staje siÚ caïkiem prosty do zrozumienia. 36 ROZDZIAà 1 Twoja pierwsza aplikacja iOS Pierwsze polecenie odpowiada deklaracjom dyrektyw @property umieszczonym w pliku CoinTossViewController.h. Koncepcja wïaĂciwoĂci i zalety pïynÈce z ich uĝy- wania zostanÈ szczegóïowo omówione w rozdziale 5. WiÚkszoĂÊ logiki pliku CoinTossViewController.m zostaïa umieszczona w meto- dzie simulateCoinToss:, która jest wywoïywana za kaĝdym razem, gdy uĝytkownik chce poznaÊ wynik kolejnego rzutu monetÈ. W pierwszym wierszu nastÚpuje symula- cja rzutu monetÈ poprzez wygenerowanie losowej liczby z zakresu od 0 do 1, przed- stawiajÈcej odpowiednio orzeïka lub reszkÚ. Wynik jest przechowywany w zmiennej coinLandedOnHeads. Po okreĂleniu wyniku rzutu monetÈ nastÚpuje uaktualnienie dwóch kontrolek UILabel w interfejsie uĝytkownika. Pierwsza konstrukcja warunkowa powoduje wy- Ăwietlenie w etykiecie wyniku rzutu monetÈ, natomiast druga wskazuje, czy uĝytkow- nik prawidïowo wytypowaï ten wynik. i Pozostaïa czÚĂÊ kodu metody simulateCoinToss: jest odpowiedzialna za ustawienie dwóch obiektów CABasicAnimation — , dziÚki którym uaktualnienie informacji w etykietach odbywa siÚ z uĝyciem animacji zamiast po prostu niezauwaĝalnej zmiany tekstu. Animacja odbywa
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:


Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: