AKADEMIA GÓRNICZO-HUTNICZA IM. STANISŁAWA STASZICA W KRAKOWIE

Wydział Inżynierii Metali i Informatyki Przemysłowej

PRACA DYPLOMOWA MAGISTERSKA

pt.

„Opracowanie własnej strony i przeglądarki dla iPhone”

Imię i nazwisko dyplomanta: Mirosław Suchy

Kierunek studiów: Informatyka Stosowana

Specjalność: Systemy Informatyki Przemysłowej

Nr albumu: 204653

Promotor: dr Magdalena Kopernik

Recenzent: dr hab. inż. Krzysztof Banaś, prof. AGH

Podpis dyplomanta: Podpis promotora:

Kraków 2012

Oświadczam, świadomy(-a) odpowiedzialności karnej za poświadczenie nieprawdy, że niniejszą pracę dyplomową wykonałem(-am) osobiście i samodzielnie i że nie korzystałem(-am) ze źródeł innych niż wymienione w pracy.

Kraków, dnia …… Podpis dyplomanta…………….

2

Spis treści Część I.................................................................................................................... 5

1. Wprowadzenie.................................................................................................... 5

1.1. Wstęp......................................................................................................... 5

2. iPhone..................................................................................................................6

2.1. Ekran.......................................................................................................... 6

2.2. Komunikacja............................................................................................... 9

2.3. Aparat......................................................................................................... 9

2.4. Funkcje dodatkowe.................................................................................... 9

2.5. Brakujące funkcje..................................................................................... 10

2.6. Podsumowanie......................................................................................... 11

3. iOS..................................................................................................................... 12

3.1. Core OS................................................................................................... 13

3.2. Core Service............................................................................................ 14

3.3. Media....................................................................................................... 15

3.4. Cocoa Touch............................................................................................ 15

3.5. Podsumowanie......................................................................................... 15

4. Framework....................................................................................................... 17

4.1. Core Foundation Framework.................................................................... 17

4.2. Foundation Framework............................................................................ 17

4.3. UIKit Framework.......................................................................................20

4.4. Podsumowanie......................................................................................... 21

5. Objective-C....................................................................................................... 23

5.1. Wprowadzenie......................................................................................... 23

5.2. Historia..................................................................................................... 23

5.3. Charakterystyka języka Objective-C.........................................................24

5.4. Objective-C język..................................................................................... 25

5.5. Podsumowanie......................................................................................... 30

6. Zarządzanie pamięcią...................................................................................... 31

6.1. Podsumowanie......................................................................................... 35

7. Narzędzia.......................................................................................................... 36

7.1. Hardware & Software............................................................................... 36

7.2. Xcode....................................................................................................... 38

7.3. Podsumowanie......................................................................................... 45

8. Architektura Model-View-Controller............................................................ 46

9. Projektowanie strony internetowej dla iPhone.............................................48

9.1. HTML....................................................................................................... 49

9.2. CSS.......................................................................................................... 51

9.3. PHP.......................................................................................................... 52

9.4. JavaScript................................................................................................ 52

9.5. MySQL..................................................................................................... 53

9.6. WebKit......................................................................................................54

9.7. Safari........................................................................................................ 54

9.8. Projektowanie witryn internetowych dla urządzeń mobilnych...................56

10. Cel pracy......................................................................................................... 58

Część II.................................................................................................................59

11. Projekt Aplikacji............................................................................................ 59

11.1. Opis ogólny.............................................................................................60

11.2. Widok..................................................................................................... 62

11.3. Model i Kontroler.................................................................................... 70

11.4. Test......................................................................................................... 73

12. Projekt Strony WWW................................................................................... 77

12.1. Opis ogólny............................................................................................ 77

12.2. Zastosowane technologie....................................................................... 77

12.3. Funkcjonalność...................................................................................... 78

12.4. Podsumowanie....................................................................................... 80

13. Wnioski i podsumowanie...............................................................................81

14. Dodatek A .......................................................................................................82

15. Spis tabel, ilustracji, bibliografia..................................................................84

4

Część I

1. WPROWADZENIE

1.1. WSTĘP

W styczniu 2007 roku Steve Jobs ogłosił zmianę nazwy firmy Apple Computer Inc. na

Apple Inc., tego samego dnia, świat po raz pierwszy usłyszał nazwę nowego smartfona -

iPhone. Pracę nad urządzeniem, mającym być połączeniem telefonu komórkowego oraz

komputera kieszonkowego z dotykowym ekranem trwają już od 2005 roku, jednak dopiero

29 czerwca 2007 roku iPhone został oficjalnie wprowadzony do sprzedaży. Tego dnia zaczęła

się rewolucja w świecie urządzeń mobilnych [1].

iPhone oraz inne urządzenia tego typu, np.: Samsung Galaxy, HTC Wildfire, są

określane jako szczyt możliwości współczesnej technologii. Urządzenie wystarczająco małe,

aby zmieścić się w kieszeni spodni, pozwala na wykonywanie rozmów telefonicznych,

wysyłanie i odbieranie wiadomości SMS, MMS, wiadomości email, odtwarzanie muzyki oraz

filmów, reaguje na zmiany położenia, pozwala na robienie zdjęć oraz filmów, granie w gry

oraz wygodne korzystanie z Internetu dzięki wysokiej jakości wyświetlaczowi. Ważną cechą

iPhone jest możliwość instalowania aplikacji, które można pobrać ze sklepu internetowego

AppStore lub co jest jeszcze istotniejsze, można pisać własne aplikacje [2].

Pojawienie się na rynku smartfonów, a następnie tabletów z możliwością korzystania z

Internetu, m. in. dzięki wbudowanym kartom Wi-Fi, spowodowało zmiany również w

Internecie. iPhone posiada znacznie mniejszy ekran niż laptop lub monitor komputera

stacjonarnego co sprawia, że strona internetowa napisana dla użytkowników komputerów jest

bardzo mała i mało czytelna na smartfonie, bez jej powiększania. Wymusiło to na twórcach

stron internetowych zmianę sposobu projektowania stron WWW, tak aby można było

korzystać z nich w wygodny sposób, zarówno na komputerze jak i na innych urządzeniach

posiadających mniejsze ekrany [3].

5

2. IPHONE

Obecnie na rynku jest dostępnych pięć wersji iPhone, z czego trzy ciągle są dostępne w

oficjalnej sprzedaży. Poszczególne modele różnią się między sobą przede wszystkim

dostępnymi zasobami tj. pamięcią RAM, mocą obliczeniową procesora, procesorem

graficznym, itd. (Tabela 1).

Tabela 1. Porównanie parametrów różnych wersji iPhone [4].

2.1. EKRAN

Praca z aplikacjami na platformie iOS jest znacząco odmienna od pracy na komputerze.

Na iPhone tylko jedna aplikacja może być aktywna i być wyświetlana w danej chwili na

ekranie [5]. iOS wersji 4 pozwala na chwilowe działanie aplikacji w tle, ale jest to

ograniczone tylko do specjalnych przypadków, zadań i nie może trwać zbyt długo. Oznacza

to, że do dyspozycji mamy jedno okno jednej aplikacji, poprzez które odbywa się cała

interakcja z użytkownikiem. Ponadto wielkość tego okna jest stała i równa wielkości ekranu.

W iPhone (Rysunek 1) [6] mamy do dyspozycji bardzo dobrej jakości ekran. Już w

chwili wprowadzenia urządzenia do sprzedaży był to telefon z największa rozdzielczością

ekranu stosowaną w produktach konsumenckich. W iPhone wersji 4 zastosowano

wyświetlacz o nazwie Retina i rozdzielczości 960x640 pikseli, starsze wersje urządzenia mają

ekran o rozdzielczości 480x320 pikseli. W 3,5 calowym ekranie pomieszczono niewiele mniej

pikseli, niż do niedawana posiadały komputery z 17 calowymi monitorami CRT, w których

standardowa rozdzielczość wynosiła 1024x768 pikseli.

Najważniejszą cechą ekranu jest to, że reaguję na dotyk. Jest on wyposażony w czujnik

dotyku i przystosowany do obsługi jednym, bądź kilkoma placami (Multitouch [5]), bez

6

konieczności używania rysika. W produktach Apple nie ma nawet możliwości użycia rysika,

urządzenia na niego nie reagują, ze względu na rodzaj zastosowanej konstrukcji tj. ekranu

pojemnościowego, który reaguje na zmiany pojemności elektrycznej dotykanego ekranu [1].

Rysunek 1. Zdjęcie telefonu z podanymi wymiarami [7].

2.1.1. Technologia Multitouch

Stosowany we wszystkich urządzeniach iOS ekran z technologią Multitouch [4] to

jeden z głównych elementów przyczyniających się do tak dużej użyteczności tych urządzeń.

Ponieważ ekran daję możliwość wykrywania wielu dotknięć na raz, oraz śledzenia ich ruchu

niezależnie od siebie, daję to ogromne możliwości interakcji z aplikacją wykraczające poza

możliwości interfejsu graficznego.

Typy interakcji z ekranem i ich obsługę można podzielić na kilka kategorii [5]:

Zdarzenie - jest generowane podczas interakcji z ekranem. Dla każdego

zdarzenia jest poszukiwany obiekt który może na nie odpowiedzieć. Odbywa się to

poprzez przeszukanie łańcucha odpowiedzi. Jeżeli pierwszy obiekt typu responder nie

jest wstanie odpowiedzieć na zaistniałe zdarzenie przekazuje je dalej. Kiedy kolejny

obiekt odpowiada na zdarzenie, przeszukiwanie łańcucha dobiega końca. W

przeciwnym przypadku przekazywanie zdarzenia odbywa się aż do samej góry

7

łańcucha (Rysunek 2). Jeżeli zdarzenie przejdzie przez cały łańcuch odpowiedzi i

żaden obiekt nie będzie w stanie obsłużyć zdarzenia to zostaje ono odrzucone.

Rysunek 2. Fragment hierarchii dziedziczenia z korzeniem na dole (fragment zrzutu ekranu programu Interface Builder).

UIView jest podklasą UIResponder, natomiast UIWebView jest podklasą UIView. Każda

klasa posiadająca UIResponder jako klasę nadrzędną nosi miano respondera. Zgodnie z

powyższymi rysunkami wszystkie widoki oraz kontrolki są responderami.

Gest - dowolna sekwencja zdarzeń, które wystąpiły między dotknięciem ekranu

jednym lub kilkoma palcami a zdjęciem tych palców z ekranu. Od chwili położenia

palca lub palców na ekranie i przytrzymaniu ich niezależnie od czasu trwania tej

czynności, mamy do czynienia z gestem.

Dotknięcie - oznacza umieszczenie palca na ekranie i przesunięci po nim lub

podniesienie go z ekranu. Każde dotknięcie jest śledzone, niezależnie czy jest ono

wykonane jednym palcem czy kilkoma. Użytkownik ma możliwość położenia pięciu

palców na ekranie, a system rozpozna je i będzie śledził niezależnie od siebie. iPad

jest w stanie obsłużyć do jedenastu dotknięć.

Naciśnięcie - naciśnięcie dobywa się w chwili kiedy użytkownik dotknie ekranu

palcem i natychmiast do podniesie. System jest w stanie rozróżnić pojedyncze

dotknięcie od wielokrotnego. iOS śledzi liczbę dotknięć i jest w stanie podjąć akcje w

zależności od liczby naciśnięć, o ile znajdzie się obiekt będący w stanie na takie

zdarzenie odpowiedzieć.

Obiekt rozpoznający gesty - to obiekt typu responder, który potrafi obsłużyć

strumień zdarzeń wygenerowanych przez użytkownika i rozpoznać je, kiedy następuję

dotknięcie i przesunięcie po ekranie w sposób odpowiadający zdefiniowanemu

gestowi.

8

2.2. KOMUNIKACJA

2.2.1. Łączność bezprzewodowa

iPhone 4 posiada możliwość połączenia z Internetem poprzez wbudowane Wi-Fi [2].

Urządzenie jest w stanie połączyć się w kilku standardach: 802.11b, 802.11g oraz 802.11n

(niedostępny w 3GS). Podczas wykonywania połączeń telefonicznych lub przesyłania danych,

gdy nie jest wykorzystywane połączenie Wi-Fi, iPhone wykorzystuję komunikację

GSM/EDGE inaczej określaną jako G2. Dla szybszych połączeń, wymagających większej

przepustowości można wykorzystać połączenia poprzez UMTS, HSDPA i HSUPA, znane

jako technologia 3G. Pozwala ona na przesyłanie danych z maksymalną prędkością 7.2 Mbps.

iPhone 4 posiada również możliwość przesyłania danych poprzez Bluetooth v2.1 z EDR

(Enhanced Data Rate) [2, 4].

2.2.2. Łączność przewodowa

Przewodowa łączność ograniczona jest tylko do dwóch [4]:

a) do łączności kablowej w celu przysłania danych wykorzystano USB v2.0

umożliwiające również ładowanie baterii telefonu,

b) podłączenia do telefonu słuchawek z wtyczką typu “jack” 3,5 mm.

2.3. APARAT

iPhone 4 posiada dwie wbudowane kamery [4]:

a) 5.0 megapikselowy aparat z autofocusem i możliwością nagrywania filmów

w rozdzielczości HD ready, czyli 720p z prędkością 30 klatek na sekundę,

umieszczony z tyłu urządzenia,

b) aparat VGA 0.3 megapiksela, 480p, 30 klatek na sekundę umieszczony

z przodu.

2.4. FUNKCJE DODATKOWE

• GPS (A-GPS - Assisted GPS)

• Akcelerometr

• Żyroskop 3-osiowy

• Czujnik pomiaru światła

• Czujnik zbliżeniowy

9

• Wibracja

• Lampa LED

• System operacyjny

System działający na pierwszych modelach iPhone nie miał swojej oficjalnej nazwy, aż

do chwili wydania pierwszego zestawu narzędzi dla programistów (SDK - Software

Development Kit) - iPhone SDK, 6 marca 2008 roku, kiedy to został przedstawiony jako

iPhone OS.

7 czerwca 2010 roku nazwa została zmieniona na iOS ze względu na to, iż nie tylko na

iPhone był zainstalowany dotychczasowy system. Na rynku dostępne były urządzenia iPod

Touch oraz iPad, na których był zainstalowany iPhone OS specjalnie dla nich przygotowany.

Ostatnia wersja iPhone OS v3.2 była przygotowana specjalnie pod iPad. Od 8 kwietnia

2010 roku wychodziły kolejne wersje beta systemu iOS v4.0, by ostatecznie 21 czerwca 2010

roku została udostępniona oficjalna stabilna wersja iOS 4.0, dostępna na iPod Touch oraz

iPhone 4.0 [8].

2.5. BRAKUJĄCE FUNKCJE

iPhone to telefon z dotykowym ekranem, gdzie niemal cała przestrzeń zajęta jest przez

ekran. Do dyspozycji pozostaje tylko kilka przycisków oraz jeden główny tzw. przycisk

Początek.

W odróżnieniu od tradycyjnych komputerów nie ma fizycznej klawiatury oraz myszy.

Oznacza to inny sposób interakcji z użytkownikiem. iOS dostarcza tzw. wirtualną klawiaturę,

która pojawia się w chwili, gdy aktywne jest pole przeznaczone do wprowadzania tekstu. Do

obsługi takiego zachowania nie jest potrzebne tworzenie dodatkowego kodu przez

programistę.

Aktualnie dostępne urządzenia z systemem iOS pozwalają na podłączenie zewnętrznej

klawiatury poprzez Bluetooth, dzięki czemu mamy dostęp do fizycznej klawiatury oraz

pewnej wygody z tym związanej. Nie jest to jednak często stosowane rozwiązanie.

Podłączenie myszy nadal nie jest niemożliwe [5].

10

2.6. PODSUMOWANIE

Świadomość możliwości urządzenia, dla którego tworzone jest później oprogramowanie

jest niezbędna. Różnice pomiędzy poszczególnymi modelami będą rzutować na sposób

pisania aplikacji, oraz wymuszać na twórcach oprogramowania stosowania najlepszych

rozwiązań dla szerszego grona odbiorców, przyszłych użytkowników aplikacji. Ograniczenia

urządzeń będą zaś stopowały, często zbyt ambitne pomysły projektantów aplikacji.

11

3. IOS

iOS jest systemem operacyjnym, który jest zainstalowany na urządzeniach iPhone, iPod

Touch oraz iPad. System ten zarządza częścią fizyczną urządzeń (hardware) oraz dostarcza

technologie niezbędne do poprawnego działania urządzania. System jest również bazą dla

szerokiego spektrum aplikacji dostępnych w ramach świadczenia standardowych usług

przewidzianych na urządzeniach.

Architektura iOS jest podobna do podstawowej architektury w Mac OS X. Na

najwyższym poziomie, iOS działa jako pośrednik pomiędzy sprzętem i aplikacjami, które

pojawiają się na ekranie (Rysunek 3). Aplikacje tworzone przez programistów rzadko kiedy

komunikują się bezpośrednio z warstwą sprzętową. Zamiast tego aplikacje komunikują się ze

sprzętem poprzez dobrze zdefiniowany w systemie zestaw interfejsów, które chronią aplikację

przed wpływem różnic urządzeń. Taki poziom abstrakcji umożliwia pisanie aplikacji, które

działają bez problemów na urządzeniach o różnej konfiguracji sprzętowej.

Rysunek 3. Ogólny zarys architektury [9].

12

Implementacje iOS można zaprezentować jako kilka warstw (Rysunek 4):

• Cocoa Touch

• Media

• Core Services

• Core OS

Warstwy niższe systemu zawierają podstawowe usługi oraz obsługę sprzętu. Wyższe

warstwy są odpowiedzialne za dostarczanie bardziej złożonych usług.

Rysunek 4. Warstwy architektury iOS [9].

Podczas pisania kodu zalecane jest korzystanie z frameworków wyższego poziomu nad

frameworkami niższych warstw, gdy jest to możliwe. Frameworki wyższych warstw zostały

opracowane w celu dostarczenia zorientowanych obiektowo abstrakcji konstrukcji niższych

warstw. Takie podejście zastosowano w celu ułatwienia tworzenia aplikacji poprzez

zminimalizowanie ilości niezbędnego kodu, który trzeba napisać, aby obsłużyć potencjalnie

złożone mechanizmy, takie jak wątki czy gniazda. Pomimo takiego podejścia warstwy

wyższego poziomu nie blokują dostępu do mechanizmów warstw niższych. Frameworki

niższego poziomu są dostępne dla programistów, którzy wolą z nich korzystać lub

wykorzystać aspekty niedostępne w ramach warstw wyższych.

3.1. CORE OS

Warstwa Core OS zawiera funkcję niskiego poziomu, na których oparte są technologie

dostępne w warstwach wyższego poziomu. Nawet jeśli mechanizmy tej warstwy nie są

używane bezpośrednio przez programistę, to istnieje duże prawdopodobieństwo, że

wykorzystuje je jeden z wykorzystywanych frameworków warstw wyższych. W sytuacji, gdy

trzeba jawnie zająć się obsługą bezpieczeństwa lub komunikacją z akcesoriami, bądź innym

sprzętem zewnętrznym, dokonujemy tego używając tej warstwy.

13

Składniki warstwy:

• Accelerate Framework

• Core Bluetooth

• External Accessory Framework

• Generic Security Services Framework

• Security Framework

• System

System obejmuje jądro środowiska, sterowniki oraz niskiego poziomu interfejsy

systemu operacyjnego UNIX. Jądro systemu jest oparte na jądrze Mach i jest odpowiedzialne

za każdy aspekt systemu operacyjnego. Jądro zarządza pamięcią wirtualną systemu, wątkami,

systemem plików, siecią, komunikacją między procesami. Sterowniki tej warstwy dostarczają

interfejs pomiędzy dostępnym sprzętem a frameworkami systemowymi. W celu zapewnienia

bezpieczeństwa, dostęp do jądra i sterowników jest ograniczony do kilku systemowych

frameworków i aplikacji.

3.2. CORE SERVICE

Warstwa Core Service zawiera podstawowe usługi systemowe, z których korzystają

wszystkie aplikacje.

Funkcje:

• iCloud Storage

• Automatic Reference Counting

• Block Object

• Grand Central Dispatch

• In-App Purchase

• SQLite

• XML Support

Frameworki:

• Accounts Framework

• Address Book Framework

• CFNetwork Framework

• Core Data Framework

14

• Core Foundation Framework

• Core Location Framework

• Core Media Framework

• Core Telephony Framework

• Event Kit Framework

• Foundation Framework

• Mobile Core Services Framework

• Newsstand Kit Framework

• Quick Look Framework

• Store Kit Framework

• System Configuration Framework

3.3. MEDIA

Warstwa zawierająca opracowane mechanizmy do obsługi grafiki, dźwięku oraz wideo

zaprojektowane, aby ułatwić tworzenie aplikacji oraz zapewnić odpowiedni wysoki standard

obsługi treści multimedialnych.

Technologie:

• Graphics Technologies

• Audio Technologies

• Video Technologies

• AirPlay

3.4. COCOA TOUCH

Warstwa Cocoa Touch zawiera kluczowe frameworki do budowy aplikacji iOS.

Warstwa definiuję podstawową infrastrukturę oraz obsługę technologii takich jak

wielozadaniowość, obsługę gestów, przesyłanie powiadomień oraz wiele

wysokopoziomowych usług. Podczas projektowania aplikacji jest to pierwsza warstwa na,

której mechanizmach należy opierać projektowaną aplikację.

3.5. PODSUMOWANIE

Każda napisana aplikacja wykorzystuje zasoby udostępniane przez system. Znajomość

systemu oraz możliwość wykorzystania usług przez niego udostępnianych jest kluczowym

15

elementem tworzenia aplikacji. Znajomość poszczególnych poziomów abstrakcyjności

dostępnych interfejsów pozwala na omijanie ograniczeń warstwa wyższego poziomu na rzecz

warstw niższego poziomu.

16

4. FRAMEWORK

4.1. CORE FOUNDATION FRAMEWORK

Core Foundation framework (CoreFoundation.framework) jest to zestaw interfejsów

opartych na C, które dostarczają podstawowe funkcje operacji na danych oraz usługi dla

aplikacji iOS. Framework obejmuję m. in. [9]:

• typy kolekcji (arrays, sets, itd.)

• manipulacje Stringami

• zarządzanie datą i godziną

• wątki oraz pętle

• bloki danych

• manipulacje URL oraz strumieniami

• porty oraz gniazda komunikacyjne

• bundles

• ustawienia preferencji

4.2. FOUNDATION FRAMEWORK

Foundation framework (Foundation.framework) dostarcza podstawową warstwę klas

Objective-C. Oprócz zestawu prostych typów obiektów, wprowadza kilka paradygmatów,

które definiują funkcjonalności nieobjęte w języku Objective-C. Framework zaprojektowano,

aby osiągnąć kilka celów [9]:

• dostarczenie niedużego zestawu użytecznych klas

• ułatwienie wytwarzania oprogramowania poprzez wprowadzenie kilku konwencji,

m. in. dla takich operacji jak dealokacja

• wsparcie dla Unicode, stałych obiektów

• zapewnienie pewnego poziom niezależności od systemu operacyjnego, oraz

poprawienie przenośności

Framework zawiera korzeń wszystkich klas (root class [10]), czyli obiekt NSObject

(Rysunek 5). Cała hierarchia klas jest zakotwiczona w korzeniu, powoduje to powstanie kilku

powiązanych ze sobą grup klas, na równi z kilkoma klasami niezależnymi (Rysunek 6).

17

Root class nie jest pochodną od żadnej innej klasy, definiuje interfejs oraz zachowanie

wspólne dla wszystkich obiektów w hierarchii poniżej (klas pochodnych, dziedziczących

z klasy root). Wszystkie obiekty w tej hierarchii ostatecznie dziedziczą z root class. Root class

jest również określana jako klasa podstawowa.

Rysunek 5. Root class – NSObject [10].

Rysunek 6. NSObject oraz obiekty z niej dziedziczące połączone w grupy1 [11].

1Kolorem szarym oznaczone są klasy dostępne tylko w Mac OS X.

18

Core Foundation framework i Foundation framework są ze sobą silnie powiązane.

Foundation framework stanowi pewnego rodzaju obudowę do wielu funkcji, które znajdują

się w Core Foundation.

Foundation framework definiuje podstawowe zachowanie obiektów, mechanizmy

zarządzania obiektami oraz dostarcza jednych z podstawowych typów danych obiektów,

kolekcji oraz usług systemowych. Foundation jest obiektowo zorientowaną rozbudowaną

wersją Core Foundation.

19

4.3. UIKIT FRAMEWORK

Framework UIKit dostarcza klas potrzebnych do budowy i zarządzania aplikacją z

poziomu interfejsu graficznego dla iOS. Zawiera obiekty, zdarzenia, okna, widoki oraz

kontrolki specjalnie zaprojektowane dla interfejsu dostępnego poprzez ekran dotykowy

(Rysunek 7) [12].

20

Rysunek 7. NSObject i klasy dziedziczące – UIKit [12].

4.4. PODSUMOWANIE

Odwrotnie niż w przypadku znajomości niższych warstw systemu, znajomość warstw

wyższego poziomu, oraz frameworków pozwoli na zmniejszenie ilości kodu potrzebnego do

21

własnoręcznego napisania wymaganych mechanizmów. Bez wymienionych w rozdziale

frameworków nie da się stworzyć aplikacji dla platformy iOS.

22

5. OBJECTIVE-C

5.1. WPROWADZENIE

Objective-C jest językiem programowania zaprojektowanym w celu umożliwienia

wyrafinowanego programowania zorientowanego obiektowo. Język ten jest zdefiniowany

jako mały, ale o bardzo dużych możliwościach, zbiór rozszerzeń dla standardowego języka

ANSI C. Większość tych rozszerzeń jest oparta o Smalltalk, jeden z pierwszych obiektowych

języków programowania. Objective-C został stworzony, żeby dać językowi C pełną

obiektowość w prosty i przystępny sposób [13].

5.2. HISTORIA

Smalltalk jest historycznie drugim po Simula językiem zorientowanym obiektowo.

Został zaprojektowany w latach siedemdziesiątych, był jednak bardzo wolny na owe czasy.

Do poprawnej pracy potrzebował komputera o bardzo dużych zasobach, takiego jak Xerox

Alto z 512 KB RAM-u i procesora z częstotliwością co najmniej 2 MHz.

Brad Cox był pozytywnie nastawiony do idei Smalltalk-a, chciał jednak języka, który

byłby dostępny dla każdego. Jego pomysłem było połączenie obiektowego Smalltalk’a z

bardzo szybkim językiem C. Na początku lat osiemdziesiątych Cox zaczął pisać preprocesor

dla C, żeby dodać pewne możliwości z Smalltalk. Wkrótce opracował działającą

implementację zorientowanego obiektowo rozszerzenia dla C, którą nazwał OOPC (Object-

Oriented Pre-Compiler). W 1986 roku Brad Cox i Tom Love założyciele firmy StepStone

zaczęli sprzedawać produkt o nazwie Objective-C bazujący na wcześniejszym tworze Brada

(Rysunek 8) [13].

Rysunek 8. Linia czasu (na podstawie [14]).

W 1988 roku firma NeXT kupiła licencję do kodu firmy StepStone i nabyła prawa do

znaku towarowego Objective-C. NeXT zostało kupione przez Apple w 1996 roku, a

Objective-C zostało zaadoptowane jako główny język dla frameworku Yellow Box w nowym

23

systemie operacyjnym Apple - Rhapsody. Aktualnie framework nazywa się Cocoa, a system

OS X.

5.3. CHARAKTERYSTYKA JĘZYKA OBJECTIVE-C

5.3.1. Wieloplatformowość

GCC

Kod napisany w Objective-C można z powodzeniem skompilować przy wykorzystaniu

GCC [15]. Niestety stara wersja kompilatora jest opóźniona o około 5 lat w stosunku do

ostatniej wersji Objective-C. Wykorzystując środowisko uruchomieniowe GNUstep można

ten problem ominąć. GNUstep jest to projekt, który tworzy implementację frameworków

Foundation i AppKit.

Wykorzystując GCC wraz z bibliotekami Objective-C 2.0 z projektu GNUstep, można

uzyskać dostęp do większości funkcji. Wersja GCC 4.6 i nowsze wersje zawierają

uaktualnione środowisko uruchomieniowe, dzięki czemu posiada ten sam poziom

kompatybilności, ale nie wymaga już specjalnego frameworku.

Clang - LLVM

W 2007 roku Apple rozpoczęło pracę nad nowym kompilatorem. Clang [16]

to front-end kompilator dla języków z rodziny C: C, Objective-C, C++ i Objective-C++,

stworzony w ramach projektu LLVM (Low Level Virtual Machine), który jest używany jako

generator kodu natywnego i optymalizator. Jest bardziej modularny niż GCC

i obok kompilacji może być stosowany podczas uzupełniania kodu, kolorowania składni i

statycznej analizy kodu. Clang posiada jasny podział na kod używany w poszczególnych

warstwach i izoluje kod uruchomieniowy w osobnych klasach.

Obecnie projekt jest ciągle w fazie rozwojowej, ale jako kompatybilny zamiennik dla

GCC jest już intensywnie wykorzystywany w systemach uniksopodobnych. System

operacyjny FreeBSD Release 9.0 posiada wsparcie dla kompilowania większości programów

z portów oraz samego systemu przy pomocy Clang.

Korzystając z kompilatora Clang i środowiska uruchomieniowego dostępnego

w projekcie GNUstep, można uzyskać dostęp do pełnej funkcjonalności języka

Objective-C 2.0. Oznacza to, że w Objective-C 2.0 można programować na platformach

Windows, Linux, *BSD, Solaris i podobnych, gdzie występuje ten kompilator.

24

5.4. OBJECTIVE-C JĘZYK

Objective-C jest rozbudowanym o nowe elementy językiem C. Każdy kod napisany w

języku C jest w stu procentach kompatybilny i poprawny w Objective-C, co więcej - duża

część składni i struktury wywodzi się wprost z języka C. Istnieje zatem możliwość pisania

programów w Objective-C wykorzystując wszystkie dobrodziejstwa języka C (Rysunek 9).

Rysunek 9. Objective-C to język C z dodatkowymi elementami (na podstawie [14]).

W celu wyraźnego odróżnienia języków, Objective-C stosuje własną składnie kodu,

niespotykaną i niepodobną do innych języków programowania [13] [17]:

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[]) {

NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

NSArray *param = [[NSProcessInfo processInfo] arguments];

NSCountedSet *cset = [[NSCountedSet alloc] initWithArray:param];

NSArray *sorted_args = [[cset allObjects]

sortedArrayUsingSelector:@selector(compare:)];

NSEnumerator *enm = [sorted_args objectEnumerator];

id word;

while (word = [enm nextObject]) {

printf("%s\n", [word UTF8String]);

}

[cset release];

[pool release];

return 0;

}

25

W powyższym kodzie można dostrzec elementy nietypowe dla języka C, takie jak

wywołania metod w nawiasach kwadratowych [ ], obiekty NS czy @selector. Nawiasy [ ]

przez jednego z twórców zostały określone jako informacje dla programisty o tym, że ma do

czynienie z programowaniem obiektowym.

Obiekty

Jak sama nazwa języka wskazuje, zorientowany obiektowo język Objective-C opiera się

na tworzeniu aplikacji za pomocą obiektów. Obiekt łączy dane z operacjami, które mogę

wykorzystywać lub wpływać na te dane.

W Objective-C operacje są określane jako metody obiektów, a dane jako zmienne instancji.

Obiekty są zawsze alokowane na stercie i dlatego dostęp do nich zawsze następuje poprzez

wskaźnik.

Klasa a instancja

Klasa jest to zarys, schemat tworzonego później obiektu, jest planem budowy. Instancja

jest egzemplarzem obiektu stworzonego na podstawie klasy. Może być wiele instancji jednej

klasy.

Można to porównać do budowy domu. Klasa jest planem domu, ze wszystkimi wytycznymi.

Instancja jest to już gotowy dom. Na podstawie klasy można postawić wiele domów.

Wysyłanie wiadomości a wywoływanie metod

W celu zmuszenie obiektu do wykonania pewnej czynności lub zmiany jego stanu,

wysyłamy do obiektu wiadomość.

[odbiorca wiadomość];

odbiorca jest obiektem, a wiadomość mówi co ma zostać wykonane. W kodzie wiadomość to

po prostu nazwa metody, z lub bez parametrów. Kiedy wiadomość zostanie wysłana,

środowisko uruchomieniowe wyszykuję odpowiadającą metodę z pośród wszystkich

dostępnych i ją uruchamia.

Ponieważ metoda jest wybierana z pośród wszystkich dostępnych implementacji, nazwa

metody w wiadomości jest często określana jako selector.

26

Wysyłanie wiadomości różni się znacząco od wywoływania metody jakie jest znane w

innych językach programowania. Gdy wysyłamy wiadomość, sposób jej obsługi w całości

zależy od odbiorcy. W Objective-C jedyną rzeczą, która ma wpływ na wybór wywoływanej

metody, jest realny typ obiekt. W C++ i innych językach z rodziny Simula wybór metody

zależy również od tego, co na temat typu obiektu wie kompilator.

Definiowanie zmiennych

Wartości zmiennych można modyfikować na dwa sposoby, nowym tj. Objective-C:

[myInstance setValue:10];

printf(“myInstance value: %d”, [myInstance value]); // zwróci: myInstance

value: 10

lub starym tj. C:

myInstance.value = 10;

printf(“myInstance value: %d”, [myInstance value]); // zwróci: myInstance

value: 10

inny przykład:

person.address.street.name = @"Oxford Road";

[[[person address] street] setName: @"Oxford Road"];

id

NSObject deklaruje prototyp init dla inicjalizatorów, jest to instancja metody

zdefiniowana do zwracania obiektu typu id. W Objective-C identyfikatory obiektów są

specjalnego typu id. Typ id jest ogólnym typem dla każdego obiektu niezależnie od klasy i

może być używany dla instancji klasy i dla samych obiektów klasy.

id anObject;

Słowo kluczowe nil jest zdefiniowane jako obiekt null, id o wartości 0. id, nil oraz pozostałe

typy podstawowe Objective-C są zdefiniowane w pliku nagłówkowym objc/objc.h.

id jest zdefiniowany jako wskaźnik do struktury danych obiektu:

27

typedef struct objc_object {

Class isa;

} *id;

Każdy obiekt ma zmienną isa, która mówi jakiej klasy jest to instancja. Ponieważ typ Class

jest zdefiniowany jako wskaźnik:

typedef struct objc_class *Class;

zmienna isa jest określana jako wskaźnik isa.

Tworzenie obiektów

Class aClass = [anObject class];

NSMutableArray *array = [[NSMutableArray alloc] init];

lub

NSMutableArray *array = [NSMutableArray new];

W powyższym fragmencie kodu, wersja druga z new jest rzadziej spotykana. Wynika to z

fakty że metoda init często występuję z parametrami:

NSMutableArray *array = [[NSMutableArray alloc] initWithObjects:objc,nil];

Definiowanie klas

W Objective-C klasy są definiowane w dwóch częściach:

• interfejs deklaruję metody, zmienne (właściwości) oraz nazwę jej superklasy.

• implementacja, która faktycznie definiuję klasę (zawiera kod, który implementuje jej

metody)

Każda część znajduję się w osobnym pliku. Kompilator oczekuję pojedynczego pliku, a

separacja jest uzyskiwana dzięki preprocesorowi, który łączy różne pliki. W Objective-C

konwencją jest umieszczanie interfejsów klas w plikach nagłówkowych z rozszerzeniem .h, a

implementacje w plikach z rozszerzeniem .m. Pliki są nazywane tak samo jak klasa, np. dla

klasy Rectangle będzie zdeklarowana w Rectangle.h i zdefiniowana w Rectangle.m.

28

Interface

@interface ClassName : ItsSuperclass

// Deklaracja metod i właściwości.

@end

Metody można podzielić na:

• metody klasy - oznaczone plusem:

+ alloc;

• metody instancji - oznaczone minusem:

- (void)display;

Zwracają wartości deklarowane tak samo jak w języku C:

- (float)radius;

Określanie parametrów:

- (void)setRadius:(float)aRadius;

- (void)setWidth:(float)width andHeight:(float)height;

Deklaracja właściwości:

@property (attributes) Type propertyName;

Import interfejsu:

#import "WebViewController.h"

Importowanie klas z poza hierarchii dziedziczenia:

@class Rectangle, Circle;

Przykład:

#import <UIKit/UIKit.h>

@class WebViewController;

@interface WebAppDelegate : NSObject <UIApplicationDelegate> {

UIWindow *window;

WebViewController *viewController;

}

@property (nonatomic, retain) IBOutlet UIWindow *window;

@property (nonatomic, retain) IBOutlet WebViewController *viewController;

@end

29

Implementacja

@implementation ClassName

{

// deklaracja dodatkowych zmiennych

} // blok pomijalny

// implementacja metod

@end

Implementacja właściwości:

@synthesize aObject;

Można użyć dyrektywy @synthesize w celu wymuszenia na kompilatorze utworzenia metod

setter i getter podczas kompilacji. Dzięki temu programista nie musi tworzyć tych metod w

bloku @implementation.

Przykład:

#import "WebAppDelegate.h"

#import "WebViewController.h"

@implementation WebAppDelegate

@synthesize window;

@synthesize viewController;

- (void)dealloc {

[viewController release];

[window release];

[super dealloc];

}

@end

5.5. PODSUMOWANIE

Objective-C jest językiem, w którym został napisany system iOS, jest też językiem, w

którym pisane są wszystkie aplikacje na ten system. Jest on nieodłączną częścią tworzenia

oprogramowania dla produktów firmy Apple.

30

6. ZARZĄDZANIE PAMIĘCIĄ

W każdym programie bardzo ważne jest zarządzanie pamięcią w taki sposób, żeby

nieużywane obiekty zostały usunięte z pamięci tj. zwolniły zajmowaną przestrzeń w pamięci i

zwolniły zasoby. W przeciwnym przypadku aplikacja będzie zajmować większy obszar

pamięci, niż jest wymagany. Bardzo ważne jest również, żeby nie zwolnić obszaru pamięci

zajmowanej przez obiekt, który w dalszym ciągu jest używany.

Objective-C oferuję trzy mechanizmy zarządzania pamięcią, które umożliwiają

osiągnięcie tych celów [5].

• Automatyczne zliczenie referencji (Automatic Reference Counting) - gdzie

kompilator decyduje o długości “życia” obiektu.

• Ręczne zliczanie referencji (Manual Reference Counting) - cała odpowiedzialność

za alokacje i dealokacje jest przeniesiona na programistę.

• Garbage collection - gdzie odpowiedzialność za określenie długości “życia” obiektu

jest przeniesiona na “collector”.

W iOS dostępne są tylko pierwsze dwa sposoby zarządzanie pamięcią. Przy czym ARC

jest stosunkowo nową metodą jeszcze nie tak powszechnie stosowaną. Pierwsza wersja tego

mechanizmu dostępna jest w iOS 5. Pierwsza oficjalna dokumentacja tej metody została

opublikowana 12 października 2011 roku.

Garbage collection pomimo, że jest dostępny w Objective-C, może być

wykorzystywany jedynie na platformie Mac OS X. W iOS garbage collection nie jest

dostępny w żadnej wersji.

Dlaczego zarządzanie pamięcią w iOS jest tak istotne?

W pierwszej wersji iPhone’a dostępne było 128 MB DRAM pamięci. Biorąc pod

uwagę, to że mowa jest o telefonie, może wydawać się, że to dużo. Gdy jednak

przeanalizujemy, że sam system operacyjny, wtedy jeszcze pod nazwą iPhone OS, potrafił

zarezerwować ponad 80 MB, do dyspozycji zostaje ok 40 MB lub mniej.

W iPhone jest kilka programów np. mail, ipod, safari, które pochłaniają kolejną porcję

pamięci, ponieważ są to specjalne programy działające w tle.

31

Oznacza to, że programista musi zadbać o każdy stworzony obiekt pisanej aplikacji.

Ponieważ do tej pory nie było automatycznego zliczanie referencji, a garbage collection nie

jest dostępny w iOS, całą odpowiedzialność za zarządzanie pamięcią spada na programistę.

Zliczanie referencji

Programista musi zadbać o zwolnienie pamięci po każdym stworzonym przez niego

obiekcie. Zarządzanie prymitywnymi typami takimi jak int, float, BOOL nie jest tutaj

uwzględniane, ponieważ nie są to obiekty.

Zarys problemu

Weźmy pod uwagę fragment pamięci, który jest otwarty i dostępny do wglądu w iPhone

podczas pracy aplikacji (Rysunek 10) [14]:

Rysunek 10. Schemat fragmentu pamięci.

oraz fragment kodu wykonywanej aplikacji:

Dog *fido = [Dog new];

[fido bark];

[fido release];

[fido bark]; // !!

Pierwsza linia kodu jest odpowiedzialna za utworzenie nowego obiektu typu Dog - fido

będącego wskaźnikiem (ang. pointer). W celu utworzenia obiektu używamy operatora new.

Kiedy ta linia zostanie wykonana, w pamięci zostaje zajęty pewien obszar, na który wskaźnik

zostaje ustawiony. Obszar poza “wypełnieniem” zainicjalizowaniem, zawiera pewną wartość

retainCount, która zostaje ustawiona na wartość 1 (Rysunek 11).

Dog *fido = [Dog new];

32

Rysunek 11. Schemat fragmentu pamięci z zajętą przestrzenią.

następnie wykonujemy pewne operacje na stworzonym obiekcie:

[fido bark];

Kiedy wykonamy wszystkie operacje powiązane z tym obiektem i dłużej go nie

potrzebujemy, należy zwolnić zajmowaną przez niego pamięć. W tym celu wywołujemy

metodę release na tym obiekcie:

[fido release];

W efekcie wartość retainCount zmienia się z 1 na 0 (Rysunek 12).

Rysunek 12. Schemat fragmentu pamięci tuż po zwolnieniu przestrzeni.

Kiedy nastąpi to co powyżej, to system zwolni wcześniej zarezerwowany obszar pamięci

(Rysunek 13).

Rysunek 13. Schemat fragmentu pamięci po zwolnieniu i wyczyszczeniu.

Może to prowadzić do pewnego rodzaju problemu. Wskaźnik fido ciągle istnieje, ale nie

wskazuję na żaden obszar pamięci, jest to tzw. dangling pointer (Rysunek 13). Problem

pojawi się w chwili, kiedy będziemy chcieli wywołać metodę na rzecz tego obiektu:

33

[fido bark]; // !!

Program zakończy swoje działanie z powodu błędu. Jest to jedno z wyzwań stawianych przed

programistą podczas zarządzania pamięcią; unikanie błędów wykonywania operacji na

obiektach, których pamięć została wcześniej zwolniona.

Innym rodzajem złego zarządzania pamięcią jest sytuacja odwrotna do zaprezentowanej,

tzn. nie zwalnianie pamięci już niewykorzystywanej.

Wycieki pamięci

Przyjmijmy, że wykonujemy poniższy fragment kodu:

Dog *fido = [Dog new];

[fido bark];

} // end of function

Nie wykonanie na obiekcie lucky metody release, spowoduje przetrzymywanie pamięci,

pomimo że obiekt w dalszej części programu nie jest już wykorzystywany

(Rysunek 14):

Rysunek 14. Schemat fragmentu pamięci z obiektem lucky.

W efekcie działający program może rezerwować duże obszary pamięci, z której nie korzysta

(Rysunek 15).

Rysunek 15. Schemat fragmentu pamięci z przetrzymywanym obszarem.

34

6.1. PODSUMOWANIE

Powyższe przykłady prowadzą do kilku wniosków. Jeśli jesteśmy właścicielem obiektu,

naszą odpowiedzialnością jest zwolnienie zajmowanej przez niego pamięci. Właścicielem

zostajemy gdy, tworzymy obiekt, kopiujemy bądź przetrzymujemy obiekt. Nie zwalniamy

pamięci obiektu, którego nie jesteśmy właścicielem, będzie to prowadzić do powstawania

dangling pointerów, a w efekcie do błędu programu. Nie należy zwalniać pamięci zbyt

wcześnie.

Sposób wykrywania błędów związanych z zarządzaniem pamięcią został opisany w

następnym rozdziale, podczas prezentacji narzędzi do wykrywania wycieków pamięci (7.2.4).

35

7. NARZĘDZIA

W celu rozpoczęcia tworzenia oprogramowania będą potrzebne niezbędne do tego

narzędzia. Niestety na tym etapie większość zainteresowanych zakończy swoją przygodę z

programowaniem na platformę iOS.

7.1. HARDWARE & SOFTWARE

Do tworzenia aplikacji na iOS konieczne jest posiadanie komputera firmy Apple

zbudowanego w oparciu o procesor Intel (Rysunek 16) [6].

Rysunek 16. Komputery firmy Apple: MacBook Pro oraz iMac [6].

Do tworzenia aplikacji na iOS wymagane jest również iOS SDK. To zaś wymaga

oprogramowania Xcode w wersji co najmniej 3.x, a co za tym idzie wymagany jest system

Mac OS X 10.5 (Leopard) i komputer, który ma wystarczające zasoby do poprawnej pracy

tego systemu.

Zgodnie z zaleceniami iOS Dev Center [18] do realizacji pracy będzie potrzebny Mac

z procesorem Intel działający pod kontrolą Mac OS X 10.6 (Snow Leopard) lub nowszy.

Najlepiej posiadać komputer wyprodukowany w 2009 roku lub nowszy (Rysunek 16). Apple

nie przewiduje możliwości programowania na iOS na innych systemach operacyjnych niż ich

36

własny. Licencja każdego systemu Mac OS X nie pozwala instalować systemu na inny sprzęt

niż ten dostarczony przez Apple, a co za tym idzie, jesteśmy zmuszeni do posiadania

stosunkowo nowego komputera od Apple.

Ponadto niezbędne jest zarejestrowanie się na stronie iOS Dev Center

(https://developer.apple.com/devcenter/ios/index.action) w charakterze programisty iOS, aby

móc pobrać iOS SDK oraz Xcode, czyli opracowane przez Apple zintegrowane środowisko

programistyczne (Rysunek 17).

Rysunek 17. Zrzut ekraniu z fragmentem strony internetowej iOS Dev Center [18].

37

7.2. XCODE

Poprzez Xcode często określa się zestaw kilku narzędzi, programów do wytwarzania

oprogramowania na platformę iOS.

• Xcode

• Interface Builder

• iOS Simulator

• Instruments

7.2.1. Xcode

Xcode to zintegrowane środowisko programistyczne (IDE - Integrated Development

Environment) zawierające narzędzia opracowane przez Apple do tworzenia oprogramowania

dla OS X oraz iOS. Program zawiera narzędzia do tworzenia kodu źródłowego, usuwania z

niego błędów, kompilacji aplikacji oraz poprawiania wydajności już utworzonych aplikacji

(Rysunek 18).

Najnowsze wersje środowiska (3.2 i nowsze) korzystają z kompilatora LLCV z Clang

jako front-end, w starszych występuję zmodyfikowana wersja GCC. Xcode posiada wsparcie

dla takich języków jak: C, C++, Objective-C, Objective-C++, Java, AppleScript, Python,

Ruby oraz poprzez dodatki dla GNU Pascal, Free Pascal, Ada, C#, Perl i D [19].

Rysunek 18. Okno programu Xcode 3 (zrzut ekranu).

38

7.2.2. Interface Builder

Interface Builder jest niezależną częścią Xcode przeznaczoną do tworzenia graficznego

interfejsu aplikacji.

Program Interface Builder stworzony w języku programowania Lisp, po raz pierwszy

ukazał się w roku 1986. Przez lata był wykorzystywany podczas tworzenia aplikacji dla

systemów NeXTSTEP, OpenSTEP, Mac OS X, a obecnie dla urządzeń korzystających z

systemu iOS. Interface Builder obsługuję dwa typy plików:

• .nib - starszy format, skrót od NeXT Interface Builder

• .xib - nowszy format

Obecnie wszystkie szablony projektów używają nowego formatu .xib, ale do niedawna

wszystkie tworzone przez Interface Builder pliki miały rozszerzenie .nib. Z tego powodu

większość programistów nadal nazywa pliki Interface Builder plikami nib, wynika to również

z łatwości wypowiedzenia „nib file” w przeciwieństwie do „xib file” [5].

Rysunek 19. Okna programu Interface Builder (zrzut ekranu z widocznymi oknami: biblioteka, widok, właściwości oraz okno główne pliku „HelloWorldViewConroller.xib”) [2].

39

7.2.3. iOS Simulator

Napisaną aplikacje trzeba będzie kiedyś przetestować i sprawdzić czy uzyskany rezultat

jest zgodny z oczekiwaniami programisty. Tutaj może pojawić się kolejne rozczarowanie.

Bezpłatne konto na iOS Dev Center [18] nie pozwala na umieszczenie aplikacji w

rzeczywistym urządzeniu, np. iPhone. Nie mamy też możliwości umieszczenia aplikacji w

sklepie App Store. Taką możliwość daje nam konto płatne:

• Program Standard - koszt 99 USD rocznie, przeznaczony dla programistów, firm,

organizacji, itd.

• Program Enterprise - koszt 299 USD rocznie, przeznaczony dla firm, itd., z

nastawieniem na większe projekty.

Częściowym rozwiązaniem problemu jest iOS Simulator (Rysunek 20), który pozwala na

zbudowanie i uruchomienie na komputerze aplikacji przeznaczonej dla platformy iOS.

Symulator ma pewne ograniczenia, nie oferuje wszystkich funkcji prawdziwego urządzenia

m. in. brak dostępu do kamery, wibracji, GPS, akcelerometru, żyroskopu, gesty ograniczone

do symulacji potrząsania telefonem. Ponadto symulator korzysta z zasobów dostępnych na

komputerze, to oznacza lepszy procesor i więcej pamięci RAM niż prawdziwe urządzenie.

Rysunek 20. Okno programu iOS Simulator (zrzut ekranu).

40

7.2.4. Instruments

Program Instruments [20] jest analizatorem wydajności aplikacji z graficzną prezentacją

wyników wchodzący w skład Xcode 3.0 oraz nowszych wersji programu Xcode. Instruments

jest zbudowany w oparciu o framework DTrace systemu OpenSolaris i przystosowany do

działania na Mac OS X.

Instruments prezentuję linię czasu wyświetlając wszystkie zdarzenia występujące w

aplikacji, takie jak: zmiana aktywności procesora, przydział pamięci, aktywność sieciową

oraz aktywność plików, dodatkowo prezentując wykresy oraz statystyki. Grupa zdarzeń jest

monitorowana poprzez konfigurowalne „instrumenty” (Rysunek 21), które mają możliwość

nagrywania wygenerowanych zdarzeń oraz ich odtworzenia (zasymulowania) tyle razy ile

będzie trzeba. Programista może zobaczyć efekt zmian w kodzie nie wykonując powtórnie

zdarzeń. Interface Builder posiada możliwość tworzenia niestandardowych instrumentów

analitycznych.

Rysunek 21. Widok części dostępnych instrumentów (zrzut ekranu).

41

Wykrywanie wycieków pamięci

Podczas pisania aplikacji tworzy się dużą ilość zmiennych, obiektów, tworzone są

odwołani do obiektów, obiekty są przetrzymywane. Każda z tych operacji wymaga

wywołania metody zwalniającej pamięć, gdy instancja nie jest już dłużej potrzebna.

Większość metod posiada własne zmienne lokalne, wykorzystywane tylko w ramach jej bloku

danych. Metody zaś w większości przypadków są wykonywane wielokrotnie. Wystarczy

zapomnieć o wywołaniu metody zwalniającej pamięć tylko dla jednej zmiennej lokalnej, żeby

doszło od wycieku pamięci.

Opisany poniżej przypadek miał miejsce podczas tworzenia aplikacji opisanej w drugiej

części pracy.

Po zakończeniu pisania części aplikacji związanej z tworzeniem historii odwiedzanych

stron oraz weryfikacji poprawności logiki aplikacji, program została sprawdzony pod

względem ewentualnych wycieków pamięci. Po uruchomieniu aplikacji Instruments z

instrumentem „Leaks” okazało się, że występują wycieki pamięci (Rysunek 22).

Program Instruments pozwala na wyświetlanie bardzo szczegółowych informacji o

śledzonej aplikacji. Dzięki temu można sprawdzić, które adresy w pamięci w dalszym ciągu

są zajęte, tzn. mają ustawioną wartość retain count różną od zera, ale aplikacja nie posiada

już do nich odwołania.

Sposób wykorzystania programu.

Po włączeniu należy uruchomić aplikację, która ma być analizowana, oraz wybrać ją z

listy działających programów Target (Rysunek 24). Następnie włączyć nagrywanie –

czerwona kropka w lewym górnym rogu (Rysunek 22) Record (Rysunek 24). Pojawią się

dwie linie czasu, odpowiednio dla wykrywania (Rysunek 22):

a) alokacji pamięci (fioletowa linia czasu),

b) wycieków pamięci (szara linia czasu).

Gdy włączone jest śledzenie, należy przetestować działanie aplikacji. Fioletowa linia czasu

Allocations pokazuję, kiedy obszar w pamięci jest zajmowany, szara linia czasu Leaks

pokazuje ewentualne wycieki pamięci. Na załączonym zrzucie ekranu (Rysunek 22) oraz

(Rysunek 25), na linii czasu Leaks widać kreski oznaczające wyciek pamięci.

Rozwijając drzewo obiektu widoku głównego, WebView (Rysunek 23), można

prześledzić stos wykonywanych operacji.

42

Rysunek 22. Widok programu Instruments podczas śledzenia/nagrywania działania aplikacji Web (zrzut ekranu).

Rysunek 23. Widok drzewa śledzonych obiektów w programie Instruments (zrzut ekranu).

43

Rysunek 24. Przyciski Record (nagrywanie) oraz Target (cel) programu Instruments (fragment zrzutu ekranu).

Rysunek 25. Widoczny wyciek pamięci (fragment zrzutu ekranu).

Program Instruments jest w stanie wykryć w kodzie programu miejsce, w którym zaczyna się

problem z zarządzaniem pamięcią (Rysunek 26).

Rysunek 26. Instruments z zaznaczonym fragmentem kotu, gdzie powstał problem (zrzut ekranu).

44

Zaznaczony linia kodu (Rysunek 26) jest odpowiedzialna za wykonanie metody

addHistory, odpowiedzialnej za zapisywanie historii odwiedzanych stron. Po przejściu do

kodu metody addHistory, Instruments zaznacza, które obiekty są przyczyną wycieku

(Rysunek 27).

Rysunek 27. Fragment kodu z zaznaczonymi zmiennymi odpowiedzialnymi za wyciek pamięci (zrzut ekranu).

Przyczyną okazało się pominięcie wykonania metody release na zmiennych lokalnych,

w efekcie, za każdym razem, gdy była odwiedzana strona WWW i metoda zapisująca historię

była wykonywana, tworzone były nowe obiekty, ale nie były one zwalniane.

Rozwiązaniem problemu są dwie linie kodu zwalniające pamięć, na końcu metody:

[dateFormatter release];

[plLocale release];

7.3. PODSUMOWANIE

Przedstawione narzędzia pozwalają zarówno na stworzenie aplikacji, jak również na

przetestowanie poprawności jej działania. Pomimo, że są to cztery oddzielne programy, ich

znacznie jest równie ważne podczas całego cyklu tworzenia aplikacji na iOS.

45

8. ARCHITEKTURA MODEL-VIEW-CONTROLLER

Projektanci platformy Cocoa Touch zastosowali architektoniczny wzorzec projektowy o

nazwie MVC (Model-View-Controller, czyli Model-Widok-Kontroler), który stanowi

logiczny sposób tworzenia aplikacji, organizowania struktury w aplikacji posiadającej

interfejs graficzny.

Model-View-Controller został zaprojektowany w 1979 roku przez norweskiego

programistę Trygve Reenskaug pracującego wtedy nad językiem Smalltalk w laboratoriach

Xerox i początkowo nosił nazwę Model-View-Editor [21].

Architekturę MVC pod względem funkcjonalności można podzielić na trzy oddzielne

kategorie (Rysunek 28):

• Model (model) - są to klasy przechowujące dane aplikacji;

• View (widok) - to kod odpowiedzialny za okna, kontrolki i inne elementy widoczne

dla użytkownika, z którymi można prowadzić interakcję;

• Controller (kontroler) - łączy w aplikacji model i widok; stanowi logikę aplikacji i

decyduję, w jaki sposób obsłużyć dane wejściowe pochodzące od użytkownika.

Rysunek 28. Schemat modelu MVC wersja dla Cocoa [22].

Model hermetyzuje dane specyficzne dla aplikacji oraz definiuje logikę i sposób

manipulacji oraz przetwarzania danych. Model może reprezentować postać w grze lub

kontakt w książce adresowej. Obiekt modelu może posiadać relacje do jednego lub do wielu

innych obiektów modelu.

Widok jest najprostszy do zdefiniowania. Jest to element aplikacji, który użytkownik

może zobaczyć. Widok wie, w jaki sposób ma się zaprezentować i może odpowiadać na akcję

wykonywane przez użytkownika. Głównym celem widoku jest prezentacja danych modelu

46

aplikacji oraz umożliwienie edycji tych danych. Obiekty widoku są oddzielone od obiektów

modelu w aplikacji MVC.

Kontroler działa jako pośrednik pomiędzy jednym lub wieloma widokami i jednym lub

wieloma obiektami modelu. Kontroler jest medium, przez które widok dowiaduję się o

zmianach w obiektach modelu i odwrotnie. Akcje wykonywane przez użytkownika w

warstwie widoku w celu stworzenia lub modyfikacji danych są przesyłane przez obiekty

kontrolera, w wyniku czego obiekty modelu są tworzone lub modyfikowane. Analogicznie,

gdy zmianie ulegną dane modelu, obiekt kontrolera wychwytuje je, co powoduje odpowiednią

zmianę obiektów widoku. Warstwa kontrolera może również dokonywać zmian ustawień i

koordynować zadaniami aplikacji oraz zarządzać cyklami życia innych obiektów

(Rysunek 29).

Rysunek 29. Model warstwowy wzorca MVC w iOS [22].

Sposób tworzenia aplikacji dla iOS wymusza na programiście podejście wykorzystujące

wzorzec MVC. Dla każdego widoku stworzonego za pomocą Interface Builder’a trzeba

stworzyć kontroler widoku, oraz model określający jakie dane i w jaki sposób muszą zostać

zmodyfikowane w wyniku reakcji na działania użytkownika w warstwie widoku.

47

9. PROJEKTOWANIE STRONY INTERNETOWEJ DLA IPHONE

Świat urządzeń mobilnych to zupełnie nowe medium. Gdy pojawiały się pierwsze

telefony z możliwością przeglądania stron WWW, nie istniały żadne wytyczne mówiące w

jaki sposób tradycyjna strona ma się zachować na tak nietypowym urządzeniu. Najlepsze

praktyki znane z tradycyjnych witryn, po prostu nie zdają egzaminu na urządzeniach

mobilnych. Unikatowa charakterystyka urządzeń, nietypowy system, a przede wszystkim

nowe, niespotykane wcześniej wymagania użytkowników, wymagają nowego podejścia do

projektowania i wytwarzania mobilnych witryn internetowych.

Współczesne urządzenia mobilne oferują swoim użytkownikom przeglądarki

opracowane zgodnie z pewnymi standardami, ale nie zawsze w pełni je spełniają.

Przeglądarki dostępne na tych urządzeniach umożliwiają prezentowanie treści stron

stworzonych w jednym z kilku mobilnych języków znaczników. Do najpopularniejszych

należą [3]:

• XHTML

• XHTML-MP

• HTML

• CHTML

• WML

Mobilne witryny internetowe tworzone wyłącznie z myślą o smartfonach, mogą

korzystać z pełnej specyfikacji języka HTML oraz XHTML. Większość smartfonów posiada

zainstalowane mobilne wersje przeglądarek internetowych opartych o te same silniki

wyświetlania stron, co standardowe przeglądarki na komputerach PC.

Oprócz języków znaczników, unowocześnieniu uległy również mobilne języki

skryptowe. Do niedawna przetwarzanie skryptów po stronie przeglądarek było domeną tylko

najbardziej zaawansowanych smartfonów. Obecnie dostępna jest mobilna wersja JavaScript w

formie standardu ECMAScript-MP [3].

Forma prezentacji CSS również ma swoją mobilną odmianę w postaci dwóch

standardów:

• Wireless CSS

• CSS Mobile Profile

W dalszej części rozdziału opisano technologie, które zostały wykorzystane do

stworzenia mobilnej strony internetowej dla iPhone.

48

9.1. HTML

HTML (ang. HyperText Markup Language), czyli hipertekstowy język znaczników jest

wykorzystywany do tworzenia stron internetowych. Nie jest zaliczany do języków

programowania, ze względu na brak wyrażeń obliczeniowych, instrukcji warunkowych czy

iteracyjnych. Początki języka sięgają lat osiemdziesiątych ubiegłego wieku, kiedy to w

ośrodku naukowo-badawczym CERN powstał prototyp hipertekstowego systemu

informacyjnego ENQUIRE, służącego go udostępniania dokumentów związanych z

prowadzonymi badaniami naukowymi. HTML jest niezależny do systemu operacyjnego oraz

wykorzystywanego sprzętu, co przyczyniło się do jego popularności w początkowych latach,

aktualnie jest to powszechnie uznawany standard.

Język posiada kilka specyfikacji rozumianych jako kolejne wersje oraz kilka projektów

niezależnych bazujących na HTML. Najbardziej znanym jest XHTML, którego drugi

wydanie XHTML 2.0 miało w całości zastąpić specyfikacje HTML. Ze względu na brak

kompatybilności z wersjami wcześniejszymi projekt został porzucony na rzecz HTML 5.

Aktualnie trwają niezależne od siebie prace nad XHTML 1.1 będącym następcą XHTML 1.0,

oraz HTML 5 jako następca HTML 4 oraz XHTML 1.0 [23].

Standard HTML 5 pomimo ciągle trwających prac już udostępnia swoją specyfikację i

jest coraz powszechniej stosowany. Do coraz większej popularności tego standardu

przyczynia się fakt dodania nowych znaczników, tagów odpowiedzialnych za semantykę

dokumentu. Strony projektowane w starszych standardach do organizacji struktury

dokumentu wykorzystywały element <div> (Tabela 2). Aktualnie traci on na znaczeniu na

rzecz nowych elementów takich jak (Tabela 3):

• header

• footer

• section

• article

• aside

• nav

49

Tabela 2. Przykładowy kod strony w HTML 4 oraz sposób prezentacji w przeglądarce Safari [24].

Kod HTML 4 Zrzut ekranu

<html> <head> ...dane... </head> <body> <div id="header"> <h1>Moja strona</h1> </div> <div id="nav"> <ul> <li>Początek</li> <li>Informacje</li> <li>Kontakt</li> </ul> </div> <div id=content> <h1>Artykuł</h1> <p>...</p> </div> <div id="footer"> <p>...</p> </div> </body></html>

Tabela 3. Ta sama struktura strony w HTML 5 oraz sposób prezentacji w przeglądarce Safari [24].

Kod HTML 5 Zrzut ekranu<!DOCTYPE html><html> <head> ...dane... </head> <body> <header> <h1>Moja strona</h1> </header> <nav> <ul> <li>Początek</li> <li>Informacje</li> <li>Kontakt</li> </ul> </nav> <section> <h1>Artykuł</h1> <article> <p>...</p> </article> </section> <footer> <p>...</p> </footer> </body></html>

50

HTML jest używany do tworzenia struktury dokumentu (Rysunek 30), podzielenia go

na logiczne struktury. Część związana z formatowaniem treści np. kolor tekstu, rozmiar i

rodzaj czcionki, parametry tła strony została odseparowana do oddzielnego pliku lub do

osobnego elementu struktury dokumentu niebędącego prezentowanym podczas wyświetlania

treści dokumentu. Nie zaleca się stosowania elementów formy prezentacyjnej bezpośrednio

we właściwościach tagów, chyba że ma to logiczne uzasadnienie i nie jest możliwe uzyskanie

wymaganego efektu poprzez inne metody [23].

Rysunek 30. Widok struktury podzielonej na sekcje z nagłówkami.

9.2. CSS

CSS (ang. Cascading Style Sheets), czyli kaskadowe arkusze stylów jest to język

służący do opisu semantyki prezentacji dokumentu napisanego w języku znaczników.

Najpowszechniej wykorzystywany jest do formatu stylu prezentacji dokumentów napisanych

w HTML i XHTML (Rysunek 31). Język ten został stworzony w celu odseparowania

struktury dokumentu od formy jego prezentacji.

Dostępne są trzy standardy CSS: CSS 1, CSS 2 oraz CSS 3, ale tylko pierwsze dwa są

zatwierdzone przez W3C. CSS 3 jest w trakcie prac, niemniej podobnie jak HTML 5, jest już

stosowany.

Część właściwości CSS 3 określanych jako w fazie eksperymentalnej jest opatrzona

prefiksem odpowiednim dla przeglądarki lub wykorzystywanego przez nią silnika np.

-moz-border-radius dla Gecko, -webkit-border-radius dla WebKit. Spora cześć właściwości

jest dostępna tylko dla jednego silnika i nie ma swojego odpowiednika dla pozostałych lub

posiada unikatowe wartości [25].

51

Rysunek 31. Widok strony HTML bez wykorzystania CSS.

9.3. PHP

PHP [26] jest językiem skryptów ogólnego przeznaczenia po stronie serwera,

zaprojektowanym w celu tworzenie dynamicznych stron internetowych. Jest jednym

z pierwszy języków skryptowych wykonywanych po stronie serwera, który umożliwia

osadzenie go bezpośrednio w dokumentach HTML zamiast wywoływania zewnętrznych

plików w celu przetworzenia danych. Kod jest interpretowany przez serwer WWW

z zainstalowanym modułem PHP, którego wynikiem jest wygenerowana strona internetowa.

9.4. JAVASCRIPT

JavaScript [27] to prototypowy język skryptowy o dynamicznym, słabym typowaniu,

najczęściej wykorzystywany w celu zwiększenia funkcjonalności tworzonych stron

52

internetowych. Skrypty są wykonywane po stronie klienta (w rzadkich przypadkach po

stronie serwera) do dynamicznego reagowania na zdarzenia generowane przez użytkownika.

9.5. MYSQL

MySQL [28] to system zarządzania bazami danych udostępniany na zasadach licencji

GPL. Aktualnie jest własnością firmy Oracle, wcześniej Sun Microsystems, który został przez

Oracle kupiony w 2008 roku. Najważniejszymi cechami MySQL jest jej szybkość oraz

dostępność na wielu platformach systemowych m. in. Linux, Windows, Mac OS X, FreeBSD,

Solaris, AIX.

Sporą popularność zdobył dzięki narzędziu phpMyAdmin, sprawiającemu że

administracja bazą stała się bardzo prosta.

phpMyAdmin

Darmowe, otwarte narzędzie napisane w PHP, służące do łatwego zarządzania oraz

administrowania bazą danych MySQL z poziomu przeglądarki internetowej (Rysunek 32)

[29].

Rysunek 32. Okno główne aplikacji phpMyAdmin.

53

9.6. WEBKIT

WebKit [30] to silnik wyświetlania (renderowania) stron internetowych

wykorzystywany głównie przez przeglądarki internetowe. Rozwijany na zasadach wolnego

(otwartego) oprogramowania. Jest odpowiedzialny za przetwarzanie kodu strony (HTML,

XHTML, skrypty, grafika) oraz elementów formatujących (CSS, XSL) i renderowanie

wyniku. WebKit jest najbardziej znany z wykorzystania w przeglądarkach Safari, Google

Chrome oraz Maxthon. W roku 2012 posiadał największy udział w rynku z pośród wszystkich

silników przeglądarek internetowych.

Silnik ten zawiera dwa najważniejsze komponenty, WebCore oraz JavaScriptCore

dostępne w ramach licencji GNU LGPL, zaczerpnięte z projektu rozwijanego przez KDE.

Pozostałe elementy silnika są dostępne na licencji BSD.

WebCore jest aplikacją szkieletową, którą stanowią biblioteki renderowania, DOM

(Document Object Model) i struktury HTML oraz SVG rozwijane w ramach otwartego

projektu WebKit.

JavaScriptCore jest aplikacją szkieletową dostarczającą silnik JavaScript, umożliwiając

obsługę tego języka w aplikacjach wykorzystujących silnik WebKit.

Framework WebKit zawiera WebCore i JavaScriptCore zapewniając Objective-C

interfejs programowania aplikacji (API) do silnika renderującego WebCore oraz silnika

skryptów JavaScriptCore stworzonych w języku C++, umożliwiając łatwe tworzenie aplikacji

opartych na Cocoa API [31].

9.7. SAFARI

Safari [32] to przeglądarka internetowa stworzona przez firmę Apple. Jest domyślną

przeglądarką stron WWW systemu operacyjnego Mac OS X (Rysunek 33) oraz iOS

(Rysunek 34). Od 2007 roku dostępna również na systemach Windows XP, Windows Vista

oraz Windows 7. Safari jest stworzona w oparciu o silnik wyświetlania stron WebKit. Zgodnie

z danymi pochodzącymi ze strony Wikipedia.org, 15,87% odwiedzających stronę

Wikipedia.org w sierpniu 2012 roku, korzystało z przeglądarki Safari.

Safari w pełni obsługuję najnowsze standardy internetowe, m. in. XHTML, HTML 4,

DOM, XML oraz posiada zaawansowaną obsługę CSS 1 i 2. Dodatkowo posiada wsparcie dla

dużej części specyfikacji HTML 5 [32].

54

Rysunek 33. Safari na Mac OS X (zrzut ekranu).

Rysunek 34. Safari na iOS/iOS Simulator (zrzut ekranu).

55

9.8. PROJEKTOWANIE WITRYN INTERNETOWYCH DLA URZĄDZEŃ MOBILNYCH

Projektowanie stron internetowych dla urządzeń mobilnych jakim jest iPhone, znacząco

różni się od standardowego projektowania witryn. Wynika to przede wszystkim z

nietypowego charakteru urządzenia, jego parametrów fizycznych oraz z okoliczności w jakich

korzystamy z Internetu. W Polsce większość internautów to użytkownicy Internetu

stacjonarnego, korzystający z niego ponad dwie godziny dziennie w domu, pracy lub szkole,

uczelni. Z Internetu mobilnego korzystają głównie ludzie młodzi, studenci w celu zdobycia

konkretnych informacji lub do kontaktowania się ze znajomymi [33,34].

Większość stron internetowych nie jest przystosowana do wyświetlania na urządzeniach

mobilnych. Powoduje to kłopoty podczas odwiedzania takich stron. Większość z nich nie

mieści się na ekranie urządzenia lub jest prezentowana w pomniejszonej formie, co sprawia

że korzystanie ze strony jest niemożliwe lub bardzo niewygodne. Ilość prezentowanego,

przesyłanego materiału powoduje, że wzrasta transfer danych co pociąga za sobą zwiększenie

kosztu połączenia. Takie strony zniechęcają potencjalnych użytkowników do ponownego

odwiedzania.

Wraz ze wzrostem popularności Internetu mobilnego projektanci stron internetowych

zaczynają stosować praktyki tworzenia stron użytecznych na urządzeniach mobilnych. Do

takich praktyk można zaliczyć m. in. [33]:

• uproszczony styl strony,

• brak zbędnych grafik,

• optymalizacja pod względem przepustowości,

• stosowanie większej, czytelnej czcionki,

• elementy nawigacyjne powinny być dostosowywane do rozmiarów urządzania,

odpowiednio duże przyciski, pola typu input i inne elementy formularzy,

• tylko niezbędna funkcjonalność,

• liniowy układ strony (Rysunek 35) [35].

56

Rysunek 35. Zalecana struktura strony mobilnej [33].

Elementy struktury strony powinny mieć stałą wielkość lub ich wymiary powinny

zmieniać się w wyniku odpowiedzi na zdarzenia wygenerowane przez użytkownika. Jedną ze

złych praktyk jest stosowanie dynamicznych elementów o różnych rozmiarach. W efekcie

strona zaczyna skakać w odpowiedzi na cykliczne zwiększanie i zmniejszanie się wielkości

jednego z jej elementów (Rysunek 36).

Rysunek 36. Strona wp.pl z elementem dynamicznie zmieniającym rozmiar.

57

10.CEL PRACY

Celem niniejszej pracy jest zapoznanie z systemem iOS, zintegrowanym środowiskiem

programistycznym Xcode oraz językiem programowania Objective-C, następnie w oparciu o

już posiadaną wiedzę napisanie aplikacji na iPhone, tj. przeglądarki internetowej z

wykorzystaniem dostępnych w Xcode frameworków.

Przeglądarka powinna spełniać podstawowe zadanie, jakim jest wyświetlanie treści

stron internetowych. Dodatkowo, zgodnie z aktualnymi standardami, przeglądarka powinna

pozwalać na zapisywanie adresów ulubionych stron, oraz stron ostatnio odwiedzanych.

Dalsza część pracy obejmuje utworzenie strony internetowej dla iPhone, w oparciu o

technologie przedstawione w części teoretycznej. Głównymi celami stawianym przed stroną

WWW, to jej mobilność oraz wygodny interfejs. Przedstawiona witryna internetowa będzie

formą prezentacji, jak może wyglądać mobilna wersja strony WWW, która już istniejącej, ale

nie jest przystosowana do działania na urządzeniach mobilnych.

58

Część II

11.PROJEKT APLIKACJI

W ramach pracy dyplomowej, na podstawie stanu wiedzy przedstawionego w części

teoretycznej, powstała aplikacja na iPhone: przeglądarka internetowa (Rysunek 37).

Rysunek 37. Zrzut ekranu prezentujący kilka widoków napisanej aplikacji: a) opcje aplikacji Ustawienia związane z przeglądarką; b) ostrzeżenie przed wykonaniem czynności usuwania; c) widok ustawień; d) widok główny aplikacji; e) zakładka ulubione; f) zakładka historia; g) wyszukiwanie.

59

11.1. OPIS OGÓLNY

Powstała aplikacja, jest prostą wersją przeglądarki internetowej. Zawiera okno główne

(Rysunek 38), w którym wyświetlana jest strona WWW, paski narzędzi oraz kilka widoków

pomocniczych (Rysunek 37).

Rysunek 38. Widok główny.

Przeglądarka zawiera takie elementy jak:

• pasek adresu, który pozwala również na wyszukiwanie w przeglądarce Google,

• przyciski:

o wstecz,

o dalej,

o odśwież stronę,

o wyszukiwanie/pasek adresu,

o strona domowa (drugi pasek narzędzi),

o ustawienia/opcje (drugi pasek narzędzi),

o zapisz w ulubionych (drugi pasek narzędzi),

o pokaż w Safari (drugi pasek narzędzi),

60

o pokaż inny pasek narzędzia,

• widoki:

o główny,

o wyszukiwania,

o zakładek,

o ustawień.

Aplikacja składa się z sześciu klas (Rysunek 39):

• WebAppDelegate,

• WebViewController,

• BookmarksRootViewController,

• FavoritesTabViewController,

• HistoryTabViewController,

• PreferencesModalViewController.

Pliki pomocnicze (Rysunek 39):

• ModalViewDelegate.h - protokół,

• Utilities.h – stałe, deklaracja metoda położenia pliku,

• Utilities.m – definicja metody.

Pliki nib Interface Builder (Rysunek 39):

• MainWindow.xib

• WebViewController.xib

• HistoryTabViewController.xib

• FavoritesTabViewController.xib

• PreferencesModalViewController.xib

Przeglądarka pozwala na wyświetlanie stron internetowych, których dokładny adres

URL został wpisany w pasku adresu. Jeśli użytkownik nie poda adresu strony, tylko wpisze

inny wyraz w pasku adresu, to zostanie poinformowany o możliwości wyszukania słowa w

wyszukiwarce google.pl. Aplikacja pozwala na dodawanie ulubionych stron do listy zakładek,

oraz na zapisywanie historii odwiedzanych stron. Dodatkowo istnieje możliwość ustawienia

strony domowej, sprawdzenia stanu ustawień domyślnych używanej aplikacji oraz

przełączenia aktualnie wyświetlanej strony do przeglądarki Safari.

61

Rysunek 39. Lista elementów aplikacji.

11.2. WIDOK

Element aplikacji utworzony w większości za pomocą programu Interface Builder

(7.2.2). Część widoku aplikacji związanej z wyświetleniem zakładek, ze względu na duży

stopień skomplikowania został utworzony programowo.

62

11.2.1. Opis elementów widoku głównego

Widok główny (Rysunek 40) zawiera najwięcej elementów typu przyciski, paski

narzędzi (Rysunek 45). Pierwszy pasek narzędzi, zawiera przyciski odpowiedzialne za

podstawową nawigację podczas przeglądania Internetu tj. wstecz, dalej, odśwież

(Rysunek 41). Dodatkowo zawiera przycisk pokazujący drugi pasek narzędzi oraz przycisk

pokazujący podwidok (Rysunek 42) z paskiem adresu, wirtualną klawiaturę oraz przycisk

pokazywania widoku zakładek (Rysunek 44).

Rysunek 40. Okno programu Interface Builder z widocznymi elementami widoku głównego.

Rysunek 41. Pierwszy pasek narzędzi/nawigacji.

Widok główny posiada drugi pasek narzędzi utworzony w celu zwiększenie funkcjonalności

przeglądarki, nie zwiększając przestrzeni potrzebnej do umieszczenia przycisków na ekranie

(Rysunek 43). Drugi pasek narzędzi w widoku głównym zawiera przyciski: strona domowa,

przycisk ustawienia/opcje, zapisz w ulubionych, przycisk powrotu do paska pierwszego oraz

przycisk przekierowujący aktualnie wyświetlaną stronę do przeglądarki Safari.

63

Rysunek 42. Podwidok widoku głównego.

Rysunek 43. Drugi pasek narzędzi.

Rysunek 44. Pasek adresu z widocznymi: nagłówkiem wyświetljącym tytuł aktualnie przeglądanej strony, przyciskiem zakładek, paskiem adresu wraz z przyciskiem czyszczącym jego zawartość, przyciskiem chowającym widok – Zamknij.

64

Rysunek 45. Lista elementów widoku głównego.

Widoki modalne

Oprócz widoku głównego i podwidoku wyszukiwania, w aplikacji są jeszcze dwa

widoki określane jako modalne. Widoki takie charakteryzują się tym, że podczas ich

wyświetlania musi zostać podjęta pewna decyzja, efektem której jest schowanie widoku

modalnego.

11.2.2. Widok ustawień

Pierwszy widok modalny został zastosowany do wyświetlania informacji

o ustawieniach oraz przyciski czyszczenia historii przeglądanych stron i ulubione

(Rysunek 46).

Widok ten wyświetla informacje ustawione w preferencjach aplikacji, dostępne poprzez

aplikacje systemu iOS o nazwie Ustawienia (ang. Settings). Dodatkowo pozwala na

wyczyszczenie danych zawartych w plikach modelu danych, będące treścią drugiego widoku

65

modalnego związanego z wyświetlaniem informacji o historii przeglądanych stron oraz

zapisanych zakładkach ulubionych.

Rysunek 46. Widok modany prezentujący ustawienia oraz możliwość usuwania zapisanych stron.

Rysunek 47. Aplikacja Ustawienia.

66

Ustawienia

Aplikacja Ustawienia (Rysunek 47) pozwala na wprowadzanie i zmianę preferencji

każdej aplikacji, która posiada element Settings Bundle. Element ten to grupa wbudowanych

plików w aplikacji, która informuje aplikację Ustawienia, które preferencje powinny zostać

ustawione/wprowadzone przez użytkownika. Aplikacja Ustawiania działa jako graficzny

interfejs użytkownika dla mechanizmu domyślnych ustawień użytkownika w iOS (ang. iOS

User Defaults).

11.2.3. Widok zakładek

Drugi widok modalny związany z wyświetlaniem zapisanych stron jest bardziej złożony

i w dużej części został utworzony programowo (Rysunek 48).

Rysunek 48. Diagram widoku zakładek.

Widok ten prezentuje zapisane odwołania do stron ulubionych oraz historię

przeglądanych stron w postaci widoku tabeli (UITableView). Przełączanie pomiędzy

widokiem stron ulubionych a historią odbywa się dzięki zakładkom elementu Tab Bar

Controller (UITabBarController).

67

Rysunek 49. Widok zakładek.

Zakładka Ulubione (Rysunek 49) może być edytowana, w tym celu należy kliknąć

przycisk Edytuj. Tryb edycji pozwala na usuwanie elementów tablicy (znak zakazu) lub ich

przenoszenie (znak trzech kresek) (Rysunek 50) (Rysunek 52). Usuwać wpisy można również

bez wchodzenia w tryb edycji, poprzez gest szybkiego przesunięcia palcem w bok na

wybranym wpisie (Rysunek 51). Dodatkowo można usunąć cała zawartość zakładki Ulubione

poprzez widok ustawień (Rysunek 46).

Rysunek 50. Usuwanie wpisu.

Rysunek 51. Usuwanie wpisu bez wchodzenia w tryb edycji.

68

Rysunek 52. Przenoszenie wpisu.

Zakładka Historią (Rysunek 49) nie pozwala na edycję, istnieje tylko możliwość

usunięcia wszystkich danych i określenie ilości wpisów, odbywa się to poprzez odpowiedni

widok ustawień (Rysunek 46) oraz poprzez Ustawienia (Rysunek 47).

11.2.4. Diagram widoku

Diagram widoku (Rysunek 53), prezentuje zależności pomiędzy widokami stworzonej

aplikacji. Pozwala także prześledzić jakie kontrolery są odpowiedzialne za prawidłowe

działanie widoków.

Rysunek 53. Diagram elementów struktury widoku.

69

11.3. MODEL I KONTROLER

Model i kontroler są to elementy architektury aplikacji, które przeplatają się w niemal

wszystkich stworzonych klasach.

W napisanej aplikacji elementy modelu i kontrolera można podzielić na trzy instancje:

• settings bundle,

• zakładki,

• cykl życia aplikacji.

Settings Bundle

Ustawienia preferencji aplikacji określane są w aplikacji iOS - Ustawienia

(Rysunek 47). Użytkownik ustawia/wprowadza odpowiednie dane w aplikacji Ustawienia,

które później są pobierane do aplikacji właściwej. Na podstawie tych danych kontroler

aktualizuję odpowiednie elementy widoku.

Zakładki

Informacje wyświetlane w tabelach zakładek są zapisywanie w plikach .plist czyli

plikach typu property list (Rysunek 54). Pliki te mogą być używane do przechowywania kilku

typów obiektów:

• NSArray,

• MSMutableArray,

• NSDictionary,

• NSMutableDictionary,

• NSData,

• NSMutableData,

• NSString,

• NSMutableString,

• NSNumber,

• NSDate.

70

Rysunek 54. Plik history.plist otwarty w programie Property List Editor.

Kontroler odbiera od widoku informacje o modyfikacji danych – usuwaniu,

przenoszeniu lub dodawaniu i przesyła je do elementów modelu. Obiekty modelu dokonują

odpowiednich zmian, efektem których jest modyfikacja property list oraz informacja zwrotna

wychwytywana przez kontroler, skierowana do widoku o konieczności zaktualizowania

odpowiednich elementów widoku.

Cała operacja jest o tyle skomplikowana, że odbywa się to z wykorzystaniem operacji

delegacji wykonania zadania. Powyższa metoda usuwa z lokalnej zmiennej self.dataList

zaznaczoną wartość (rekord) i przekazuję informacje, który wiersz powinien zostać usunięty z

property list do widoku głównego, który jest delegatem dla tej metody. Wykonanie

faktycznego usuwania jest oddelegowane do innego kontrolera. Przekazywanie delegacji

odbywa się poprzez wszystkie kontrolery pośrednie, aż do samej góry (Rysunek 55).

71

Rysunek 55. Diagram z zaznaczonymi na czerwono liniami przekazywania delegacji wykonania metody.

Cykl życia aplikacji

Podczas pracy aplikacji kontroler steruje przepływem danych pomiędzy elementami

modelu i widoku, aby wiedział jakie elementy są ze sobą połączone w Cocoa Touch, w tym

celu dostępne są odpowiednie słowa kluczowe:

a) IBOutlet – jest to słowo kluczowe nie mające dla kompilatora żadnego znaczenia, jest

za to informacją dla Interface Buildera (IB), że dany element instancji jest połączony z

obiektem znajdującym się w pliku nib.

@property (nonatomic, retain) IBOutlet UIButton *OKButton;

b) IBAction – słowo kluczowe oznaczające, że dana metoda jest akcją i może być

wywoływana przez kontrolkę. Akcje to metody będące elementami kontrolera.

- (IBAction)deleteHistory:(id)sender;

72

11.4. TEST

Stworzona przeglądarka została porównana z domyślną przeglądarką na iOS - Safari.

Test polegał na sprawdzeniu wyniku kilku testów online, dostępnych w Internecie. Wyniki

zostały zestawione w postaci tabelki (Tabela 4) ze zrzutami ekranu prezentującymi rezultat.

Opis testów

Acid3

Test Acid3 [36] sprawdza zgodność przeglądarki z webowymi standardami

wyznaczanymi przez organizację W3C. Składa się on z wielu mniejszych podtestów, które są

uruchamiane zaraz po wejściu na stronę, wyniki podawane są na bieżąco. Aby przeglądarka

przeszła test w całości, nie wystarczy tylko osiągnąć wynik 100/100, także animacja musi

przebiegać płynnie, a po zakończeniu całości testu strona powinna wyglądać identycznie jak

strona wzorcowa (Rysunek 56).

Acid3 jest podzielony na 100 podtestów połączonych w 6 grup, zwanych wiadrami

(ang. Bucket):

• 1: DOM Traversal, DOM Range, HTTP

• 2: DOM2 Core, DOM2 Events

• 3: DOM2 Views, DOM2 Style, selektory i Media Queries

• 4: Zachowanie się formularzy i tabel HTML, podczas przetwarzania przez

skrypty oraz DOM2 HTML

• 5: Testy pochodzące z zawodów Acid3 Competition (SVG, HTML, SMIL,

Unicode, ...)

• 6: ECMAScript

Rysunek 56. Wzorcowy obraz testu Acid3 [37].

73

HTML 5 test

Test HTML 5 [38] sprawdza jak testowana przeglądarka wspiera nadchodzący standard

HTML 5. Specyfikacja HTML 5 nie jest jeszcze skończona, ale większość twórców

przeglądarek dokłada wszelkich starań, aby ich produkt był jak najbardziej zgodny z

dotychczas udostępnioną specyfikacją. Wynik testu jest określany na podstawie ilości nowych

funkcji HTML 5 już udostępnionych, które przeglądarka jest wstanie obsłużyć.

SunSpider

SunSpider JavaScript Benchmark [39] jest rodzajem testu sprawności, służący do

pomiaru wydajności JavaScript w ramach aktualnie stosowanych rozwiązań oraz przyszłe

wykorzystanie JavaScript, w takich zastosowaniach jak szyfrowanie oraz manipulacja

tekstem. Test sprawdza rdzeń języka JavaScripts, nie sprawdza DOM oraz innych

stosowanych technologii. Zaprojektowany w celu porównywania różnych wersji tej samej

przeglądarki oraz porównywania osiągów różnych przeglądarek względem siebie. Test jest

wykonywany w pętli pięciokrotnie, a całość trwa 5 minut.

Tabela 4. Zestawienie wyników testów.

Stworzona aplikacja SafariTest Acid3

74

Stworzona aplikacja SafariTest HTML 5

Test SunSpider 0.9.1

Wyniki testów dla obu aplikacji są bardzo podobne. Nie powinno to jednak dziwić,

ponieważ obie przeglądarki korzystają z tego samego silnika WebKit, który jest najbardziej

odpowiedzialny za sposób prezentacji treści i same możliwości wyświetlania stron WWW

przez przeglądarki. Największą różnice da się zauważyć w wyniku testu Acid3, gdzie widać

kilka elementów, świadczących o tym, że nie wszystkie testy udało się przejść poprawnie.

Stworzona aplikacja nie przeszła trzech testów, Safari dwóch, przy czym są to te same testy,

które nieudały się w przeglądarce stworzonej w ramach pracy.

75

Podobieństwa i różnice

Obie przeglądarki oprócz podstawowej funkcjonalności, jaką jest wyświetlanie stron,

pozwalają na:

• zapisywanie adresów stron ulubionych

• zapisywanie historii stron ostatnio odwiedzanych

• wyszukiwanie w Google za pomocą paska adresu

• podstawową nawigację (wstecz, dalej, odśwież)

• działanie w trybie landscape

Do najważniejszych różnic po stronie Safari należą:

• możliwość przeglądanie stron na kilku kartach

• tworzenie skrótów stron na pulpicie telefonu

• możliwość tworzenia katalogów zakładek

Do najważniejszych różnic po strona napisanej aplikacji należą:

• możliwość przeglądania ustawień domyślnych przeglądarki z poziomu aplikacji

• przeglądanie stron tylko na jednej karcie

• możliwość ustawienia strony domowej/startowej

• możliwość zmiany położenia zakładek ulubionych

76

12.PROJEKT STRONY WWW

12.1. OPIS OGÓLNY

W ramach drugiej części pracy powstała strona internetowa przeznaczona dla

urządzenia iPhone (Rysunek 57). Strona jest mobilnym odpowiednikiem wyszukiwarki

pracowników.

W zamyśle strona powstała w celu zaprezentowanie przykładowej, mobilnej wersji

strony SKOS (http://regent2.uci.agh.edu.pl/skos/) - składu osobowego AGH, dla

pracowników wydziału inżynierii metali i informatyki przemysłowej.

Strona poza wygodniejszym interfejsem została zaprojektowana w celu możliwości

modyfikacji własnych danych osobowych.

Rysunek 57. Strona główna.

12.2. ZASTOSOWANE TECHNOLOGIE

Projekt został stworzony w oparciu o:

• HTML 5

• CSS 3

• PHP 5

• MySQL 5

• JavaScript

77

12.3. FUNKCJONALNOŚĆ

Strony mobilne charakteryzują się tym, że musza prezentować w prosty sposób

najbardziej poszukiwane wiadomości. Źle zaprojektowana strona lub strona nie

przystosowana do wyświetlania na małych ekranach telefonów, utrudnia lub wręcz

uniemożliwia korzystanie ze strony. Dobrym przykładem może być aktualna strona SKOS

(Rysunek 58).

Rysunek 58. Strona składu osobowego AGH wyświetlona na iPhone [40].

Stworzona strona mobilna jest uproszczoną wersją, przystosowaną do działania pod

iPhone. Strona została napisana w oparciu o silnik WebKit co oznacza, że powinna zostać

poprawnie wyświetlona na wszystkich przeglądarkach internetowych korzystających z tego

silnika.

Podstawowe i główne zadanie strony polega na dostarczaniu informacji o wybranym

pracowniku. Wyszukiwanie pracownika odbywa się na dwa sposoby: poprzez użycie

wyszukiwarki lub poprzez przeglądnięcie całej listy pracowników. Wyszukiwarka nie

wymaga żadnych danych (Rysunek 59), w takim przypadku zaprezentuje cała listę, wpisanie

nazwisk lub imienia lub tylko fragmentu, spowoduje doprecyzowanie wyników

wyszukiwania. Oprócz wyszukiwania pracowników, strona pozwala na modyfikacje własnych

danych. W celu dodania swojej osoby do listy pracowników, należy się na stronie

zarejestrować. Podanie imienia i nazwiska na stronie profilu spowoduje, że pracownik będzie

widoczny w wynikach wyszukiwania. Dane profilu są wyświetlane po kliknięciu na zieloną

kropkę, widoczną po zalogowaniu (Rysunek 61).

78

Rysunek 59. Wyszukiwarka oraz wynik wyszukiwania.

Rysunek 60. Dane osobowe poszukiwanej osoby.

Dane osobowe (Rysunek 60) zawierają takie informacje jak prefiks np. tytuł, imię,

nazwisko, miejsce pracy (budynek, pokój, katedra), nr tel., adres email oraz adres strony

www, informacje o godzinach konsultacji oraz ostatnie pole – informacje ogólne.

79

Rysunek 61. Widok profilu oraz jego edycja.

Pasek Strona główna jest odnośnikiem do strony głównej, a zielona kropka do widoku

profilu. Dodatkowo na samym dole widoczny jest pasek z trzema odnośnikami prowadzącymi

do strony AGH, Wydziału Inżynierii Metali i Informatyki Przemysłowej oraz do strony składu

osobowego AGH.

12.4. PODSUMOWANIE

Strona została opracowana w oparciu o już istniejącą witrynę internetową, która nie jest

dostosowana do poprawnego działania na urządzeniach mobilnych. Mobilna wersją jest

bardziej czytelna oraz dużo łatwiejsza w nawigacji, ze względu na większe elementy

nawigujące oraz dzięki zastosowaniu widoku tabeli znanej z aplikacji tworzonych dla iPhone.

Strona jest prosta w użyciu, nie zawiera zbędnych grafik, dzięki czemu użytkownik może

szybko uzyskać poszukiwane informacje.

80

13.WNIOSKI I PODSUMOWANIE

Stworzona w ramach pracy dyplomowej przeglądarka internetowa pozwala na wygodne

przeglądanie stron internetowych, oraz korzystanie z funkcji zakładek. Największe zalety

stworzonej aplikacji zostały dostrzeżone podczas tworzenia drugiej części pracy tj. strony

internetowej na urządzenia mobilne. Przeglądarka okazała się bardzo przydatnym narzędziem

do sprawdzania poprawności prezentacji strony m. in. dzięki możliwości zapisywania stron do

zakładek ulubionych oraz dzięki stałemu rozmiarowi okna głównego, wyświetlającego

zawartość strony WWW. Safari dysponuję widokiem okna głównego, w którym pasek adresu

może wypełnić przestrzeń okna jeżeli treść strony nie zajmuje całej powierzchni ekranu, co

nie zawsze jest pożądane. Zakładki pozwalały na szybkie przełączanie pomiędzy różnymi

wersjami projektowanej strony. Dodatkowa funkcja pozwalająca przełączyć wyświetlaną

stronę do Safari, umożliwiała w szybki sposób sprawdzenie poprawności działania witryny na

dwóch aplikacjach.

Mobilna witryna internetowa powstała w ramach drugiej części pracy dyplomowej,

przedstawia jak można przerobić istniejącą stronę WWW lub zaprojektować nową, tak aby

potencjalni użytkownicy bez problemów mogli korzystać z dawnych funkcjonalności w nowy

sposób, na nowych urządzeniach.

Tworzenie aplikacji oraz witryn przeznaczonych na urządzenia mobilne, wymaga od

projektantów świadomości nowych możliwości, ale również nowych ograniczeń. Znajomość

przedstawionych w pracy narzędzi oraz technologii umożliwia tworzenie rozwiązań jakich

jeszcze kilka lat temu, przed erą smartfonów nie dało się uzyskać. Rynek urządzeń mobilnych

jest jednym z najszybciej rozwijających się. Duża część społeczeństwa dopiero niedawno

oswoiła się z możliwością załatwiania swoich spraw przez Internet w domu, a część tych

rozwiązań już jest przenoszona na urządzenia mobilne. Rozrywka, sprawy bankowe,

inwestycje giełdowe, zarządzanie finansami, te wszystkie czynności za niedługi czas będzie

można wykonać przez telefon, smartfon, pad siedząc w pociągu.

81

14.DODATEK A

Słownik kilku pojęć występujących w pracy, opracowany na podstawie haseł z

Wikipedia.org [41].

DTrace - czyli Dynamic Tracing Framework, to narzędzie służące do monitorowania i

diagnozowania działania aplikacji oraz system operacyjnego, stworzone przez firmę Sun

Microsystems dla system operacyjnego Solaris. Został przeportowany na kilka innych

systemów m. in. FreeBSD, NetBSD.

EDGE - technologia używana w sieciach GSM do przesyłania danych, będąca

rozszerzeniem technologii GPRS. Pozwala na przesyłanie danych z przepływnością do 236.8

kbit/s.

FreeBSD - to system z rodziny Unix. Stworzony przez Computer Systems Research

Group (CSRG) na Uniwersytecie Kalifornijskim w Berkeley. Ze względu na wydajność

i niezawodność często stosowany jakoś serwer lub zapora sieciowa. Dostępny na zasadach

licencji BSD.

HSDPA - technologia używana w sieciach komórkowych, umożliwia przesyłanie

danych z sieci do odbiorcy z przepływnością do 21,6 Mbit/s.

HSUPA - technologia używana w sieciach komórkowych, umożliwia przesyłanie

danych od użytkownika do sieci z przepływnością do 5,76 Mbit/s.

OpenSolaris - otwarty (open source) system operacyjny firmy Sun Microsystems

oparty na komercyjnym systemie Solaris.

Simula - język programowania opracowany w 1967 roku. Jest uznawany za pierwszy

język obiektowy i stał się podstawą do projektowania nowych języków m. in. C++.

UMTS - następca technologii GSM, standard telefonii komórkowej trzeciej generacji.

Dzięki zaimplementowaniu technologii HSDPA oraz HSUPA pozwala na transfer danych z

przepływnością 21,6 Mbit/s podczas pobierania danych oraz 5,76 Mbit/s podczas wysyłania

danych.

82

W3C - czyli World Wide Web Consortium, to organizacja, która zajmuję się

ustanawianiem standardów tworzenia oraz przesyłu stron WWW. Zrzesza ponad 400

organizacji, firm, uczelni oraz agencji rządowych z całego świata.

83

15.SPIS TABEL, ILUSTRACJI, BIBLIOGRAFIA

Spis tabelTabela 1. Porównanie parametrów różnych wersji iPhone [4]......................................................................... 6

Tabela 2. Przykładowy kod strony w HTML 4 oraz sposób prezentacji w przeglądarce Safari [24]. ...........50

Tabela 3. Ta sama struktura strony w HTML 5 oraz sposób prezentacji w przeglądarce Safari [24]. ...........50

Tabela 4. Zestawienie wyników testów.......................................................................................................... 74

Spis ilustracjiRysunek 1. Zdjęcie telefonu z podanymi wymiarami [7].................................................................................7

Rysunek 2. Fragment hierarchii dziedziczenia z korzeniem na dole

(fragment zrzutu ekranu programu Interface Builder)................................................................. 8

Rysunek 3. Ogólny zarys architektury [9]...................................................................................................... 12

Rysunek 4. Warstwy architektury iOS [9]...................................................................................................... 13

Rysunek 5. Root class – NSObject [10]......................................................................................................... 18

Rysunek 6. NSObject oraz obiekty z niej dziedziczące połączone w grupy [11]. .........................................18

Rysunek 7. NSObject i klasy dziedziczące – UIKit [12]................................................................................21

Rysunek 8. Linia czasu (na podstawie [14])...................................................................................................23

Rysunek 9. Objective-C to język C z dodatkowymi elementami (na podstawie [14])...................................25

Rysunek 10. Schemat fragmentu pamięci.......................................................................................................32

Rysunek 11. Schemat fragmentu pamięci z zajętą przestrzenią..................................................................... 33

Rysunek 12. Schemat fragmentu pamięci tuż po zwolnieniu przestrzeni...................................................... 33

Rysunek 13. Schemat fragmentu pamięci po zwolnieniu i wyczyszczeniu....................................................33

Rysunek 14. Schemat fragmentu pamięci z obiektem lucky.......................................................................... 34

Rysunek 15. Schemat fragmentu pamięci z przetrzymywanym obszarem.....................................................34

Rysunek 16. Komputery firmy Apple: MacBook Pro oraz iMac [6]..............................................................36

Rysunek 17. Zrzut ekraniu z fragmentem strony internetowej iOS Dev Center [18].....................................37

Rysunek 18. Okno programu Xcode 3 (zrzut ekranu).................................................................................... 38

Rysunek 19. Okna programu Interface Builder (zrzut ekranu z widocznymi oknami: biblioteka, widok,

właściwości oraz okno główne pliku „HelloWorldViewConroller.xib”) [2]..............................39

Rysunek 20. Okno programu iOS Simulator (zrzut ekranu)...........................................................................40

Rysunek 21. Widok części dostępnych instrumentów (zrzut ekranu)............................................................ 41

Rysunek 22. Widok programu Instruments podczas śledzenia/nagrywania działania aplikacji Web

(zrzut ekranu)............................................................................................................................. 43

Rysunek 23. Widok drzewa śledzonych obiektów w programie Instruments (zrzut ekranu).........................43

Rysunek 24. Przyciski Record (nagrywanie) oraz Target (cel) programu Instruments

(fragment zrzutu ekranu)............................................................................................................ 44

Rysunek 25. Widoczny wyciek pamięci (fragment zrzutu ekranu)................................................................ 44

Rysunek 26. Instruments z zaznaczonym fragmentem kotu, gdzie powstał problem (zrzut ekranu).............44

84

Rysunek 27. Fragment kodu z zaznaczonymi zmiennymi odpowiedzialnymi za wyciek pamięci

(zrzut ekranu)............................................................................................................................. 45

Rysunek 28. Schemat modelu MVC wersja dla Cocoa [22].......................................................................... 46

Rysunek 29. Model warstwowy wzorca MVC w iOS [22]............................................................................ 47

Rysunek 30. Widok struktury podzielonej na sekcje z nagłówkami.............................................................. 51

Rysunek 31. Widok strony HTML bez wykorzystania CSS...........................................................................52

Rysunek 32. Okno główne aplikacji phpMyAdmin....................................................................................... 53

Rysunek 33. Safari na Mac OS X (zrzut ekranu)............................................................................................55

Rysunek 34. Safari na iOS/iOS Simulator (zrzut ekranu).............................................................................. 55

Rysunek 35. Zalecana struktura strony mobilnej [33].................................................................................... 57

Rysunek 36. Strona wp.pl z elementem dynamicznie zmieniającym rozmiar................................................57

Rysunek 37. Zrzut ekranu prezentujący kilka widoków napisanej aplikacji: a) opcje aplikacji Ustawienia

związane z przeglądarką; b) ostrzeżenie przed wykonaniem czynności usuwania;

c) widok ustawień; d) widok główny aplikacji; e) zakładka ulubione; f) zakładka historia;

g) wyszukiwanie.........................................................................................................................59

Rysunek 38. Widok główny............................................................................................................................ 60

Rysunek 39. Lista elementów aplikacji.......................................................................................................... 62

Rysunek 40. Okno programu Interface Builder z widocznymi elementami widoku głównego.....................63

Rysunek 41. Pierwszy pasek narzędzi/nawigacji............................................................................................63

Rysunek 42. Podwidok widoku głównego..................................................................................................... 64

Rysunek 43. Drugi pasek narzędzi..................................................................................................................64

Rysunek 44. Pasek adresu z widocznymi: nagłówkiem wyświetljącym tytuł aktualnie przeglądanej

strony, przyciskiem zakładek, paskiem adresu wraz z przyciskiem czyszczącym jego

zawartość, przyciskiem chowającym widok – Zamknij.............................................................64

Rysunek 45. Lista elementów widoku głównego........................................................................................... 65

Rysunek 46. Widok modany prezentujący ustawienia oraz możliwość usuwania zapisanych stron.............66

Rysunek 47. Aplikacja Ustawienia................................................................................................................. 66

Rysunek 48. Diagram widoku zakładek......................................................................................................... 67

Rysunek 49. Widok zakładek..........................................................................................................................68

Rysunek 50. Usuwanie wpisu.........................................................................................................................68

Rysunek 51. Usuwanie wpisu bez wchodzenia w tryb edycji........................................................................ 68

Rysunek 52. Przenoszenie wpisu....................................................................................................................69

Rysunek 53. Diagram elementów struktury widoku.......................................................................................69

Rysunek 54. Plik history.plist otwarty w programie Property List Editor...................................................... 71

Rysunek 55. Diagram z zaznaczonymi na czerwono liniami przekazywania delegacji wykonania metody. 72

Rysunek 56. Wzorcowy obraz testu Acid3 [37]............................................................................................. 73

Rysunek 57. Strona główna............................................................................................................................ 77

Rysunek 58. Strona składu osobowego AGH wyświetlona na iPhone [40]................................................... 78

Rysunek 59. Wyszukiwarka oraz wynik wyszukiwania................................................................................. 79

Rysunek 60. Dane osobowe poszukiwanej osoby...........................................................................................79

Rysunek 61. Widok profilu oraz jego edycja..................................................................................................80

85

Bibliografia[1] iPhone - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/IPhone

[2] Techotopia - iPhone iOS 4 Development Essentials. [Dostęp 1 września 2012].

http://www.techotopia.com/index.php/IPhone_iOS_4_Development_Essentials

[3] Frederick G., Lal R., Beginning Smartphone Web Development: Building JavaScript,

CSS, HTML and Ajax-based Applications for iPhone, Android, Palm Pre, BlackBerry,

Windows Mobile and Nokia S60. Apress, 2010.

[4] iPhone - en.wikipedia.org. [Dostęp 1 września 2012].

http://en.wikipedia.org/wiki/IPhone

[5] Mark D., Nutting J., LaMarche J., Beginning iPhone 4 Development: Exploring the

iOS SDK. Apress, 2011.

[6] Apple.com. [Dostęp 1 września 2012]. http://www.apple.com/pl/mac/

[7] iPhone. [Dostęp 1 września 2012]. http://support.apple.com/kb/HT3939?

viewlocale=pl_PL

[8] iOS - pl.wikipedia.org. [Dostęp 1 września 2012]. http://pl.wikipedia.org/wiki/IOS

[9] iOS Technology Overview - The iOS Architecture. [Dostęp 1 września 2012].

http://developer.apple.com/library/ios/#documentation/Miscellaneous/Conceptual/iPho

neOSTechOverview/IPhoneOSOverview/IPhoneOSOverview.html#//apple_ref/doc/ui

d/TP40007898-CH4-SW1

[10] Cocoa Core Competencies. [Dostęp 1 września 2012].

https://developer.apple.com/library/mac/#documentation/General/Conceptual/DevPedi

a-CocoaCore/RootClass.html#//apple_ref/doc/uid/TP40008195-CH46-SW1

[11] Foundation Framework Reference. [Dostęp 1 września 2012].

http://developer.apple.com/library/ios/#documentation/Cocoa/Reference/Foundation/O

bjC_classic/Intro/IntroFoundation.html#//apple_ref/doc/uid/20000687-25735

[12] UIKit Framework Reference. [Dostęp 1 września 2012].

http://developer.apple.com/library/ios/#documentation/UIKit/Reference/UIKit_Frame

work/Introduction/Introduction.html#//apple_ref/doc/uid/TP40006955-CH1-SW1

[13] Chisnall D., Objective-C Phrasebook (Developer's Library). Addison-Wesley

Professional, 2011.

[14] lynda.com. [Dostęp 1 września 2012]. http://www.lynda.com/iPhone-3-

tutorials/iphone-sdk-essential-training/48369-2.html

[15] GCC - en.wikipedia.org. [Dostęp 1 września 2012].

http://en.wikipedia.org/wiki/GNU_Compiler_Collection

86

[16] Clang - en.wikipedia.org. [Dostęp 1 września 2012].

http://en.wikipedia.org/wiki/Clang

[17] The Objective-C Programming Language. [Dostęp 1 września 2012].

http://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/ObjectiveC

/Introduction/introObjectiveC.html#//apple_ref/doc/uid/TP30001163-CH1-SW2

[18] iOS Dev Center. [Dostęp 1 września 2012].

https://developer.apple.com/devcenter/ios/index.action

[19] Xcode - en.wikipedia.org. [Dostęp 1 września 2012].

http://en.wikipedia.org/wiki/Xcode

[20] Instruments - en.wikipedia.org. [Dostęp 1 września 2012].

http://en.wikipedia.org/wiki/Instruments_(application)

[21] MVC - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/Model-View-Controller

[22] Concepts in Objective-C Programming - Model-View-Controller. [Dostęp 1 września

2012].

https://developer.apple.com/library/ios/#documentation/General/Conceptual/CocoaEnc

yclopedia/Introduction/Introduction.html

[23] HTML - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/HTML

[24] Building Web Pages With HTML 5. [Dostęp 1 września 2012].

http://www.webmonkey.com/2010/02/building_web_pages_with_html_5/

[25] CSS - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/Kaskadowe_arkusze_styl%C3%B3w

[26] PHP - pl.wikipedia.org. [Dostęp 1 września 2012]. http://pl.wikipedia.org/wiki/PHP

[27] JavaScript - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/JavaScript

[28] MySQL - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/Mysql

[29] phpMyadmin - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/PhpMyAdmin

[30] WebKit - pl.wikipedia.org. [Dostęp 1 września 2012].

http://pl.wikipedia.org/wiki/WebKit

[31] WebKit - en.wikipedia.org. [Dostęp 1 września 2012].

http://en.wikipedia.org/wiki/WebKit

87

[32] Safari - en.wikipedia.org. [Dostęp 1 września 2012].

http://en.wikipedia.org/wiki/Safari_(web_browser)

[33] Raport na temat mobilnego Internetu. [Dostęp 1 września 2012].

http://www.clickmaster.pl/raport-nt-mob-int.pdf

[34] Raport o wpływie Internetu mobilnego na życie Polaków. [Dostęp 1 września 2012].

http://kobiety.nazwa.pl/Raport_Mobilnosc2010.pdf

[35] iPhoneIntegration. [Dostęp 1 września 2012].

http://developer.apple.com/library/safari/#samplecode/iPhoneIntegration/Listings/inde

x_html.html

[36] Acid3 - pl.wikipedia.org. [Dostęp 22 września 2012].

http://pl.wikipedia.org/wiki/Acid3

[37] The Acid3 test. [Dostęp 22 września 2012]. http://acid3.acidtests.org/

[38] The HTML5 test. [Dostęp 22 września 2012]. http://html5test.com/

[39] SunSpider JavaScript Benchmark. [Dostęp 22 września 2012].

http://www.webkit.org/perf/sunspider/sunspider.html

[40] Skład osobowy AGH. [Dostęp 22 września 2012]. http://regent2.uci.agh.edu.pl/skos/

[41] Wikipedia - pl.wikipedia.org. [Dostęp 22 września 2012]. http://pl.wikipedia.org/

88