Darmowy fragment publikacji:
Adobe Air i Ajax.
Szybki start
Autor: Larry Ullman
T³umaczenie: Krzysztof Rychlicki-Kicior
ISBN: 978-83-246-2192-7
Tytu³ orygina³u: Adobe AIR (Adobe Integrated
Runtime) with Ajax: Visual QuickPro Guide
Format: 170230, stron: 400
Rozpocznij przygodê ze œrodowiskiem Adobe AIR!
• Jak rozpocz¹æ przygodê ze œrodowiskiem Adobe AIR?
• Jak tworzyæ bezpieczne aplikacje internetowe?
• Jak opublikowaæ nowo stworzon¹ aplikacjê?
Adobe AIR to œrodowisko wykonawcze dostêpne na wielu platformach. Pozwala ono
opracowywaæ nowoczesne i atrakcyjne aplikacje internetowe. Do ich tworzenia mo¿esz
wykorzystaæ takie technologie, jak HTML/AJAX, Adobe Flex lub Adobe Flash. Pomimo
krótkiej obecnoœci na rynku – premiera mia³a miejsce w lutym 2008 roku – œrodowisko
to ju¿ zdoby³o sobie rzeszê fanów. O jego jakoœci œwiadczy tak¿e liczba aplikacji, które
powsta³y w oparciu o Adobe AIR.
Ksi¹¿ka, któr¹ trzymasz w rêku, to œwietny podrêcznik, cierpliwie wprowadzaj¹cy
w tajniki Adobe AIR. Liczne przyk³ady i opisy „krok po kroku” sprawiaj¹, ¿e AIR
b³yskawicznie i bezproblemowo odkrywa swe kolejne tajemnice. Dziêki lekturze
dowiesz siê, jak zainstalowaæ œrodowisko deweloperskie oraz rozpocz¹æ przygodê
z Adobe AIR. W kolejnych rozdzia³ach zaznajomisz siê ze sposobami tworzenia okien,
menu oraz importu i eksportu danych. Ponadto nauczysz siê wykonywaæ operacje na
plikach i katalogach oraz sprawdzisz, jak po³¹czyæ siê z baz¹ danych z poziomu Twojej
aplikacji. „Adobe Air i Ajax. Szybki start” to wyczerpuj¹cy przewodnik, który sprawi, ¿e
zaczniesz swobodnie wykorzystywaæ mo¿liwoœci œrodowiska Adobe AIR.
• Instalacja bibliotek uruchomieniowych oraz œrodowiska deweloperskiego
• Przegl¹d narzêdzi programistycznych dla AIR
• Debugowanie aplikacji
• Tworzenie okien, menu oraz ich obs³uga
• Importowanie oraz eksportowanie danych
• Operacje na plikach i katalogach
• £¹czenie z baz¹ danych oraz przetwarzanie danych w niej zapisanych
• Wykorzystanie operacji sieciowych
• Zapewnienie bezpieczeñstwa aplikacjom korzystaj¹cym z AIR
• Przygotowanie i publikacja aplikacji
SprawdŸ i wykorzystaj mo¿liwoœci Adobe AIR!
Spis treĂci
Rozdziaï 1.
Rozdziaï 2.
Rozdziaï 3.
Rozdziaï 4.
Rozdziaï 5.
9
Wprowadzenie
13
Uruchamianie aplikacji AIR
Instalacja biblioteki uruchomieniowej ................................................................. 14
Instalowanie aplikacji ............................................................................................ 16
Uruchamianie aplikacji AIR.................................................................................. 19
Tworzenie aplikacji
21
Instalacja SDK ....................................................................................................... 22
Aktualizowanie Ăcieĝki w systemie Windows....................................................... 23
Aktualizowanie Ăcieĝki w systemie Mac OS X ..................................................... 25
Tworzenie struktury projektu ............................................................................... 28
Tworzenie pliku HTML ........................................................................................ 30
Tworzenie pliku XML ........................................................................................... 31
Testowanie aplikacji............................................................................................... 35
Tworzenie certyfikatu............................................................................................ 37
Kompilowanie aplikacji ......................................................................................... 39
NarzÚdzia programistyczne dla AIR
41
Aptana Studio ......................................................................................................... 42
Dreamweaver w akcji ............................................................................................ 49
Tworzenie cyfrowych podpisów............................................................................ 52
Podstawowe pojÚcia
57
Podstawy technologii ............................................................................................. 58
JavaScriptowe frameworki..................................................................................... 63
Biblioteki ActionScript .......................................................................................... 66
Obsïuga zdarzeñ..................................................................................................... 68
Obiekt XMLHttpRequest ..................................................................................... 71
Debugowanie
77
Okna dialogowe w jÚzyku JavaScript.................................................................... 78
Wykorzystywanie narzÚdzia Trace ....................................................................... 80
AIR Introspector — introspektor kodu ............................................................... 82
Inne techniki debugowania................................................................................... 84
S
p
i
s
t
r
e
Ă
c
i
5
Tworzenie okien
87
Tworzenie nowego okna........................................................................................ 88
Tworzenie nowego okna natywnego..................................................................... 92
Dostosowywanie okien .......................................................................................... 95
Uzyskiwanie dostÚpu do okna natywnego............................................................ 98
Tworzenie okien peïnoekranowych .................................................................... 102
Obsïuga zdarzeñ okien ........................................................................................ 105
Tworzenie nowego wyglÈdu aplikacji................................................................. 108
Przesuwanie i zmiana rozmiarów okien.............................................................. 112
Tworzenie menu
115
Przydatne pojÚcia................................................................................................. 116
Tworzenie menu .................................................................................................. 118
Obsïuga zdarzeñ menu ........................................................................................ 123
Menu zaleĝne od systemu operacyjnego............................................................ 127
Dodawanie skrótów klawiaturowych .................................................................. 130
Zmiana stanu elementu menu............................................................................. 135
Import i eksport danych
139
Kopiowanie........................................................................................................... 140
Wycinanie............................................................................................................. 145
Wklejanie.............................................................................................................. 149
Operacje na schowku a róĝne typy danych ........................................................ 153
PrzeciÈganie i upuszczanie danych w aplikacji.................................................. 158
PrzeciÈganie danych poza aplikacjÚ.................................................................... 163
Pliki i katalogi
167
Podstawowe informacje ....................................................................................... 168
PrzeglÈdanie plików i katalogów......................................................................... 171
Uzyskiwanie informacji o plikach ....................................................................... 176
Odczytywanie zawartoĂci katalogów................................................................... 180
Usuwanie plików i katalogów.............................................................................. 184
Kopiowanie i przenoszenie.................................................................................. 189
195
Odczyt danych z pliku ......................................................................................... 196
Zapis do plików .................................................................................................... 201
Mechanizm asynchroniczny ................................................................................ 207
Obsïuga danych binarnych.................................................................................. 213
Rozdziaï 10. Praca wewnÈtrz plików
Spis treĂci
Rozdziaï 6.
Rozdziaï 7.
Rozdziaï 8.
i
c
Ă
e
r
t
s
i
p
S
Rozdziaï 9.
6
Rozdziaï 11. Bazy danych w aplikacjach AIR
Rozdziaï 12. Rozmaite techniki bazodanowe
Rozdziaï 13. Operacje sieciowe
Spis treĂci
217
Èczenie z bazÈ danych ....................................................................................... 218
Tworzenie bazy danych ....................................................................................... 221
Wstawianie rekordów .......................................................................................... 225
Obsïuga bïÚdów ................................................................................................... 230
Pobieranie rekordów............................................................................................ 233
Modyfikowanie i usuwanie rekordów................................................................. 239
247
Rozpowszechnianie bazy danych........................................................................ 248
Zapytania parametryzowane................................................................................ 252
Porcjowanie wyników .......................................................................................... 257
Wykonywanie transakcji...................................................................................... 261
Poprawianie wydajnoĂci ...................................................................................... 272
Techniki debugowania......................................................................................... 273
275
Klasa URLRequest............................................................................................... 276
Odbieranie danych............................................................................................... 280
Parsowanie danych............................................................................................... 283
Wysyïanie danych ................................................................................................ 287
Pobieranie plików ................................................................................................ 292
Pobieranie duĝych plików ................................................................................... 295
Wysyïanie plików................................................................................................. 299
303
Odtwarzanie děwiÚków ....................................................................................... 304
Odtwarzanie dïugich plików ............................................................................... 306
Odtwarzanie strumieniowe ................................................................................. 310
Kontrola odtwarzania děwiÚków .......................................................................... 315
WyĂwietlanie dokumentów PDF........................................................................ 320
Obsïuga danych XML.......................................................................................... 324
331
Model bezpieczeñstwa AIR................................................................................. 332
Piaskownice zewnÚtrzne...................................................................................... 337
Mostek miÚdzypiaskownicowy............................................................................ 340
Przechowywanie zaszyfrowanych danych .......................................................... 351
Walidacja danych ................................................................................................. 355
Najlepsze praktyki bezpieczeñstwa .................................................................... 356
Rozdziaï 14. Obsïuga pozostaïych mediów
Rozdziaï 15. Bezpieczeñstwo aplikacji AIR
S
p
i
s
t
r
e
Ă
c
i
7
Spis treĂci
Rozdziaï 16. Publikowanie aplikacji
357
Dodatkowe opcje pliku deskryptora aplikacji .................................................... 358
Dodawanie wïasnych ikon................................................................................... 361
Tryb cichej instalacji............................................................................................ 363
Jeszcze wiÚcej ciekawych pomysïów.................................................................... 366
Aktualizowanie aplikacji ...................................................................................... 370
Skorowidz
379
i
c
Ă
e
r
t
s
i
p
S
8
Tworzenie aplikacji 2
Rozdziaá 2. Tworzenie aplikacji
Gdy przystÚpujesz do tworzenia aplikacji Adobe AIR, masz do wyboru róĝne technologie
i narzÚdzia programistyczne. Do technologii naleĝÈ Ajax (HTML i JavaScript), Adobe
Flex i Adobe Flash. W niniejszej ksiÈĝce bÚdÚ omawiaï wyïÈcznie aplikacje stworzone
z wykorzystaniem Ajaksa. W przypadku narzÚdzi programistycznych nie ma prawie
ĝadnych ograniczeñ. W tym rozdziale zaprezentujÚ proces tworzenia aplikacji przy uĝyciu
edytora tekstowego i AIR SDK (z ang. Software Development Kit — zestaw narzÚdzi
programistycznych). W nastÚpnym rozdziale pokaĝÚ Ci, jak wykorzystywaÊ bardziej
rozbudowane narzÚdzia, takie jak Dreamweaver CS3 czy Aptana Studio Integrated
Development Environments (IDE).
Tworzenie aplikacji AIR naleĝy rozpoczÈÊ od utworzenia folderu projektu. NastÚpnie
dodasz do niego dwa pliki: HTML i XML. Na koñcu przetestujesz i skompilujesz aplikacjÚ
przy uĝyciu narzÚdzi z pakietu AIR SDK. Najpierw jednak zajmiemy siÚ instalacjÈ
i konfiguracjÈ tego pakietu — jest to, podobnie jak w przypadku samej biblioteki AIR,
proces jednorazowy.
T
w
o
r
z
e
n
i
e
a
p
l
i
k
a
c
j
i
21
Rozdziaï 2.
Instalacja SDK
Adobe AIR SDK to pakiet niezaleĝny od biblioteki
AIR, którÈ wykorzystujemy do uruchamiania
aplikacji. W skïad SDK wchodzÈ:
X dwa narzÚdzia uruchamiane z wiersza poleceñ,
umoĝliwiajÈce testowanie i pakowanie aplikacji;
X frameworki (biblioteki udostÚpniajÈce
uĝyteczne funkcje);
X przykïady (na przykïad ikony aplikacji);
X szablon pliku XML.
Do prawidïowego dziaïania SDK niezbÚdny
jest Java Runtime Environment (JRE) lub Java
Development Kit (JDK). Obydwa zestawy
aplikacji moĝesz pobraÊ za darmo ze strony
http://java.sun.com (jako fragment pakietu Java
Standard Edition, Java SE). Po zakoñczeniu
instalacji (w przypadku systemu Mac OS X
istnieje duĝe prawdopodobieñstwo, ĝe JRE jest
juĝ zainstalowane; w systemie Windows z reguïy
trzeba je dopiero zainstalowaÊ) moĝesz wykonaÊ
poniĝsze kroki.
Aby zainstalowaÊ SDK:
1. Pobierz SDK dla Twojego systemu
operacyjnego ze strony Adobe (rysunek 2.1)
— http://www.adobe.com/products/air/tools/
sdk/. W momencie pisania tej ksiÈĝki SDK
jest dostÚpny zarówno dla systemu Windows,
jak i Mac OS X.
K
D
S
a
j
c
a
l
a
t
s
n
I
2. Otwórz i rozpakuj pobrany plik
(rysunek 2.2). Uĝytkownicy systemu
Windows muszÈ rozpakowaÊ archiwum
ZIP, podczas gdy posiadacze systemu
Mac OS X muszÈ zamontowaÊ plik .dmg
(obraz dysku).
3. Skopiuj zawartoĂÊ pobranego pliku
do innego katalogu na Twoim komputerze.
Moĝesz wybraÊ dowolny katalog
— na przykïad Pulpit lub katalog wewnÈtrz
Twojego katalogu domowego. Niezaleĝnie
od wybranej Ăcieĝki naleĝy jÈ zapamiÚtaÊ,
by moĝna byïo wykonaÊ nastÚpne kroki.
4. Zaktualizuj ĂcieĝkÚ systemowÈ, tak aby
wskazywaïa na podkatalog bin Twojego
SDK. Ten krok zostaï szerzej omówiony
w dwóch nastÚpnych podrozdziaïach.
Wskazówki
JRE i JDK sÈ wymagane tylko w przypadku
instalacji AIR SDK. Koñcowi uĝytkownicy
Twojej aplikacji bÚdÈ musieli zainstalowaÊ
tylko bibliotekÚ AIR (zob. rozdziaï 1.).
Poza samym SDK moĝesz takĝe pobraÊ
stosownÈ dokumentacjÚ, przykïadowe
aplikacje i kody ěródïowe ze strony Adobe.
Rysunek 2.1. Pobierz SDK odpowiedni dla Twojego
systemu
Rysunek 2.2. ZawartoĂÊ katalogu Adobe AIR SDK
22
Rysunek 2.3.
Uzyskiwanie
dostÚpu
do okna
WïaĂciwoĂci
systemu
Rysunek 2.4. ¥cieĝkÚ systemowÈ moĝna edytowaÊ
w oknie Zmienne Ărodowiskowe wywoïywanym
z zakïadki Zaawansowane
Tworzenie aplikacji
Aktualizowanie Ăcieĝki
w systemie Windows
Dwa narzÚdzia, które otrzymujemy razem z SDK
— AIR Development Tool (adt) i AIR Debug
Launcher (adl) — sÈ uruchamiane z poziomu
konsoli. Oznacza to, ĝe do ich uruchomienia
w systemie Windows musisz skorzystaÊ z wiersza
poleceñ, a nie graficznego interfejsu. Skïadnia
konsoli nie jest skomplikowana, niemniej wystÚpuje
pewien kruczek — oba programy (adt i adl) muszÈ
byÊ „rozpoznawane” przez Twój komputer. W tym
celu musisz dodaÊ podkatalog bin z katalogu
zawierajÈcego SDK (rysunek 2.2) do Ăcieĝki
systemowej.
¥cieĝka stanowi zwykle listÚ katalogów, w których
system ma szukaÊ wywoïywanych programów.
Na co dzieñ nie korzystasz ze Ăcieĝki, poniewaĝ
nie masz zbyt czÚsto do czynienia z wierszem
poleceñ. Wystarczy zrealizowaÊ poniĝsze kroki,
a systemowa Ăcieĝka nie bÚdzie miaïa przed TobÈ
tajemnic.
Aby zmodyfikowaÊ ĂcieĝkÚ systemowÈ:
1. Zamknij wszystkie otwarte okna wiersza poleceñ.
Zmiana Ăcieĝki, którÈ zamierzasz wykonaÊ,
odniesie zamierzony efekt w oknach, które
zostanÈ otwarte po wykonaniu zmiany. Aby
uniknÈÊ niepotrzebnego zamieszania, zamknij
wszystkie okna konsoli, zanim przystÈpisz
do wïaĂciwej zmiany Ăcieĝki.
2. Uruchom okno WïaĂciwoĂci systemu, klikajÈc
prawym przyciskiem ikonÚ Mój komputer
i wybierajÈc opcjÚ WïaĂciwoĂci (rysunek 2.3).
3. W oknie WïaĂciwoĂci systemu wybierz zakïadkÚ
Zaawansowane (rysunek 2.4).
4. Kliknij przycisk Zmienne Ărodowiskowe.
Jest on widoczny na dole rysunku 2.4.
23
A
k
t
u
a
l
i
z
o
w
a
n
i
e
Ă
c
i
e
ĝ
k
i
w
s
y
s
t
e
m
i
e
W
i
n
d
o
w
s
Rozdziaï 2.
5. W oknie Zmienne Ărodowiskowe kliknij element
Path na liĂcie Zmienne systemowe, aby go
zaznaczyÊ (rysunek 2.5).
6. Kliknij przycisk Edytuj, aby wyĂwietliÊ okno
Edytowanie zmiennej Ărodowiskowej.
7. Na koñcu pola tekstowego WartoĂÊ zmiennej
umieĂÊ Ărednik, a nastÚpnie peïnÈ ĂcieĝkÚ
do podkatalogu bin (rysunek 2.6).
Musisz postÚpowaÊ bardzo ostroĝnie;
w ĝadnym przypadku nie usuwaj
dotychczasowej zawartoĂci tej zmiennej!
Aby upewniÊ siÚ, ĝe wprowadzasz poprawnÈ
ĂcieĝkÚ, uruchom Eksploratora Windows
(rysunek 2.7) w folderze SDK i skopiuj adres.
Upewnij siÚ, ĝe Ăcieĝka, którÈ wklejasz, jest
zakoñczona podkatalogiem bin, poniewaĝ jest
to tak naprawdÚ najwaĝniejszy element caïej
Ăcieĝki.
8. Kliknij OK we wszystkich trzech oknach
dialogowych, aby je zamknÈÊ.
Wskazówka
Teoretycznie nie musisz modyfikowaÊ Ăcieĝki,
aby korzystaÊ z narzÚdzi w wierszu poleceñ.
JeĂli jednak tego nie zrobisz, w celu
uruchomienia tych programów trzeba bÚdzie
wprowadziÊ polecenie takie jak C: Documents
´and Settings Larry Ullman Desktop
´SDKinadt zamiast po prostu adt. Zmiana
Ăcieĝki jest niezwykle przydatnym skrótem.
s
w
o
d
n
i
W
e
i
m
e
t
s
y
s
w
i
k
ĝ
e
i
c
Ă
e
i
n
a
w
o
z
i
l
a
u
t
k
A
Rysunek 2.5. Lista zmiennych systemowych znajduje
siÚ w dolnej czÚĂci okna Zmienne Ărodowiskowe
Rysunek 2.6. Zmienna Path zawiera listÚ wszystkich
katalogów, które sÈ przeszukiwane przez system
pod kÈtem programów wykonywalnych. Wszystkie
katalogi sÈ rozdzielane Ărednikiem
Rysunek 2.7. Folder SDK, znajdujÈcy siÚ w gïównym
katalogu dysku C, wraz ze ĂcieĝkÈ widocznÈ w oknie
Eksploratora
24
Rysunek 2.8. Jeĝeli uĝywasz systemów
uniksowych (w tym takĝe Mac OS X), musisz
wiedzieÊ, z jakiej powïoki korzystasz,
aby poprawnie zmieniÊ ĂcieĝkÚ. Informacje
o wykorzystywanej powïoce znajdziesz
w programie Inspektor
Tworzenie aplikacji
Aktualizowanie Ăcieĝki
w systemie Mac OS X
Dwa narzÚdzia, które otrzymujemy razem z SDK
— AIR Development Tool (adt) i AIR Debug
Launcher (adl) — sÈ uruchamiane z poziomu
powïoki. Oznacza to, ĝe w celu ich uruchomienia
w systemie Mac OS X musisz skorzystaÊ z aplikacji
Terminal, a nie z graficznego interfejsu. Skïadnia
poleceñ wykorzystywanych w powïoce nie jest
skomplikowana, niemniej wystÚpuje pewien
kruczek — oba programy (adt i adl) muszÈ byÊ
„rozpoznawane” przez Twój komputer. W tym celu
musisz dodaÊ podkatalog bin z katalogu
zawierajÈcego SDK do Ăcieĝki systemowej.
¥cieĝka stanowi zwykle listÚ katalogów, w których
system ma szukaÊ wywoïywanych programów.
Na co dzieñ nie korzystasz ze Ăcieĝki, poniewaĝ
nie masz zbyt czÚsto do czynienia z powïokÈ.
Wystarczy zrealizowaÊ poniĝsze kroki, a systemowa
Ăcieĝka nie bÚdzie miaïa przed TobÈ tajemnic.
Aby zmodyfikowaÊ ĂcieĝkÚ systemowÈ:
1. Zamknij wszystkie otwarte okna Terminala.
Zmiana Ăcieĝki, którÈ zamierzasz wykonaÊ,
odniesie zamierzony efekt w oknach, które
zostanÈ otwarte po wykonaniu zmiany.
2. Sprawdě wykorzystywanÈ przez Ciebie powïokÚ,
korzystajÈc z opcji Powïoka/Pokaĝ Inspektora,
aby wyĂwietliÊ okno Inspektor (rysunek 2.8).
A
k
t
u
a
l
i
z
o
w
a
n
i
e
Ă
c
i
e
ĝ
k
i
w
s
y
s
t
e
m
i
e
M
a
c
O
S
X
25
Rozdziaï 2.
Sposób zmiany Ăcieĝki zaleĝy
od wykorzystywanej przez Ciebie powïoki
(jeĂli zainteresowaïy CiÚ powïoki same
w sobie, przeszukaj internet pod kÈtem
wyraĝenia powïoka uniksowa lub unix shell).
Pozycja Powïoka w oknie Inspektor okreĂla
wykorzystywanÈ powïokÚ. Do najczÚĂciej
spotykanych powïok naleĝÈ (nazwa programu
znajduje siÚ w nawiasach):
V Bourne (sh),
V Bourne Again Shell (bash — to nie ja
wymyĂliïem tÚ nazwÚ),
V C shell (csh),
V T shell lub T C shell (tcsh),
V Korn shell (ksh).
Najnowsze wersje system Mac OS X
wykorzystujÈ domyĂlnie powïokÚ bash
(jak na rysunku 2.8). W poniĝszych instrukcjach
równieĝ bÚdÚ korzystaï z tej powïoki.
JeĂli w oknie Inspektor widnieje nazwa innej
powïoki, musisz przeszukaÊ internet pod kÈtem
zmiany Ăcieĝki w tej konkretnej powïoce.
3. Otwórz okno Terminala (Powïoka/Nowe
okno lub Command+N), jeĂli do tej pory
tego nie zrobiïeĂ (rysunek 2.9).
4. Przejdě do swojego katalogu domowego,
wprowadzajÈc polecenie cd i potwierdzajÈc
klawiszem Return.
Moĝliwe, ĝe ten krok nie bÚdzie konieczny,
poniewaĝ po otwarciu Terminala z reguïy
znajdujesz siÚ w swoim katalogu domowym,
jednak ostroĝnoĂci nigdy za wiele. Polecenie
cd jest wykorzystywane do zmiany
aktualnego katalogu (z ang. change
directory — zmieñ katalog). Wywoïanie
go bez ĝadnych dodatkowych argumentów
(jak na przykïad nazwa katalogu) spowoduje
zmianÚ aktualnego katalogu na domowy.
5. Wypisz wszystkie pliki w katalogu
przy uĝyciu polecenia ls -a (jak zawsze
polecenie naleĝy potwierdziÊ klawiszem
Return — rysunek 2.10).
Polecenie ls wyĂwietla zawartoĂÊ
aktualnego katalogu; opcja -a okreĂla,
ĝe wyĂwietlone powinny byÊ wszystkie
pliki, takĝe te ukryte.
Rysunek 2.9. Okno programu Terminal
Rysunek 2.10. Lista wszystkich plików znajdujÈcych siÚ w katalogu domowym
X
S
O
c
a
M
e
i
m
e
t
s
y
s
w
i
k
ĝ
e
i
c
Ă
e
i
n
a
w
o
z
i
l
a
u
t
k
A
26
Tworzenie aplikacji
JeĂli Twój plik .bash_profile zawiera juĝ
wiersz export PATH, dodaj na jego koñcu
dwukropek i peïnÈ ĂcieĝkÚ do aktualnego
katalogu.
9. Zapisz i zamknij plik.
10. Zamknij okno Terminala.
Zmiana Ăcieĝki nastÈpi przy ponownym
otwarciu Terminala.
Wskazówki
W przypadku wiÚkszoĂci programów
w systemie Mac OS X moĝesz wstawiaÊ peïnÈ
ĂcieĝkÚ katalogu do pliku, przeciÈgajÈc ten
katalog do pliku. JeĂli przeciÈgniesz podkatalog
bin (widoczny w programie Finder) do pliku
.bash_profile w programie BBEdit, peïna
Ăcieĝka do podkatalogu bin zostanie wstawiona
do pliku .bash_profile w miejscu, w którym
zwolnisz przycisk myszy.
Teoretycznie nie musisz modyfikowaÊ Ăcieĝki,
aby korzystaÊ z narzÚdzi w Terminalu. JeĂli
jednak tego nie zrobisz, w celu uruchomienia
tych programów bÚdziesz musiaï wprowadziÊ
polecenie takie jak /Users/larryullman/
´Desktop/AIR/SDK/bin/adt zamiast po
prostu adt. Zmiana Ăcieĝki jest niezwykle
przydatnym skrótem.
6. JeĂli nie widzisz na liĂcie pliku .bash_profile
(rysunek 2.10), utwórz go, korzystajÈc
z polecenia touch .bash_profile. Pliki,
które rozpoczynajÈ siÚ kropkÈ, sÈ plikami
specjalnymi, ukrytymi. Plik .bash_profile
okreĂla sposób zachowania powïoki bash.
JeĂli plik nie istnieje, polecenie touch
utworzy go.
7. Otwórz plik .bash_profile w dowolnym
edytorze tekstu (rysunek 2.11).
Ja korzystam z popularnego (i doskonaïego)
edytora BBEdit. Aby otworzyÊ plik, wystarczy
wywoïaÊ w powïoce polecenie bbedit
.bash_profile. Moĝesz takĝe skorzystaÊ
z darmowego edytora TextWrangler firmy
BareBones (www.barebones.com) lub
z jednego z wielu popularnych edytorów
dziaïajÈcych w powïoce: vi, vim, emacs,
pico itd.
8. W pliku .bash_profile dodaj poniĝszy wiersz:
export PATH= $PATH:/Ăcieĝka/do/SDK/AIR/bin/
Polecenie export PATH zmienia ĂcieĝkÚ
w powïoce bash. Jej nowa wartoĂÊ bÚdzie
siÚ skïadaÊ z dotychczasowej Ăcieĝki ($PATH),
a takĝe peïnej Ăcieĝki do podkatalogu bin
(musisz podaÊ faktycznÈ ĂcieĝkÚ w miejsce
fragmentu /path/to/; zapoznaj siÚ z pierwszÈ
wskazówkÈ do tego podrozdziaïu).
Kaĝdy katalog w Ăcieĝce jest oddzielany
dwukropkiem.
A
k
t
u
a
l
i
z
o
w
a
n
i
e
Ă
c
i
e
ĝ
k
i
w
s
y
s
t
e
m
i
e
M
a
c
O
S
X
Rysunek 2.11. Polecenie bbedit .bash_profile uruchamia plik .bash_profile
w edytorze BBEdit
27
Rozdziaï 2.
Tworzenie struktury projektu
Chociaĝ tworzenie ĂciĂle okreĂlonej struktury
katalogów dla aplikacji AIR nie jest konieczne,
moim zdaniem to bardzo dobry programistyczny
zwyczaj. ProgramiĂci aplikacji webowych starajÈ
siÚ organizowaÊ swoje pliki i zasoby; podobnie
powinni postÚpowaÊ inni programiĂci. Nie kaĝdy
projekt musi zawieraÊ takÈ samÈ strukturÚ — byÊ
moĝe bÚdziesz stosowaÊ inne konwencje
nazewnictwa — jednak pewne podstawy, opisane
poniĝej, sÈ warte naĂladowania.
W poniĝszych krokach omówiÚ praktyki
i zwyczaje, które moĝna zastosowaÊ w dowolnym
projekcie. W przykïadzie, który zrealizujemy
w tym rozdziale, nie trzeba bÚdzie korzystaÊ
z plików CSS ani JavaScript, jednak warto
wiedzieÊ, jak z nimi postÚpowaÊ.
Aby utworzyÊ strukturÚ aplikacji:
1. Utwórz nowy folder w dowolnej lokalizacji
na Twoim komputerze. BÚdziesz w nim
przechowywaÊ swoje aplikacje AIR.
W systemie Windows kliknij prawym
przyciskiem, a nastÚpnie wybierz opcjÚ
Nowy/Folder, a w systemie Mac OS X
wybierz opcjÚ Plik/Nowy katalog lub skorzystaj
z kombinacji klawiszy Command+Shift+N.
Moĝesz stworzyÊ katalog o nazwie Aplikacje
AIR wewnÈtrz Twojego katalogu domowego
lub na Pulpicie. Waĝne, aby wszystkie Twoje
aplikacje byïy przechowywane w jednym
miejscu, dziÚki czemu ïatwiej bÚdzie tworzyÊ
kolejne aplikacje.
2. WewnÈtrz katalogu utworzonego w kroku 1.
moĝesz tworzyÊ katalogi, w których bÚdÈ
znajdowaÊ siÚ osobne aplikacje. PamiÚtaj,
aby wszystkie te foldery znajdowaïy siÚ
wewnÈtrz jednego folderu nadrzÚdnego
(na przykïad Aplikacje AIR).
3. Folder aplikacji powinien mieÊ tÚ samÈ nazwÚ,
co aplikacja (rysunek 2.12). Na poczÈtek,
aby tradycji staïo siÚ zadoĂÊ, stworzymy
aplikacjÚ Hello, World!. UtworzÚ wiÚc folder
HelloWorld, w którym znajdÈ siÚ wszystkie
pliki tej aplikacji.
u
t
k
e
j
o
r
p
y
r
u
t
k
u
r
t
s
e
i
n
e
z
r
o
w
T
Rysunek 2.12. Folder HelloWorld bÚdzie zawieraï pliki pierwszej przykïadowej aplikacji
28
Tworzenie aplikacji
4. WewnÈtrz katalogu HelloWorld utwórz katalog
dla kaskadowych arkuszy stylów.
Z oczywistych wzglÚdów folder ten powinien
nosiÊ nazwÚ css. ZnajdÈ siÚ w nim wszystkie
pliki CSS wykorzystywane przez aplikacjÚ.
PamiÚtaj, ĝe podstawÚ kaĝdej aplikacji AIR
stanowiÈ pliki HTML. Z tego wzglÚdu struktura
katalogów Twoich aplikacji moĝe przypominaÊ
strukturÚ strony internetowej.
5. WewnÈtrz katalogu aplikacji utwórz katalog
dla skryptów JavaScript.
Folder ten otrzyma nazwÚ js. BÚdÈ w nim
przechowywane wszystkie skrypty i pliki
tworzone w jÚzyku JavaScript.
Rysunek 2.13. Struktura katalogów prostej aplikacji
6. WewnÈtrz katalogu aplikacji utwórz katalog
do przechowywania obrazków.
Nie powinno dziwiÊ, ĝe nazwiemy go images.
MoglibyĂmy skorzystaÊ takĝe z nazwy assets
lub imgs. Tak naprawdÚ nie ma to ĝadnego
znaczenia; istotne jest tylko, ĝe wïaĂnie do
tego katalogu bÚdÈ trafiaÊ wszystkie obrazki.
7. WewnÈtrz katalogu aplikacji utwórz katalog
dla ikon (rysunek 2.13).
Po chwili zastanowienia postanowiïem utworzyÊ
takĝe katalog icons. W rozdziale 16. zajmiemy
siÚ tworzeniem specjalnych ikon na potrzeby
naszych aplikacji. Pliki nie naleĝÈ do obrazków
wykorzystywanych w aplikacji, dlatego
postanowiïem umieĂciÊ je w osobnym katalogu.
Wskazówka
W swojej aplikacji moĝesz umieĂciÊ takĝe inne
katalogi, na przykïad audio (do przechowywania
děwiÚków wykorzystywanych w aplikacji), docs
(dla dokumentacji) lub resources (dla innych
zasobów). OczywiĂcie nazwy te nie sÈ
obowiÈzkowe, stanowiÈ tylko sugestiÚ.
29
T
w
o
r
z
e
n
i
e
s
t
r
u
k
t
u
r
y
p
r
o
j
e
k
t
u
Rozdziaï 2.
Tworzenie pliku HTML
Pierwszym plikiem, który utworzÚ w tej aplikacji,
jest plik HTML (nazywany teĝ stronÈ gïównÈ).
W trakcie tworzenia aplikacji AIR z wykorzystaniem
jÚzyków HTML i JavaScript ten dokument bÚdzie
stanowiï ich podstawÚ.
JednÈ z najwiÚkszych zalet biblioteki AIR jest
moĝliwoĂÊ wykorzystania wiedzy na temat tworzenia
aplikacji webowych do tworzenia aplikacji
uruchamianych na komputerze uĝytkownika
— desktopowych. Oznacza to, ĝe do tworzenia
interfejsu aplikacji moĝesz wykorzystywaÊ
te same mechanizmy, co w przypadku stron
internetowych. Moĝesz takĝe uruchamiaÊ strony
internetowe w przeglÈdarce internetowej
— aplikacja bÚdzie wyglÈdaÊ w niej tak samo,
jak uruchamiana samodzielnie.
W pierwszym przykïadzie zademonstrujÚ klasycznÈ
stronÚ typu Hello, World!. Powstaïa aplikacja nie
bÚdzie realizowaÊ ĝadnej praktycznej
funkcjonalnoĂci, pozwoli Ci jednak zapoznaÊ siÚ
z procesem tworzenia, pakowania i uruchamiania
aplikacji, co przyda siÚ w nastÚpnych rozdziaïach,
aĝ do koñca ksiÈĝki.
Aby utworzyÊ plik HTML:
1. Utwórz nowy dokument HTML w dowolnym
edytorze tekstowym (skrypt 2.1) i wprowadě
w nim nastÚpujÈcÈ treĂÊ:
html
head
title Witaj, Ăwiecie! /title
/head
Nie tworzymy prawdziwej strony internetowej,
dlatego nie musimy umieszczaÊ wielu
dodatkowych znaczników, takich jak DOCTYPE,
META itd.
2. Dodaj ciaïo (treĂÊ) dokumentu HTML:
body
h1 Witaj, Ăwiecie! /h1
/body
30
Jak juĝ wspomnieliĂmy, nie jest to
najbardziej rozbudowana aplikacja,
jakÈ przyjdzie nam napisaÊ. DziÚki temu
dziaïaniu dowiesz siÚ, jak ïatwo moĝna
tworzyÊ wïasne aplikacje desktopowe.
3. Zakoñcz dokument HTML:
/html
4. Zapisz plik pod nazwÈ HelloWorld.html
w katalogu aplikacji.
Plik ten powinien byÊ umieszczony
w gïównym katalogu aplikacji,
a nie w którymĂ z podkatalogów.
Wskazówki
Silnik renderujÈcy jÚzyk HTML
— mechanizm, który interpretuje
ten jÚzyk i tworzy efekt graficzny
— wykorzystywany przez AIR nosi nazwÚ
WebKit (www.webkit.org). Jest on
wykorzystywany równieĝ przez
przeglÈdarkÚ Safari, dlatego wïaĂnie
ta przeglÈdarka interpretuje dokumenty
HTML w sposób najbardziej zbliĝony
do biblioteki AIR. Z Safari 3 mogÈ
korzystaÊ zarówno uĝytkownicy systemów
Mac, jak i Windows.
Aplikacje AIR mogÈ byÊ tworzone
z wykorzystaniem Ajaksa, Flasha
lub Fleksa. Aplikacje AIR tworzone
w Ajaksie majÈ rozszerzenie .html.
W przypadku pozostaïych dwóch formatów
mamy do czynienia z plikami SWF (format
Shockwave).
Skrypt 2.1. Plik HTML, który stanowi podstawÚ
naszej aplikacji AIR
html
head
title Witaj, Ăwiecie! /title
/head
body
h1 Witaj, Ăwiecie! /h1
/body
/html
L
M
T
H
u
k
i
l
p
e
i
n
e
z
r
o
w
T
Rysunek 2.14. Okno About aplikacji, w którym
widnieje nazwa programu, nota copyright
i informacja o autorze
Rysunek 2.15. Niektóre z informacji zawartych
w pliku deskryptora aplikacji sÈ wykorzystywane
w trakcie instalacji
Tworzenie aplikacji
Tworzenie pliku XML
Oprócz pliku HTML Twoja aplikacja AIR musi
zawieraÊ takĝe plik XML, który jest okreĂlany jako
plik deskryptora aplikacji. W pliku tym umieszcza
siÚ wszelkie metadane (informacje zwiÈzane
z programem) dla aplikacji. W ich skïad wchodzÈ
miÚdzy innymi:
X nazwa,
X wersja,
X autor,
X opis,
X nota copyright,
X ikony,
X domyĂlny folder instalacji,
X wyglÈd okna i jego zachowanie,
X i inne.
Wiele spoĂród tych informacji jest widocznych
w menu About (rysunek 2.14), a takĝe w trakcie
procesu instalacji (rysunek 2.15).
JeĂli nigdy wczeĂniej nie tworzyïeĂ dokumentów
XML, nie musisz siÚ martwiÊ: dokumenty takie
nie róĝniÈ siÚ znacznie od plików HTML. WyjaĂniÚ
Ci dokïadnie wszystkie szczegóïy, które powinieneĂ
wiedzieÊ. SkupiÚ siÚ przy tym na wymaganych
elementach XML. W kolejnych rozdziaïach
(zwïaszcza w rozdziale 16.) poznasz inne dodatkowe
ustawienia, które podaje siÚ w tym pliku.
T
w
o
r
z
e
n
i
e
p
l
i
k
u
X
M
L
31
Skrypt 2.2. Plik deskryptora aplikacji w formacie
XML, wymagany przez kaĝdÈ aplikacjÚ AIR
?xml version= 1.0 encoding= utf-8 ?
application xmlns= http://ns.adobe.com/
´air/application/1.0
id com.dmci.air.HelloWorld /id
filename Hello World /filename
version 1.0 /version
initialWindow
content HelloWorld.html /content
visible true /visible
/initialWindow
/application
Rozdziaï 2.
Aby utworzyÊ plik XML:
1. Utwórz dokument XML w edytorze tekstowym
(skrypt 2.2) i rozpocznij go nastÚpujÈcÈ
instrukcjÈ:
?xml version= 1.0 encoding= utf-8 ?
Pliki XML sÈ zwykïymi dokumentami
tekstowymi, które moĝna tworzyÊ w niemal
dowolnym edytorze tekstowym. Na poczÈtku
kaĝdego pliku umieszcza siÚ deklaracjÚ XML
(jest to powyĝszy wiersz). OkreĂla ona
wykorzystywanÈ wersjÚ XML (1.0 to jedna
z najczÚĂciej stosowanych) i kodowanie
(zapoznaj siÚ z pierwszÈ wskazówkÈ na koñcu
podrozdziaïu).
2. Dodaj znacznik application.
application
/application
Wszystkie pliki XML muszÈ okreĂlaÊ jeden
znacznik bazowy (zauwaĝ, ĝe pliki HTML
zawierajÈ znacznik bazowy html). W przypadku
deskryptora aplikacji AIR jest to znacznik
application. Caïa pozostaïa treĂÊ danych XML
musi znaleěÊ siÚ pomiÚdzy znacznikami
otwierajÈcym i zamykajÈcym application.
3. Dodaj atrybut xmlns do znacznika otwierajÈcego
application.
application xmlns= http://ns.adobe.com/
´air/application/1.0
Atrybut xmlns okreĂla przestrzeñ nazw XML.
Przestrzenie nazw sÈ skomplikowanÈ
konstrukcjÈ programistycznÈ, której nie musisz
na szczÚĂcie znaÊ. Musisz tylko wiedzieÊ,
ĝe wartoĂÊ tego atrybutu okreĂla najstarszÈ
wersjÚ biblioteki AIR, z którÈ aplikacja moĝe
wspóïpracowaÊ. W tym przypadku odwoïujemy
siÚ do pierwszej oficjalnej wersji biblioteki.
Programy napisane dla tej wersji powinny
uruchamiaÊ siÚ na dowolnej wersji biblioteki
AIR opublikowanej od momentu wydania
wersji 1.0.
32
L
M
X
u
k
i
l
p
e
i
n
e
z
r
o
w
T
4. PomiÚdzy znacznikami otwierajÈcym
i zamykajÈcym application dodaj
element id.
6. PomiÚdzy znacznikami otwierajÈcym
i zamykajÈcym application dodaj element
version.
id com.dmci.air.HelloWorld /id
version 1.0 /version
Tworzenie aplikacji
WartoĂÊ znacznika ID okreĂla unikalne
odniesienie (nazwa) AIR dla programu.
Zalecana postaÊ to com.firma.aplikacja.
Powinna w ten sposób powstaÊ unikatowa
wartoĂÊ, niemniej musi ona teĝ mieÊ jakieĂ
znaczenie. Aplikacja AIR firmy Adobe
przyjmie id o wartoĂci com.adobe.air.
´nazwa. W przypadku aplikacji stworzonej
przez mojÈ firmÚ (DMC Insights, Inc.)
korzystam z nazwy com.dmci.air.
´HelloWorld. PowinieneĂ dostosowaÊ
format wedïug wïasnego uznania.
W nazwach moĝesz korzystaÊ z liter A-Z,
cyfr 0-9, znaków kropki i myĂlnika.
Nie stosuj spacji. Maksymalna dïugoĂÊ
elementu id to 255 znaków.
5. PomiÚdzy znacznikami otwierajÈcym
i zamykajÈcym application dodaj znacznik
filename.
filename Hello World /filename
Znacznik ten okreĂla nazwÚ aplikacji,
jakÈ bÚdÈ widzieÊ jej uĝytkownicy. Nazwa
ta jest widoczna w menu About (rysunek
2.14), w skrótach (rysunek 2.16), w menu
Start (tylko w systemie Windows) itd.
Z drugiej strony istnieje przecieĝ znacznik
id, który stanowi nazwÚ wykorzystywanÈ
tylko w mechanizmach aplikacji — koñcowi
uĝytkownicy prawdopodobnie nigdy nie
bÚdÈ mieli z niÈ do czynienia.
Ten element okreĂla wersjÚ aplikacji. Chociaĝ
moĝe to byÊ wartoĂÊ dowolna, w praktyce
powinna ona mieÊ ĂciĂle okreĂlonÈ budowÚ.
Wersje beta aplikacji otrzymujÈ z reguïy liczby
mniejsze od 1. Kolejne waĝne dla aplikacji
aktualizacje otrzymujÈ jako wersjÚ kolejne
liczby caïkowite (od 1 do 2, od 2 do 3 itd.),
natomiast w przypadku niewielkich poprawek
do „duĝego” numeru wersji dodaje siÚ czÚĂÊ
dziesiÚtnÈ (niewielka aktualizacja wersji 1.1
zwiÚkszy numer wersji do 1.2). Najwaĝniejsze,
aby kolejne wersje aplikacji miaïy wiÚksze
numery, dziÚki czemu uĝytkownik wie,
ĝe zmiana wersji oznacza aktualizacjÚ.
Jak widaÊ na skrypcie 2.2, kaĝdy element
(lub para znaczników) jest umieszczony
pomiÚdzy znacznikami application
otwierajÈcym a zamykajÈcym. Nie ma znaczenia,
w jakiej kolejnoĂci elementy sÈ podawane.
7. PomiÚdzy znacznikami otwierajÈcym
i zamykajÈcym application dodaj element
initialWindow.
initialWindow
/initialWindow
Element initialWindow od tego momentu
bÚdzie zawieraï wartoĂci okreĂlajÈce treĂÊ
i wyglÈd gïównego okna aplikacji.
T
w
o
r
z
e
n
i
e
p
l
i
k
u
X
M
L
Rysunek 2.16. Skrót do zainstalowanej
aplikacji, w którym jest wykorzystywany
element filename z pliku XML
33
10. Zapisz plik pod nazwÈ application.xml
w tym samym katalogu, co plik
HelloWorld.html. Moĝesz nadaÊ teĝ
innÈ nazwÚ (z rozszerzeniem .xml),
jednak przyjÚïo siÚ stosowaÊ wïaĂnie
nazwÚ application.xml. MógïbyĂ takĝe
skorzystaÊ z nazw HelloWorld.xml lub
HelloWorld-app.xml (dziÚki temu widaÊ,
ĝe to wïaĂnie ten plik jest deskryptorem
aplikacji HelloWorld).
Wskazówki
Kodowanie okreĂla, jaki rodzaj znaków
bÚdzie obsïugiwany w danym pliku.
UTF-8 jest jednym z najpopularniejszych
standardów kodowania; nie powinien
on sprawiaÊ problemów w plikach XML.
JednÈ z przydatnych funkcji Ărodowisk
programistycznych obsïugujÈcych
bibliotekÚ AIR (na przykïad Dreamweaver
z rozszerzeniem AIR lub Aptana) jest pomoc
w tworzeniu plików XML. W rozdziale 3.
piszÚ wiÚcej na ten temat.
JeĂli utworzyïeĂ dwie aplikacje AIR o tym
samym id, zostanÈ one potraktowane przez
bibliotekÚ uruchomieniowÈ jako ten sam
program, przez co nie bÚdziesz mógï
korzystaÊ z obu aplikacji na jednym
komputerze. Dwie aplikacje mogÈ mieÊ
te same wartoĂci znaczników filename,
jednak taka sytuacja byïaby mylÈca dla
koñcowych uĝytkowników.
Rozdziaï 2.
8. PomiÚdzy znacznikami otwierajÈcym
i zamykajÈcym initialWindow dodaj znacznik
content.
content HelloWorld.html /content
WartoĂÊ elementu content okreĂla dokïadnÈ
nazwÚ bazowego pliku HTML (skrypt 2.1).
Najlepiej jest przechowywaÊ zarówno pliki
HTML, jak i XML w tym samym folderze,
dziÚki czemu w tym miejscu wystarczy podaÊ
samÈ nazwÚ pliku HTML (bez dodatkowych
oznaczeñ Ăcieĝki). GdybyĂ zdecydowaï
siÚ wybraÊ dwa róĝne katalogi, musiaïbyĂ
w pliku XML skorzystaÊ z relatywnej
Ăcieĝki do pliku HTML (na przykïad
../HelloWorld.html lub content/
HelloWorld.html).
9. PomiÚdzy znacznikami otwierajÈcym
i zamykajÈcym initialWindow dodaj
znacznik visible.
visible true /visible
W tym rozdziale chcÚ siÚ skupiÊ
na wymaganych elementach deskryptora
aplikacji. Element visible (stanowiÈcy
fragment znacznika initialWindow) nie jest
co prawda wymagany, ale z niewiadomych
przyczyn jego domyĂlna wartoĂÊ to false.
Oznacza to, ĝe aplikacja po napisaniu,
przetestowaniu i wdroĝeniu bÚdzie dziaïaÊ,
ale nie bÚdzie widoczna! Zakïadam,
ĝe chcesz, aby uĝytkownicy mogli oglÈdaÊ
rezultaty Twojej pracy — powinieneĂ wiÚc
dodaÊ ten wiersz.
L
M
X
u
k
i
l
p
e
i
n
e
z
r
o
w
T
34
Rysunek 2.17. Skorzystaj z narzÚdzia Uruchom,
aby otworzyÊ konsolÚ systemu Windows
Rysunek 2.18. Okno konsoli systemu Windows
(na Twoim komputerze prawdopodobnie ujrzysz
biaïy tekst na czarnym tle)
Rysunek 2.19. PrzejĂcie w strukturze katalogów
do katalogu aplikacji HelloWorld w oknie Terminala
systemu Mac OS X
Tworzenie aplikacji
Testowanie aplikacji
Po utworzeniu caïej aplikacji (w tym przypadku
jednego pliku HTML i jednego XML) musisz jÈ
przetestowaÊ i skompilowaÊ (kompilacja jest
ostatnim krokiem, w którego wyniku powstaje
plik wykonywalny). Do testowania aplikacji
wykorzystuje siÚ narzÚdzie uruchamiane z linii
poleceñ — AIR Debug Launcher (adl), które
wchodzi w skïad SDK. Skïadnia polecenia jest
prosta:
adl ApplicationXMLFile.xml
MoĝliwoĂÊ testowania aplikacji w trakcie ich
tworzenia jest niezwykle waĝna. Moĝesz równieĝ
skompilowaÊ caïÈ aplikacjÚ, zainstalowaÊ jÈ
i zobaczyÊ, jak (czy w ogóle) dziaïa. Po wykonaniu
poniĝszych kroków zaoszczÚdzisz sporo czasu
— bÚdziesz musiaï kompilowaÊ aplikacjÚ tylko
raz, juĝ po zakoñczeniu tworzenia i testowania
aplikacji.
Aby przetestowaÊ aplikacjÚ AIR:
1. Uruchom powïokÚ w swoim systemie.
W systemie Windows wybierz opcjÚ Uruchom
z menu Start i wprowadě polecenie cmd w pole
tekstowe (rysunek 2.17). Rysunek 2.18
przedstawia uruchomiony wiersz polecenia.
Uĝytkownicy systemu Mac OS X muszÈ jedynie
uruchomiÊ aplikacjÚ Terminal (Programy/
NarzÚdzia). JeĂli okno powïoki nie zostanie
otwarte automatycznie, wybierz opcjÚ Powïoka/
Nowe okno lub wciĂnij kombinacjÚ klawiszy
Command+N.
2. Przejdě do katalogu projektu — wprowadě
polecenie cd Ăcieĝka_do_projektu_HelloWorld
i wciĂnij klawisz Enter/Return (rysunek 2.19).
Musisz zmieniÊ argument polecenia,
aby dopasowaÊ go do lokalizacji projektu.
Moĝesz teĝ wpisaÊ polecenie cd i spacjÚ,
a nastÚpnie przeciÈgnÈÊ folder HelloWorld
do okna konsoli. ¥cieĝka do katalogu zostanie
automatycznie wpisana w tym oknie.
35
T
e
s
t
o
w
a
n
i
e
a
p
l
i
k
a
c
j
i
Rozdziaï 2.
3. Wprowadě poniĝsze polecenie i wciĂnij klawisz
Enter/Return (rysunek 2.20).
adl application.xml
Aplikacja powinna uruchomiÊ siÚ w osobnym
oknie (rysunek 2.21). Plik XML zawiera
odniesienie do gïównego dokumentu — pliku
HTML — dlatego tak wywoïane polecenie
wystarcza do przetestowania aplikacji.
JeĂli zobaczysz informacjÚ o niemoĝnoĂci
znalezienia Javy (rysunek 2.22), oznacza to,
ĝe JRE nie zostaïo jeszcze zainstalowane
w systemie. Jeĝeli system nie rozpoznaje
polecenia adl, musisz jeszcze raz
zmodyfikowaÊ ĂcieĝkÚ systemowÈ, poniewaĝ
wczeĂniej popeïniïeĂ jakiĂ bïÈd w trakcie
wykonywania tego kroku (zapoznaj siÚ
z instrukcjami poĂwiÚconymi modyfikowaniu
Ăcieĝki, zawartymi w tym rozdziale).
4. Zamknij narzÚdzie adl, aby zamknÈÊ aplikacjÚ
i powróciÊ do powïoki.
Testowanie w przeglÈdarce
Aplikacje AIR opisywane i tworzone
w niniejszej ksiÈĝce wykorzystujÈ technologiÚ
Ajax (czyli HTML i JavaScript), dlatego
moĝna testowaÊ je takĝe w przeglÈdarce
internetowej. AIR wykorzystuje ten sam
silnik renderujÈcy, co przeglÈdarka Safari
firmy Apple, dlatego to wïaĂnie w tej
aplikacji uzyskuje siÚ najlepsze (najbardziej
zbliĝone do oryginaïu) rezultaty. PrzeglÈdarka
ta jest dostÚpna w wersji 3 zarówno
w systemie Windows, jak i Mac OS X. Dobre
efekty powinno takĝe przynieĂÊ testowanie
aplikacji w Firefoksie — zwïaszcza
ĝe przeglÈdarka ta udostÚpnia znakomite
narzÚdzia do debugowania kodu JavaScript.
Teoretycznie moĝna testowaÊ aplikacje
takĝe w Internet Explorerze. Odradzam
jednak takie rozwiÈzanie z dwóch przyczyn.
Po pierwsze, JavaScript w tej przeglÈdarce
nie zawsze jest wykonywany tak samo,
jak w aplikacjach AIR (to typowy problem
wszystkich aplikacji Ajaksowych). Po drugie,
Internet Explorer zawiera wiele dziwnych
mechanizmów, które komplikujÈ tworzenie
i testowanie aplikacji webowych ponad
miarÚ (przynajmniej moim zdaniem).
Rysunek 2.20. Wywoïanie programu AIR Debug Launcher w systemie Windows
Rysunek 2.21. Efekt dziaïania
aplikacji w systemie Windows
Rysunek 2.22. JeĂli aplikacja adl nie moĝe znaleěÊ Java Runtime Environment
(JRE), prawdopodobnie zobaczysz takÈ informacjÚ o bïÚdzie
36
i
j
c
a
k
i
l
p
a
e
i
n
a
w
o
t
s
e
T
Tworzenie certyfikatu
Po zakoñczeniu testowania aplikacji AIR moĝesz
wykonaÊ kompilacjÚ. Skompilowana aplikacja
teoretycznie mogïaby byÊ uruchamiana przez
koñcowych uĝytkowników. Teoretycznie,
poniewaĝ w praktyce AIR wymaga, aby kaĝda
aplikacja miaïa cyfrowy podpis certyfikujÈcy.
DziÚki temu ïatwiej jest zweryfikowaÊ
autentycznoĂÊ aplikacji — uĝytkownik
ma pewnoĂÊ, ĝe aplikacja nie uszkodzi jego
komputera.
IstniejÈ dwa rodzaje certyfikatów, które moĝesz
wykorzystywaÊ. Moĝesz zakupiÊ certyfikaty
w centrum autentyfikujÈcym, potwierdzajÈcym
autentycznoĂÊ certyfikatów wystawionych
dla firm. Do takich centrów naleĝÈ Thawte
lub VeriSign. Certyfikaty wystawiane przez
te firmy wymagajÈ najwyĝszego poziomu
bezpieczeñstwa, poniewaĝ firmy te sprawdzajÈ
dane osoby/instytucji, która chce uzyskaÊ
certyfikat (dziÚki temu cracker nie uzyska
certyfikatu potwierdzajÈcego jego autentycznoĂÊ
jako na przykïad banku). Certyfikaty moĝna teĝ
generowaÊ samemu. W ten sposób bÚdziesz
w stanie tworzyÊ instalatory AIR dla Twoich
aplikacji, jednak koñcowi uĝytkownicy aplikacji
nie bÚdÈ mieli pewnoĂci, ĝe Twoja aplikacja
dziaïa bezpiecznie. Generowanie certyfikatów
w ten sposób jest bezpïatne, ale uĝytkownicy
muszÈ mieÊ do Ciebie zaufanie. JeĂli jednak
chcesz tylko przetestowaÊ aplikacjÚ, tworzenie
wïasnego certyfikatu na pewno ma sens.
W nastÚpnych krokach zademonstrujÚ metodÚ
tworzenia takiego certyfikatu przy uĝyciu
narzÚdzia adt (AIR Development Tool).
Tworzenie aplikacji
Aby utworzyÊ certyfikat:
1. Uruchom powïokÚ systemowÈ.
Sposoby uruchamiania powïoki (wiersza
poleceñ) omówiïem zarówno dla systemu
Windows, jak i Mac OS X w poprzednim
podrozdziale.
2. Przejdě do katalogu, w którym znajduje siÚ
Twoja aplikacja, wprowadzajÈc polecenie
cd Ăcieĝka_do_aplikacji_AIR i wciskajÈc
klawisz Enter/Return.
Certyfikat najlepiej jest utworzyÊ w tym
samym katalogu, co aplikacjÚ (zakïadam,
ĝe posiadasz aplikacjÚ utworzonÈ wczeĂniej
w tym rozdziale). Musisz zmieniÊ wyĝej
podane polecenie, aby dopasowaÊ je
do poïoĝenia Twojej aplikacji na dysku.
JeĂli chcesz utworzyÊ certyfikat gdzieĂ
indziej (na przykïad na Pulpicie), nic nie stoi
na przeszkodzie, ale musisz skorzystaÊ
z polecenia cd, aby upewniÊ siÚ, czy
na pewno znajdujesz siÚ w katalogu,
w którym chciaïeĂ siÚ znaleěÊ.
3. Wprowadě nastÚpujÈce polecenie i wciĂnij
klawisz Enter/Return (rysunek 2.23).
adt -certificate -cn NazwaCertyfikatu
´1024-RSA plikCertyfikatu.pfx haslo
T
w
o
r
z
e
n
i
e
c
e
r
t
y
f
i
k
a
t
u
Rysunek 2.23. Tworzenie nowego (automatycznie podpisanego) certyfikatu o nazwie
plikCertyfikatu.pfx
37
Rozdziaï 2.
Za pomocÈ tej instrukcji utworzysz
automatycznie podpisany certyfikat (korzystamy
tylko z niezbÚdnych opcji; kursywÈ zaznaczyïem
wartoĂci, które prawdopodobnie bÚdziesz
chciaï zmieniÊ). WartoĂÊ NazwaCertyfikatu
powinna byÊ zmieniona na nazwÚ, którÈ
z reguïy nadajesz certyfikatom. Moĝe to byÊ
nazwa Twojej firmy lub inna wartoĂÊ, która
bÚdzie wskazywaÊ, ĝe jesteĂ twórcÈ aplikacji.
WartoĂÊ plikCertyfikatu.pfx okreĂla nazwÚ
generowanego pliku. Równieĝ w tym miejscu
warto wykorzystaÊ sensownÈ nazwÚ (na przykïad
CertyfikatAplikacji); nie zapomnij jednak
o rozszerzeniu .pfx. Argument haslo okreĂla
hasïo, które bÚdzie skojarzone z certyfikatem
(nie moĝe zawieraÊ polskich znaków).
Trzeba bÚdzie wprowadziÊ je w momencie
kompilowania aplikacji (w jednym z nastÚpnych
kroków).
Oznaczenie 1024-RSA wskazuje, z jakiego
rodzaju klucza korzystamy w przypadku
tego certyfikatu (w ten sposób okreĂlamy siïÚ
klucza, a wiÚc jednÈ z gïównych kwestii
bezpieczeñstwa). Moĝna takĝe skorzystaÊ
z wartoĂci 2048-RSA.
4. Sprawdě zawartoĂÊ katalogu, aby upewniÊ siÚ,
ĝe certyfikat zostaï utworzony poprawnie.
Wskazówki
PeïnÈ listÚ opcji dostÚpnych dla generowania
certyfikatów znajdziesz po wywoïaniu polecenia
adt --help. Moĝesz teĝ przejrzeÊ oficjalnÈ
dokumentacjÚ biblioteki AIR, aby poznaÊ wiÚcej
szczegóïów na ten temat.
Kaĝdy certyfikat wygenerowany przez narzÚdzie
adt bÚdzie unikalny, nawet jeĂli wykonasz te
same czynnoĂci w celu jego wygenerowania.
Przy tworzeniu nowszych wersji swojej aplikacji
pamiÚtaj o podpisaniu jej z wykorzystaniem
tego samego certyfikatu, który zostaï uĝyty
w oryginalnej wersji aplikacji.
38
u
t
a
k
i
f
y
t
r
e
c
e
i
n
e
z
r
o
w
T
Kaĝdy certyfikat generowany samodzielnie
bÚdzie aktualny przez piÚÊ lat od momentu
powstania. Oznacza to, ĝe kaĝda aplikacja
utworzona przy uĝyciu takiego certyfikatu
musi byÊ aktualizowana przynajmniej
raz na piÚÊ lat. Po tym czasie trzeba
opublikowaÊ nowÈ wersjÚ aplikacji,
zawierajÈcÈ nowy certyfikat.
Kompilowanie aplikacji
Po utworzeniu i przetestowaniu aplikacji moĝesz
wykonaÊ kompilacjÚ (nazywanÈ teĝ pakowaniem)
aplikacji. W wyniku tego procesu otrzymasz plik
.air, który moĝesz dostarczaÊ uĝytkownikom
i instalowaÊ.
Skïadnia polecenia adt pozwalajÈca
na skompilowanie aplikacji ma postaÊ:
adt -package -storetype pkcs12 -keystore
´plikCertyfikatu.pfx NazwaAplikacji.air
´DeskryptorAplikacji.xml BazowyPlikHTML.html
Argument -package wskazuje, ĝe chcemy
utworzyÊ aplikacjÚ spakowanÈ. Parametry
-storetype pkcs12 -keystore plikCertyfikatu.pfx
okreĂlajÈ certyfikat, który bÚdzie wykorzystywany
w aplikacji (korzystamy z pliku utworzonego
w poprzednim podrozdziale). NastÚpny argument
definiuje nazwÚ pliku .air, który zostanie
utworzony. Na koñcu podajemy nazwÚ pliku
XML, pliku bazowego HTML i wszystkich
innych plików, które muszÈ byÊ razem spakowane.
Kaĝdy zasób, plik lub folder, wykorzystywany
przez aplikacjÚ, musi byÊ podany w wywoïaniu
polecenia adt.
Tworzenie aplikacji
Aby w procesie kompilacji doïÈczyÊ takĝe
katalogi (to konieczne, jeĂli Twoja aplikacja
bÚdzie zawieraÊ pliki CSS, skrypty JavaScript,
obrazki itd.), musiaïbyĂ skorzystaÊ z polecenia:
adt -package -storetype pkcs12 -keystore
´plikCertyfikatu.pfx NazwaAplikacji.air
´DeskryptorAplikacji.xml BazowyPlikHTML.html
´css icons images js …
Wykorzystajmy zdobytÈ wiedzÚ, aby skompilowaÊ
aplikacjÚ HelloWorld.
Aby skompilowaÊ aplikacjÚ:
1. Uruchom powïokÚ systemowÈ.
Sposoby uruchamiania powïoki (wiersza
poleceñ) omówiïem zarówno dla systemu
Windows, jak i Mac OS X w poprzednim
podrozdziale.
2. Przejdě do katalogu, w którym znajduje siÚ
Twoja aplikacja, wprowadzajÈc polecenie
cd Ăcieĝka_do_aplikacji_AIR i wciskajÈc
klawisz Enter/Return.
Ponownie musisz dostosowaÊ polecenie,
tak aby mogïo ono byÊ wykonane poprawnie
na Twoim komputerze.
3. Wprowadě nastÚpujÈce polecenie i wciĂnij
klawisz Enter/Return (rysunek 2.24).
adt -package -storetype pkcs12
´-keystore /Ăcieĝka/do/certyfikatu/
´plikCertyfikatu.pfx HelloWorld.air
´application.xml HelloWorld.html
K
o
m
p
i
l
o
w
a
n
i
e
a
p
l
i
k
a
c
j
i
Rysunek 2.24. Tworzenie pliku .air przy uĝyciu programu adt (wraz ze spakowaniem wymienionych
elementów)
39
Rozdziaï 2.
Musisz zmieniÊ argument /Ăcieĝka_do_
´certyfikatu/plikCertyfikatu.pfx na
relatywnÈ (wzglÚdem katalogu aplikacji)
ĂcieĝkÚ dostÚpu do Twojego certyfikatu.
Kiedy wykonywaïem to polecenie
(rysunek 2.24), znajdowaïem siÚ w folderze
HelloWorld, wewnÈtrz katalogu Aplikacje
AIR. W katalogu Aplikacje AIR znajduje siÚ
teĝ plik plikCertyfikatu.pfx, dlatego
odwoïujÈc siÚ do tego pliku, podaïem
ĂcieĝkÚ ../plikCertyfikatu.pfx. Zapis
ten oznacza, ĝe w hierarchii katalogów
naleĝy przejĂÊ jeden katalog wyĝej i tam
odszukaÊ plik plikCertyfikatu.pfx. Jedynym
problemem zwiÈzanym z wywoïywaniem
powyĝszego polecenia jest koniecznoĂÊ
wprowadzenia go w jednym wierszu
(nie moĝesz wciskaÊ klawisza Enter/Return
w trakcie podawania tego polecenia).
Po wpisaniu caïego polecenia moĝesz wcisnÈÊ
klawisz Enter/Return. Zostaniesz zapytany
o hasïo certyfikatu.
4. Sprawdě, czy udaïo siÚ poprawnie
skompilowaÊ aplikacjÚ — wystarczy
potwierdziÊ obecnoĂÊ pliku HelloWorld.air
w folderze aplikacji (rysunek 2.25).
5. Zainstaluj i uruchom aplikacjÚ HelloWorld.air,
korzystajÈc z instrukcji podanych
w rozdziale 1.
Wskazówka
NarzÚdzie adt mógïbyĂ wywoïaÊ równieĝ
w nastÚpujÈcy sposób:
adt -package -storetype pkcs12 -keystore
´plikCertyfikatu.pfx NazwaAplikacji.air
´DeskryptorAplikacji.xml .
Kropka na koñcu polecenia reprezentuje
wszystkie pliki i katalogi w bieĝÈcym
katalogu, dziÚki czemu wszystkie pliki trafiÈ
do instalatora aplikacji. Jest to doĂÊ wygodne
rozwiÈzanie, ale niezbyt eleganckie.
Wywoïanie z dokïadnym okreĂleniem
plików wchodzÈcych w skïad instalacji
to z pewnoĂciÈ najlepsze rozwiÈzanie.
i
j
c
a
k
i
l
p
a
e
i
n
a
w
o
l
i
p
m
o
K
40
Rysunek 2.25. Nowo utworzony plik HelloWorld.air moĝe byÊ rozpowszechniany
i wykorzystywany do instalacji naszej aplikacji
Pobierz darmowy fragment (pdf)
