Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00429 006158 14277147 na godz. na dobę w sumie
Programowanie aplikacji na iPhone 4. Poznaj platformę iOS SDK3 od podstaw - książka
Programowanie aplikacji na iPhone 4. Poznaj platformę iOS SDK3 od podstaw - książka
Autor: , , Liczba stron: 592
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-3588-7 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie mobilne >> iphone
Porównaj ceny (książka, ebook (-25%), audiobook).

Rewolucyjne urządzenia - nowatorskie oprogramowanie!

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.

Kompendium wiedzy na temat tworzenia oprogramowania dla iOS-a!

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

Darmowy fragment publikacji:

Tytuł oryginału: Beginning iPhone 4 Development: Exploring the iOS SDK Tłumaczenie: Robert Górczyński ISBN: 978-83-246-3588-7 Original edition copyright © 2011 by Dave Mark, Jack Nutting, Jeff LaMarche. 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/praip4 Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność „ „ „ Spis treĂci 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 PROGRAMOWANIE APLIKACJI NA IPHONE 4 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 6 SPIS TRE¥CI 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 7 PROGRAMOWANIE APLIKACJI NA IPHONE 4 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 8 SPIS TRE¥CI 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 9 PROGRAMOWANIE APLIKACJI NA IPHONE 4 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 10 SPIS TRE¥CI 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 11 PROGRAMOWANIE APLIKACJI NA IPHONE 4 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 12 R O Z D Z I A ’ 3 „ „ „ Obsïuga podstawowej interakcji Omówiona w poprzednim rozdziale aplikacja Hello World była dobrym wprowadzeniem do programowania iOS za pomocą Cocoa Touch, ale brakowało w niej jednej zasadniczej funkcji — możliwości interakcji z użytkownikiem. Bez tego aplikacja ma bardzo ograniczony zakres oferowanych możliwości. W tym rozdziale utworzymy nieco bardziej skomplikowaną aplikację składającą się z dwóch przycisków oraz etykiety (zobacz rysunek 3.1). Tekst wyświetlany w etykiecie będzie zależał od przycisku naciśniętego przez użytkownika. Ten przykład może wydawać się bardzo prosty, ale przedstawia kluczowe koncepcje implementacji interakcji z użytkownikiem w aplikacji iOS. Rysunek 3.1. Prosta dwuprzyciskowa aplikacja, która będzie zbudowana w tym rozdziale PROGRAMOWANIE APLIKACJI NA IPHONE 4 Architektura Model-View-Controller Przed rozpoczęciem pracy nad projektem nieco teorii. Projektanci platformy Cocoa Touch zastosowali koncepcję o nazwie MVC (ang. Model-View-Controller, czyli Model-Widok-Kontroler), która stanowi logiczny sposób tworzenia kodu w aplikacji graficznej. Obecnie niemal wszystkie platformy zorientowane obiektowo wykorzystują w pewnym stopniu architekturę MVC, ale w kilku z nich (w tym także Cocoa Touch) zastosowano prawdziwy model MVC. Architekturę MVC pod względem funkcjonalności można podzielić na trzy oddzielne kategorie: x Model (model) —są to klasy przechowujące dane aplikacji; x View (widok) — to kod odpowiedzialny za okna, kontrolki i inne elementy widoczne dla użytkownika, z którymi można prowadzić interakcję; x Controller (kontroler) — łączy w aplikacji model i widok; stanowi więc tak zwaną logikę aplikacji i decyduje, w jaki sposób obsłużyć dane wejściowe pochodzące od użytkownika. Celem w MVC jest tworzenie obiektów implementujących trzy wymienione typy kodu jako maksymalnie oddzielne elementy. Budowany obiekt powinien być bez problemu zaklasyfikowany jako należący do jednej z trzech wymienionych kategorii bez funkcji (lub z ich niewielką liczbą), które można zaliczyć do dwóch pozostałych. Przykładowo obiekt implementujący przycisk nie powinien zawierać kodu przetwarzającego dane po jego naciśnięciu, a implementacja obsługi konta bankowego nie powinna zawierać kodu odpowiedzialnego za tworzenie tabeli wyświetlającej operacje bankowe. Architektura MVC pomaga w zapewnieniu maksymalnej możliwości ponownego wykorzystania kodu. Klasa implementująca przycisk może być użyta w dowolnej aplikacji. Natomiast klasa implementująca przycisk i przeprowadzająca pewne operacje po jego kliknięciu może być zastosowana tylko w aplikacji, dla której pierwotnie powstała. Podczas opracowywania aplikacji Cocoa Touch programista będzie najczęściej tworzył elementy widoku w programie Interface Builder, choć czasami interfejs będzie modyfikowany również z poziomu kodu. Inną możliwością jest wykorzystanie podklas istniejących widoków i kontrolek. Model jest tworzony za pomocą klas Objective-C zaprojektowanych do przechowywania danych aplikacji bądź poprzez zbudowanie modelu danych z użyciem Core Data (to zagadnienie zostanie przedstawione w rozdziale 12.). W aplikacji omawianej w tym miejscu nie będziemy budować żadnych obiektów modelu, ponieważ nie trzeba przechowywać czy zachowywać danych. Jednak w następnych rozdziałach podczas budowy bardziej skomplikowanych aplikacji będziemy używać także obiektów modelu. Komponent kontrolera to najczęściej klasy utworzone specjalnie dla danej aplikacji. Kontroler może być zupełnie dowolną klasą (podklasa NSObject) choć najczęściej będzie podklasą jednej z istniejących klas kontrolerów struktury UIKit, na przykład UIViewController, którą poznasz w dalszej części rozdziału. Dzięki tworzeniu podklas jednej z istniejących klas programista na początek otrzymuje wiele gotowych, najczęściej używanych funkcji, więc nie musi poświęcać czasu na opracowywanie ich od początku. Po nabyciu większego doświadczenia w programowaniu przy użyciu Cocoa Touch zaczniesz zauważać, jak w klasach UIKit zastosowano zasady architektury MVC. Wykorzystując koncepcję MVC w trakcie opracowywania własnych aplikacji, programista tworzy czysty, przejrzysty i łatwy w obsłudze kod. Utworzenie projektu Nadszedł czas na utworzenie projektu Xcode. W tym przykładzie użyty zostanie ten sam szablon, z którym pracowaliśmy w poprzednim rozdziale: View-based Application. Dzięki ponownemu rozpoczęciu pracy od prostego szablonu znacznie łatwiej będziesz mógł zobaczyć, w jaki sposób w aplikacji iOS współdziałają obiekty kontrolera i widoku. Inne szablony aplikacji iOS będą używane w następnych rozdziałach. W Xcode należy więc utworzyć nowy projekt: jako urządzenie (rozwijane menu Product) wskazać iPhone i zapisać projekt pod nazwą Button Fun. Jeśli napotkasz problemy w trakcie tworzenia nowego projektu, warto powrócić do poprzedniego rozdziału, w którym proces ten został dokładnie omówiony. 46 ROZDZIA’ 3. „ OBS’UGA PODSTAWOWEJ INTERAKCJI Prawdopodobnie pamiętasz, że szablon projektu zawiera przygotowane pewne klasy. Te same klasy znajdą się w nowym projekcie, chociaż ich nazwy będą nieco inne. Wynika to z faktu, że nazwy klas są nadawane na podstawie nazwy projektu. Utworzenie kontrolera widoku W dalszej części rozdziału w programie Interface Builder zostanie utworzony widok (czyli interfejs użytkownika) dla naszej aplikacji, podobnie jak to zrobiono w poprzednim rozdziale. Wcześniej jednak trzeba zapoznać się z przygotowanymi w szablonie plikami kodu źródłowego oraz wprowadzić w nich kilka zmian. Tak, dobrze przeczytałeś, w tym rozdziale będziemy tworzyć rzeczywisty kod źródłowy. Przed wprowadzeniem zmian warto zobaczyć, jakie pliki domyślnie znajdują się w projekcie utworzonym z szablonu. W panelu Groups Files należy rozwinąć katalog Classes, który zawiera cztery pliki (zobacz rysunek 3.2). Rysunek 3.2. Panel Groups Files zawiera pliki klas domyślnie znajdujące się w szablonie projektu. Warto zwrócić uwagę na użycie nazwy projektu w nazwach plików klas Cztery pokazane na rysunku pliki implementują w sumie dwie klasy, z których każda składa się z pliku implementacji (.m) oraz nagłówkowego (.h). Aplikacja tworzona w tym rozdziale będzie zawierała tylko jeden widok, a klasa kontrolera odpowiedzialna za zarządzanie tym widokiem nosi nazwę Button_FunViewController. Część Button_Fun pochodzi z nazwy projektu, natomiast część ViewController oznacza klasę kontrolera widoku. Warto kliknąć plik Button_FunViewController.h w panelu Groups Files i przyjrzeć się jego zawartości: #import UIKit/UIKit.h @interface Button_FunViewController : UIViewController { } @end Plik nie zawiera zbyt wiele kodu, prawda? Button_FunViewController to podklasa UIViewController będąca jedną z podstawowych klas kontrolerów, o których wcześniej wspomniano. Klasa stanowi część struktury UIKit i dostarcza dużą liczbę funkcji. Program Xcode nie wie nic na temat funkcji charakterystycznych dla tworzonej aplikacji. Jednak zakłada, że programista na pewno będzie potrzebował pewnych funkcji, więc tworzy wspomnianą klasę przeznaczoną dla przechowywania funkcji. Spójrz ponownie na rysunek 3.1. Aplikacja składa się z dwóch przycisków oraz etykiety tekstowej odzwierciedlającej naciśnięcie przycisku. Wszystkie trzy elementy zostaną utworzone w programie Interface Builder. Ponieważ w aplikacji powstanie także kod źródłowy, musi istnieć jakiś mechanizm pozwalający na interakcję kodu z elementami utworzonymi w programie Interface Builder. Oczywiście. Klasa kontrolera może odwoływać się do obiektu w pliku nib za pomocą specjalnego typu zmiennej egzemplarza o nazwie outlet (z ang. gniazdo). Outlet należy traktować jako wskaźnik prowadzący do obiektu znajdującego się w pliku nib. Przykładowo zakładamy, że utworzyłeś etykietę tekstową w programie Interface Builder, a następnie z poziomu kodu źródłowego chcesz zmienić tekst 47 PROGRAMOWANIE APLIKACJI NA IPHONE 4 etykiety. Po zadeklarowaniu outletu oraz jego połączeniu z obiektem etykiety zdefiniowany w ten sposób outlet można wykorzystać do zmiany z poziomu kodu tekstu wyświetlanego w etykiecie. Takie rozwiązanie zostanie przedstawione w dalszej części rozdziału. Z drugiej strony, obiekty interfejsu znajdujące się w pliku nib mogą mieć możliwość wywoływania metod specjalnych zdefiniowanych w klasie kontrolera. Wspomniane metody specjalne noszą nazwę actions (z ang. akcje). Przykładowo w programie Interface Builder można zdefiniować, że kiedy użytkownik zwolni dany przycisk (to znaczy zdejmie palec z przycisku na ekranie), wówczas zostanie wywołana określona metoda znajdująca się w kodzie źródłowym. W tworzonej tutaj aplikacji znajdzie się outlet prowadzący do etykiety, który pozwoli na zmianę tekstu w tej etykiecie. Ponadto zostanie utworzona metoda o nazwie buttonPressed:1 wywoływana po naciśnięciu jednego z przycisków. Zadaniem tej metody będzie ustawienie tekstu etykiety informującego użytkownika, który przycisk został naciśnięty. Przyciski i etykieta powstaną w programie Interface Builder, w którym również później nastąpi połączenie etykiety z outletem oraz przycisków z metodą buttonPressed:. Jednak przed rozpoczęciem tworzenia kodu trzeba nieco dokładniej poznać outlety i akcje. Outlety Outlety to zmienne egzemplarza zadeklarowane za pomocą słowa kluczowego IBOutlet. Deklaracja outletu w pliku nagłówkowym kontrolera może wyglądać następująco: @property (nonatomic, retain) IBOutlet UIButton *myButton; Słowo kluczowe IBOutlet jest definiowane następująco: #ifndef IBOutlet #define IBOutlet #endif Zdezorientowany? Z punktu widzenia kompilatora słowo kluczowe IBOutlet nie ma żadnego specjalnego znaczenia. Służy jedynie w charakterze podpowiedzi dla programu Interface Builder i informuje, że dany element jest zmienną egzemplarza łączoną z obiektem znajdującym się w pliku nib. Każda tworzona zmienna egzemplarza, która ma być połączona z obiektem w pliku nib, musi być poprzedzona słowem kluczowym IBOutlet. Po otworzeniu pliku nib w panelu Groups Files program Interface Builder skanuje pliki nagłówkowe projektu w poszukiwaniu wystąpień tego słowa, a następnie pozwala na tworzenie połączeń z kodu do pliku nib na podstawie tych (i tylko tych) zmiennych. W podpunkcie „Tworzenie połączenia z outletem” znajdującym się w dalszej części rozdziału dowiesz się, w jaki sposób tworzyć w programie Interface Builder połączenie między outletem i obiektem interfejsu użytkownika. Akcje Akcje to metody stanowiące część klasy kontrolera. Są one deklarowane z użyciem słowa kluczowego IBAction, które informuje Interface Builder, że dana metoda jest akcją i może być wywołana przez kontrolkę. Zazwyczaj deklaracja metody akcji przedstawia się następująco: - (IBAction)dowolnaOperacja:(id)sender; Rzeczywista nazwa metody może być dowolna, ale zwracanym typem musi być IBAction, który ma takie same znaczenie jak typ void. To po prostu inny sposób wskazania, że metoda akcji nie zwraca 1 Na końcu nazwy metody znajduje się dwukropek, o którym nie wolno zapomnieć. Dwukropek występuje w nazwach wielu metod Cocoa i Cocoa Touch — przyp. tłum. 48 ROZDZIA’ 3. „ OBS’UGA PODSTAWOWEJ INTERAKCJI Zmiany w outletach W pierwszym wydaniu ksiÈĝki sïowo kluczowe IBOutlet byïo umieszczane przed deklaracjÈ zmiennej egzemplarza, na przykïad: IBOutlet UIButton *myButton; Od tamtej chwili w przykïadowych fragmentach kodu publikowanych przez Apple sïowo kluczowe IBOutlet jest umieszczane w deklaracji wïaĂciwoĂci, na przykïad tak: @property (nonatomic, retain) IBOutlet UIButton *myButton; Obsïugiwane sÈ obie skïadnie, w wiÚkszoĂci przypadków nie ma równieĝ ĝadnych róĝnic zaleĝÈcych od miejsca umieszczenia wymienionego sïowa kluczowego. Jednak od tej reguïy istnieje jeden wyjÈtek. Jeĝeli wïaĂciwoĂÊ zostanie zadeklarowana z nazwÈ innÈ niĝ powiÈzana z niÈ zmienna egzemplarza (co moĝna zrobiÊ w dyrektywie @synthesize), wówczas w celu zapewnienia prawidïowego dziaïania sïowo kluczowe IBOutlet musi byÊ umieszczone w deklaracji wïaĂciwoĂci, a nie przed deklaracjÈ zmiennej egzemplarza. Jeĝeli nie do koñca rozumiesz koncepcjÚ wïaĂciwoĂci, nie przejmuj siÚ, wkrótce zostanie ona omówiona nieco dokïadniej. Wprawdzie obie omówione skïadnie dziaïajÈ, ale w caïym kodzie ěródïowym przedstawionym w ksiÈĝce uĝyto skïadni stosowanej przez Apple, czyli umieszczono sïowo kluczowe IBOutlet w deklaracji wïaĂciwoĂci. WiÚcej informacji na temat nowych wïaĂciwoĂci Objective-C moĝna znaleěÊ w ksiÈĝce Learn Objective-C on the Mac napisanej przez Marka Dalrymple’a i Scotta Knastera (Apress, 2009) oraz w dokumencie Introduction to The Objective-C Programming Language dostÚpnym na witrynie Apple pod adresem http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC/Introduction/ introObjectiveC.html. wartości. Metoda akcji najczęściej pobiera pojedynczy argument zwykle zdefiniowany jako typ id o nazwie sender. Kontrolka wywołująca metodę używa argumentu sender w odniesieniu do samej siebie. Jeśli przykładowo metoda akcji jest wywołana w wyniku naciśnięcia przycisku, argument sender będzie zawierał odniesienie do naciśniętego przycisku. Jak przekonasz się w kolejnym punkcie, przedstawiona w rozdziale aplikacja będzie korzystała z argumentu sender w celu ustawienia tekstu wyświetlanego przez etykietę w zależności od naciśniętego przycisku („lewy” lub „prawy”). Jeżeli nie trzeba wiedzieć, która kontrolka wywołała metodę, definicja metody akcji nie musi zawierać parametru sender. W takim przypadku może przybierać postać: - (IBAction)dowolnaOperacja; Jednak naprawdę nie zaszkodzi zadeklarowanie metody akcji wraz z argumentem sender, a następnie jego ignorowanie. Spotkasz się z dużą ilością kodu tworzonego w taki sposób, ponieważ wcześniej metody akcji w Cocoa musiały akceptować argument sender niezależnie od tego, czy był używany, czy nie. Dodanie akcji i outletów do kontrolera widoku Skoro już wiesz, czym są outlety i akcje, można przystąpić do ich dodania w klasie kontrolera. Potrzebny będzie outlet pozwalający na zmianę tekstu wyświetlanego przez etykietę. Ponieważ przyciski nie będą zmieniane, nie trzeba tworzyć dla nich outletów. Konieczne będzie również zdefiniowanie pojedynczej metody akcji wywoływanej po naciśnięciu dowolnego z dwóch przycisków. Wprawdzie wiele metod akcji jest przeznaczonych dla poszczególnych kontrolek, jednak istnieje możliwość użycia pojedynczej akcji do obsłużenia danych wejściowych z wielu kontrolek. Takie rozwiązanie będzie zastosowane w omawianej aplikacji. Metoda akcji pobierze nazwę 49 PROGRAMOWANIE APLIKACJI NA IPHONE 4 przycisku z argumentu sender, a następnie użyje outletu etykiety do wyświetlenia tej nazwy w etykiecie. Sposób działania tego mechanizmu zostanie przedstawiony w dalszej części rozdziału przy okazji omawiania metody buttonPressed:. „ Uwaga: Poniewaĝ po utworzeniu projektu program Xcode umieszcza w nim pewne pliki zawierajÈce przydatny kod, nowy kod bardzo czÚsto jest dodawany do istniejÈcych plików. Kiedy widzisz listing (na przykïad Button_funViewController.h), warto pamiÚtaÊ, ĝe kod zapisany zwykïÈ czcionkÈ oznacza kod juĝ istniejÈcy w pliku, natomiast kod zapisany czcionkÈ pogrubionÈ oznacza nowy kod, który trzeba wprowadziÊ. Do pliku Button_funViewController.h należy dodać następujący kod: #import UIKit/UIKit.h @interface Button_FunViewController : UIViewController { UILabel *statusText; } @property (nonatomic, retain) IBOutlet UILabel *statusText; - (IBAction)buttonPressed:(id)sender; @end Jeżeli programowałeś już w Objective-C, prawdopodobnie znasz deklarację @property. W przeciwnym razie ten wiersz kodu może wydawać się nieco przerażający. Nie należy się obawiać — właściwości w Objective-C są całkiem proste. Warto poświęcić chwilę na ich poznanie, ponieważ w książce będą używane bardzo często. Nawet jeśli jesteś już mistrzem w stosowaniu właściwości, to i tak powinieneś przeczytać ten fragment, ponieważ znajdziesz w nim użyteczne informacje dotyczące Cocoa Touch. WïaĂciwoĂci w Objective-C Przed dodaniem właściwości do Objective-C dla każdej zmiennej egzemplarza klasy programiści najczęściej definiowali parę metod służących do ustawiania i pobierania jej wartości. Metody te nazywano akcesorami i mutatorami (ewentualnie getters i setters) i mogły mieć postać podobną do przedstawionej poniżej: - (id)foo { return foo; } - (void)setFoo:(id)aFoo { if (aFoo != foo) { [aFoo retain]; [foo release]; } } Wprawdzie powyższe podejście nadal pozostaje jak najbardziej poprawne, deklaracja @property zwalnia programistę ze żmudnego tworzenia wymienionych metod dla każdej zmiennej egzemplarza. Deklaracja @property połączona z deklaracją w pliku implementacji (@synthesize, którą poznasz podczas wprowadzania zmian w pliku Button_FunViewController.m) nakazuje kompilatorowi utworzenie w trakcie kompilacji metod akcesora i mutatora. Programista normalnie deklaruje zmienne egzemplarza, jak to tutaj przedstawiono, ale nie musi samodzielnie definiować metod akcesora i mutatora. W naszej deklaracji za słowem kluczowym @property znajdują się pewne atrybuty opcjonalne umieszczone w nawiasie. Wskazują one sposób utworzenia akcesorów i mutatorów przez kompilator, a także ułatwiają programiście odczyt kodu, ponieważ informują, jak obiekt będzie traktować swoje zmienne egzemplarza. Dwa atrybuty najczęściej stosowane podczas definiowania właściwości w aplikacjach iPhone zostały pokazane poniżej: @property (retain, nonatomic) IBOutlet UILabel *statusText; 50 ROZDZIA’ 3. „ OBS’UGA PODSTAWOWEJ INTERAKCJI „ Uwaga: MogïeĂ zwróciÊ uwagÚ na uĝycie w poprzednim zdaniu sïowa „normalnie” w kontekĂcie deklarowania zmiennych egzemplarza dopasowanych do wïaĂciwoĂci. Wynika z tego, ĝe „nienormalne” jest zadeklarowanie ich w inny sposób. JÚzyk Objective-C 2.0 pozwala na pominiÚcie deklaracji zmiennej egzemplarza, o ile zmienna egzemplarza i wïaĂciwoĂÊ majÈ takie same nazwy. W ten sposób w kodzie pozostaje jedynie deklaracja wïaĂciwoĂci. Jednak taka moĝliwoĂÊ jest ograniczona tylko do najnowszych Ărodowisk dostarczanych przez Apple, obejmujÈcych iOS oraz 64-bitowe aplikacje dla systemu Mac OS X w wersji 10.6 (Snow Leopard) lub nowszej. Takiej moĝliwoĂci nie ma w przypadku 32-bitowych aplikacji dla Mac OS X. Do lata 2010 roku to ograniczenie obejmowaïo takĝe oprogramowanie dziaïajÈce w symulatorze iPhone. Poniewaĝ kaĝdy programista w pewnym stopniu korzystaï z symulatora, uĝywanie kodu pozbawionego zmiennych egzemplarza jest bardzo kïopotliwe. Tak wiÚc niemal caïe oprogramowanie iOS utworzone do wspomnianego momentu zawieraïo zmienne egzemplarza. Nawet obecnie obsïuga pomijania zmiennych egzemplarzy nie dziaïa najlepiej. Przykïadowo debugger w Xcode ma problemy z wyĂwietlaniem informacji dotyczÈcych wïaĂciwoĂci, jeĂli zmienna egzemplarza nie zostaïa zadeklarowana. W przykïadach przedstawionych w ksiÈĝce niemal zawsze sÈ stosowane zmienne egzemplarza. Jednak powinieneĂ mieÊ ĂwiadomoĂÊ, ĝe pewnego dnia narzÚdzia programistyczne zostanÈ dopracowane i wspomniane zmienne egzemplarza bÚdÈ wyglÈdaïy jak relikty przeszïoĂci. Pierwszy atrybut o nazwie retain nakazuje kompilatorowi wysłanie wiadomości retain każdemu obiektowi, do którego jest przypisywana ta właściwość. W ten sposób unika się usunięcia zmiennej egzemplarza z pamięci, gdy właściwość nadal pozostaje w użyciu. To jest niezbędne, ponieważ zachowanie domyślne (assign) jest przeznaczone do używania z typami danych C niskiego poziomu bądź z mechanizmem garbage collection (akurat ta funkcja języka Objective-C 2.0 jest obecnie niedostępna na platformie iOS). Dlatego też podczas definiowania właściwości będącej obiektem (w przeciwieństwie do zwykłego typu danych, takiego jak int) należy podać retain jako atrybut opcjonalny. W trakcie deklarowania właściwości dla int, float lub innego zwykłego typu danych nie ma konieczności określania jakichkolwiek atrybutów opcjonalnych. W rzeczywistości podanie atrybutu retain w deklaracji właściwości dla typu danych niskiego poziomu powoduje powstanie błędów. Wynika to z faktu, że elementy niebędące obiektami Objective-C w ogóle nie mogą otrzymywać żadnych wiadomości, w tym także retain lub release. Drugi atrybut opcjonalny nonatomic zmienia sposób generowania akcesora i mutatora. Bez zagłębiania się w szczegóły techniczne wystarczy powiedzieć, że domyślnie wymienione metody są generowane wraz z dodatkowym kodem przydatnym w trakcie tworzenia programów wielowątkowych. Takie dodatkowe obciążenie, choć niewielkie, jednak jest niepotrzebne podczas deklarowania wskaźnika do obiektu interfejsu użytkownika. Użycie opcji nonatomic powoduje więc wyeliminowanie wspomnianego obciążenia. Oczywiście, będą zdarzały się sytuacje, gdy programista nie będzie chciał używać atrybutu nonatomic we właściwości, ale ogólnie rzecz ujmując, podczas tworzenia aplikacji iOS zwykle korzysta się z tego atrybutu. Język Objective-C 2.0 ma jeszcze inną interesującą funkcję, którą będziemy stosować wraz z właściwościami. Ta funkcja to zapis z użyciem kropki. Aby w tradycyjnym podejściu użyć metody akcesora, należało do obiektu wysłać wiadomość, na przykład: mojaZmienna = [wybranyObiekt foo]; Powyższe podejście nadal działa doskonale. Jednak po zdefiniowaniu właściwości programista uzyskuje możliwość zastosowania składni z użyciem kropki, czyli podobnej do wykorzystywanej w językach Java, C++ oraz C#, na przykład: mojaZmienna = wybranyObiekt.foo; Z punktu widzenia kompilatora dwa powyższe polecenia są identyczne, możesz zatem wybrać, które będzie stosować. Składnia z użyciem kropki działa również w przypadku mutatorów. Tak więc polecenie: wybranyObiekt.foo = mojaZmienna; jest pod względem funkcjonalnym identyczne z poleceniem: [wybranyObiekt setFoo:mojaZmienna]; 51 PROGRAMOWANIE APLIKACJI NA IPHONE 4 „ Uwaga: W tej ksiÈĝce autorze zdecydowali siÚ na Ăcisïe podejĂcie podczas pracy z wïaĂciwoĂciami. Za kaĝdym razem gdy nastÚpuje uzyskanie dostÚpu do zmiennej egzemplarza bÚdÈcej jednoczeĂnie wïaĂciwoĂciÈ, dostÚp odbywa siÚ za pomocÈ wywoïania metody akcesora
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Programowanie aplikacji na iPhone 4. Poznaj platformę iOS SDK3 od podstaw
Autor:
, ,

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ą: