Stáhnout PDF s nápovědou

Transkript

Vývoj aplikací ADOBE AIR 1.1
pomocí programu
ADOBE FLASH CS4 PROFESSIONAL
®
®
®
™
© 2008 Adobe Systems Incorporated. Všechna práva vyhrazena.
Copyright
Vývoj aplikací Adobe® AIR™ 1.1 pomocí programu Adobe® Flash® CS4 Professional
Pokud je tato příručka distribuovaná se softwarem, u kterého je zahrnuta i smlouva s koncovým uživatelem, je tato příručka, stejně jako v ní popisovaný software,
poskytována na základě licence, a může být používána nebo kopírována pouze podle podmínek této licence. S výjimkami povolenými v takové licenci nesmí být
žádná část této příručky reprodukována, ukládána ve vyhledávacím systému a přenášena v jakékoliv formě nebo jakýmikoliv prostředky, elektronickými,
mechanickými, záznamovými nebo jinými, bez předchozího písemného povolení společnosti Adobe Systems Incorporated. Uvědomte si prosím, že obsah této
příručky je chráněn copyrightem i v případě, že není distribuovaná se softwarem, u kterého je zahrnuta i licenční smlouva s koncovým uživatelem.
Obsah této příručky slouží pouze pro informaci, může se měnit bez upozornění a nelze ho vykládat jako závazek společnosti Adobe Systems Incorporated.
Společnost Adobe Systems Incorporated nepřebírá žádnou odpovědnost za chyby nebo nepřesnosti, které se v informačním obsahu této příručky mohou objevit.
Uvědomte si prosím, že existující umělecká díla nebo obrazy, které byste chtěli zahrnout do svých projektů, mohou být chráněny copyrightem. Neautorizované
začlenění takových materiálů do vaší nové práce může být porušením práv majitele copyrightu. Opatřete si prosím vyžadované povolení pro použití díla od
majitele copyrightu.
Všechny odkazy na názvy společností nebo jména osob ve vzorových předlohách jsou pouze pro demonstrační účely a nejsou zamýšleny jako odkaz na
jakoukoliv skutečnou organizaci nebo osobu.
Adobe, the Adobe logo, Acrobat, ActionScript, Adobe AIR, ColdFusion, Dreamweaver, Flash, Flex, Flex Builder, and Reader are either registered trademarks or
trademarks of Adobe Systems Incorporated in the United States and/or other countries.
Microsoft and Windows are either registered trademarks or trademarks of Microsoft Corporation in the United States and/or other countries. Apple, Macintosh,
and Mac OS are trademarks of Apple Inc., registered in the United States and other countries. Java is a trademark or registered trademark of Sun Microsystems,
Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
This product includes software developed by the Apache Software Foundation (http://www.apache.org/)
MPEG Layer-3 audio compression technology licensed by Fraunhofer IIS and Thomson Multimedia (http://www.mp3licensing.com).
Speech compression and decompression technology licensed from Nellymoser, Inc. (www.nellymoser.com)
Video compression and decompression is powered by On2 TrueMotion video technology. © 1992-2005 On2 Technologies, Inc. All Rights Reserved.
http://www.on2.com.
This product includes software developed by the OpenSymphony Group (http://www.opensymphony.com/)
This product contains either BSAFE and/or TIPEM software by RSA Security, Inc.
Sorenson Spark™ video compression and decompression technology licensed from Sorenson Media, Inc.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, California 95110, USA.
Notice to U.S. Government End Users. The Software and Documentation are “Commercial Items,” as that term is defined at 48 C.F.R. §2.101, consisting of
“Commercial Computer Software” and “Commercial Computer Software Documentation,” as such terms are used in 48 C.F.R. §12.212 or 48 C.F.R. §227.7202,
as applicable. Consistent with 48 C.F.R. §12.212 or 48 C.F.R. §§227.7202-1 through 227.7202-4, as applicable, the Commercial Computer Software and
Commercial Computer Software Documentation are being licensed to U.S. Government end users (a) only as Commercial Items and (b) with only those rights
as are granted to all other end users pursuant to the terms and conditions herein. Unpublished-rights reserved under the copyright laws of the United States.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, CA 95110-2704, USA. For U.S. Government End Users, Adobe agrees to comply with all applicable
equal opportunity laws including, if appropriate, the provisions of Executive Order 11246, as amended, Section 402 of the Vietnam Era Veterans Readjustment
Assistance Act of 1974 (38 USC 4212), and Section 503 of the Rehabilitation Act of 1973, as amended, and the regulations at 41 CFR Parts 60-1 through 60-60,
60-250, and 60-741. The affirmative action clause and regulations contained in the preceding sentence shall be incorporated by reference.
iii
Obsah
Kapitola 1: Instalace prostředí Adobe AIR
Systémové požadavky prostředí Adobe AIR
Instalace prostředí Adobe AIR
............................................................................ 1
.......................................................................................... 2
Odinstalace prostředí Adobe AIR
....................................................................................... 2
Instalace a spuštění ukázkových aplikací AIR
............................................................................ 2
Kapitola 2: Instalace aktualizace Adobe AIR pro program Flash CS3
Požadavky na systém pro aktualizaci Adobe AIR pro program Flash CS3
Odinstalování aktualizace Adobe AIR pro program Flash CS3
Instalace aktualizace Adobe AIR pro program Flash CS3
Doplňky prostředí Adobe AIR pro program Flash CS3
................................................. 4
........................................................... 4
................................................................ 5
................................................................... 5
Kapitola 3: Úvod do aplikace Adobe AIR
Kapitola 4: Vyhledávání zdrojů prostředí AIR
Kapitola 5: Vytvoření první aplikace AIR v programu Flash CS3 nebo CS4
Vytvoření aplikace „Hello World“ v programu Flash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Testování aplikace
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Převod aplikace Flash na aplikaci Adobe AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Kapitola 6: Aktualizace Adobe AIR pro program Flash CS3 Professional
Vytvoření souboru Adobe AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Nastavení publikování prostředí Adobe AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
Náhled aplikace Adobe AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Ladění aplikace Adobe AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Vytváření souborů aplikace AIR a instalátoru
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Vytvoření vlastního souboru deskriptoru aplikace
Podepisování aplikace
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Kapitola 7: Zabezpečení aplikace AIR
Základy zabezpečení aplikace AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Instalace a aktualizace
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Karantény zabezpečení
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Zabezpečení HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Skriptování mezi obsahem v různých doménách
Zápis na disk
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Bezpečná práce s nedůvěryhodným obsahem
Nejlepší postupy zabezpečení pro vývojáře
Podepisování kódu
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Kapitola 8: Nastavení vlastností aplikace AIR
Struktura souboru deskriptoru aplikace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Definování vlastností v souboru deskriptoru aplikace
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
VÝVOJ APLIKACÍ ADOBE AIR 1.1 POMOCÍ PROGRAMU ADOBE FLASH CS4 PROFESSIONAL iv
Obsah
Kapitola 9: Nové funkce v aplikaci Adobe AIR
Nové třídy chodu programu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Třídy chodu programu s novými funkcemi
Třídy rámců pro monitorování služeb
Kapitola 10: Práce s nativními okny
Další informace o nativních oknech online
Základní koncepce oken v aplikaci AIR
Vytváření oken
Správa oken
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Poslouchání událostí oken
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Zobrazení oken na celou obrazovku
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Kapitola 11: Obrazovky
Další online informace o obrazovkách
Základní informace o obrazovkách
Výčet obrazovek
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Kapitola 12: Práce s nativními nabídkami
Další informace o nativních nabídkách online
Základní koncepce nabídky AIR
Vytváření nativních nabídek
Kontextové nabídky
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Kontextové nabídky v HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Definování nativních nabídek deklarativním způsobem
Zobrazení rozbalovacích nabídek
Zpracování událostí nabídky
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Příklad: Nabídka okna a aplikace
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
Kapitola 13: Ikony na hlavním panelu
Doplňující online informace o ikonách na hlavním panelu
O ikonách na hlavním panelu
Ikony doku
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Ikony oznamovací oblasti
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Ikony hlavního panelu a tlačítka okna
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96
Kapitola 14: Práce se systémem souborů
Další online informace o souborovém API aplikace AIR
Základy souborů aplikace AIR
Práce s objekty File
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
Získání informací o systému souborů
Práce s adresáři
Práce se soubory
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
Čtení a zápis souborů
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Kapitola 15: Přetažení
Doplňující online informace o přetahování myší
Základy přetažení
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
VÝVOJ APLIKACÍ ADOBE AIR 1.1 POMOCÍ PROGRAMU ADOBE FLASH CS4 PROFESSIONAL v
Obsah
Podpora gesta tažení ven
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Podpora gesta tažení dovnitř
Přetažení HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Kapitola 16: Kopírování a vkládání
Doplňující online informace o kopírování a vkládání
Základy kopírování a vkládání
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Operace čtení a zápis se systémovou schránkou
Kopírování a vkládání v HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Příkazy nabídky a stisknutí kláves pro kopírování a vkládání
Schránka:formáty dat
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
Kapitola 17: Práce s bytovými poli
Čtení a zapisování do objektu ByteArray
Příklad ByteArray: Čtení souboru .zip
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
Kapitola 18: Práce s lokálními databázemi SQL
Další online dostupné informace o lokálních databázích SQL
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
O lokálních databázích SQL
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Vytváření a úpravy databáze
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
Manipulace s daty databází SQL
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
Použití synchronních a asynchronních operací databáze
Strategie pro práci s databázemi SQL
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
Kapitola 19: Ukládání šifrovaných dat
Kapitola 20: Prostředí HTML
Přehled prostředí HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
Rozšíření prostředí AIR a modulu Webkit
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
Kapitola 21: Programování v jazycích HTML a JavaScript
Popis třídy HTMLLoader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
Zamezení vzniku chyb jazyka JavaScript souvisejících se zabezpečením
Přístup ke třídám API aplikace AIR z jazyka JavaScript
Popis URL v aplikaci AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Zpřístupňování objektů ActionScript pro JavaScript
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
Přístup k objektovému modelu dokumentu HTML a objektům JavaScript z jazyka ActionScript
Vložení obsahu SWF do HTML
. . . . . . . . . . . . . . . . . . . . . . . . 216
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
Použití knihoven jazyka ActionScript na stránce HTML
Převádění objektů Date a RegExp
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
Práce se seznamem stylů HTML z jazyka ActionScript
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
Vytváření křížových skriptů pro obsah v různých karanténách zabezpečení
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Kapitola 22: Zpracování událostí týkajících se HTML
Události HTMLLoader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
Zpracování událostí DOM pomocí jazyka ActionScript
Reagování na nezachycené výjimky JavaScript
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
Zpracování událostí chodu programu pomocí jazyka JavaScript
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
VÝVOJ APLIKACÍ ADOBE AIR 1.1 POMOCÍ PROGRAMU ADOBE FLASH CS4 PROFESSIONAL vi
Obsah
Kapitola 23: Skriptování kontejneru HTML
Vlastnosti zobrazení objektů HTMLLoader . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
Rolování obsahu HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Přístup k seznamu historie HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Nastavení agenta uživatele použitého při načítání obsahu HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Nastavení kódování znaků, které bude použito pro obsah HTML.
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Definování uživatelských rozhraní podobných prohlížeči pro obsah HTML.
Vytváření podtříd třídy HTMLLoader
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Kapitola 24: Přidávání obsahu PDF
Zjišťování schopností PDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
Načítání obsahu PDF
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Skriptování obsahu PDF
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Známá omezení obsahu PDF v aplikaci AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Kapitola 25: Použití správy digitálních práv
Další informace o správě digitálních práv online
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
Popis toku operací při zpracování zašifrovaných souborů FLV
Změny ve třídě NetStream
Použití třídy DRMStatusEvent
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
Použití třídy DRMAuthenticateEvent
Použití třídy DRMErrorEvent
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256
Kapitola 26: Možnosti spuštění a ukončení aplikací
Vyvolání aplikací . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
Zachycení argumentů příkazového řádku
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
Spuštění při přihlášení
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Vyvolání z prohlížeče
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
Ukončení aplikace
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264
Kapitola 27: Čtení nastavení aplikace
Čtení souboru deskriptoru aplikace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Získávání identifikátorů aplikace a vydavatele
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Kapitola 28: Práce s runtime a informacemi operačního systému
Správa asociací souboru . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
Získávání verze runtime a úrovně dočasné opravy.
Zjišťování možností AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Sledování přítomnosti uživatele
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
Kapitola 29: Sledování připojení k síti
Zjišťování změn síťového připojení . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Základní informace o sledování služeb
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Zjišťování připojení pomocí protokolu HTTP
Zjišťování soketového připojení
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270
VÝVOJ APLIKACÍ ADOBE AIR 1.1 POMOCÍ PROGRAMU ADOBE FLASH CS4 PROFESSIONAL vii
Obsah
Kapitola 30: Požadavky URL a práce v síti
Používání třídy URLRequest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
Změny v třídě URLStream
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Otevření URL ve výchozím systémovém webovém prohlížeči
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Kapitola 31: Distribuce, Instalace a Spuštění aplikací AIR
Instalace a spuštění aplikace AIR z pracovní plochy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Instalace a spuštění aplikací AIR z webové stránky
Nasazení firmy
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
Digitální podepisování souboru AIR
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Kapitola 32: Aktualizace aplikací AIR
O aktualizaci aplikací . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
Představení vlastního uživatelského rozhraní pro aktualizaci aplikace
Stažení souboru AIR do počítače uživatele
Zjištění, zda je aplikace spuštěná poprvé
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Kapitola 33: Lokalizace aplikací AIR
Úvod do lokalizace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Lokalizace názvu aplikace a popisu v instalačním programu aplikace
Výběr lokální verze
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Lokalizace obsahu Flash
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Lokalizace obsahu HTML
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296
Lokalizace data, času a měny
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
Kapitola 34: Vytváření aplikace AIR pomocí nástrojů příkazového řádku
Použití programu AIR Debug Launcher (ADL) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Zabalení instalačního souboru AIR pomocí programu AIR Developer Tool (ADT)
Podepsání souboru AIR pro změnu certifikátu aplikace
Vytvoření certifikátu s vlastním podpisem pomocí programu ADT
Použití nástroje Apache Ant s nástroji sady SDK
Rejstřík
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
1
Kapitola 1: Instalace prostředí Adobe AIR
Adobe® AIR™ umožňuje spouštění aplikací AIR na pracovní ploše. Modul runtime můžete nainstalovat následujícími
způsoby:
• Samostatnou instalací modulu runtime (aniž byste instalovali i některou aplikaci AIR)
• První instalací aplikace AIR (budete rovněž vyzváni k instalaci modulu runtime)
• Instalací některého vývojového prostředí AIR, jako je například AIR SDK, Adobe® Flex™ Builder™ 3 nebo Adobe
Flex™ 3 SDK (které zahrnuje vývojářské nástroje příkazového řádku AIR)
Modul runtime může být nainstalován v každém počítači pouze jednou.
Systémové požadavky prostředí Adobe AIR
Systémové požadavky pro spouštění prostředí Adobe AIR jsou následující:
• Pro základní aplikace Adobe AIR:
Procesor
Windows
Macintosh
Intel® Pentium® 1,0 GHz nebo rychlejší
PowerPC® G3 1,0 GHz nebo rychlejší nebo
Intel Core™ Duo 1,83 GHz nebo rychlejší
Paměť
256 MB paměti RAM
256 MB paměti RAM
Operační systém
Windows 2000 Service Pack 4;
Mac OS X 10.4.10 nebo 10.5.x (PowerPC);
Windows XP SP2;
Mac OS X 10.4.x nebo 10.5.x (Intel)
Vista
• Pro aplikace Adobe AIR využívající video v režimu celé obrazovky s hardwarovými změnami měřítka:
Procesor
Windows
Macintosh
Intel® Pentium® 2,0 GHz nebo rychlejší
PowerPC® G4 1,8 GHz nebo rychlejší nebo
Intel Core™ Duo 1,33 GHz nebo rychlejší
Paměť
512 MB paměti RAM; 32 MB videopaměti RAM
256 MB paměti RAM; 32 MB videopaměti RAM
Operační systém
Windows 2000 Service Pack 4;
Mac OS X v.10.4.10 nebo v.10.5 (Intel nebo
PowerPC)
Windows XP SP2;
Vista
POZNÁMKA: Kodek používaný pro zobrazení
videa ve formátu H.264 vyžaduje procesor Intel
VÝVOJ APLIKACÍ ADOBE AIR 1.1 POMOCÍ PROGRAMU ADOBE FLASH CS4 PROFESSIONAL 2
Podle následujících pokynů si stáhněte verzi prostředí AIR pro operační systémy Windows® nebo Mac OS X.
Aby mohl uživatel aktualizovat modul runtime, musí mít k počítači oprávnění správce.
Instalace modulu runtime v počítači s operačním systémem Windows
1 Stáhněte si instalační soubor modulu runtime.
2 Poklepejte na instalační soubor modulu runtime.
3 Instalaci dokončete podle výzev v instalačním okně.
Instalace modulu runtime v počítači Macintosh
1 Stáhněte si instalační soubor modulu runtime.
2 Poklepejte na instalační soubor modulu runtime.
3 Instalaci dokončete podle výzev v instalačním okně.
4 Pokud se v instalačním programu zobrazí okno Authenticate (Ověřit), zadejte jméno uživatele operačního systému
Mac OS a heslo.
Odinstalace prostředí Adobe AIR
Nainstalovaný modul runtime prostředí AIR můžete odinstalovat následujícími postupy.
Odinstalace modulu runtime z počítače s operačním systémem Windows
1 V nabídce Start operačního systému Windows vyberte položku Nastavení > Ovládací panely.
2 Vyberte ovládací panel Přidat nebo odebrat programy.
3 Abyste mohli odinstalovat modul runtime, vyberte položku Adobe AIR.
4 Klepněte na tlačítko Změnit nebo odebrat.
Odinstalace modulu runtime z počítače Macintosh
• Poklepejte na položku Adobe AIR Uninstaller, která se nachází ve složce /Applications (Aplikace).
Instalace a spuštění ukázkových aplikací AIR
K dispozici je několik ukázkových aplikací, které slouží k předvádění funkcí prostředí AIR. Pro přístup a instalaci
můžete použít následující pokyny:
1 Stáhněte si a spusťte ukázkové aplikace AIR. K dispozici jsou kompilované aplikace i zdrojový kód.
2 Chcete-li stáhnout a spustit ukázkovou aplikaci, klepněte na tlačítko ukázkové aplikace Instalovat. Zobrazí se výzva
k instalaci a spuštění aplikace.
3 Pokud se rozhodnete stáhnout ukázkové aplikace a spouštět je později, vyberte odkazy na stažení. Aplikace AIR
můžete spouštět kdykoli následujícím postupem:
• V operačním systému Windows poklepejte na ikonu aplikace na ploše nebo ji vyberte v nabídce Start.
• V operačním systému Mac OS poklepejte na ikonu aplikace, která je ve výchozím nastavení nainstalována ve
složce Applications (Aplikace) ve vašem uživatelském adresáři (například Macintosh
HD/Users/JoeUser/Applications/).
Poznámka: V poznámkách k verzi prostředí AIR vyhledejte aktualizace těchto pokynů, které se nacházejí zde:
http://www.adobe.com/go/learn_air_relnotes_cz.
4
Kapitola 2: Instalace aktualizace Adobe
AIR pro program Flash CS3
Aktualizace Adobe® AIR™ pro program Adobe® Flash® CS3 Professional rozšiřuje vývojové prostředí programu Flash
o části, které slouží k vytváření aplikací AIR pomocí programu Flash. Umožňuje v programu Flash vytvářet, testovat
a ladit soubory aplikací AIR.
Program Adobe® Flash® CS4 Professional má zabudovanou podporu pro vytváření aplikací AIR. Další informace viz
část Publikování pro prostředí Adobe AIR v dokumentu Používání programu Flash.
Požadavky na systém pro aktualizaci Adobe AIR pro
program Flash CS3
Abyste mohli program Flash CS3 používat k vývoji a spouštění aplikací AIR, musí být nainstalován následující
software:
• Flash CS3 Professional
Pokud program Flash CS3 Professional nemáte, můžete ho zakoupit na webu společnosti Adobe na adrese:
http://www.adobe.com/products/flash/.
• Adobe AIR
Informace o instalaci prostředí Adobe AIR naleznete v části „Instalace prostředí Adobe AIR“ na stránce 1.
• Aktualizace Adobe AIR pro program Flash CS3
Pokud jste již dříve nainstalovali nějakou verzi aktualizace Adobe AIR pro program Flash CS3, postupujte podle
pokynů v tématu Odinstalování aktualizace Adobe AIR pro program Flash CS3 a nejdříve tuto aktualizaci odinstalujte.
Pokud jste aktualizaci Adobe AIR pro program Flash CS3 zatím neinstalovali, přejděte do části „Instalace aktualizace
Adobe AIR pro program Flash CS3“ na stránce 5.
Odinstalování aktualizace Adobe AIR pro program Flash
CS3
Pokud jste aktualizaci Adobe AIR pro program Flash CS3 nainstalovali již dříve, postupujte podle těchto pokynů a
před instalací nové aktualizace Adobe AIR pro program Flash CS3 ji odinstalujte.
1 Odstraňte následující složku:
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\AIK
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/AIK
2 Přejděte do následujícího umístění:
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\<jazyk>\First Run\Commands\
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/First Run/Commands
a odstraňte následující soubory nebo složky:
• Složku AIR
• AIR - Application and Installer Settings.jsfl
• AIR - Create AIR File.jsfl
3 Odstraňte následující soubor:
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\<jazyk>\Configuration\External
Libraries\FLAir.dll
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/Configuration/External Libraries/FLAir.bundle.
4 Odstraňte následující soubor:
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash
CS3\<jazyk>\Configuration\Players\AdobeAIR1_0.xml
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/Configuration/Players/ AdobeAIR1_0.xml
5 Přejděte do následujícího umístění:
(Systém Windows) [jednotka]:\Document and Settings\<jméno_uživatele>\Local Settings\Data
aplikací\Adobe\Flash CS3\<jazyk>\Configuration\Commands\
(Počítače Mac) [jednotka]:/Users/<jméno_uživatele>/Library/Application Support/Adobe/Flash
CS3/<jazyk>/Configuration/Commands/
a odstraňte následující soubory nebo složky:
• Složku AIR
• AIR - Application and Installer Settings.jsfl
• AIR - Create AIR File.jsfl
Poznámka: Pokud uvedená umístění v systému Windows nevidíte, zaškrtněte ve volbách složky přepínací tlačítko
Zobrazovat skryté soubory a složky.
Před instalací aktualizace Adobe AIR pro program Flash CS3 ukončete program Flash a všechny otevřené prohlížeče.
• Stáhněte aktualizaci Adobe AIR pro program Flash CS3.
• Až aktualizaci stáhnete, nainstalujte ji poklepáním na soubor aktualizace.
Doplňky prostředí Adobe AIR pro program Flash CS3
Po nainstalování aktualizace Adobe AIR dojde v programu Flash k následujícím změnám:
• Nová položka pro prostředí Adobe AIR 1.0 v nabídce Verze na kartě Flash v dialogovém okně Nastavení
publikování (Soubor > Nastavení publikování)
• Aktualizovaná úvodní obrazovka obsahující položku pro vytvoření souboru Flash (Adobe AIR)
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\en\FirstRun\StartPage
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\en\FirstRun\StartPage\resources
Poznámka: Pokud se na počítačích Macintosh neobjeví na úvodní obrazovce položka pro soubor Flash (Adobe
AIR), odstraňte následující složku a restartujte program Flash:
[jednotka]:/Users/<jméno_uživatele>/Libraries/Application Support/Adobe/Flash
CS3/<jazyk>/Configuration/StartPage
• Nový soubor playerglobal.swc obsahující všechna rozhraní API jazyka ActionScript 3.0 a rozhraní API prostředí
Adobe AIR ve složce ActionScript 3.0/Classes
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\en\Configuration\ActionScript 3.0 Classes
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/Configuration/ActionScript 3.0/Classes/
• Nové soubory jsfl (AIR - Application and Installer Settings.jsfl, AIR - Publish AIR File.jsfl)
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\en\FirstRun\Commands
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/First Run/Commands/
• Sada Adobe AIR Software Development Kit (AIK)
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\AIK
• Externí knihovna
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\en\Configuration\External Libraries
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/Configuration/External Libraries/
• Cílový konfigurační soubor
(Systém Windows) [jednotka]:\Program Files\Adobe\Adobe Flash CS3\en\Configuration\Players\
(Počítače Mac) [jednotka]:/Applications/Adobe Flash CS3/Configuration/Players/
7
Kapitola 3: Úvod do aplikace Adobe AIR
Aplikace Adobe® AIR™ je běhový modul nezávislý na operačním systému, pomocí něhož lze využít existující
schopnosti vyvíjení webu (Adobe® Flash® CS3 Professional, Adobe® Flex™, HTML, JavaScript®, Ajax) při vytváření a
implementaci aplikací RIA (Rich Internet Applications).
Aplikace AIR umožňuje práci ve známém prostředí, takže je možné využívat nástroje a postupy, které jsou pro
vývojáře nejpohodlnější. Tím, že podporuje technologii Flash, Flex, HTML, JavaScript a Ajax, umožňuje vytvoření co
nejlepší aplikace vyhovující vašim potřebám.
Při vývoji aplikací je například možné využít některou z následujících technologií nebo jejich kombinaci:
• Flash / Flex / ActionScript
• HTML / JavaScript / CSS / Ajax
• PDF lze použít s jakoukoliv aplikací
V důsledku toho aplikace AIR mohou být:
• založené na technologii Flash nebo Flex: aplikace, jejichž základní obsah je ve formátu Flash/Flex (SWF);
• založené na technologii Flash nebo Flex s formátem HTML nebo PDF: aplikace, jejichž základní obsah je ve
formátu Flash/Flex (SWF) a zahrnuje obsah ve formátu HTML (HTML, JS, CSS) nebo PDF;
• založené na HTML: aplikace, jejichž základní obsah je ve formátu HTML, JS, CSS;
• založené na HTML s formátem Flash/Flex (SWF) nebo PDF: aplikace, jejichž základní obsah je ve formátu HTML
a zahrnuje obsah ve formátu Flash/Flex (SWF) nebo PDF.
Uživatelé interaktivně pracují s aplikacemi AIR stejným způsobem jako s nativními počítačovými aplikacemi. Běhový
modul se jednou nainstaluje v počítači uživatele a aplikace AIR se pak instalují a spouští stejně jako kterákoliv jiná
počítačová aplikace.
Běhový modul poskytuje jednotnou platformu nezávislou na operačním systému a pevný rámec pro zavádění aplikací,
takže eliminuje testování napříč prohlížeči, neboť zajišťuje jednotnou funkčnost a stejné interakce mezi různými
počítači. Místo toho, aby se aplikace vyvíjela pro určitý operační systém, zaměří se běhový modul, což přináší
následující výhody:
• Aplikace vyvinuté pro aplikaci AIR lze spouštět v různých operačních systémech, aniž by to pro vývojáře
znamenalo další práci. Běhový modul zajišťuje jednotnou prezentaci dat a předvídatelné interakce napříč všemi
operačními systémy, které aplikace AIR podporuje.
• Aplikace lze vytvářet rychleji, neboť je možné využít existující webové technologie a návrhové vzory a zavést tak
webové aplikace do počítače bez toho, aby bylo potřeba znát tradiční počítačové vývojové technologie nebo složitý
nativní kód.
• Vyvíjení aplikací je jednodušší než při použití jazyků nižší úrovně, například C a C++. Není potřeba spravovat
složitá rozhraní API nižší úrovně specifická pro jednotlivé operační systémy.
Při vyvíjení aplikací pro aplikaci AIR lze využít pestrou škálu technologií a rozhraní API:
• Rozhraní API specifická pro aplikaci AIR, jež poskytuje běhový modul a technologie AIR
• Rozhraní API jazyka ActionScript používaná v souborech SWF a v technologii Flex (jakož i v dalších knihovnách
a technologiích založených na jazyce ActionScript)
Úvod do aplikace Adobe AIR
• HTML, CSS a JavaScript
• Většina technologií Ajax
Aplikace AIR výrazně mění způsob vytváření, zavádění a používání aplikací. Zajišťuje mnohem větší kreativní
kontrolu a zavádění aplikací založených na technologiích Flash, Flex, HTML a Ajax do počítače, aniž by bylo potřeba
znát tradiční počítačové vývojové technologie.
9
Kapitola 4: Vyhledávání zdrojů prostředí
AIR
Další informace o vývoji aplikací prostředí Adobe® AIR™ naleznete v následujících zdrojích:
Zdroj
Umístění
Programování v jazyce ActionScript 3.0
http://www.adobe.com/go/learn_fl_cs4_programmingAS3_en
Referenční příručka jazyka ActionScript 3.0 a jeho
komponent (zahrnuje prostředí AIR)(
http://www.adobe.com/go/learn_flashcs4_langref_en
Adobe AIR – stručné úvody pro aplikaci Flash
http://www.adobe.com/go/learn_air_flash_qs_cz
Používání aplikace Flash
http://www.adobe.com/go/learn_fl_cs4_using_en
Používání komponent jazyka ActionScript 3.0
http://www.adobe.com/go/learn_fl_cs4_as3components_en
Na stránkách Adobe AIR Developer Connection na adrese http://www.adobe.com/devnet/air/ naleznete články,
ukázky a prezentace odborníků ze společnosti Adobe a z komunity. Z těchto stránek si rovněž můžete stáhnout
prostředí Adobe AIR a související software.
Na stránkách http://www.adobe.com/devnet/air/flash/ naleznete oddíl určený konkrétně pro vývojáře aplikace Flash.
Navštivte web podpory společnosti Adobe na adrese http://www.adobe.com/support/, kde najdete informace o
odstraňování problémů pro váš produkt a dozvíte se o možnostech bezplatné i placené technické podpory. Pomocí
odkazu Školení získáte přístup ke knihám nakladatelství Adobe Press, různým výukovým zdrojům, programům
certifikací pro software Adobe a dalším informacím.
10
Kapitola 5: Vytvoření první aplikace AIR
v programu Flash CS3 nebo CS4
Toto téma nabízí rychlou a praktickou ukázku toho, jakým způsobem pracuje prostředí Adobe ® AIR™. Postupujte
podle pokynů a vytvořte a zabalte jednoduchou aplikaci AIR „Hello World“.
Pokud jste to ještě neudělali, stáhněte a nainstalujte aktualizaci Adobe AIR pro program Flash CS3. Další informace o
instalaci prostředí Adobe AIR pro program Flash CS3 naleznete v části „Instalace aktualizace Adobe AIR pro program
Flash CS3“ na stránce 4.
Pokud používáte program Flash CS4, je podpora prostředí Adobe AIR již zabudována a abyste mohli začít, nemusíte
nic instalovat.
Vytvoření aplikace „Hello World“ v programu Flash
Vytvoření aplikace Adobe AIR v programu Flash se velice podobá vytvoření jakékoli jiné aplikace Flash. Rozdíl je v
tom, že začínáte vytvořením souboru Flash (Adobe AIR) z úvodní obrazovky a postup uzavřete vytvořením nastavení
aplikace a instalátoru a instalací své aplikace AIR. Následující postup vás provede procesem vytvoření jednoduché
aplikace „Hello World“.
Vytvoření aplikace „Hello World“
1 Spusťte program Flash.
2 Klepněte na úvodní obrazovce na příkaz Soubor Flash (Adobe AIR), abyste vytvořili prázdný soubor FLA s
nastavením publikování prostředí Adobe AIR.
3 Na přehledové dialogové okno Vývoj pro prostředí Adobe AIR pomocí programu Flash CS3 reagujte klepnutím na
tlačítko OK. Poprvé je na toto dialogové okno třeba několik sekund čekat. (Toto dialogové okno se v programu
Flash CS4 nezobrazuje.)
4 Vyberte v panelu Nástroje textový nástroj a vytvořte ve středu vymezené plochy pole statického textu (výchozí
volba). Pole musí být dostatečně široké, aby obsáhlo 15–20 znaků.
5 Zadejte do tohoto textového pole text „Hello World“.
6 Uložte soubor a pojmenujte ho (například „helloAIR“).
Testování aplikace
1 Chcete-li aplikaci otestovat v prostředí Adobe AIR, stiskněte klávesy Ctrl+Enter nebo vyberte příkaz Ovládání >
Testovat film.
2 Abyste mohli použít funkci Ladit film, musíte nejdříve do aplikace přidat kód jazyka ActionScript. Toho rychle
dosáhnete, když přidáte příkaz trace, jako je například tento:
trace("Running AIR application using Debug Movie");
3 Chcete-li aplikaci spustit s funkcí Ladit film, stiskněte klávesy Ctrl+Shift+Enter nebo vyberte příkaz Ovládání >
Ladit film.
Vytvoření první aplikace AIR v programu Flash CS3 nebo CS4
4 Chcete-li v programu Flash CS3 otevřít dialogové okno AIR – Nastavení aplikace a instalátoru, vyberte příkaz
Příkazy > AIR – Nastavení aplikace a instalátoru. Toto dialogové okno lze v programu Flash CS4 otevřít výběrem
příkazu Soubor > Nastavení AIR.
5 Podpis balíčku Adobe AIR pomocí digitálního certifikátu s vlastním podpisem:
a Klepněte na tlačítko Nastavit, aby výzva Digitální podpis otevřela dialogové okno digitálního podpisu.
b Klepnutím na tlačítko Vytvořit otevřete dialogové okno Vytvořit digitální certifikát s vlastním podpisem.
c Vyplňte položky Jméno vydavatele, Útvar organizace, Název organizace, E-mail, Země, Heslo a Potvrzení hesla.
d Určete typ certifikátu. Volba typu certifikátu označuje úroveň zabezpečení: 1024-RSA používá 1024bitový klíč
(méně zabezpečený), 2048-RSA 2048bitový (více zabezpečený).
e Uložte informaci do souboru certifikátu – vyplňte položku Uložit jako nebo přejděte do umístění složky po
klepnutí na tlačítko Procházet. (Například C:/Temp/mujcert.pfx). Po dokončení klepněte na tlačítko OK.
f
Program Flash vás vrátí do dialogového okna Digitální podpis. V textovém poli Certifikát se objeví cesta a název
souboru certifikátu s vlastním podpisem, který jste vytvořili. Pokud k tomu nedojde, zadejte cestu a název
souboru nebo je najděte a vyberte po klepnutí na tlačítko Procházet.
g Zadejte do pole Heslo dialogového okna Digitální podpis stejné heslo, jako bylo heslo přiřazené v kroku c, a
klepněte na tlačítko OK. Další informace o podepisování aplikací Adobe AIR naleznete v části „Podepisování
aplikace“ na stránce 21.
Vytvoření první aplikace AIR v programu Flash CS3 nebo CS4
6 Chcete-li vytvořit soubor aplikace a instalátoru, klepněte na tlačítko Publikovat soubor AIR. Abyste vytvořili
soubory SWF a soubory .xml aplikace před vytvořením souboru AIR, musíte nejdříve spustit příkaz Testovat film
nebo Ladit film.
7 Chcete-li aplikaci nainstalovat, poklepejte na soubor AIR (aplikace.air), který je umístěný ve stejné složce, do které
jste svou aplikaci uložili.
8 V dialogovém okně Instalace aplikace klepněte na tlačítko Instalovat.
9 Zkontrolujte nastavení instalačních předvoleb a umístění a ujistěte se, zda je zaškrtnuto zaškrtávací políčko Spustit
aplikaci po dokončení instalace. Pak klepněte na tlačítko Pokračovat.
10 Až se objeví zpráva o dokončení instalace, klepněte na tlačítko Dokončit.
Aplikace „Hello World“ vypadá jako v této ukázce:
Převod aplikace Flash na aplikaci Adobe AIR
Můžete také převést existující aplikaci Flash na aplikaci AIR. Informace o tom, jak tuto akci provést v programu Flash
CS3, najdete v části „Nastavení publikování prostředí Adobe AIR“ na stránce 13. Pokud používáte program Flash CS4,
viz část Publikování pro prostředí Adobe AIR v dokumentu Používání programu Flash.
13
Kapitola 6: Aktualizace Adobe AIR pro
program Flash CS3 Professional
Aktualizace Adobe® AIR™ pro program Adobe® Flash® CS3 Professional rozšiřuje vývojové prostředí s cílem umožnit
vám vytváření, ladění a balení aplikací Adobe AIR pomocí programu Flash. Proces vytvoření aplikace Adobe AIR
spočívá ve vytvoření souboru Adobe AIR ve formátu FLA, nastavení příslušných nastavení publikování, vývoji
aplikace a vytvoření souborů aplikace a instalátoru, které vám umožní její nasazení.
Pokud používáte program Adobe® Flash® CS4 Professional, najdete další informace o vytváření aplikací AIR v části
Publikování pro prostředí Adobe AIR dokumentu Používání programu Flash.
Informace o rozhraních API jazyka ActionScript™ prostředí Adobe AIR naleznete v dokumentu Referenční příručka
jazyka ActionScript 3.0 a jeho komponent.
Seznam rozhraní API jazyka ActionScript prostředí Adobe AIR naleznete v části „Nové funkce v aplikaci Adobe AIR“
na stránce 50.
Poznámka: Chcete-li používat třídy v balíčku air.net, přetáhněte nejdříve z panelu Komponenty do panelu Knihovna
komponentu ServiceMonitorShim a pak přidejte následující příkaz import do kódu jazyka ActionScript 3.0:
import air.net.*;
Vytvoření souboru Adobe AIR
Dokumenty ve formátu souborů Flash (Adobe AIR) můžete vytvořit pomocí úvodní obrazovky programu Flash. Také
můžete vytvořit soubor Flash (ActionScript™ 3.0) a tento soubor převést na soubor Adobe AIR pomocí dialogového
okna Nastavení publikování. Soubor Adobe AIR ale nelze vytvořit pomocí dialogového okna Nový dokument (Soubor
> Nový). Informace o převodu souboru Flash na soubor Adobe AIR naleznete v části „Nastavení publikování prostředí
Adobe AIR“ na stránce 13.
1 Spusťte program Flash, nebo v případě, že jste program Flash již spustili, zavřete všechny otevřené dokumenty a
vraťte se na úvodní obrazovku.
Poznámka: Pokud jste úvodní obrazovku programu Flash zakázali, můžete ji znovu zobrazit. Vyberte příkaz Úpravy
> Předvolby a v kategorii Všeobecné vyberte z rozbalovací nabídky Při spuštění možnost Úvodní obrazovka.
2 Klepněte na úvodní obrazovce na položku Soubor Flash (Adobe AIR).
Objeví se výstražné dialogové okno, které vás informuje o způsobu přístupu k nastavení aplikací Adobe AIR a
dokumentaci nápovědy. Vyberete-li možnost (Příště nezobrazovat), můžete tuto výstrahu v budoucnu přeskočit.
Neexistuje ale způsob, jak tuto výstrahu znovu zobrazit.
Nastavení publikování prostředí Adobe AIR
Nastavení publikování programu Flash slouží k prozkoumání nebo změně nastavení souboru AIR nebo převodu
dokumentu ve formátu souboru Flash (ActionScript 3.0) na dokument ve formátu souboru Flash (Adobe AIR).
Aktualizace Adobe AIR pro program Flash CS3 Professional
Zobrazení nastavení publikování prostředí Adobe AIR
1 Otevřete z úvodní obrazovky programu Flash dokument ve formátu souboru Flash (Adobe AIR).
2 Vyberte příkaz Soubor > Nastavení publikování a zobrazte nastavení publikování prostředí Adobe AIR klepnutím
na záložku Flash.
Když otevřete dokument Adobe AIR, je v nabídce Verze automaticky vybrána verze Adobe AIR 1.0. Verze jazyka
ActionScript™ je automaticky nastavena na verzi ActionScript 3.0. Nastavení Lokální zabezpečení přehrávání je
ztlumeno, protože nemá pro soubor SWF prostředí AIR žádný význam.
Pokud jste otevřeli soubor FLA programu Flash, můžete tento soubor převést na soubor Flash prostředí AIR tím, že
změníte nastavení publikování.
Převod souboru FLA programu Flash na soubor Flash prostředí AIR pomocí dialogového okna Nastavení
publikování
1 Proveďte jeden z následujících úkonů:
• Otevřete existující soubor Flash.
• Otevřete nový soubor Flash pomocí úvodní obrazovky nebo výběrem příkazu Soubor > Nový.
2 Vyberte příkaz Soubor > Nastavení publikování.
3 Na záložce Flash vyberte z rozbalovací nabídky Verze možnost Adobe AIR 1.0.
Položka verze jazyka ActionScript je zakázána, protože jedinou volbou pro soubor AIR je verze ActionScript 3.0.
Ostatní výchozí volby jsou pro soubor Flash i soubor Adobe AIR shodné.
4 Klepněte na tlačítko Publikovat a pak zavřete dialogové okno Nastavení publikování klepnutím na tlačítko OK.
Když je vybrán nástroj pro výběr, inspektor vlastností nyní udává, že cílová verze přehrávače je Adobe AIR 1.
Poznámka: Zvolíte-li profil Adobe AIR 1.0, přidá program Flash do proměnné prostředí Classpath umístění souboru
playerglobal.swc prostředí AIR automaticky. Soubor playerglobal.swc prostředí AIR umožňuje, abyste mohli používat
rozhraní API jazyka ActionScript prostředí AIR. Pokud ale přepnete z profilu Adobe AIR 1 na profil Adobe® Flash®
Player 9, nepřejde program Flash zpět na výchozí profil ani nezmění nastavení proměnné Classpath tak, aby používal
soubor playerglobal.swc i pro profil Flash Player 9. Pokud změníte nastavení publikování z profilu Adobe AIR 1 na
Flash Player 9, musíte změnit profil publikování na Výchozí.
Další informace o dialogovém okně Nastavení publikování naleznete v tématu Používání programu Flash na adrese
www.adobe.com/go/learn_fl_using_cz.
Převod souboru FLA programu Flash na soubor Flash prostředí AIR pomocí nabídky Příkazy
1 Otevřete soubor FLA programu Flash.
2 Pokud otevíráte nový soubor Flash (ActionScript 3.0), soubor uložte. Pokud soubor neuložíte, objeví se při
provedení následujícího kroku varování.
3 Vyberte příkaz Příkazy > AIR – Nastavení aplikace a instalátoru.
Objeví se výstražné dialogové okno s dotazem, zda chcete soubor převést na nastavení publikování prostředí Adobe AIR.
4 Chcete-li soubor FLA převést na nastavení publikování prostředí Adobe AIR, klepněte na tlačítko OK. Objeví se
dialogové okno AIR – Nastavení aplikace a instalátoru.
Informace o dialogovém okně AIR – Nastavení aplikace a instalátoru naleznete v části „Vytváření souborů aplikace
AIR a instalátoru“ na stránce 15.
Na převedeném souboru FLA prostředí AIR můžete používat příkazy Testovat film, Ladit film a Vytvořit soubor AIR.
Náhled aplikace Adobe AIR
Můžete si zobrazit náhled soubor SWF programu Flash pro prostředí AIR, který bude vypadat stejně, jako by byl
zobrazen v okně aplikace AIR. Zobrazení náhledu je užitečné v situaci, kdy chcete zobrazit viditelné aspekty vzhledu
aplikace a přitom nechcete aplikaci balit a instalovat.
1 Ujistěte se, zda jste nastavili nastavení publikování pro aplikaci Adobe AIR. Další informace naleznete v části
„Nastavení publikování prostředí Adobe AIR“ na stránce 13.
2 Vyberte příkaz Ovládání > Testovat film nebo stiskněte klávesy Ctrl+Enter.
Pokud jste nenastavili nastavení aplikace pomocí dialogového okna AIR – Nastavení aplikace a instalátoru, vytvoří
program Flash do stejné složky, do které zapíše soubor SFW, výchozí soubor deskriptoru aplikace
( název_souboru_swf-app.xml). Pokud jste nastavili nastavení aplikace pomocí dialogového okna AIR – Nastavení
aplikace a instalátoru, používá soubor deskriptoru aplikace tato nastavení.
Ladění aplikace Adobe AIR
Až na možnost vzdáleného ladění můžete soubor SWF Adobe AIR ladit stejným způsobem jako soubor SWF jazyka
ActionScript 3.0 přehrávače Flash Player 9.
1 Zkontrolujte, zda jste nastavili nastavení publikování prostředí Adobe AIR.
2 Přidejte do panelu Akce kód jazyka ActionScript (Okno > Akce). Za účelem testování stačí na panelu Akce do
prvního snímku časové osy jednoduše přidat příkaz trace(), podobný následujícímu:
trace("My application is running");
3 Vyberte příkaz Ladění > Ladit film nebo stiskněte klávesy Ctrl+Shift+Enter.
Program Flash spustí debugger jazyka ActionScript a exportuje soubor SWF i s informací o ladění.
Pokud jste nenastavili nastavení aplikace pomocí dialogového okna AIR – Nastavení aplikace a instalátoru, vytvoří
program Flash do stejné složky, do které zapíše soubor SFW, výchozí soubor deskriptoru aplikace
( název_souboru_swf-app.xml). Pokud jste nastavili nastavení aplikace pomocí dialogového okna AIR – Nastavení
aplikace a instalátoru, používá soubor deskriptoru aplikace tato nastavení.
Chcete-li ladit aplikaci a vyberete příkaz Ladění > Ladit film nebo stisknete klávesy Ctrl+Shift+Enter, zobrazí
program Flash výstrahu v případě, že aplikace neobsahuje žádný kód jazyka ActionScript.
Vytváření souborů aplikace AIR a instalátoru
Po dokončení aplikace vytvořte soubory aplikace AIR a instalátoru, které budou sloužit k jejímu nasazení. Prostředí
Adobe AIR přidává do nabídky Příkazy programu Flash dvě nové položky nabídky: AIR – Nastavení aplikace a
instalátoru a AIR – Vytvořit soubor AIR. Po vytvoření nastavení aplikace a instalátoru AIR můžete pomocí položky
AIR – Vytvořit soubor AIR soubor AIR (.air) znovu vytvořit s existujícím nastavením.
Vytvoření souborů aplikace a instalátoru Adobe AIR
1 Otevřete v programu Flash stránku nebo sadu stránek, které tvoří aplikaci Adobe AIR.
2 Než otevřete dialogové okno AIR – Nastavení aplikace a instalátoru, uložte soubor FLA prostředí Adobe AIR.
3 Vyberte příkaz Příkazy > AIR – Nastavení aplikace a instalátoru.
4 Dokončete dialogové okno AIR – Nastavení aplikace a instalátoru a pak klepněte na tlačítko Publikovat soubor AIR.
Když klepnete na tlačítko Publikovat souboru AIR, vytvoří se balíček s následujícími soubory: souborem FLA,
souborem SWF, souborem deskriptoru aplikace, soubory ikon aplikace a soubory uvedenými v textovém poli
Zahrnuté soubory. Pokud jste ještě nevytvořili digitální certifikát, zobrazí program Flash po klepnutí na tlačítko
Publikovat soubor AIR dialogové okno Digitální podpis.
Dialogové okno AIR – Nastavení aplikace a instalátoru je rozděleno do dvou částí: Nastavení aplikace a Nastavení
instalátoru. Další informace o těchto nastaveních naleznete v následujících částech.
Nastavení aplikace
Část pro nastavení aplikace dialogového okna AIR – Nastavení aplikace a instalátoru obsahuje následující volby:
Název souboru Název hlavního souboru aplikace. Výchozí název je název souboru SWF.
Název Název, který instalátor použije k vytvoření názvu souboru a složky aplikace. Název musí obsahovat pouze
znaky, které jsou pro názvy souborů a složek platné. Výchozí název je název souboru SWF.
Verze Volitelné. Určuje číslo verze aplikace. Tato hodnota je ve výchozím nastavení prázdná.
Identifikátor Identifikuje aplikaci pomocí jedinečného identifikátoru. V případě potřeby můžete výchozí identifikátor
změnit. Nepoužívejte v identifikátoru mezery nebo speciální znaky. Platné znaky jsou pouze 0–9, a–z, A–Z, . (tečka) a
- (spojovník) a délka může být 1 až 212 znaků. Výchozí hodnota je com.adobe.example.název_aplikace.
Popis Volitelné. Umožňuje zadat popis aplikace, který se bude zobrazovat při instalaci aplikace uživatelem. Tato
hodnota je ve výchozím nastavení prázdná.
Copyright Volitelné. Umožňuje zadat oznámení o copyrightu, který se bude zobrazovat při instalaci aplikace
uživatelem.
Styl okna Určuje, jaký styl okna (nebo vzhledu) se použije pro uživatelské rozhraní, když uživatel spustí aplikaci na
svém počítači. Můžete vybrat volbu Systémový vzhled, která odkazuje na vizuální styl používaný operačním systémem.
Můžete také vybrat volby Vlastní vzhled (neprůhledný) nebo Vlastní vzhled (průhledný). Chcete-li aplikaci zobrazit
bez systémového vzhled, vyberte možnost Žádné. Volba Systémový vzhled používá standardní ovládací prvky oken
operačního systému. Volba Vlastní vzhled (neprůhledný) odstraní standardní systémový vzhled a umožní vám
vytvořit pro aplikaci vlastní vzhled. (Vlastní vzhled vytváříte přímo v souboru FLA.) Volba Vlastní vzhled (průhledné)
je podobná jako volba neprůhledný vlastní vzhled, obsahuje ale navíc možnost přidat do okrajů stránky průhlednost.
Tato možnost slouží k vytváření oken aplikací, které nemají čtvercový nebo obdélníkový tvar.
Ikona Volitelné. Slouží k určení ikony aplikace. Tato ikona se zobrazí poté, co aplikaci nainstalujete a spustíte v
prostředí Adobe AIR. Aby bylo možné ikonu zobrazovat v různých zobrazeních, můžete pro ni určit čtyři různé
velikosti (128, 48, 32 a 16 obrazových bodů). Ikona se například může objevit v prohlížeči souborů v zobrazení
miniatury, podrobností nebo v dlaždicovém zobrazení. Může se také objevit jako ikona na ploše, v titulu okna aplikace
AIR i na dalších místech.
Pokud nejsou určeny žádné jiné soubory ikon, použije se pro obraz ikony výchozí ukázková ikona aplikace AIR.
Chcete-li určit ikonu, klepněte v dialogovém okně AIR – Nastavení aplikace a instalátoru na tlačítko Vybrat obrázky
ikon. V zobrazeném dialogovém okně Obrazy ikon klepněte pro každou velikost ikony na určitou složku a vyberte,
který soubor ikony chcete použít. Soubory musí být ve formátu PNG (Portable Network Graphics).
Následující ukázka zobrazuje dialogové okno Obrazy ikon s výchozími ikonami aplikace Adobe AIR.
Určení různých velikostí obrazů ikon aplikace
Pokud určíte nějaký obraz, musí mít přesnou velikost (128 x 128, 48 x 48, 32 x 32 nebo 16 x 16). Pokud pro určitou
velikost ikony nedodáte obraz, vytvoří prostředí Adobe AIR chybějící obraz ikony změnou velikosti jednoho z
dodaných obrazů.
Rozšířené nastavení
Tlačítko Nastavení v dialogovém okně AIR – Nastavení aplikace a instalátoru slouží k určení rozšířených nastavení
pro soubor deskriptoru aplikace. Po klepnutí na tlačítko Nastavení se objeví dialogové okno Rozšířené nastavení.
Dialogové okno Rozšířené nastavení slouží k určení všech přiřazených typů souborů, se kterými by měla aplikace
pracovat. Pokud například chcete, aby sloužila jako hlavní aplikace pro práci se soubory HTML, měli byste tuto volbu
určit v textovém poli Přiřazené typy souborů.
Můžete také určit nastavení následujících aspektů aplikace:
• velikost a umístění počátečního okna;
• složku, do které se aplikace nainstaluje;
• složku nabídky programu, do které se aplikace umístí.
Toto dialogové okno obsahuje následující volby:
Přiřazené typy souborů Slouží k určení všech přiřazených typů souborů, se kterými bude aplikace AIR pracovat.
Chcete-li do textového pole přidat nový typ souborů, klepněte na tlačítko (+). Když klepnete na tlačítko pro přidání,
zobrazí se dialogové okno Nastavení typu souboru. Klepnutím na tlačítko (-) odeberete položku, které je vybrána v
textovém poli. Klepnete-li na tlačítko tužky, zobrazí se dialogové okno Nastavení typu souboru, které slouží k úpravě
položky, kterou jste vybrali v textovém poli. Tlačítko tužky a tlačítko (-) jsou ve výchozím nastavení ztlumená. Pokud
v textovém poli vyberete položku, tlačítka (-) a tužka se povolí, takže položku můžete odebrat nebo upravit. Výchozí
hodnota textového pole je Žádné.
Další informace o nastavení typů souborů pro přiřazené typy souborů naleznete v části „Nastavení typu souboru“ na
stránce 18.
Počáteční nastavení okna Slouží k určení nastavení velikosti a umístění počátečního okna aplikace.
• Šířka: Určuje počáteční šířku okna v obrazových bodech. Tato hodnota je ve výchozím nastavení prázdná.
• Výška: Určuje počáteční výšku okna v obrazových bodech. Tato hodnota je ve výchozím nastavení prázdná.
• X: Určuje počáteční vodorovnou polohu okna v obrazových bodech. Tato hodnota je ve výchozím nastavení
prázdná.
• Y: Určuje počáteční svislou polohu okna v obrazových bodech. Tato hodnota je ve výchozím nastavení prázdná.
• Maximální šířka a Maximální výška: Slouží k určení maximální velikosti okna v obrazových bodech. Tyto hodnoty
jsou ve výchozím nastavení prázdné.
• Minimální šířka a Minimální výška: Slouží k určení minimální velikosti okna v obrazových bodech. Tyto hodnoty
jsou ve výchozím nastavení prázdné.
• Maximalizovatelné: Umožňuje určit, zda uživatel může maximalizovat okno. Tato volba je vybrána ve výchozím
nastavení (nebo má hodnotu true).
• Minimalizovatelné: Umožňuje určit, zda uživatel může minimalizovat okno. Tato volba je vybrána ve výchozím
nastavení (nebo má hodnotu true).
• Nastavitelná velikost: Umožňuje určit, zda uživatel může změnit velikost okna. Pokud není tato volba vybrána, jsou
ztlumené možnosti pro maximální a minimální výšku i šířku. Tato volba je vybrána ve výchozím nastavení (nebo
má hodnotu true).
• Viditelné: Slouží k určení toho, zda je okno aplikace od počátku viditelné. Volba je vybrána ve výchozím nastavení
(nebo má hodnotu true).
Další nastavení Slouží k určení následujících dodatečných informací, které se týkají instalace:
• Složka pro instalaci: Určuje složku, do které se aplikace nainstaluje.
• Složka nabídky programu: Určuje název složky nabídky programu aplikace.
• Vlastní uživatelské rozhraní aktualizací: Slouží k určení toho, co se stane v případě, kdy uživatel otevře soubor AIR
pro dříve nainstalovanou aplikaci. Ve výchozím nastavení zobrazí prostředí AIR dialogové okno, které uživateli
umožní nainstalovanou verzi aktualizovat verzí v souboru AIR. Tuto volbu vyberte tehdy, pokud nechcete
uživatelům umožnit rozhodování o této záležitosti a chcete, aby úplnou kontrolu nad svými aktualizacemi měla
aplikace. Vyberete-li tuto volbu, potlačíte výchozí chování a umožníte aplikaci ovládat své vlastní aktualizace.
Informace o programatické aktualizaci aplikace AIR naleznete v části „Aktualizace aplikací AIR“ na stránce 291.
Nastavení typu souboru
Pokud v dialogovém okně Rozšířené nastavení klepnete na tlačítko (+) nebo na tlačítko tužky, abyste přidali nebo
upravili typy souborů přiřazené aplikaci, zobrazí program Flash dialogové okno Nastavení typu souboru.
Jediná dvě pole v tomto dialogovém okně, která jsou povinná, jsou pole Název a Přípona. Pokud klepnete na tlačítko
OK a některé z těchto polí je prázdné, zobrazí program Flash chybové dialogové okno.
U přiřazených typů souborů můžete určit následující nastavení:
Název Název typu souborů (například Hypertextový značkovací jazyk – HTML, Textový soubor nebo Příklad).
Přípona Přípona názvu souborů (například html, text nebo xmpl); přípona může obsahovat až 39 základních
alfanumerických znaků (A–Z, a–z, 0–9) a nesmí obsahovat počáteční tečku.
Popis Volitelné. Popis typu souborů (Například Soubor videa Adobe).
Typ obsahu Volitelné. Určuje typ MIME pro tento soubor.
Nastavení ikony typu souboru Volitelné. Slouží k určení ikony, která je přiřazena k danému typu souborů. Aby bylo
možné ikonu zobrazovat v různých zobrazeních, můžete pro ikonu určit čtyři různé velikosti (128 x 128, 48 x 48,
32 x 32 a 16 x 16 obrazových bodů). Ikona se například může objevit v prohlížeči souborů v zobrazení miniatury,
podrobností nebo v dlaždicovém zobrazení.
Pokud určíte nějaký obraz, musí mít vámi specifikovanou velikost. Pokud pro určitou velikost obraz neurčíte, použije
prostředí AIR obraz, který se tomuto obrazu nejvíce blíží svoji velikostí, a tento obraz přizpůsobí konkrétnímu výskytu
změnou jeho velikosti.
Ikonu určíte tak, že klepnete na složku pro velikost ikony a vyberete soubor ikony, který chcete použít, nebo že zadáte do
textového pole u příkazového řádku cestu a název souboru pro soubor ikony. Soubor ikony musí být ve formátu PNG.
Po vytvoření nového typu souborů se tento typ souborů zobrazuje v dialogovém okně Rozšířené nastavení v poli
seznamu Typ souboru.
Nastavení souboru deskriptoru aplikace
Určená nastavení aplikace jsou uložena do souboru název_aplikace-app.xml. Můžete ale v programu Flash nastavit, že
chcete použít vlastní soubor deskriptoru aplikace.
Použít vlastní soubor deskriptoru aplikace Tato volba slouží k vyhledání vlastního souboru deskriptoru aplikace.
Pokud vyberete volbu Použít vlastní soubor deskriptoru aplikace, část pro nastavení aplikace dialogového okno se
ztlumí. Chcete-li určit umístění vlastního souboru deskriptoru aplikace, zadejte toto umístění do textového pole pod
volbou Použít vlastní soubor deskriptoru aplikace nebo klepněte na ikonu složky a přejděte do tohoto umístění. Další
informace o souboru deskriptoru aplikace naleznete v části „Vytvoření vlastního souboru deskriptoru aplikace“ na
stránce 20.
Nastavení instalátoru
Druhá část dialogového okna AIR – Nastavení aplikace a instalátoru obsahuje nastavení, která se týkají instalace
aplikace.
Digitální podpis Všechny aplikace Adobe AIR je třeba podepsat, aby je bylo možno nainstalovat do jiného systému.
Informace o přiřazení digitálního podpisu aplikaci Adobe AIR programu Flash naleznete v části „Podepisování
Cíl Určuje, kam bude soubor AIR uložen. Výchozí umístění je adresář, do kterého jste uložili soubor FLA. Chcete-li
vybrat jiné umístění, klepněte na ikonu složky. Výchozí název balíčku je název aplikace s příponou souboru .air.
Zahrnuté soubory/složky Určuje, které další soubory nebo složky budou do aplikace zahrnuty. Chcete-li přidat
soubory, klepněte na tlačítko (+), chcete-li přidat složky, klepněte na tlačítko složky. Chcete-li soubor nebo složku
odstranit ze seznamu, vyberte tento soubor nebo složku a klepněte na tlačítko (-).
Ve výchozím nastavení jsou soubor deskriptoru aplikace a hlavní soubor SWF do seznamu balíčku přidány
automaticky. Seznam balíčku tyto soubory zobrazuje dokonce i tehdy, pokud jste soubor FLA Adobe AIR ještě
nepublikovali. Seznam balíčku zobrazuje soubory a složky nestrukturovaně. Nejsou uváděny soubory ve složkách a
plné názvy cest k souborům jsou sice zobrazeny, ale v případě potřeby jsou zkráceny.
Součástí tohoto seznamu nejsou soubory ikon. Když program Flash vytváří ze souborů balíček, zkopíruje soubory ikon
do dočasné složky, která je vztažená k umístění souboru SWF. Po vytvoření balíčku program Flash tuto složku
odstraní.
Chyby při vytváření souborů aplikace a instalátoru
K chybě vytvoření souborů aplikace nebo instalátoru dojde v následujících případech:
• Řetězec identifikátoru aplikace má nesprávnou délku nebo obsahuje neplatné znaky. Řetězec identifikátoru
aplikace může mít 1 až 212 znaků a může obsahovat následující znaky: 0–9, a–z, A–Z, . (tečku), - (spojovník).
• Soubory v seznamu instalátoru neexistují.
• Velikost vlastních souborů ikon je nesprávná.
• Cílová složka AIR nemá oprávnění pro zápis.
• Aplikaci jste nepodepsali nebo jste neurčili, že se jedná o aplikaci Adobe AIRI, která bude podepsána později.
Vytvoření vlastního souboru deskriptoru aplikace
Soubor deskriptoru aplikace je soubor XML, který můžete upravit pomocí textového editoru. Chcete-li vytvořit vlastní
soubor deskriptoru aplikace, určete požadované hodnoty úpravou těchto hodnot. Výchozí hodnoty jsou zobrazeny zde:
• id = com.adobe.example.název_swf
• fileName = název_swf
• name = název_swf
• version = 1.0
• description = blank
• copyright = blank
• initialWindow
• title = name
• content = název_swf.swf
• systemChrome = standard, type = normal
• transparent = false
• visible = true
• icon
• image128x128 = icons/AIRApp_128.png
• customUpdateUI = false
• allowBrowserInvocation = false
Další informace o souboru deskriptoru aplikace naleznete v části „Nastavení vlastností aplikace AIR“ na stránce 42.
Podepisování aplikace
Všechny aplikace Adobe AIR je třeba podepsat, aby je bylo možno nainstalovat do jiného systému. Program Flash
nicméně poskytuje možnost vytvořit nepodepsané soubory instalátoru Adobe AIR, takže lze aplikaci podepsat později.
Tyto nepodepsané soubory instalátoru Adobe se označují jako balíček AIRI. Tato možnost zajišťuje případy, kdy je
certifikát v jiném počítači nebo je podepisování zpracováváno od vývoje aplikace odděleně.
Podpis aplikace Adobe AIR pomocí předem zakoupeného digitálního certifikátu od kořenového certifikačního
úřadu
1 Klepněte v dialogovém okně AIR – Nastavení aplikace a instalátoru v části Digitální podpis na tlačítko Nastavit.
Otevře se dialogové okno Digitální podpis.
Toto dialogové okno obsahuje dvě přepínací tlačítka, která slouží buď k podpisu aplikace Adobe AIR pomocí
digitálního certifikátu nebo k přípravě balíčku AIRI. Pokud svou aplikaci AIR podepisujete, můžete buď použít
digitální certifikát udělený kořenovým certifikačním úřadem nebo vytvořit certifikát s vlastním podpisem (selfsigned certificate). Certifikát s vlastním podpisem lze jednoduše vytvořit, není ale tak důvěryhodný jako certifikát,
který byl udělen kořenovým certifikačním úřadem.
Dialogové okno Digitální podpis sloužící k podpisu aplikace AIR
2 Vyberte soubor certifikátu z rozbalovací nabídky nebo přejděte k souboru certifikátu po klepnutí na tlačítko
Procházet.
3 Vyberte certifikát.
4 Zadejte heslo.
5 Klepněte na tlačítko OK.
Další informace o podepisování aplikace AIR naleznete v části „Digitální podepisování souboru AIR“ na stránce 285.
Vytvoření digitálního certifikátu s vlastním podpisem
1 Klepněte na tlačítko Vytvořit. Otevře se dialogové okno Digitální certifikát s vlastním podpisem.
2 Vyplňte položky Jméno vydavatele, Útvar organizace, Název organizace, Země, Heslo a Potvrzení hesla.
3 Určete typ certifikátu.
Volba Typ označuje úroveň zabezpečení, kterou certifikát využívá: 1024-RSA používá 1024bitový klíč (méně
zabezpečený), 2048-RSA 2048bitový (více zabezpečený).
4 Uložte informaci do souboru certifikátu – vyplňte položku Uložit jako nebo přejděte do umístění složky po klepnutí
na tlačítko Procházet.
5 Klepněte na tlačítko OK.
6 Zadejte v dialogovém okně Digitální podpis heslo, které jste přiřadili v druhém kroku tohoto postupu, a klepněte
na tlačítko OK.
Po nastavení digitálního certifikátu se tlačítko Nastavit změní na tlačítko Změnit.
Aby si program Flash zapamatoval heslo, které jste pro tuto relaci použili, klepněte na možnost Pamatovat si heslo pro
tuto relaci.
Pokud je při klepnutí na tlačítko OK odznačena volba Časové razítko, objeví se dialogové okno s varováním, že po
vypršení platnosti digitálního certifikátu bude instalace neúspěšná. Pokud v reakci na toto varování klepnete na
tlačítko Ano, je používání časového razítka zakázáno. Pokud klepnete na tlačítko Ne, vybere se volba Časové razítko
automaticky a používání časového razítka je povoleno.
Další informace o vytvoření digitálního certifikátu s vlastním podpisem naleznete v části „Digitální podepisování
souboru AIR“ na stránce 285.
Můžete také vytvořit aplikaci AIRI (AIR Intermediate), která digitální podpis neobsahuje. Uživatelé ale tuto aplikaci
nemohou do počítače nainstalovat do té doby, než přidáte digitální podpis.
Příprava balíčku AIRI s pozdějším přidáním podpisu
❖ Vyberte v dialogovém okně Digitální podpis přepínací tlačítko Připravit balíček AIRI, který bude podepsán později
a klepněte na tlačítko OK.
Stav digitálního podpisu se změní, aby informoval o tom, že jste si vybrali přípravu balíčku AIRI, který bude
podepsán později, a tlačítko Nastavit se změní na tlačítko Změnit.
23
Kapitola 7: Zabezpečení aplikace AIR
Toto téma popisuje problematiku zabezpečení, které byste měli zvážit při vývoji aplikací AIR.
Základy zabezpečení aplikace AIR
Aplikace AIR se spouští se stejnými uživatelskými oprávněními, jako nativní aplikace. Obecně tato oprávnění
umožňují široký přístup k možnostem operačního systému, například ke čtení a zápisu souborů, spouštění aplikací,
vykreslování na obrazovce a komunikaci se sítí. Omezení operačního systému, která platí pro nativní aplikace,
například uživatelsky specifická oprávněná, platí shodně pro aplikace AIR.
I když model zabezpečení aplikace Adobe® AIR™ je vývojem modelu zabezpečení aplikace Adobe® Flash® Player,
dohoda o zabezpečení je odlišná od způsobu použitého pro obsah v prohlížeči. Tato dohoda nabízí vývojářům
bezpečné prostředky pro širší funkce, pro větší svobodu, která by byla pro aplikace na základě prohlížeče nepříslušná.
Aplikace AIR jsou zapsány buď se zkompilovaným bajtovým kódem (obsah SWF) nebo interpretovaným skriptem
(JavaScript, HTML), takže chod programu zajišťuje správu paměti. To minimalizuje možnost, že aplikace AIR budou
ovlivněny zranitelností související se správou paměti, například přetečením vyrovnávací paměti, nebo narušením
paměti. Existují některé nejběžnější zranitelnosti, které ovlivňují počítačové aplikace napsané v nativním kódu.
Instalace a aktualizace
Aplikace AIR jsou distribuovány prostřednictvím souborů instalačního programu, který používá příponu air. Když
je aplikace Adobe AIR nainstalována a soubory instalačního programu jsou otevřeny, chod programu spravuje celý
proces instalace.
Poznámka: Vývojáři mohou specifikovat verzi, název aplikace a zdroj vydavatele, ale počáteční pracovní postup
instalace aplikace samotný modifikovat nelze. Toto omezení je výhodné pro uživatele, protože všechny aplikace AIR
sdílejí bezpečný, přímý a konzistentní postup instalace, řízený chodem programu. Pokud je uzpůsobení aplikace nutné,
může být provedeno při prvním spuštění aplikace.
Umístění instalace modulu runtime
Aplikace AIR nejprve vyžaduje nainstalování modulu runtime do počítače uživatele, stejně jako soubory SWF nejprve
vyžadují nainstalování zásuvného modulu přehrávače Flash Player.
Modul runtime je nainstalován do následujícího umístění v počítači uživatele:
• Mac OS: /Library/Frameworks/
• Windows: C:\Program
Files\Common Files\Adobe AI
V systému Mac OS musí mít uživatel pro instalaci aktualizované verze aplikace odpovídající systémová práva k
instalaci adresáře aplikace. V systému Windows musí mít uživatel práva správce.
Modul runtime může být nainstalován dvěma způsoby: pomocí funkce plynulé instalace (instalace přímo z webového
prohlížeče) nebo prostřednictvím manuální instalace. Další informace naleznete v kapitole „Distribuce, Instalace a
Spuštění aplikací AIR“ na stránce 276.
Zabezpečení aplikace AIR
Plynulá instalace (modulu runtime a aplikace)
Plynulá instalace poskytuje vývojáři možnost plynule instalovat aplikaci pro uživatele, kteří ještě nemají
nainstalovanou aplikaci Adobe AIR. Metoda plynulé instalace umožňuje vývojáři vytvořit soubor SWF, který
představuje aplikaci pro instalování. Když uživatel klepne na soubor SWF pro instalování aplikace, soubor SWF se
pokusí detekovat modul runtime. Pokud modul runtime nelze detekovat, je nainstalován a aktivuje se ihned po
spuštění procesu instalace aplikace vývojáře.
Ruční instalace
Alternativně může uživatel ručně stáhnout a nainstalovat modul runtime před otevřením souboru AIR. Vývojář může
poté distribuovat soubor AIR pomocí jiných prostředků (například prostřednictvím emailu, nebo odkazu HTML na
webové stránky). Když je soubor AIR otevřen, modul runtime začne zpracovávat instalaci aplikace.
Další informace o tomto procesu naleznete v kapitole „Distribuce, Instalace a Spuštění aplikací AIR“ na stránce 276
Průběh instalace aplikace
Model zabezpečení aplikace AIR umožňuje uživateli rozhodnout se, zda aplikaci AIR nainstaluje. Instalace aplikace
AIR poskytuje několik zlepšení ve srovnání s technologiemi instalace nativních aplikací, což pro uživatele činí celý
rozhodovací proces důvěryhodnější:
• Modul runtime poskytuje pohodlný instalační proces pro všechny operační systémy, i s aplikací AIR
nainstalovanou prostřednictvím odkazu na webový prohlížeč. Většina postupů instalací nativních aplikací závisí na
prohlížeči nebo jiné aplikaci, které musí poskytnout informace o zabezpečení, pokud jsou vůbec poskytnuty.
• Postup instalace aplikace AIR identifikuje zdroj aplikace a informace o tom, která oprávnění jsou pro aplikaci
dostupná (pokud uživatel umožní aplikaci pokračovat).
• Modul runtime řídí proces instalace aplikace AIR. Aplikace AIR nemůže manipulovat s procesem instalace, který
modul runtime používají.
Obecně uživatelé nemohou nainstalovat žádné aplikace, které pocházejí ze zdroje, kterému nedůvěřují, nebo který
nelze ověřit. Břemeno dokladování zabezpečení pro nativní aplikace je stejné pro aplikace AIR, jako pro ostatní
instalovatelné aplikace.
Cílové místo aplikace
Instalační adresář může být nastaven pomocí jedné z následujících možností:
1 Uživatel uzpůsobuje cílové umístění během instalace. Aplikace se nainstaluje tam, kam uživatel specifikuje.
2 Pokud uživatel nezmění cílové umístění instalace, instalace aplikace do výchozí cesty bude taková, jak je stanoveno
chodem programu:
• Mac OS: ~/Applications/
• Windows XP a dřívější: C:\Program
Files\
• Windows Vista: ~/Apps/
Pokud vývojář specifikuje nastavení installFolder v propisovacím souboru aplikace, aplikace se nainstaluje do
podřízené cesty tohoto adresáře.
Systém souborů AIR
Proces instalace aplikací AIR kopíruje všechny soubory, které vývojář zahrne do instalačního souboru aplikace AIR do
místního počítače uživatele. Instalovaná aplikace je tvořena následujícími součástmi:
• Windows: adresář obsahující všechny soubory zahrnuté do instalačního souboru aplikace AIR. Modul runtime
rovněž vytvoří během instalace soubor EXE pro aplikaci AIR.
• Mac OS: soubor app obsahující veškerý obsah instalačního souboru AIR. Zkontrolovat jej lze pomocí možnosti
„Zobrazit obsah balíku“ ve Vyhledávači. Modul runtime vytvoří tento soubor app jako součást instalace aplikace AIR.
Aplikace AIR je spuštěna takto:
• Windows: spuštění souboru .exe v instalační složce, nebo zástupce, který odpovídá tomuto souboru (například
zástupce v nabídce Start nebo na pracovní ploše).
• Mac OS: spuštění souboru .app nebo aliasu, který na něj ukazuje.
Systém souborů aplikace rovněž zahrnuje podadresáře související s funkcí aplikace. Například, informace zapsané do
šifrovaného lokálního umístění je uložena do podadresáře uloženého v adresáři pojmenovanému podle identifikátoru
aplikace.
Uložení dat aplikace AIR
Aplikace AIR má oprávnění pro zápis do kteréhokoliv umístění na pevném disku uživatele; nicméně vývojářům se
doporučuje používat cestu app-storage:/ pro lokální uložení související s aplikací. Soubory zapsané do adresáře
app-storage:/ aplikací jsou uloženy ve standardním umístění, v závislosti na operačním systému uživatele:
• Mac OS: adresář pro uložení dat aplikace je <appData>/<appId>/Local
Store/, kde <appData> je „složka
předvoleb“ uživatele, typicky /Users/<user>/Library/Preferences
• Windows: adresář pro uložení dat aplikace je
<appData>\<appId>\Local Store\ , kde <appData> je „Speciální
složka“ uživatele CSIDL_APPDATA, typicky C:\Documents and Settings\<userName>\Application Data
Adresář uložení dat aplikace je přístupný prostřednictvím vlastnosti air.File.applicationStorageDirectory. K
obsahu můžete přistupovat pomocí metody resolvePath() třídy File. Podrobnosti viz také „Práce se systémem
souborů“ na stránce 98.
Aktualizace aplikace Adobe AIR
Když uživatel nainstaluje aplikaci AIR, která vyžaduje aktualizovanou verzi modulu runtime, ten automaticky
instaluje požadovanou aktualizaci.
K aktualizaci modulu runtime potřebuje mít uživatel v počítači administrátorská práva.
Aktualizace aplikací AIR
Vývoj a nasazení softwarových aplikací jsou jednou z největších bezpečnostních výzev, kterým čelí aplikace s nativním
kódem. Rozhraní API aplikace AIR poskytuje mechanismus pro zlepšení: metoda Updater.update() může být
vyvolána po spuštění ke kontrole vzdáleného umístění souboru AIR. Pokud je aktualizace správná, soubor AIR je
stažen, nainstalován a aplikace se restartuje. Vývojáři mohou tuto třídu používat nejenom pro poskytnutí nové funkce,
ale také pro reakci na potenciální bezpečnostní zranitelnosti.
Poznámka: Vývojáři mohou specifikovat verzi aplikace nastavením vlastnosti version souboru popisovače aplikace. AIR
řetězec žádným způsobem neinterpretuje. Tak verze „3.0“ není považována za aktuálnější, než verze „2.0“. Na vývojáři
je udržení smysluplné stanovení verze. Další podrobné informace viz „Definování vlastností v souboru deskriptoru
Odinstalování aplikace AIR
Uživatel může odinstalovat aplikaci AIR:
• V systému Windows: pomocí ovládacího panelu Přidat/Odebrat programy se aplikace odstraní.
• V systému Mac OS: odstranění souboru app z místa instalace.
Odebráním aplikace AIR se odstraní všechny soubory v adresáři aplikace. Neodstraní se však soubory, které mohla
aplikace zapsat mimo adresář aplikace. Odebráním aplikace AIR nevrací změny, které aplikace AIR provedla v
souborech mimo adresář aplikace.
Odinstalování aplikace Adobe AIR
Aplikace Adobe AIR může být odinstalována:
• V systému Windows: spuštěním funkce Přidat/Odebrat programy v Ovládacích panelech, vybráním položky
Adobe AIR a zvolením tlačítka „Odebrat“.
• V systému Mac OS: spuštěním odinstalačního programu aplikace Adobe AIR v adresáři aplikace.
Nastavení registru Windows pro správce
V systému Windows mohou správci nakonfigurovat počítač tak, aby zabránil (nebo umožnil) instalaci aplikace AIR a
aktualizací modulu runtime. Tato nastavení jsou obsažena v registru Windows v následujícím klíči:
HKLM\Software\Policies\Adobe\AIR. Zahrnují následující:
Nastavení registru
Popis
AppInstallDisabled
Specifikuje, že instalace a odinstalace aplikace AIR jsou povoleny. Nastavte na hodnotu 0 = „povoleno“,
nebo na hodnotu 1 = „zakázáno“.
UntrustedAppInstallDisabled
Specifikuje, že instalace nedůvěryhodných aplikací AIR (aplikace, které nezahrnují důvěryhodný
certifikát) je povolena (viz „Digitální podepisování souboru AIR“ na stránce 285). Nastavte na hodnotu 0
= „povoleno“, nebo na hodnotu 1 = „zakázáno“.
UpdateDisabled
Specifikuje, že aktualizace modulu runtime je povolena, buď jako úkol na pozadí nebo jako součást
explicitní instalace. Nastavte na hodnotu 0 = „povoleno“, nebo na hodnotu 1 = „zakázáno“.
Karantény zabezpečení
Aplikace AIR poskytuje komplexní architekturu zabezpečení, která definuje oprávněné podle každého souboru v
aplikaci AIR, interně i externě. Oprávnění jsou poskytnuta souborům podle jejich původu a jsou přiřazena do
logických skupin zabezpečení, nazývaných karantény zabezpečení.
O karanténě zabezpečení aplikace AIR
Model karantén zabezpečení modulu runtime je tvořen modelem zabezpečení aplikace Flash Player s doplněním
karantény zabezpečení aplikace. Soubory, které nejsou v karanténě zabezpečení aplikace, mají bezpečnostní omezení
podobná těm, která jsou specifikovaná v modelu zabezpečení aplikace Flash Player.
Modul runtime používá karantény zabezpečení k definování rozsahu dat, ke kterým může kód přistupovat a operace,
které může vykonávat. Pro uchování lokálního zabezpečení jsou soubory v každé karanténě zabezpečení izolovány od
souborů jiných karantén zabezpečení. Například soubor SWF načtený do aplikace AIR z externí internetové adresy
URL, je uložen do vzdálené karantény zabezpečení a nemá výchozí oprávnění pro skriptování souborů, které jsou
uloženy v adresáři aplikace, které jsou přiřazeny do karantény zabezpečení aplikace.
Následující tabulka popisuje každý typ karantény zabezpečení:
Karanténa zabezpečení
Popis
aplikace
Soubor je umístěn v aplikačním adresáři a pracuje s úplnou sadou oprávnění AIR.
vzdáleně
Soubor pochází z internetové adresy URL a pracuje podle doménových pravidel karantény zabezpečení,
analogických k pravidlům, která platí pro vzdálené soubory aplikace Flash Player. (Jedná se o samostatné
karantény zabezpečení pro každou síťovou doménu, například http://www.example.com a
https://foo.example.org.)
lokální-důvěryhodné
Soubor je lokální a uživatel jej označil jako důvěryhodný, pomocí Správce nastavení nebo
důvěryhodného konfiguračního souboru aplikace Flash Player. Soubor může číst lokální datové zdroje a
komunikovat s Internetem, ale nemá úplnou sadu oprávnění AIR.
lokální-se-sítí
Soubor je lokální soubor SWF publikovaný s označením sítě, ale nebyl pro uživatele explicitně
důvěryhodný. Tento soubor může komunikovat s Internetem, ale nemůže číst z lokálních datových
zdrojů. Tato karanténa zabezpečení je dostupná pouze pro obsah SWF.
lokální-se-systémem souborů
Soubor je lokální skriptovací soubor, který nebyl publikovaný s označením sítě, ale nebyl pro uživatele
explicitně důvěryhodný. Patří sem soubory JavaScript, které nebyly důvěryhodné. Soubor může číst z
lokálních datových zdrojů, ale nemůže komunikovat s Internetem.
Toto téma se zaměřuje primárně na karanténu zabezpečení aplikace a její vztah s ostatními karanténami zabezpečení
v aplikaci AIR. Vývojáři, kteří používají obsah přiřazený k ostatním karanténám zabezpečení by si měli dále
prostudovat dokumentaci modelu zabezpečení aplikace Flash Player. Viz také kapitola „Zabezpečení aplikace Flash
Player“ v Programování jazyka ActionScript 3.0 (http://www.adobe.com/go/flashCS3_progAS3_security_cz) a
Dokument zabezpečení Flash Player 9 (http://www.adobe.com/go/fp9_0_security_cz).
Karanténa zabezpečení aplikace
Když je aplikace nainstalovaná, všechny soubory obsažené v instalačním programu jsou nainstalovány v počítači
uživatele do adresáře aplikace. Vývojáři mohou odkazovat na tento adresář v kódu prostřednictvím schématu URL
app:/ (viz „Používání schémat URL AIR v adresách URL“ na stránce 272). Všechny soubory stromové struktury
adresářů aplikace jsou přiřazeny do karantény zabezpečení aplikace, když je aplikace spuštěna. Obsah v karanténě
zabezpečení aplikace má všechna oprávnění dostupná pro aplikaci AIR, včetně interakce s lokálním souborovým
systémem.
Mnoho aplikací AIR používá pro spuštění aplikace pouze tyto lokálně nainstalované soubory. Nicméně aplikace AIR
nejsou omezeny pouze na soubory v adresáři aplikace - mohou načítat jakýkoliv typ soubor z libovolného zdroje. Patří
sem lokální soubory pro počítač uživatele a také soubory z dostupných externích zdrojů, například místní sítě nebo
Internetu. Typ souboru nemá žádný dopad na omezení zabezpečení; načtené soubory HTML mají stejná bezpečnostní
oprávnění, jako načtené soubory SWF ze stejného zdroje.
Obsah v karanténě zabezpečení aplikace má přístup k rozhraní API aplikace AIR, jehož obsah se v jiných karanténách
nesmí používat. Například vlastnost air.NativeApplication.nativeApplication.applicationDescriptor,
která vrací obsah souboru popisovače aplikace, je omezena na obsah karantény zabezpečení aplikace. Další příklad
omezeného rozhraní API představuje třída FileStream, která obsahuje metody pro čtení a zápis místního systému
souborů.
Rozhraní API jazyka ActionScript, které je jediné dostupné pro obsah v karanténě zabezpečení aplikace, je indikováno
logem AIR v Referenční příručka jazyka Flex 3.0 pro aplikaci Adobe AIR. Použití těchto rozhraní API v jiných
karanténách zabezpečení způsobí, že modul runtime odešle výjimku SecurityError.
Pro obsah HTML (v objektu HTMLLoader), jsou všechna rozhraní API jazyka JavaScript AIR (ta, která jsou dostupná
prostřednictvím vlastnosti window.runtime nebo objektu air při použití souboru AIRAliases.js) dostupná pro obsah
v karanténě zabezpečení aplikace. Obsah HTML v jiné karanténě zabezpečení nemá přístup k vlastnosti
window.runtime,takže obsah nemůže přistupovat k rozhraní APU aplikace AIR.
Omezení pro JavaScript a HTML
Pro obsah HTML v karanténě zabezpečení aplikace existují omezení, pro použití rozhraní API, která mohou
dynamicky transformovat řetězce do spustitelného kódu poté, co byl kód načten. Tak tomu je proto, aby aplikaci bylo
zabráněno v náhodném vložení (a spuštění) kódu z neaplikačních zdrojů (například jako potenciálně nezabezpečené
síťové domény). Příkladem je použití funkce eval(). Podrobnosti viz také „Omezení kódu pro obsah v různých
karanténách zabezpečení“ na stránce 31.
Omezení ve značkách img v obsahu textového pole jazyka ActionScript
Na ochranu před možnými phishingovými útoky jsou značky img v obsahu HTML v objektech TextField jazyka
ActionScript ignorovány v obsahu SWF v karanténě zabezpečení aplikace.
Omezení pro asfunction
Obsah v karanténě zabezpečení aplikace nemůže použít protokol asfunction v obsahu HTML v textovém poli
ActionScript 2.0.
Žádný přístup k trvalé mezidoménové vyrovnávací paměti
Obsah SWF v karanténě zabezpečení aplikace nemůže používat mezidoménovou vyrovnávací paměť, funkce byla
přidána do 3. aktualizace aplikace Flash Player 9. Tato funkce umožňuje aplikaci Flash Player trvale ukládat do
vyrovnávací paměti obsah součástí platformy Adobe a používat jej v načteném obsahu SWF na vyžádání (eliminuje se
tak potřeba několikerého načtení obsahu).
Oprávnění obsahu v neaplikačních karanténách zabezpečení
Soubory načtené ze sítě nebo internetového umístění jsou přiřazeny do vzdálené karantény zabezpečení. Soubory
načtené z vnějšku adresáře aplikace jsou přiřazeny buď karanténě zabezpečení lokální-se-systémem soubor ,
lokální-se-sítí nebo lokální-d v ryhodný; to závisí na tom, jak byl soubor vytvořen a zda uživatel explicitně
důvěřoval souboru prostřednictvím Správce globálního nastavení aplikace Flash Player. Podrobnosti viz
http://www.macromedia.com/support/documentation/en/flashplayer/help/settings_manager.html.
Omezení pro JavaScript a HTML
Na rozdíl od obsahu v karanténě zabezpečení aplikace, obsah jazyka JavaScript v neaplikační karanténě zabezpečení
může kdykoliv volat funkci eval() pro vykonání dynamicky generovaného kódu. Existují však omezení jazyka
JavaScript v neaplikační karanténě zabezpečení. Patří sem:
• Kód JavaScript v neaplikační karanténě zabezpečení nemá přístup do objektu window.runtime a takový kód
nemůže rozhraní API aplikace AIR vykonat.
• Standardně obsah v neaplikační karanténě zabezpečení nemůže použít volání XMLHttpRequest pro načtení dat z
jiné domény, kromě domény volající daný požadavek. Kód aplikace však může zaručit toto oprávnění
neaplikačnímu obsahu a to nastavením atributu allowCrossdomainXHR v obsaženém snímku nebo snímku iframe.
Další informace viz „Skriptování mezi obsahem v různých doménách“ na stránce 34.
• Existují omezení volání metody window.open() jazyka JavaScript. Podrobnosti viz také „Omezení pro volání
metody JavaScript window.open()“ na stránce 33.
Podrobnosti viz také „Omezení kódu pro obsah v různých karanténách zabezpečení“ na stránce 31.
Omezení pro načítání CSS, snímku, snímku iframe a prvků img
Obsah HTML ve vzdálených (síťových) karanténách zabezpečení může načítat pouze obsah CSS, frame, iframe a img
ze vzdálených domén (ze síťových adres URL).
Obsah HTML v karanténách zabezpečení lokální-se-systémem souborů, lokální-se-sítí nebo lokální-důvěryhodný
mohou pouze načítat obsah CSS, frame, iframe a img z místních karantén zabezpečení (nikoliv z aplikačních nebo
síťových adres URL).
Zabezpečení HTML
Modul runtime si vynucuje pravidla a poskytuje mechanismy pro překonávání možných zranitelností zabezpečení v
kódu HTML a JavaScript. Stejná pravidla jsou vynucena bez ohledu na to, zda je aplikace primárně napsána v jazyce
JavaScript nebo zda načítáte obsah HTML a JavaScript v aplikaci založené na SWF. Obsah v karanténě zabezpečení
aplikace a v neaplikační karanténě zabezpečení (viz „Karantény zabezpečení“ na stránce 26) mají odlišná oprávnění.
Při načítání obsahu do iframe nebo frame, modul runtime poskytuje zabezpečený mechanismu můstku karantén
zabezpečení, který umožňuje obsahu v frame nebo iframe komunikovat zabezpečeným způsobem s obsahem v
karanténě zabezpečení aplikace.
Toto téma popisuje architekturu zabezpečení AIR HTML a jak používat snímky iframes, snímky a můstek karantény
zabezpečení pro nastavení aplikace.
Další informace viz také „Zamezení vzniku chyb jazyka JavaScript souvisejících se zabezpečením“ na stránce 208.
Přehled konfigurování aplikací HTML
Snímky a snímky iFrames poskytují pohodlnou strukturu pro organizování obsahu HTML v aplikaci AIR. Snímky
poskytují prostředky pro zajištění trvalosti data a pro bezpečnou práci se vzdáleným obsahem.
Protože HTML v aplikaci AIR udržujte normální, stránkovou organizaci, prostředí HTML se zcela aktualizuje v
případě, že horní snímek obsahu HTML se „naviguje” na jinou stránku. Můžete použít snímky a snímky iframes k
údržbě trvalosti dat v AIR, stejně jako by tomu bylo pro webové aplikace spuštěné v prohlížeči. Definujte hlavní
objekty aplikace v horním snímku, které přetrvají, dokud neumožníte snímku přejít na novou stránku. Použijte závislé
snímky nebo snímky iFrames k načtení a zobrazení přechodových součástí aplikace. (Existuje mnoho způsobů údržby
trvalosti dat, které lze použít navíc ke snímkům, nebo místo nich. Patří sem soubory cookies, místní sdílené objekty,
místní úložiště souborů, šifrované úložiště souborů a úložiště místní databáze.)
HTML si v aplikaci AIR uchovává svou normální, rozmazanou čáru mezi spustitelným kódem a daty. V důsledku toho
aplikace AIR vloží obsah do horního snímku prostředí HTML do karantény zabezpečení aplikace a omezuje jakékoliv
operace, například eval(), které mohou převést řetězec textu do spustitelného objektu. Toto omezení je vynuceno i v
případě, že aplikace nenačte vzdálený obsah. Chcete-li pracovat zabezpečeným způsobem se vzdáleným obsahem
HTML v aplikaci AIR, musíte použít snímky nebo snímky iframes. I když nenačtete vzdálený obsah, může být
pohodlnější spustit obsah v závislém snímku v karanténě zabezpečení, aby tak obsah mohl být spouštěn bez omezení
v eval(). (Uzavření do karantény zabezpečení může být nutné v případě, že používáte aplikační struktury JavaScript.)
Úplný seznam omezení jazyka JavaScript v karanténě zabezpečení aplikace, viz také „Omezení kódu pro obsah v
různých karanténách zabezpečení“ na stránce 31.
Protože si HTML v aplikaci AIR uchovává schopnost načítat vzdálený, patrně nezabezpečený obsah, aplikace AIR si
vynucuje zásady, které zabraňují obsahu v jedné doméně, aby spolupracoval s obsahem v jiné doméně. Aby byla možná
spolupráce mezi obsahem aplikace a obsahem v jiné doméně, nastavte můstek, který bude sloužit jako rozhraní mezi
řídicím a závislým snímkem.
Nastavení vztahu mezi řídicí a závislou karanténou zabezpečení
Aplikace AIR přidá atributy sandboxRoot a documentRoot do prvků frame a iframe v HTML. Tyto atributy umožní
jednat s obsahem aplikace, jako by pocházel z jiné domény.
Atribut
Popis
sandboxRoot
Adresa URL, kterou použijete pro stanovené karantény zabezpečení a domény, do které umístíte obsah snímku. Je
třeba použít schéma URL file:, http: nebo https:.
documentRoot
Adresa URL, ze které se nahrává obsah snímku. Je třeba použít schéma URL file:, app: nebo app-storage:.
Následující příklad mapuje obsah nainstalovaný v podadresáři karantény zabezpečení aplikace, který se spustí ve
vzdálené karanténě zabezpečení a v doméně www.example.com:
<iframe
src="ui.html"
sandboxRoot="http://www.example.com/local/"
documentRoot="app:/sandbox/">
</iframe>
Nastavení můstku mezi řídicími a závislými snímky v různých karanténách zabezpečení
nebo doménách
Aplikace AIR přidává vlastnosti childSandboxBridge a parentSandboxBridge do objektu window kteréhokoliv
závislého snímku. Tyto vlastnosti umožňují definovat mosty, které slouží jako rozhraní mezi řídicím a závislým
snímkem. Každý snímek se pohybuje jedním směrem:
childSandboxBridge - vlastnost childSandboxBridge umožňuje závislému snímku zpřístupnit rozhraní obsahu v
řídicím snímku. Chcete-li zpřístupnit rozhraní, nastavte vlastnost childSandbox na funkci nebo objekt v závislém
snímku. Můžete pak přistupovat k objektu nebo funkci z obsahu v řídicím snímku. Následující příklad ukazuje, jakým
způsobem může skript spuštěný v závislém snímku zpřístupnit objekt obsahující funkci a vlastnost pro řídicí objekt:
var interface = {};
interface.calculatePrice = function(){
return .45 + 1.20;
}
interface.storeID = "abc"
window.childSandboxBridge = interface;
Pokud je závislý obsah ve snímku iframe přiřazen id pro „závislý objekt", můžete zpřístupnit rozhraní z řídicího
obsahu načtením vlastnosti childSandboxBridge snímku:
var childInterface = document.getElementById("child").childSandboxBridge;
air.trace(childInterface.calculatePrice()); //traces "1.65"
air.trace(childInterface.storeID)); //traces "abc"
parentSandboxBridge - vlastnost parentSandboxBridge umožňuje řídicímu snímku zpřístupnit rozhraní obsahu
v závislém snímku. Chcete-li zpřístupnit rozhraní, nastavte vlastnost parentSandbox závislého snímku na funkci
nebo objekt v řídicím snímku. Můžete pak přistupovat k objektu nebo funkci z obsahu v závislém snímku. Následující
příklad ukazuje, jak skript spuštěný v řídicím snímku může zpřístupnit objekt obsahující funkci uložení pro závislý
objekt:
var interface = {};
interface.save = function(text){
var saveFile = air.File("app-storage:/save.txt");
//write text to file
}
document.getElementById("child").parentSandboxBridge = interface;
Pomocí tohoto rozhraní může obsah v závislém snímku uložit text do souboru pojmenovaného save.txt. Nicméně
nebude mít žádný jiný přístup do systému souborů. Obecně by měl obsah aplikace zpřístupnit ostatním karanténám
zabezpečení nejužší možné rozhraní. Podřízený obsah by mohl vyvolat funkci save následujícím způsobem:
var textToSave = "A string.";
window.parentSandboxBridge.save(textToSave);
Pokud se podřízený obsah pokusí nastavit vlastnost objektu parentSandboxBridge, modul runtime odešle výjimku
SecurityError. Pokud se řídicí obsah pokusí nastavit vlastnost objektu childSandboxBridge, modul runtime odešle
výjimku SecurityError.
Omezení kódu pro obsah v různých karanténách zabezpečení
Jak bylo popsáno v úvodu tohoto tématu, „Zabezpečení HTML“ na stránce 29, modul runtime si vynucuje pravidla a
poskytuje mechanismy pro překonání možných bezpečnostních zranitelností v HTML a jazyce JavaScript. Toto téma
popisuje uvedená omezení. Pokud se kód pokusí zavolat tato omezená rozhraní API, modul runtime odešle chybu s
hlášením „Narušení bezpečnosti modulu runtime aplikace Adobe AIR pro kód JavaScript v karanténě zabezpečení
aplikace.“
Omezení pro používání funkce eval() jazyka JavaScript a podobných technik
Pro obsah HTML v karanténě zabezpečení aplikace existují omezení pro použití rozhraní API, které může dynamicky
transformovat řetězce do spustitelného kódu poté, co je kód načten (po odeslání události onload prvku body a
dokončení spouštění funkce manipulačního programu onload). Tak tomu je proto, aby aplikaci bylo zabráněno v
náhodném vložení (a spuštění) kódu z neaplikačních zdrojů (například jako potenciálně nezabezpečené síťové
domény).
Pokud například aplikace použijte data řetězce ze vzdáleného zdroje pro zápis vlastnosti innerHTML prvku DOM,
řetězec by mohl zahrnovat spustitelný kód (JavaScript), který může provádět nezabezpečené operace. Nicméně,
zatímco se načítá obsah, nehrozí žádné riziko vložení vzdálených řetězců do DOM.
Jedním omezením je použití funkce eval() jazyka JavaScript. Jakmile je kód v karanténě zabezpečení aplikace načten
a po zpracování události onload manipulačním programem, můžete funkci eval() použít pouze omezenými způsoby.
Následující pravidla platí pro použití funkce eval()poté, co byl kód načten z karantény zabezpečení aplikace.
• Výrazy zahrnující literály jsou povoleny Například:
eval("null");
eval("3 + .14");
eval("'foo'");
• Literály objektů jsou povoleny, jako v následujícím příkladu:
{ prop1: val1, prop2: val2 }
• Literál objektu setter/getter je zakázán, jako v následujícím příkladu:
{ get prop1() { ... }, set prop1(v) { ... } }
• Literály polí jsou povoleny, jako v následujícím příkladu:
[ val1, val2, val3 ]
• Výrazy zahrnující čtení vlastností jsou zakázány, jako v následujícím příkladu:
a.b.c
• Vyvolání funkce je zakázáno.
• Definice funkcí jsou zakázány.
• Nastavení kterékoliv vlastnosti je zakázáno.
• Literály funkcí jsou zakázány.
Nicméně, když se načítá kód, před událostí onload a během vykonávání události onload manipulačním programem,
tato omezení neplatí pro obsah v karanténě zabezpečení aplikace.
Například po načtení kódu vede následující kód k tomu, že modul runtime odešle výjimku:
eval("alert(44)");
eval("myFunction(44)");
eval("NativeApplication.applicationID");
Dynamicky generovaný kód, například takový, který vznikne při zavolání funkce eval(), bude znamenat
bezpečnostní riziko v případě, že mu bude umožněn přístup do karantény zabezpečení aplikace. Například aplikace
může náhodně vykonat řetězec načtený ze síťové domény a tento řetězec může obsahovat škodlivý kód. Například toto
může být kód, který odstraní nebo změní soubory v počítači uživatele. Nebo se může jednat o kód, který nahlásí obsah
místního souboru nedůvěryhodné síťové doméně.
Způsoby generování dynamického kódu jsou následující:
• Zavolání funkce eval().
• Použití vlastností innerHTML nebo funkcí DOM pro vložení značek skriptu, které načtou skript mimo adresář
aplikace.
• Použití vlastností innerHTML nebo funkcí DOM pro vložení značek skriptu, které mají vřazený kód (spíše než
načtení skriptu prostřednictvím atributu src).
• Nastavení atributu src pro značky script pro načtení souboru jazyka JavaScript, který je mimo adresář aplikace.
• Použití schémata URL javascript (jako v href=„javascript:alert('Test')").
• Použití funkcí setInterval() nebo setTimout(), kde první parametr (definující funkci pro asynchronní
spuštění) je řetězec (bude se hodnotit), spíše než název funkce (jako v setTimeout('x = 4', 1000)).
• Volání document.write() nebo document.writeln().
Kód v karanténě zabezpečení aplikace může používat tyto metody pouze v případě, že se načítá obsah.
Tato omezení nezabraňují použití eval() s literály objektu JSON. Umožňuje pracovat obsahu aplikace s knihovnou
JSON JavaScript. Jste však omezeni v používání přetíženého kódu JSON (s manipulačními programy událostí).
Vzhledem k dalším strukturám Ajax a knihovnám kódu JavaScript je nutné si ověřit, zda struktura nebo knihovna
pracuje s těmito omezeními a dynamicky generovaným kódem. Pokud tomu tak není, zahrňte kterýkoliv obsah
používající strukturu nebo knihovnu do neaplikační karantény zabezpečení. Podrobnosti viz také „Oprávnění obsahu
v neaplikačních karanténách zabezpečení“ na stránce 28 a „Skriptování mezi aplikačním a neaplikačním obsahem“ na
stránce 38. Společnost Adobe uchovává seznam struktury Ajax známé svou podpornou karantény zabezpečení
aplikace na adrese http://www.adobe.com/products/air/develop/ajax/features/.
Na rozdíl od obsahu v karanténě zabezpečení aplikace, obsah jazyka JavaScript v neaplikační karanténě zabezpečení
může kdykoliv volat funkci eval() pro vykonání dynamicky generovaného kódu.
Omezení přístupu k rozhraní API aplikace AIR (pro neaplikační karantény zabezpečení)
Kód JavaScript v neaplikační karanténě zabezpečení nemá přístup do objektu window.runtime a takový kód nemůže
rozhraní API aplikace AIR vykonat. Pokud obsah v neaplikační karanténě zabezpečení zavolá následující kód, aplikace
odešle výjimku TypeError.
try {
window.runtime.flash.system.NativeApplication.nativeApplication.exit();
}
catch (e)
{
alert(e);
}
Typ výjimky je TypeError (nedefinovaná hodnota), protože obsah v neaplikační karanténě zabezpečení nerozpozná
objekt window.runtime, takže je vidět jako nedefinovaná hodnota.
Funkci modulu runtime můžete zpřístupnit obsah v neaplikační karanténě zabezpečení pomocí mostu skriptu.
Podrobnosti viz také „Skriptování mezi aplikačním a neaplikačním obsahem“ na stránce 38.
Omezení při používání volání XMLHttpRequest
Obsah HTML v karanténě zabezpečení aplikace nemůže používat synchronní metody XMLHttpRequest pro načtení
data z vnější strany karantény zabezpečení aplikace, když se načítá obsah HTML a během události onLoad.
Standardně obsah HTML v neaplikační karanténě zabezpečení nesmí používat objekt JavaScript XMLHttpRequest k
načtení dat z domén jiných, než jsou domény volající požadavek. Značka frame nebo iframe může zahrnovat atribut
allowcrosscomainxhr. Nastavení tohoto atributu na nenulovou hodnotu umožní obsahu v snímku nebo snímku
iframe použít objekt Javascript XMLHttpRequest k načtení dat z domén jiných, než jsou domény kódu volajícího
požadavek:
<iframe id="UI"
src="http://example.com/ui.html"
sandboxRoot="http://example.com/"
allowcrossDomainxhr="true"
documentRoot="app:/">
</iframe>
Další informace viz „Skriptování mezi obsahem v různých doménách“ na stránce 34.
Omezení pro načítání prvků CSS, frame, iframe a img (pro obsah v neaplikačních
karanténách zabezpečení)
Obsah HTML ve vzdálených (síťových) karanténách zabezpečení může načítat pouze obsah CSS, frame, iframe a img
ze vzdálených karantén zabezpečení(ze síťových adres URL).
Obsah HTML v karanténách zabezpečení lokální-se-systémem souborů, lokální-se-sítí nebo lokální-důvěryhodný
mohou pouze načítat obsah CSS, frame, iframe a img z místních karantén zabezpečení (nikoliv z aplikačních nebo
vzdálených karantén zabezpečení).
Omezení pro volání metody JavaScript window.open()
Pokud okno vytvořené voláním metody JavaScript window.open() zobrazí obsah z neaplikační karantény
zabezpečení, název okna začíná názvem hlavního (spouštěcího) okna, poté následující znak dvojtečky. Nemůžete
používat kód k přesunutí této části názvu okna mimo obrazovku.
Obsah v neaplikačních karanténách zabezpečení může zavolat úspěšně metodu JavaScript window.open() pouze v
případě odezvy na událost aktivovanou myší nebo klávesnicí uživatele. To zabraňuje neaplikačnímu obsahu ve
vytváření oken, které mohou být použity pro škodlivé operace (například phishingové útoky). Manipulační program
událostí pro událost myši nebo klávesnice nemůže nastavit metodu window.open() tak, aby se vykonala po prodlevě
(například zavoláním funkce setTimeout()).
Obsah ve vzdálené (síťové) karanténě zabezpečení může použít metodu window.open() pouze k otevření obsahu ve
vzdálených síťových karanténách zabezpečení. Nemůže používat metodu window.open() k otevření obsahu z
aplikační nebo lokální karantény zabezpečení.
Obsah v karanténě zabezpečení typu lokální-se-systémem souborů, lokální-se-sítí, nebo lokální-důvěryhodné (viz
„Karantény zabezpečení“ na stránce 26 ), může použít metodu window.open() pouze k otevření obsahu v lokální
karanténě zabezpečení. Nemůže používat metodu window.open() k otevření obsahu z aplikační nebo vzdálené
karantény zabezpečení.
Chyby při volání omezeného kódu
Jestliže voláte kód, který má kvůli těmto omezením vyplývajícím ze zabezpečení zakázáno používat karanténu, odešle
běhový modul chybu jazyka JavaScript: „Narušení bezpečnosti běhu aplikace Adobe AIR pro kód JavaScript v
karanténě zabezpečení aplikace“.
Skriptování mezi obsahem v různých doménách
Aplikace AIR mají speciální oprávnění, když jsou nainstalovány. Je důležité, že stejná oprávnění nesmí uniknout k
jinému obsahu, včetně vzdálených souborů a místních souborů, které nejsou součástí aplikace.
O mostu karantény zabezpečení aplikace AIR
Normálně obsah z jiných domén nemůže volat skripty v jiných doménách. K ochraně aplikací AIR před náhodnými
úniky informací o oprávnění nebo řízení jsou pro obsah použita následující omezení v karanténě zabezpečení
aplikace (obsah nainstalovaný s aplikací):
• Kód v karanténě zabezpečení aplikace nemůže povolit jiné karantény zabezpečení zavoláním metody
Security.allowDomain(). Zavolání této metody z karantény zabezpečení aplikace nemá žádný účinek.
• Importování neaplikačního obsahu do karantény zabezpečení aplikace nastavením vlastnosti
LoaderContext.securityDomain nebo LoaderContext.applicationDomain je zamezeno.
Existují stále případy, kde hlavní aplikace AIR vyžaduje, aby obsah ze vzdálené domény měl řízený přístup ke skriptům
v hlavní aplikaci AIR, nebo naopak. K dosažení tohoto stavu modul runtime poskytuje mechanismu mostu karantény
zabezpečení, který slouží jako brána mezi dvěma karanténami zabezpečení. Most karantény zabezpečení může
poskytnout výslovnou interakci mezi vzdálenými a aplikačními karanténami zabezpečení.
Most karantény zabezpečení zpřístupňuje dva objekty, ke kterým může přistupovat jak načtený, tak i načítající skript:
• Objekt parentSandboxBridge umožňuje načítajícímu obsahu zpřístupnit vlastnosti a funkce pro skripty v
načteném obsahu.
• Objekt childSandboxBridge umožňuje načtenému obsahu zpřístupnit vlastnosti a funkce pro skripty v
načítajícím obsahu.
Objekty zpřístupněné prostřednictvím mostu karantény zabezpečení jsou předány ve formě hodnoty, nikoliv pomocí
reference. Všechna data jsou serializována. To znamená, že objekty zpřístupněné jednou stranou mostu nemohou být
nastaveny druhou stranou a že zpřístupněné objekty jsou všechny bez typu. Můžete také zpřístupnit pouze jednoduché
objekty a funkce; nemůžete zpřístupnit komplexní objekty.
Pokud se podřízený obsah pokusí nastavit vlastnost objektu parentSandboxBridge, modul runtime odešle výjimku
SecurityError. Podobně, pokud se řídicí obsah pokusí nastavit vlastnost objektu childSandboxBridge, modul runtime
odešle výjimku SecurityError.
Příklad mostu karantény zabezpečení (SWF)
Předpokládejme, že aplikace obchodu s hudbou AIR chcete povolit vzdáleným souborům SWF vysílat cenu alb, ale
nechte, aby vzdálené soubory SWF zjistily, zda je cena také cenou prodejní. To se provede tak, že třída StoreAPI
poskytne metodu pro získání ceny, ale zablokuje cenu prodejní. Instance této třídy StoreAPI je pak přiřazena vlastnosti
parentSandboxBridge objektu LoaderInfo pro objekt Loader, který načítá vzdálený soubor SWF.
Následující kód je pro obchod s hudbou AIR:
<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute"
title="Music Store" creationComplete="initApp()">
<mx:Script>
import flash.display.Loader;
import flash.net.URLRequest;
private var child:Loader;
private var isSale:Boolean = false;
private function initApp():void {
var request:URLRequest =
new URLRequest("http://[www.yourdomain.com]/PriceQuoter.swf")
child = new Loader();
child.contentLoaderInfo.parentSandboxBridge = new StoreAPI(this);
child.load(request);
container.addChild(child);
}
public function getRegularAlbumPrice():String {
return "$11.99";
}
public function getSaleAlbumPrice():String {
return "$9.99";
}
public function getAlbumPrice():String {
if(isSale) {
return getSaleAlbumPrice();
}
else {
return getRegularAlbumPrice();
}
}
</mx:Script>
<mx:UIComponent id="container" />
</mx:WindowedApplication>
Objekt StoreAPI zavolá hlavní aplikaci, aby načetl standardní cenu alba, ale vrátí „Nedostupné“, pokud je zavolána
metoda getSaleAlbumPrice(). Následující kód definuje třídu StoreAPI:
public class StoreAPI
{
private static var musicStore:Object;
public function StoreAPI(musicStore:Object)
{
this.musicStore = musicStore;
}
public function getRegularAlbumPrice():String {
return musicStore.getRegularAlbumPrice();
}
public function getSaleAlbumPrice():String {
return "Not available";
}
public function getAlbumPrice():String {
return musicStore.getRegularAlbumPrice();
}
}
Následující kód představuje příklad souboru PriceQuoter SWF, který hlásí cenu obchodu, ale nehlásí prodejní cenu:
package
{
import flash.display.Sprite;
import flash.system.Security;
import flash.text.*;
public class PriceQuoter extends Sprite
{
private var storeRequester:Object;
public function PriceQuoter() {
trace("Initializing child SWF");
trace("Child sandbox: " + Security.sandboxType);
storeRequester = loaderInfo.parentSandboxBridge;
var tf:TextField = new TextField();
tf.autoSize = TextFieldAutoSize.LEFT;
addChild(tf);
tf.appendText("Store price of album is: " + storeRequester.getAlbumPrice());
tf.appendText("\n");
tf.appendText("Sale price of album is: " + storeRequester.getSaleAlbumPrice());
}
}
}
Příklad mostu karantény zabezpečení (HTML)
V obsahu HTML jsou vlastnosti parentSandboxBridge a childSandboxBridge přidány k objektu v okně JavaScript
podřízeného dokumentu. Příklad nastavení funkcí mostu v obsahu HTML viz také „Vytvoření rozhraní mostu
karantény“ na stránce 222.
Omezení vystavení API
Při vystavení (zpřístupnění) mostů karantény zabezpečení je důležité vystavovat pouze rozhraní API horní úrovně, což
omezuje míru, ve které mohou být tato rozhraní zneužita. Mějte na paměti, že obsah volající vaši implementaci mostu
může být narušen (například prostřednictvím proniknutí kódu). Například vystavením metody
readFile(path:String) (která načítá obsah libovolného souboru) prostřednictvím mostu je velmi snadno
zneužitelné. Bylo by vhodnější vystavit rozhraní API readApplicationSetting(), které nevyužívá cestu a načte
specifický soubor. Sémantičtější přístup omezuje možnosti poškození, které může aplikace způsobit poté, co je její část
narušena.
Viz také
„Vytváření křížových skriptů pro obsah v různých karanténách zabezpečení“ na stránce 221
„Karanténa zabezpečení aplikace“ na stránce 27
„Oprávnění obsahu v neaplikačních karanténách zabezpečení“ na stránce 28
Zápis na disk
Aplikace spuštěná ve webovém prohlížeči má pouze omezenou interakci s místním systémem souborů uživatele.
Webový prohlížeč implementuje zásady zabezpečení pro zajištění, aby počítač uživatele nemohl být narušen v
důsledku načítání webového obsahu. Například soubory SWF spouštění aplikací Flash Player v prohlížeči nemohou
přímo spolupracovat se soubory, které jsou již v počítači uživatele umístěny. Sdílené objekty a soubory cookie mohou
být zapsány do počítače uživatele pro účely uchování uživatelských předvoleb a dalších dat, ale to je limit interakce se
systémem souborů. Protože aplikace AIR jsou nativně nainstalovány, mají odlišné dohody o zabezpečení; jedna z nich
zahrnuje možnost čtení a zápisu v lokálním systému souborů.
Tato svoboda je však vykoupena nutně vysokou odpovědností vývojářů. Náhodné nezabezpečení aplikace ohrožuje
nejenom funkčnost aplikace, ale také integritu počítače uživatele. Z tohoto důvodu by si vývojáři měli prostudovat
kapitolu „Nejlepší postupy zabezpečení pro vývojáře“ na stránce 39.
Vývojáři aplikace AIR mohou přistupovat k souborům a zapisovat je do lokálního souborového systému pomocí
několika konvencí schémat URL:
schéma URL
Popis
app:/
Alias adresáře aplikace. Soubory zpřístupněné z této cesty jsou přiřazeny karanténě zabezpečení aplikace a mají
úplné oprávnění zaručené modulem runtime.
app-storage:/
Alias lokálního adresáře pro ukládání dat, standardizovaný modulem runtime. Soubory zpřístupněné z této cesty
jsou přiřazeny neaplikační karanténě zabezpečení.
file:///
Alias zastupující kořen pevného disku uživatele. Soubor zpřístupněný z této cesty je přiřazen karanténě
zabezpečení aplikace, pokud soubor existuje v adresáři aplikace, jinak je přiřazen neaplikační karanténě
zabezpečení.
Poznámka: Aplikace AIR nemohou modifikovat obsah pomocí schématu URL app: Také adresář aplikace může být
pouze ke čtení v důsledku administrátorských nastavení.
Pokud existují omezení pro správce počítače uživatele, aplikace AIR mají oprávnění k zápisu v libovolném umístění
pevného disku uživatele. Vývojářům se doporučuje používat cestu app-storage:/ pro místní ukládání dat,
souvisejících s aplikací. Soubory zapsané do app-storage:/ z aplikace jsou uloženy do standardního umístění:
• Mac OS: adresář pro uložení dat aplikace je <appData>/<appId>/Local
Store/, kde <appData> je složka
předvoleb uživatele. To je typicky adresář /Users/<user>/Library/Preferences
• Windows: adresář pro uložení dat aplikace je <appData>\<appId>\Local
Store\, kde <appData> je speciální
složka CSIDL_APPDATA uživatele. To je typicky adresář C:\Documents and
Settings\<userName>\Application Data
Pokud je aplikace navržena tak, aby spolupracovala se stávajícími soubory v souborovém systému uživatele,
nezapomeňte si prostudovat kapitolu „Nejlepší postupy zabezpečení pro vývojáře“ na stránce 39.
Bezpečná práce s nedůvěryhodným obsahem
Obsah nepřiřazený karanténě zabezpečení aplikace může poskytnout další funkci skriptování pro vaši aplikaci, ale
pouze pokud splňuje kritéria zabezpečení modulu runtime. Toto téma vysvětluje dohodu zabezpečení aplikace AIR s
neaplikačním obsahem.
Security.allowDomain()
Aplikace AIR omezuje přístup ke skriptování pro neaplikační obsah přísněji, než nakolik zásuvný modul prohlížeče
aplikace Flash Player 9 omezuje přístup ke skriptování pro nedůvěryhodný obsah. Například v aplikaci Flash Player v
prohlížeči, když soubor SWF přidělený k lokální-d v ryhodné karanténě zabezpečení zavolá metodu
System.allowDomain(), skriptovací přístup je zajištěn všem souborům SWF načteným ze specifikované domény, s
opakovaným přiřazením tohoto vzdáleného souboru ze vzdálené karantény zabezpečení do lokální-d v ryhodné
karantény zabezpečení . Analogický přístup není z obsahu aplikacev aplikacích AIR povolen, protože by zaručil
nepřiměřený přístup do neaplikačního souboru v systému souborů uživatele. Vzdálené soubory nemohou přímo
přistupovat ke karanténě zabezpečení aplikace, bez ohledu na volání metody Security.allowDomain().
Skriptování mezi aplikačním a neaplikačním obsahem
Aplikace AIR, které skriptují mezi aplikačním a neaplikačním obsahem, mají komplexnější uspořádání zabezpečení.
Soubory, které nejsou v karanténě zabezpečení aplikace, mají povoleno přistupovat pouze k vlastnostem a metodám
souborů v karanténě zabezpečení aplikace prostřednictvím použití mostu karantény zabezpečení. Most karantény
zabezpečení plní funkci brány mezi aplikačním obsahem a neaplikačním obsahem, poskytuje tak explicitní interakci
mezi dvěma soubory. Při správném použití most karantény zabezpečení poskytuje dodatečnou vrstvu zabezpečení,
omezující neaplikační obsah v přístupu k referencím objektu, které jsou součástí aplikačního obsahu.
Výhoda mostů karantény zabezpečení je nejlépe ilustrována na příkladu. Předpokládejme, že aplikace obchodu s
hudbou AIR chce poskytnout rozhraní API pro zadavatele reklamy, který chce vytvořit vlastní soubory SWF, se kterým
bude moci aplikace obchodu poté komunikovat. Obchod chce poskytnout zadavatelům reklamy metody pro
vyhledávání interpretů a disků CD z obchodu, ale také chce z bezpečnostních důvodů izolovat některé metody a
vlastnosti od souboru SWF třetí strany.
Most karantény zabezpečení může tuto funkci poskytnout. Standardně obsah načtený externě do aplikace AIR za
chodu programu nemusí přistupovat k jakýmkoliv metodám nebo vlastnostem v hlavní aplikaci. S uživatelskou
implementací mostu karantény zabezpečení může vývojář poskytnout služby vzdálenému obsahu bez toho, že by tyto
metody nebo vlastnosti vystavil. Považujte most karantény zabezpečení za cestu mezi důvěryhodným a
nedůvěryhodným obsahem s poskytnutím komunikace mezi načítajícím a načítaným obsahem bez vystavení referencí
objektu.
Další informace o bezpečném způsobu použití mostů aplikace viz také „Skriptování mezi obsahem v různých
doménách“ na stránce 34.
Ochrana před dynamickým generováním nebezpečného obsahu SWF
Metoda Loader.loadBytes() poskytuje cestu pro aplikaci, aby mohla generovat obsah SWF z bajtového pole.
Nicméně útoky vsouváním kódu do dat načtených ze vzdálených zdrojů mohou těžce poškodit načítaný obsah. To je
obzvláště pravdivé při načítání dat do karantény zabezpečení aplikace, kde generovaný obsah SWF může přistupovat
k úplné sadě rozhraní API aplikace AIR.
Existuje legitimní použití metody loadBytes() bez generování spustitelného kódu SWF. Metodu loadBytes()
můžete například použít pro generování obrazových dat k řízení časování zobrazení obrázku. Existuje také legitimní
využití, které se spoléhá na spustitelný kód, například dynamické vytváření obsahu SWF pro přehrávání zvuku. V
aplikaci AIR metoda loadBytes() standardně neumožňuje načítání obsahu SWF; umožňuje pouze načítat obsah
obrazu. V aplikaci AIR má vlastnost loaderContext metody loadBytes() přiřazenou vlastnost
allowLoadBytesCodeExecution, kterou můžete nastavit na hodnotu true a explicitně tak povolit aplikaci používat
loadBytes() k načtení spustitelného obsahu SWF. Následujíc kód zobrazuje, jak používat tuto vlastnost:
var loader:Loader = new Loader();
var loaderContext:LoaderContext = new LoaderContext();
loaderContext.allowLoadBytesCodeExecution = true;
loader.loadBytes(bytes, loaderContext);
Pokud zavoláte loadBytes() k načtení obsahu SWF a vlastnost allowLoadBytesCodeExecution objektu
LoaderContext je nastavena na hodnotu false (výchozí), objekt Loader odešle výjimku SecurityError.
Poznámka: V budoucích verzích aplikace Adobe AIR se toto rozhraní API může změnit. Když k tomu dojde, budete
muset znovu zkompilovat obsah, který využívá vlastnost allowLoadBytesCodeExecution třídy LoaderContext.
Nejlepší postupy zabezpečení pro vývojáře
Ačkoliv jsou aplikace AIR vytvořeny s pomocí webových technologií, je důležité, aby si vývojáři uvědomili, že
nepracují uvnitř karantény zabezpečení prohlížeče. To znamená, že je možné vytvořit aplikace AIR, které mohou
lokální systém poškodit buď záměrně, nebo neúmyslně. Aplikace AIR se pokusí minimalizovat rizika, ale vždy existují
způsoby, jak mohou být zavedeny zranitelnosti. Toto téma pokrývá důležité potenciální nejistoty.
Rizika importování souborů do karantény zabezpečení aplikace
Soubory vyskytující se v adresáři aplikace jsou přiřazeny do karantény zabezpečení a mají úplná oprávnění modulu
runtime. Aplikace, které zapisují do místního systému souborů, by měly zapisovat do adresáře app-storage:/. Tento
adresář se vyskytuje nezávisle na souborech aplikace v počítači uživatele, proto soubory nejsou přiřazeny karanténě
zabezpečení aplikace a představují snížené bezpečnostní riziko. Vývojářům se doporučuje zvážit následující:
• Zahrnout soubor do souboru aplikace AIR (v nainstalované aplikaci) pouze v případě, že to je nutné.
• Zahrnout skriptovací soubor do souboru aplikace AIR (v nainstalované aplikaci) pouze v případě, že jeho chování
je zcela srozumitelné a důvěryhodné.
• Nezapisujte ani nemodifikujte obsah v adresáři aplikace. Modul runtime zabraňuje aplikacím v zápisu nebo
modifikování souborů a adresářů pomocí schématu URL app:/ a to odesláním výjimky SecurityError.
• Nepoužívejte data ze síťového zdroje jako parametry metod rozhraní API aplikace AIR, které mohou vést ke
spuštění kódu. Patří sem použití metody Loader.loadBytes() a funkce eval() jazyka JavaScript.
Riziko používání externího zdroje pro stanovení cest
Aplikace AIR může být narušena v případě, že se používají externí data nebo obsah. Z tohoto důvodu buďte obzvláště
opatrní při používání dat ze sítě nebo systému souborů. Břímě důvěryhodnosti je zcela na vývojáři a síťových
spojeních, která vytvoří, ale načtení cizích dat je přirozeným rizikem, proto by nemělo být používáno pro zadávání
vstupů pro citlivé operace. Vývojářům se nedoporučuje provádět následující operace:
• Používání dat ze síťového zdroje pro stanovení názvu souboru
• Používání dat ze síťového zdroje pro vytvoření adresy URL, kterou aplikace používá k odesílání soukromých
informací
Riziko používání, ukládání nebo přenášení nezabezpečených pověření
Uložení uživatelských pověření v lokálním systému souborů přirozeně zavádí rizika, která tato pověření mohou
narušit. Vývojářům se doporučuje zvážit následující:
• Pokud musí být pověření uložena lokálně, doporučuje se zašifrovat pověření při zápisu do lokálního systému
souborů. Modul runtime poskytuje zašifrované úložiště jedinečné pro každou nainstalovanou aplikaci a to
prostřednictvím třídy EncryptedLocalStore. Podrobnosti viz „Ukládání šifrovaných dat“ na stránce 190.
• Nepřenášejte nezašifrovaná uživatelská pověření do síťového zdroje, pokud není tento zdroj důvěryhodný.
• Nikdy nespecifikujte výchozí heslo při vytváření pověření - nechte uživatele vytvořit vlastní. Uživatelé, kteří
ponechají výchozí nastavení, vystavují svá pověření útočníkovi, který již zná výchozí heslo.
Riziko útoku pomocí downgradované verze aplikace
Během instalování aplikace modul runtime kontroluje a zjišťuje, aby daná verze aplikace nebyla aktuálně
nainstalovaná. Pokud tato aplikace již nainstalovaná je, modul runtime porovná řetězec verze proti verzi, která je již
nainstalovaná. Pokud je tato verze odlišná, uživatel si může vybrat aktualizaci instalace. Modul runtime nezaručuje, že
nově nainstalovaná verze je novější, než verze starší, pouze že je odlišná. Útočník může uživateli distribuovat starší
verzi a obejít tak slabé zabezpečení. Z tohoto důvodu se vývojářům doporučuje provést kontrolu verze, když je aplikace
spuštěna. Je vhodné, aby aplikace zkontrolovala síť s ohledem na požadované aktualizace. Tímto způsobem, i když
útočník zajistí, aby uživatel spustil starší verzi, tato stará verze rozpozná, že je nutné ji aktualizovat. Rovněž použitím
jasného schématu stanovení verzí pro vaši aplikaci znesnadníte zmatení uživatele a jeho navedení k nainstalování
downgradované verze. Podrobnosti o poskytování verzí aplikace viz také „Definování vlastností v souboru deskriptoru
Podepisování kódu
Všechny instalační programy aplikace AIR musí mít podepsaný kód. Podepisování kódu je kryptografický proces
potvrzení, že specifikovaný původ softwaru je správný. Aplikace AIR mohou být podepsány buď odkazem na certifikát
od externí certifikační autority (CA) nebo vytvořením vlastního certifikátu. Důrazně se doporučuje používat komerční
certifikát od dobře známé autority CA a poskytnout tak uživatelům jistotu, že instalují vaši aplikaci, nikoliv padělek.
Nicméně automaticky podepsané certifikáty lze vytvořit pomocí adt z SDK nebo pomocí vývojového prostředí Flash,
Flex Builder či jiné aplikace, který používá adt pro generování certifikátu. Automaticky podepsané certifikáty
neposkytují žádnou jistotu, že instalovaná aplikace je originální.
Další informace o digitálním podepsání aplikací AIR naleznete v kapitolách „Digitální podepisování souboru AIR“ na
stránce 285 a „Vytváření aplikace AIR pomocí nástrojů příkazového řádku“ na stránce 305.
42
Kapitola 8: Nastavení vlastností aplikace
AIR
Vedle všech těchto souborů a jiných datových zdrojů, které vytvářejí aplikaci AIR, vyžaduje každá aplikace AIR soubor
deskriptoru aplikace. Soubor deskriptoru aplikace je soubor XML, který definuje základní vlastnosti aplikace.
Při vyvíjení aplikací AIR pomocí programu Adobe® AIR™ Aktualizace pro Adobe® Flash® CS3 Professional, je soubor
deskriptoru aplikace automaticky vygenerován při vytvoření projektu AIR. Změnu nastavení deskriptoru aplikace
můžete provést v panelu v nabídce Příkazy > AIR - Nastavení aplikace a instalátoru. Soubor deskriptoru aplikace
můžete také upravit ručně.
Struktura souboru deskriptoru aplikace
Soubor deskriptoru aplikace obsahuje vlastnosti, které ovlivňují celou aplikaci, například její název, verzi, autorská
práva, atd. Pro soubor deskriptoru aplikace lze použít libovolný název souboru. Když vytvoříte soubor AIR v aplikaci
Flash CS3 nebo CS4 pomocí výchozího nastavení, je soubor deskriptoru aplikace přejmenován na application.xml
a umístěn do zvláštního adresáře v balíčku AIR.
Zde je příklad souboru deskriptoru aplikace:
<?xml version="1.0" encoding="utf-8" ?>
<application xmlns="http://ns.adobe.com/air/application/1.1">
<id>com.example.HelloWorld</id>
<version>2.0</version>
<filename>Hello World</filename>
<name>Example Co. AIR Hello World</name>
<description>
<text xml:lang="en">This is a example.</text>
<text xml:lang="fr">C'est un exemple.</text>
<text xml:lang="es">Esto es un ejemplo.</text>
</description>
<copyright>Copyright (c) 2006 Example Co.</copyright>
<initialWindow>
<title>Hello World</title>
<content>
HelloWorld-debug.swf
</content>
<systemChrome>none</systemChrome>
<transparent>true</transparent>
<visible>true</visible>
<minimizable>true</minimizable>
<maximizable>false</maximizable>
<resizable>false</resizable>
<width>640</width>
<height>480</height>
<minSize>320 240</minSize>
<maxSize>1280 960</maxSize>
</initialWindow>
<installFolder>Example Co/Hello World</installFolder>
<programMenuFolder>Example Co</programMenuFolder>
Nastavení vlastností aplikace AIR
<icon>
<image16x16>icons/smallIcon.png</image16x16>
<image32x32>icons/mediumIcon.png</image32x32>
<image48x48>icons/bigIcon.png</image48x48>
<image128x128>icons/biggestIcon.png</image128x128>
</icon>
<customUpdateUI>true</customUpdateUI>
<allowBrowserInvocation>false</allowBrowserInvocation>
<fileTypes>
<fileType>
<name>adobe.VideoFile</name>
<extension>avf</extension>
<description>Adobe Video File</description>
<contentType>application/vnd.adobe.video-file</contentType>
<icon>
<image16x16>icons/avfIcon_16.png</image16x16>
</icon>
</fileType>
</fileTypes>
</application>
Definování vlastností v souboru deskriptoru aplikace
Ve svých kořenech obsahuje soubor deskriptoru aplikace vlastnost application, která má několik atributů:
<application version="1.0" xmlns="http://ns.adobe.com/air/application/1.1">
xmlns Jmenný prostor AIR, který musíte definovat jako výchozí jmenný prostor XML. Jmenný prostor se změní s
každou hlavní verzí AIR (ale nikoliv s malými záplatami). Poslední segment jmenného prostoru, například „1.0“,
určuje verzi runtime vyžadovanou aplikací.
minimumPatchLevel Volitelné. Použijte atribut minimumPatchLevel pro určení minimální úrovně záplaty Adobe
AIR vyžadované aplikací. Aplikace AIR obvykle určují požadované verze aplikace AIR jednoduchým definováním
jmenného prostoru v souboru deskriptoru aplikace. Jmenný prostor se změní pro každou hlavní verzi AIR (například
1.0 nebo 1.1). Jmenný prostor se nemění pro verzi záplaty. Verze záplaty obsahuje pouze omezenou sadu oprav a žádné
změny rozhraní API. Aplikace obvykle neurčují, které verze záplaty vyžadují. Nicméně oprava ve verzi záplaty může
opravit problém v aplikaci. V této situaci může aplikace určit hodnotu pro atributminimumPatchLevel a zajistit, že je
záplata použita před nainstalováním aplikace. Je-li to nezbytné, požádá Instalátor aplikace AIR uživatele o stažení a
instalaci vyžadované verze záplaty. Následující příklad ukazuje element aplikace, který určuje hodnotu pro atribut
minimumPatchLevel:
<application version="1.0"
xmlns="http://ns.adobe.com/air/application/1.1"
minimumPatchLevel="5331">
Definice základních informací aplikace
Následující elementy definují ID aplikace, verzi, název, název souboru, popis a informace o autorských právech:
<id>com.example.samples.TestApp</id>
<version>2.0</version>
<filename>TestApp</filename>
<name>
<text xml:lang="en">Hello AIR</text>
<text xml:lang="fr">Bonjour AIR</text>
<text xml:lang="es">Hola AIR</text>
</name>
<description>An MP3 player.</description>
<copyright>Copyright (c) 2008 YourCompany, Inc.</copyright>
id Řetězec identifikátoru jedinečný pro danou aplikaci, který je znám jako ID aplikace. Hodnota atributu je omezena
na následující znaky:
• 0–9
• a–z
• A–Z
• . (tečka)
• - (pomlčka)
Hodnota musí obsahovat 1 až 212 znaků. Tento element je vyžadován.
Řetězec id obvykle používá hierarchii oddělenou tečkou v zarovnání s obrácenou adresou domény DNS, názvem
balíku nebo třídy jazyka Java™ nebo univerzálním identifikátorem typu pro OS Mac ® X. Formulář podobný DNS není
použit a AIR nevytvoří žádné asociace mezi názvem a vlastními doménami DNS.
version Určuje informaci o verzi aplikace. (Nemá souvislost s verzí runtime). Řetězec verze je aplikací definovaný
oddělovač. AIR řetězec žádným způsobem neinterpretuje. Proto se nepředpokládá, že verze „3.0“ je aktuálnější než
verze „2.0“. Příklady: „1.0", „.4", „0.5“, „4.9", „1.3.4a". Tento element je vyžadován.
filename Řetězec, který bude použit jako název souboru aplikace (bez přípony) při její instalaci. Soubor aplikace spustí
aplikaci AIR v době běhu. Jestliže není k dispozici žádná hodnota name, použije se tedy také název složky instalace
filename. Tento element je vyžadován.
Vlastnost filename může obsahovat jakýkoliv znak Unicode (UTF-8), s výjimkou následujících, které nemohou být
v různých systémech použity jako názvy souborů:
Znak
Hexadecimální kód
různé
0x00 – x1F
*
x2A
“
x22
:
x3A
>
x3C
<
x3E
?
x3F
\
x5C
|
x7C
Hodnota filename nemůže skončit v období.
name (Volitelné, ale doporučeno) Titul zobrazený instalátorem aplikace AIR.
Jestliže určíte jediný textový uzel (namísto více elementůtextu), používá instalátor aplikace AIR tento název, a to bez
ohledu na jazyk systému:
<name>Test Application</name>
Schéma deskriptoru aplikace AIR 1.0 umožňuje pouze jeden jednoduchý textový uzel, který bude pro název definován
(nikoliv více elementů textu).
V programu AIR 1.1 můžete v elementu název určit více jazyků. Například následující určuje název ve třech jazycích
(angličtina, francouzština a španělština):
<name>
<text xml:lang="en">Hello AIR</text>
<text xml:lang="fr">Bonjour AIR</text>
<text xml:lang="es">Hola AIR</text>
</name>
Atribut xml:lang pro každý textový element určuje jazykový kód, dle definice v RFC4646
(http://www.ietf.org/rfc/rfc4646.txt).
Instalátor aplikace AIR používá název, který nejvíce odpovídá jazyku uživatelskému rozhranní operačního systému
uživatele. Vezměte například v úvahu instalaci, kde element názvu souboru deskriptoru aplikace zahrnuje hodnotu
pro místní nastavení „en“ (angličtina). Instalátor aplikace AIR používá název „en“, jestliže operační systém identifikuje
„en“ (angličtina) jako jazyk uživatelského rozhraní. Název „en“ také používá, jestliže jazyk uživatelského systému
jazyka je en-US (Americká angličtina). Nicméně pokud je rozhraní uživatelského jazyka en-US a soubor deskriptoru
aplikace definuje název en-US i en-GB, poté instalátor aplikace AIR používá hodnotu en-US. Jestliže aplikace
nedefinuje žádný název, který odpovídá jazykům uživatelského rozhraní systému, používá instalátor aplikace AIR
první hodnotu name definovanou v souboru deskriptoru aplikace.
Jestliže není určen žádný element name, instalátor aplikace AIR zobrazí filename jako název aplikace.
Element name definuje pouze titul aplikace použitý v instalátoru aplikace AIR. Instalátor aplikace AIR 1.1 podporuje
více jazyků: tradiční čínštinu, zjednodušenou čínština, angličtinu, francouzštinu, němčinu, italštinu, japonštinu,
korejštinu, brazilskou portugalštinu, ruštinu a španělštinu. Instalátor aplikace AIR zvolí svůj zobrazený jazyk (pro jiný
text než titul a popis aplikace) na základě jazyka uživatelského rozhraní systému. Tento výběr jazyka nezávisí na
nastavení v souboru deskriptoru aplikace.
Element name nedefinuje místní nastavení dostupné pro spuštěnou a nainstalovanou aplikaci. Podrobnosti o vyvíjení
aplikací s více jazyky naleznete v tématu „Lokalizace aplikací AIR“ na stránce 295.
description (Volitelné) Popis aplikace zobrazený v instalátoru aplikace AIR.
Jestliže určíte jediný textový uzel (nikoliv více elementů textu), používá instalátor aplikace AIR tento popis, a to bez
ohledu na jazyk systému:
<description>This is a sample AIR application.</description>
Schéma deskriptoru aplikace AIR 1.0 umožňuje pouze jeden jednoduchý textový uzel, který bude pro název definován
(nikoliv více elementů textu).
V programu AIR 1.1 můžete v elementu description určit více jazyků. Například následující určuje popis ve třech
jazycích (angličtina, francouzština a španělština):
<description>
<text xml:lang="en">This is a example.</text>
<text xml:lang="fr">C'est un exemple.</text>
<text xml:lang="es">Esto es un ejemplo.</text>
</description>
Atribut xml:lang pro každý textový element určuje jazykový kód, dle definice v RFC4646
(http://www.ietf.org/rfc/rfc4646.txt).
Instalátor aplikace AIR používá popis, který nejvíce odpovídá jazyku uživatelskému rozhranní operačního systému
uživatele. Vezměte například v úvahu instalaci, kde element description souboru deskriptoru aplikace zahrnuje
hodnotu pro místní nastavení „en“ (angličtina). Instalátor aplikace AIR používá název „en“, jestliže operační systém
identifikuje „en“ (angličtina) jako jazyk uživatelského rozhraní. Název „en“ také používá, jestliže jazyk uživatelského
systému jazyka je en-US (Americká angličtina). Nicméně pokud je rozhraní uživatelského jazyka en-US a soubor
deskriptoru aplikace definuje název en-US i en-GB, poté instalátor aplikace AIR používá hodnotu en-US. Jestliže
aplikace nedefinuje žádný název, který odpovídá jazyku uživatelského rozhraní systému, používá instalátor aplikace
AIR první hodnotu description definovanou v souboru deskriptoru aplikace.
Více informací o vyvíjení aplikací s více jazyky naleznete v tématu „Lokalizace aplikací AIR“ na stránce 295.
copyright (Volitelné) Informace o autorských právech pro aplikaci AIR. V OS Mac se text autorských práv pro
nainstalovanou aplikaci zobrazí v dialogovém okně Adobe. V OS Mac je informace o autorských právech také použita
v poli NSHumanReadableCopyright v souboru Info.plist aplikace.
Definice složky instalace a složky nabídky programu
Složky instalace a nabídky programu jsou definovány následujícím nastavením vlastností:
<installFolder>Acme</installFolder>
<programMenuFolder>Acme/Applications</programMenuFolder>
installFolder (Volitelné) Určuje podadresář výchozího adresáře aplikace.
V OS Windows je výchozím podadresářem instalace adresář Program Files. V OS Mac se jedná o adresář
/Applications. Například jestliže je vlastnost installFolder nastavena na „Acme" a aplikace je
pojmenována„ExampleApp", poté je aplikace instalována do umístění C:\Program Files\Acme\ExampleApp v OS
Windows a do /Applications/Acme/Example.app v OS Mac.
Použijte znak lomítka (/) jako znak oddělovače adresáře, jestliže si přejete určit vnořený podadresář, viz následující
příklad:
<installFolder>Acme/Power Tools</installFolder>
Vlastnost installFolder může obsahovat znak Unicode (UTF-8) s výjimkou těch, které nesmí být v různých
systémech použity jako názvy složek (viz vlastnost filename výše pro seznam výjimek).
Vlastnost installFolder je volitelná. Jestliže neurčíte žádnou vlastnost installFolder, je aplikace nainstalovaná
do podadresáře výchozího adresáře instalace, na základě vlastnosti name.
programMenuFolder (Volitelné) Určuje lokaci, kam budou umístěny zkratky aplikace v nabídce Všechny programy
operačního systému Windows. (Toto nastavení je aktuálně v jiných operačních systémech ignorováno.) Omezení pro
znaky, které jsou povoleny v hodnotě vlastnosti, jsou stejná jako omezení pro vlastnost installFolder. Znak lomítka
(/) nepoužívejte jako poslední znak této hodnoty.
Definice vlastností úvodního okna aplikace
Při načtení aplikace AIR používá runtime hodnoty v elementu initialWindow pro vytvoření úvodního okna pro
danou aplikaci. Runtime poté načte soubor SWF nebo HTML určený v elementu content do okna.
Zde je příklad elementu initialWindow:
<initialWindow>
<content>AIRTunes.swf</content>
<title>AIR Tunes</title>
<systemChrome>none</systemChrome>
<transparent>true</transparent>
<visible>true</visible>
<minimizable>true</minimizable>
<maximizable>true</maximizable>
<resizable>true</resizable>
<width>400</width>
<height>600</height>
<x>150</x>
<y>150</y>
<minSize>300 300</minSize>
<maxSize>800 800</maxSize>
</initialWindow>
Podřazené elementy elementuinitialWindow nastavují vlastnosti okna, do kterého je kořenový soubor obsahu
načten.
content Hodnota určená pro elementcontent je adresou URL pro hlavní obsahový soubor aplikace. Může se jednat
buď o soubor SWF nebo soubor HTML. URL je určena relativně ke kořeni instalační složky aplikace. (Při spuštění
aplikace AIR s programem ADL je URL relativní ke složce obsahující soubor deskriptoru aplikace. Parametr rootdir programu ADL můžete použít pro určení odlišného kořenového adresáře.)
Poznámka: Vzhledem k tomu, že hodnota elementu obsahu je zpracovávána jako URL, musí být znaky v názvu
obsahového souboru kódovány dle URL podle pravidel definovaných v RFC 1738. Znaky mezer musí být například
kódovány jako %20.
title (Volitelný) Titul okna.
systemChrome (Volitelné) Jestliže tento atribut nastavíte na hodnotu standard, zobrazí se standardní systémový
chróm dodaný s operačním systémem. Jestliže atribut nastavíte na none, nezobrazí se žádný systémový chróm.
Nastavení systémového chrómu nelze provést za běhu.
transparent (Volitelné) Nastavte na „true", jestliže si přejete, aby okno aplikace podporovalo prolínání alfa. Okno s
průhledností se může vykreslovat pomaleji a vyžadovat více paměti. Nastavení průhlednosti nelze provést za běhu.
Důležité: Atribut transparent můžete pouze nastavit na hodnotu true, pokud je systemChrome nastaveno na
hodnotu none.
visible (Volitelné) Nastavte na hodnotu true, jestliže si přejete, aby bylo hlavní okno ihned po otevření viditelné.
Výchozí hodnota je false.
Zpočátku si můžete přát ponechat hlavní okno skryté, takže změny polohy okna, velikosti okna a rozvržení jeho
obsahu se nezobrazí. Poté můžete okno zobrazit voláním metody okna activate() nebo nastavením vlastnosti
visible na hodnotu true. Podrobnosti naleznete v tématu „Práce s nativními okny“ na stránce 54.
x, y, width, height (Volitelné) Počáteční ohraničení hlavního okna aplikace. Jestliže tyto hodnoty nenastavíte, bude
velikost okna určena nastavením v kořenovém souboru SWF nebo, v případě HTML, operačním systémem.
minSize, maxSize (Volitelné) Minimální a maximální velikost okna. Jestliže tyto hodnoty nenastavíte, budou určeny
operačním systémem.
minimizable, maximizable, resizable (Volitelné) Určuje, zda lze okno minimalizovat, maximalizovat a změnit jeho
velikost. Tato nastavení mají implicitně hodnotu true.
Poznámka: V operačním systému, například OS Mac X, kde je maximalizace oken operací změny velikosti, musí být
elementy maximalizace i změny velikosti nastaveny na hodnotu false, aby se zabránilo zvětšení nebo změně velikosti okna.
Určení souborů ikon
Vlastnost icon určuje jeden nebo více souborů ikon, které budou pro aplikaci použity. Zahrnutí ikony je volitelné.
Jestliže neurčíte vlastnosticon, zobrazí operační systém výchozí ikonu.
Určená cesta je relativní ke kořenovému adresáři aplikace. Soubory ikon musí být ve formátu PNG. Můžete určit
všechny z následujících velikostí ikon:
<icon>
<image16x16>icons/smallIcon.png</image16x16>
<image32x32>icons/mediumIcon.png</image32x32>
<image48x48>icons/bigIcon.png</image48x48>
<image128x128>icons/biggestIcon.png</image128x128>
</icon>
Jestliže je přítomen element pro danou velikost, musí mít obraz v souboru přesnou velikost odpovídající zadané
velikosti. Jestliže nejsou poskytnuty všechny velikosti, změní se nejbližší velikost tak, aby odpovídala danému použití
ikony operačním systémem.
Poznámka: Určené ikony nejsou automaticky přidány do balíku AIR. Soubory ikon musí být při zabalení aplikace
obsaženy ve svých příslušných relativních umístěních.
Pro dosažení nejlepších výsledků poskytněte pro každou z dostupných velikostí obraz. Mimo to se ujistěte, že ikony
vypadají reprezentativně v 16- i 32-bitových barevných režimech.
Poskytnutí zákaznického uživatelského rozhraní pro aktualizace aplikace
AIR nainstaluje a aktualizuje aplikace pomocí výchozích dialogových oken instalace. Pro aktualizaci aplikace můžete
nicméně poskytnout své vlastní uživatelské rozhraní. Pro určení, zda by vaše aplikace měla zpracovat proces
aktualizace sama, nastavte element customUpdateUI na hodnotu true:
Jestliže má nainstalovaná verze vaší aplikace element customUpdateUI nastavený na hodnotu true a uživatel poklepe
na soubor AIR pro novou verzi nebo nainstaluje aktualizaci aplikace pomocí funkce hladké instalace, otevře runtime
nainstalovanou verzi aplikace spíše než výchozí instalátor aplikace AIR. Logika vaší aplikace může poté určit, jak s
operací aktualizace pokračovat. (ID aplikace a ID vydavatele v souboru AIR musí odpovídat ID v nainstalované
aplikaci, aby mohla aktualizace pokračovat.)
Poznámka: Mechanismus customUpdateUI je k dispozici pouze tehdy, když je aplikace již nainstalována a uživatel
poklepe na instalační soubor AIR obsahující aktualizace nebo nainstaluje aktualizaci aplikace pomocí funkce hladké
instalace. Aktualizaci můžete stáhnout a spustit pomocí logiky své vlastní aplikace, která dle potřeby zobrazí vaše
uživatelské UI, ať je customUpdateUI nastaveno na hodnotu true nebo nikoliv.
Více informací naleznete v tématu „Aktualizace aplikací AIR“ na stránce 291.
Povolení vyvolání prohlížeče aplikace
Jestliže určíte následující nastavení, lze nainstalovanou aplikaci AIR spustit prostřednictvím funkce vyvolání
prohlížeče (když uživatel klepne na odkaz na stránce ve webovém prohlížeči):
<allowBrowserInvocation>true</allowBrowserInvocation>
Výchozí hodnota je false.
Jestliže tuto hodnotu nastavíte na true, určitě vezměte v úvahu dopady na zabezpečení popsané v tématu „Vyvolání z
prohlížeče“ na stránce 262.
Více informací naleznete v části „Instalace a spuštění aplikací AIR z webové stránky“ na stránce 277.
Deklarace asociací typů souborů
Element fileTypes vám umožňuje deklarovat typy souborů, se kterými lze aplikaci AIR asociovat. Při nainstalování
aplikace AIR je v operačním systému zaregistrován jakýkoliv deklarovaný typ souboru, a jestliže tyto typy souborů
ještě nejsou asociovány s jinou aplikací, jsou asociovány s aplikací AIR. Pro potlačení stávající asociace mezi typem
souboru a jinou aplikací použijte metodu NativeApplication.setAsDefaultApplication() v době běhu (nejlépe
se svolením uživatele).
Poznámka: Metody runtime mohou pouze spravovat asociace pro typy souborů deklarované v deskriptoru aplikace.
<fileTypes>
<fileType>
<name>adobe.VideoFile</name>
<extension>avf</extension>
<description>Adobe Video File</description>
<contentType>application/vnd.adobe.video-file</contentType>
<icon>
<image16x16>icons/AIRApp_16.png</image16x16>
</icon>
</fileType>
</fileTypes>
Element fileTypes je volitelný. Je-li přítomen, může obsahovat jakýkoliv počet elementů fileType.
Elementy name a extension jsou vyžadovány pro každou deklaraci fileType, kterou zahrnete. Stejný název lze
použít pro více přípon. Přípona jedinečným způsobem identifikuje typ souboru. (Všimněte si, že přípona je určena bez
předcházejí doby.) Element description je volitelný a je uživateli zobrazen prostřednictvím uživatelského rozhraní
operačního systému. Vlastnost contentType je také volitelná, ale pomáhá operačnímu systému vyhledat nejlepší
aplikaci, která soubor za určitých podmínek otevře. Tato hodnota by měla být typem MIME obsahu souboru.
Pro danou příponu souboru lze určit ikony, a to pomocí stejného formátu jako pro element ikony aplikace. Soubory
ikon musí být také obsaženy v instalačním souboru AIR (nejsou zabaleny automaticky).
Když je typ souboru asociovaný s aplikací AIR, bude aplikace vyvolána, kdykoliv uživatel otevře soubor daného typu.
Jestliže je aplikace již spuštěna, AIR automaticky odešle objekt InvokeEvent ke spuštěné instanci. V opačném případě
AIR nejprve spustí aplikaci. V obou případech lze cestu k souboru načíst z objektu InvokeEvent odeslaného objektem
NativeApplication. Tuto cestu můžete použít k otevření souboru.
Více informací naleznete v tématu „Správa asociací souboru“ na stránce 267 a „Zachycení argumentů příkazového
řádku“ na stránce 260.
50
Kapitola 9: Nové funkce v aplikaci Adobe
AIR
Toto téma poskytuje přehled nových funkcí v aplikaci Adobe® AIR™, které nejsou dostupné pro obsah SWF běžící v
přehrávači Adobe® Flash®.
Nové třídy chodu programu
Následující třídy chodu programu jsou v aplikaci Adobe AIR nové. Tyto třídy nejsou dostupné pro obsah SWF běžící
v prohlížeči:
Třída
Balíček
BrowserInvokeEvent
flash.events
Clipboard
flash.desktop
ClipboardFormats
flash.desktop
ClipboardTransferMode
flash.desktop
CompressionAlgorithm
flash.utils
DockIcon
flash.desktop
DRMAuthenticateEvent
flash.events
DRMErrorEvent
flash.events
DRMStatusEvent
flash.events
EncryptedLocalStore
flash.data
File
flash.filesystem
FileListEvent
flash.events
FileMode
flash.filesystem
FileStream
flash.filesystem
FocusDirection
flash.display
HTMLHistoryItem
flash.html
HTMLHost
flash.html
HTMLLoader
flash.html
HTMLPDFCapability
flash.html
HTMLUncaughtScriptExceptionEvent
flash.events
HTMLWindowCreateOptions
flash.html
Icon
flash.desktop
InteractiveIcon
flash.desktop
Nové funkce v aplikaci Adobe AIR
Třída
Balíček
InvokeEvent
flash.events
NativeApplication
flash.desktop
NativeDragActions
flash.desktop
NativeDragEvent
flash.events
NativeDragManager
flash.desktop
NativeDragOptions
flash.desktop
NativeMenu
flash.display
NativeMenuItem
flash.display
NativeWindow
flash.display
NativeWindowBoundsEvent
flash.events
NativeWindowDisplayState
flash.display
NativeWindowDisplayStateEvent
flash.events
NativeWindowInitOptions
flash.display
NativeWindowResize
flash.display
NativeWindowSystemChrome
flash.display
NativeWindowType
flash.display
NotificationType
flash.desktop
OutputProgressEvent
flash.events
RevocationCheckSettings
flash.security
Screen
flash.display
ScreenMouseEvent
flash.events
SignatureStatus
flash.security
SignerTrustSettings
flash.security
SQLCollationType
flash.data
SQLColumnNameStyle
flash.data
SQLColumnSchema
flash.data
SQLConnection
flash.data
SQLError
flash.errors
SQLErrorEvent
flash.events
SQLErrorOperation
flash.errors
SQLEvent
flash.events
SQLIndexSchema
flash.data
SQLResult
flash.data
SQLSchema
flash.data
Třída
Balíček
SQLSchemaResult
flash.data
SQLStatement
flash.data
SQLTableSchema
flash.data
SQLTransactionLockType
flash.data
SQLTriggerSchema
flash.data
SQLUpdateEvent
flash.events
SQLViewSchema
flash.data
SystemTrayIcon
flash.desktop
Updater
flash.desktop
URLRequestDefaults
flash.net
XMLSignatureValidator
flash.utils
Balíček flash.security zahrnuje rozhraní IURIDereferencer.
Třídy chodu programu s novými funkcemi
Následující třídy jsou dostupné pro obsah SWF běžící v prohlížeči, ale aplikace AIR poskytuje ještě další vlastnosti
nebo metody:
Třída
Vlastnost nebo Metoda
Capabilities
jazyky
Event
DISPLAYING
EXITING
HTML_BOUNDS_CHANGE
HTML_DOM_INITIALIZE
HTML_RENDER
LOCATION_CHANGE
NETWORK_CHANGE
USER_IDLE
USER_PRESENT
FileReference
uploadUnencoded()
HTTPStatusEvent
HTTP_RESPONSE_STATUS
responseURL
responseHeaders
KeyboardEvent
commandKey
controlKey
LoaderContext
allowLoadBytesCodeExecution
Třída
LoaderInfo
parentSandboxBridge
childSandboxBridge
NetStream
resetDRMVouchers()
setDRMAuthenticationCredentials()
URLRequest
followRedirects
manageCookies
shouldAuthenticate
shouldCacheResponse
userAgent
userCache
setLoginCredentials()
URLStream
událost httpResponseStatus
Stage
nativeWindow
Security
APPLICATION
Většina z těchto nových vlastností a metod je dostupných pouze pro obsah v karanténě zabezpečení aplikace AIR.
Avšak nové položky v třídě URLRequest jsou dostupné také pro obsah běžící v jiných karanténách.
Metody ByteArray.compress() a ByteArray.uncompress() zahrnují nový parametr algorithm, který umožňuje
volbu mezi komprimačním algoritmem deflate a zlib.
Třídy rámců pro monitorování služeb
Balíček air.net obsahuje třídy pro detekci sítě. Tento balíček je dostupný pouze pro obsah běžící v aplikaci Adobe AIR.
Balíček je součástí souboru ServiceMonitor.swc.
Balíček obsahuje následující třídy:
• ServiceMonitor
• SocketMonitor
• URLMonitor
54
Kapitola 10: Práce s nativními okny
Třídy, které jsou k dispozici v rozhraní API pro nativní okna aplikace Adobe® AIR®, slouží k vytváření a řízení oken
pracovní plochy.
Další informace o nativních oknech online
Více informací týkajících se nativních oken rozhraní API pro nativní okna a práce s nativními okny naleznete v
následujících zdrojích:
Rychlé úvody (Adobe AIR Developer Connection)
• Interaktivní práce s oknem
• Přizpůsobení vzhledu a stylu nativního okna
• Vytváření vysunovacích oken
• Řízení pořadí zobrazení oken
• Vytváření nepravoúhlých oken s měnitelnou velikostí
Referenční příručka jazyka
• NativeWindow
• NativeWindowInitOptions
Články a ukázky aplikace Adobe Developer Connection
• Adobe AIR Developer Connection pro Flash (hledat „AIR windows“)
Základní koncepce oken v aplikaci AIR
Aplikace AIR poskytuje rozhraní API pro okna, které je snadno použitelné nezávisle na platformě a slouží pro
vytváření nativních oken operačního systému pomocí programovacích metod aplikací Flash®, Flex™ a jazyka HTML.
Aplikace AIR zajišťuje velkou volnost při vývoji vzhledu aplikace. Vytvořená okna mohou vypadat jako standardní
aplikace, která při použití v systému Mac odpovídá stylu společnosti Apple a při použití v systému Windows vyhovuje
konvencím společnosti Microsoft. Nebo lze použít rozšiřitelné systémové prvky umožňující změnu vzhledu, které jsou
k dispozici v technologii Flex, a vytvořit si vlastní styl bez ohledu na to, kde je aplikace spuštěna. Můžete dokonce
kreslit vlastní okna pomocí vektorové a bitmapové grafiky s plnou podporou průhlednosti a prolínání alfa s pracovní
plochou. Už vás unavují pravoúhlá okna? Nakreslete si kulaté.
Okna v aplikaci AIR
Aplikace AIR podporuje tři různá rozhraní API pro práci s okny: třídu NativeWindow zaměřenou na jazyk
ActionScript, třídy mx:WindowedApplication a mx:Window technologie Flex (které „sdružují“ třídu NativeWindow)
a, v prostředí HTML, třídu Window jazyka JavaScript.
Práce s nativními okny
okna v jazyce ActionScript
Při vytváření oken pomocí třídy NativeWindow můžete přímo použít plochu a seznam zobrazení přehrávače Flash
Player. Chcete-li do objektu NativeWindow přidat vizuální objekt, přidejte objekt do seznamu zobrazení plochy okna
nebo do jiného objektu zobrazení na ploše.
Okna technologie Flex
Technologie Flex definuje vlastní komponenty oken, jež sdružují rozhraní API NativeWindow. Tyto komponenty,
mx:WindowedApplication a mx:Window, nelze používat mimo tuto technologii, proto je není možné použít v
aplikacích AIR vytvořených pomocí vývojové aplikace Flash.
okna HTML
Při vytváření oken HTML se k zobrazení obsahu používá HTML, CSS a JavaScript. Pokud chcete do okna HTML
přidat vizuální objekt, přidejte tento obsah do DOM HTML. Okna HTML jsou zvláštní kategorií objektů
NativeWindow. Hostitel aplikace AIR definuje v oknech HTML vlastnost nativeWindow, která zajišťuje přístup k
základní instanci objektu NativeWindow. Pomocí této vlastnosti lze přistupovat ke zde popsaným vlastnostem,
metodám a událostem objektu NativeWindow.
Poznámka: Objekt Window jazyka JavaScript má rovněž metody pro tvorbu skriptů okna, které je obsahuje, například
moveTo() a close(). Jsou-li k dispozici překrývající se metody, lze použít tu, která je nejvhodnější.
Úvodní okno aplikace
První okno v aplikaci vytvoří aplikace AIR automaticky. Aplikace AIR nastaví vlastnosti a obsah okna pomocí
parametrů stanovených v elementu initialWindow souboru deskriptoru aplikace.
Pokud je základním obsahem soubor SWF, vytvoří aplikace AIR instanci objektu NativeWindow, načte soubor SWF
a přidá jej na plochu okna. Je-li základním obsahem soubor HTML, aplikace AIR vytvoří okno HTML a načte obsah
HTML.
Další informace o vlastnostech okna určených v deskriptoru aplikace naleznete v sekci „Struktura souboru deskriptoru
Třídy nativních oken
Rozhraní API pro nativní okna obsahuje následující třídy:
Balíček
Třídy
flash.display
•
NativeWindow
•
NativeWindowInitOptions
•
•
NativeWindowResize
•
•
NativeWindowType
Konstanty řetězců oken jsou definovány v následujících třídách:
flash.events
•
•
NativeWindowResize
•
•
NativeWindowType
•
NativeWindowBoundsEvent
•
NativeWindowDisplayStateEvent
Tok událostí nativních oken
Nativní okna odesílají události, jež zúčastněné komponenty informují, že brzy dojde nebo již došlo k významné změně.
Řada událostí týkajících se oken se odesílá ve dvojicích. První událost upozorňuje, že brzy dojde ke změně. Druhá
událost oznamuje, že změna byla provedena. Událost upozornění lze zrušit, událost oznámení však nikoliv. Následující
posloupnost znázorňuje tok událostí, jež nastanou po klepnutí na tlačítko maximalizace okna.
1 Objekt NativeWindow odešle událost displayStateChanging.
2 Nedojde-li ke zrušení této události některým ze zaregistrovaných posluchačů, okno se maximalizuje.
3 Objekt NativeWindow odešle událost displayStateChange.
Kromě toho objekt NativeWindow odešle také události pro související změny velikosti a polohy okna. Okno
neodešle události upozornění pro tyto související změny. Související události jsou následující:
a Událost move se odešle, pokud se v důsledku operace maximalizace posunul levý horní roh okna.
b Událost resize se odešle, pokud se v důsledku operace maximalizace změnila velikost okna.
Objekt NativeWindow odešle podobnou posloupnost událostí také při minimalizaci, obnovení, zavření, přesunu a
změně velikosti okna.
Události upozornění se odesílají jen v případě, že změna byla zahájena pomocí systémových prvků okna či jiného
mechanismu řízeného operačním systémem. Když vyvoláte metodu okna, aby změnila velikost či polohu okna
nebo stav zobrazení, okno odešle pouze událost oznamující změnu. Pokud chcete, můžete odeslat událost
upozornění pomocí metody dispatchEvent() okna a potom ještě před provedením změny zkontrolovat, zda byla
událost upozornění zrušena.
Podrobné informace o třídách, metodách, vlastnostech a událostech rozhraní API pro okna naleznete v Referenční
příručce jazyka ActionScript 3.0 a jeho komponent (http://www.adobe.com/go/learn_flash_aslr_cz).
Všeobecné informace o použití seznamu zobrazení Flash naleznete v sekci „Programování zobrazení“ v příručce
Programování v jazyce ActionScript 3.0 (http://www.adobe.com/go/programmingAS3_cz).
Vlastnosti řídící styl a chování nativního okna
Následující vlastnosti řídí základní vzhled a chování okna:
•
type
•
systemChrome
•
transparent
Při vytváření okna se tyto vlastnosti nastaví u objektu NativeWindowInitOptions předávaného do konstruktoru okna.
Aplikace AIR čte vlastnosti pro úvodní okno aplikace z deskriptoru aplikace. (Kromě vlastnosti type, kterou nelze
nastavit v deskriptoru aplikace a která je vždy nastavena na hodnotu normal.) Po vytvoření okna již není možné tyto
vlastnosti změnit.
Některá nastavení těchto vlastností jsou vzájemně neslučitelná: vlastnost systemChrome nelze nastavit na hodnotu
standard, když je vlastnost transparent nastavena na hodnotu true nebo vlastnost type je nastavena na hodnotu
lightweight.
Typy oken
Typy oken aplikace AIR kombinují atributy systémových prvků a viditelnosti nativního operačního systému za účelem
vytvoření tří funkčních typů oken. Pomocí konstant definovaných ve třídě NativeWindowType lze v kódu vytvořit
odkazy na názvy typů. Aplikace AIR poskytuje následující typy oken:
Typ
Popis
Normální
Typické okno. Normální okna plně využívají standardní styl systémových prvků a zobrazují se na hlavním
panelu operačního systému Windows a v hlavní nabídce operačního systému Mac OS X.
Pomocné
Paleta nástrojů. Pomocná okna používají užší verzi systémových prvků a nezobrazují se na hlavním panelu
operačního systému Windows ani v hlavní nabídce operačního systému Mac OS X.
Zjednodušené
Zjednodušená okna nemají žádné systémové prvky a nezobrazují se na hlavním panelu operačního systému
Windows ani v hlavní nabídce operačního systému Mac OS X. Zjednodušená okna navíc nemají v operačním
systém Windows systémovou nabídku (Alt+mezerník). Zjednodušená okna jsou vhodná pro oznámení a
ovládací prvky, například rozbalovací seznamy, které otevřou krátkodobou obrazovou oblast. Při použití
vlastnosti type u zjednodušených oken musí být vlastnost systemChrome nastavena na hodnotu none.
Systémové prvky okna
Systémové prvky okna představuje sada ovladačů, pomocí nichž může uživatel ovládat okno v prostředí pracovní
plochy. Elementy systémových prvků zahrnují titulní pruh, tlačítka titulního pruhu, okraj a záchytné pruhy pro změnu
velikosti.
Systémové prvky operačního systému
Vlastnost systemChrome lze nastavit na hodnotu standard nebo none. Hodnotu standard zvolte pro systémové
prvky operačního systému v případě, že má mít okno sadu standardních ovladačů vytvořených a upravených
operačním systémem uživatele. Hodnotu none zvolte, pokud chcete okno vybavit vlastními systémovými prvky.
Pomocí konstant definovaných ve třídě NativeWindowSystemChrome lze v kódu vytvořit odkazy na nastavení
systémových prvků operačního systému.
Systémové prvky operačního systému spravuje systém. Aplikace nemá přímý přístup k samotným ovladačům, ale
může reagovat na události odesílané při použití ovladačů. Když se pro okno použijí standardní systémové prvky, musí
být vlastnost transparent nastavena na hodnotu false a vlastnost type musí být nastavena na hodnotu normal
nebo utility.
Vlastní systémové prvky
Při vytváření okna bez systémových prvků operačního systému je potřeba přidat vlastní ovládací prvky, které uživateli
umožní interaktivní práci s oknem. Rovněž můžete svobodně vytvářet okna průhledná a nepravoúhlá.
Průhlednost okna
Chcete-li u okna umožnit prolínání alpha s pracovní plochou či jinými okny, nastavte vlastnost transparent tohoto
okna na hodnotu true. Vlastnost transparent je nezbytné nastavit ještě před vytvořením okna a nelze ji změnit.
Průhledné okno nemá žádné výchozí pozadí. Veškerá plocha okna, která neobsahuje žádné objekty nakreslené
aplikací, je neviditelná. Pokud má zobrazený objekt v nastavení alfa zadánu hodnotu nižší než jedna, bude jím prosvítat
všechno, co se nachází pod ním, včetně ostatních objektů zobrazení umístěných ve stejném okně, ostatních oken a
pracovní plochy. Vykreslování velkých ploch s prolínáním alfa může být pomalé, proto je vhodné používat tento efekt
s mírou.
Průhledná okna jsou užitečná při vytváření aplikací s okraji, jejichž tvar je nepravidelný nebo se postupně „ztrácí“,
případně se jeví neviditelný.
Průhlednost nelze použít u oken používajících systémové prvky operačního systému. Navíc se v průhledných oknech
nezobrazuje obsah SWF a PDF v HTML. Další informace naleznete v sekci „Zohlednění při načítání obsahu SWF nebo
PDF na stránce HTML“ na stránce 232.
Některé operační systémy nemusí průhlednost podporovat v důsledku konfigurace hardwaru či softwaru nebo
vlastních voleb zobrazení. Není-li průhlednost podporována, skládá se aplikace na černém pozadí. V takovém případě
se zcela průhledná oblast aplikace zobrazí neprůhlednou černou barvou.
Statická vlastnost NativeWindow.supportsTransparency značí, zda je možné použít průhledná okna. Jestliže bude
tato vlastnost například otestována jako false, je možné zobrazit dialogové okno s upozorněním pro uživatele nebo
lze zobrazit nouzové, pravoúhlé, neprůhledné uživatelské rozhraní. Všimněte si, že operační systémy Mac a Windows
průhlednost oken vždy podporují. U operačního systému Linux podpora průhlednosti vyžaduje použití správce
průhlednosti oken, rovněž však nemusí být k dispozici v důsledku vlastních voleb zobrazení nebo konfigurace
hardwaru.
Průhlednost v okně aplikace HTML
Pozadí obsahu HTML zobrazovaného v oknech HTML a objektech HTMLLoader je standardně neprůhledné, a to i v
případě, že okno, které jej obsahuje, je průhledné. Jestliže chcete výchozí pozadí zobrazované pro obsah HTML
vypnout, nastavte vlastnost paintsDefaultBackground na hodnotu false. Následující příklad vytvoří objekt
HTMLLoader a vypne výchozí pozadí:
var html:HTMLLoader = new HTMLLoader();
html.paintsDefaultBackground = false;
V tomto příkladu se výchozí pozadí okna HTML vypne pomocí jazyka JavaScript:
window.htmlLoader.paintsDefaultBackground = false;
Pokud element v dokumentu HTML nastavuje barvu pozadí, není pozadí tohoto elementu průhledné. Nastavení
hodnoty částečné průhlednosti (nebo neprůhlednosti) není podporováno. Podobného vizuálního efektu je však možné
dosáhnout použitím průhledné grafiky ve formátu PNG jako pozadí stránky nebo elementu stránky.
Vizuální katalog okna
V následující tabulce jsou znázorněny vizuální efekty různých kombinací nastavení vlastností okna v operačních
systémech Mac OS X a Windows:
Nastavení oken
Mac OS X
Microsoft Windows
Type: normal
SystemChrome: standard
Transparent: false
Type: utility
SystemChrome: standard
Transparent: false
Type: Any
SystemChrome: none
Transparent: false
Type: Any
SystemChrome: none
Transparent: true
mxWindowedApplication nebo
mx:Window
Type: Any
SystemChrome: none
Transparent: true
Poznámka: Aplikace AIR nepodporuje následující elementy systémových prvků operačního systému: panel nástrojů
systému OS X, ikonu proxy systému OS X, ikony hlavního panelu systému Windows a alternativní systémové prvky
operačního systému.
Vytváření oken
Aplikace AIR vytvoří první okno pro aplikaci automaticky, podle potřeby je však možné vytvořit další okna. Chcete-li
vytvořit nativní okno, použijte metodu konstruktoru NativeWindow. Pokud chcete vytvořit okno HTML, použijte
buď metodu createRootWindow() objektu HTMLLoader, nebo z dokumentu HTML vyvolejte metodu
window.open() jazyka JavaScript.
Určování inicializačních vlastností okna
Po vytvoření okna pracovní plochy již nelze inicializační vlastnosti okna změnit. Tyto nezměnitelné vlastnosti a jejich
výchozí hodnoty jsou následující:
Vlastnost
Výchozí hodnota
systemChrome
standard
type
normal
transparent
false
maximizable
true
minimizable
true
resizable
true
V souboru deskriptoru aplikace nastavte vlastnosti pro úvodní okno vytvořené aplikací AIR. Hlavní okno aplikace AIR
bude vždy typu normal. (V souboru deskriptoru lze nastavit i další vlastnosti okna, například visible, width a
height, ale tyto vlastnosti je možné kdykoliv změnit.)
Vlastnosti pro ostatní nativní okna a okna HTML vytvořená danou aplikací lze nastavit pomocí třídy
NativeWindowInitOptions. Při vytváření okna je potřeba předat objekt NativeWindowInitOptions, který určuje
vlastnosti okna, do funkce konstruktoru NativeWindow nebo do metody createRootWindow() objektu
HTMLLoader.
Následující kód vytvoří objekt NativeWindowInitOptions pro pomocné okno:
var options:NativeWindowInitOptions = new NativeWindowInitOptions();
options.systemChrome = NativeWindowSystemChrome.STANDARD;
options.type = NativeWindowType.UTILITY
options.transparent = false;
options.resizable = false;
options.maximizable = false;
Nastavení vlastnosti systemChrome na hodnotu standard při nastavení vlastnosti transparent na hodnotu true nebo
vlastnosti type na hodnotu lightweight není podporováno.
Poznámka: Pro okno vytvořené pomocí funkce window.open() jazyka JavaScript nelze nastavit inicializační vlastnosti.
Avšak způsob vytváření těchto oken je možné změnit zavedením vlastní třídy HTMLHost. Další informace naleznete v
sekci „Zpracovávání volání jazyka JavaScript window.open()“ na stránce 240.
Vytváření úvodního okna aplikace
Aplikace AIR vytvoří úvodní okno aplikace na základě vlastností určených v deskriptoru aplikace a načte soubor, na
který se odkazuje v elementu obsahu. Obsah musí být soubor SWF nebo HTML.
Úvodní okno může být hlavním oknem aplikace nebo může sloužit pouze k otevření jednoho či několika dalších oken.
Nemusí být vůbec viditelné.
Vývojový nástroj Flash automaticky vytvoří soubor SWF a při testování nebo publikování projektu pro aplikaci AIR
přidá do deskriptoru aplikace příslušný odkaz. Hlavní časová osa slouží jako vstupní bod pro danou aplikaci.
Po spuštění aplikace vytvoří aplikace AIR okno a načte soubor SWF aplikace. Chcete-li ovládat okno pracovní plochy
pomocí jazyka ActionScript, můžete pomocí vlastnosti nativeWindow objektu Stage získat odkaz na objekt
NativeWindow. Pak můžete nastavit vlastnosti okna a vyvolat metody okna.
Následující příklad aktivuje hlavní okno v maximalizovaném stavu (z prvního snímku souboru FLA aplikace Flash):
import flash.display.NativeWindow;
var mainWindow:NativeWindow = this.stage.nativeWindow;
mainWindow.maximize();
mainWindow.activate();
Vytvoření objektu NativeWindow
Chcete-li vytvořit objekt NativeWindow, předejte do konstruktoru NativeWindow objekt NativeWindowInitOptions:
var newWindow:NativeWindow = new NativeWindow(options);
Okno se zobrazí až po nastavení vlastnosti visible na hodnotu true nebo vyvolání metody activate().
Po vytvoření okna lze inicializovat jeho vlastnosti a načíst do něho obsah pomocí vlastnosti pracovní plochy a metod
seznamu zobrazení aplikace Flash.
Vlastnost scaleMode pracovní plochy nového nativního okna by měla být téměř vždy nastavena na hodnotu noScale
(použijte konstantu StageScaleMode.NO_SCALE). Režimy změny velikosti aplikace Flash jsou určeny pro situace, kdy
autor aplikace předem nezná poměr stran prostoru zobrazení v dané aplikaci. Pomocí režimů změny velikosti může
autor zvolit cestu nejmenšího zla: obsah oříznout, roztáhnout nebo stlačit, případně ho vyplnit prázdným místem.
Vzhledem k tomu, že v aplikaci AIR řídíte prostor zobrazení (rám okna), můžete upravit velikost okna podle obsahu
nebo velikost obsahu podle okna bez jakýchkoliv kompromisů.
Poznámka: Jestliže chcete určit maximální a minimální velikost okna povolenou v aktuálním operačním systému,
použijte následující statické vlastnosti objektu NativeWindow:
var maxOSSize:Point = NativeWindow.systemMaxSize;
var minOSSize:Point = NativeWindow.systemMinSize;
Vytvoření okna HTML
Pokud chcete vytvořit okno HTML, můžete vyvolat metodu Window.open() jazyka JavaScript nebo můžete vyvolat
metodu createRootWindow() třídy HTMLLoader aplikace AIR.
Obsah HTML v jakékoliv karanténě zabezpečení může použít standardní metodu Window.open() jazyka JavaScript.
Jestliže je obsah spuštěný mimo aplikační karanténu, lze metodu open() vyvolat pouze v odezvě na interakci uživatele,
například po kliknutí myší nebo stisknutí klávesy. Po vyvolání metody open() se vytvoří okno se systémovými prvky
operačního systému, v němž bude zobrazen obsah na určené adrese URL. Například:
newWindow = window.open("xmpl.html", "logWindow", "height=600, width=400, top=10, left=10");
Poznámka: Třídu HTMLHost lze v jazyce ActionScript rozšířit, aby bylo možné přizpůsobit okno vytvořené pomocí
funkce window.open() jazyka JavaScript. Viz sekce „O rozšiřování třídy HTMLHost“ na stránce 236.
Obsah v aplikační karanténě zabezpečení má přístup k výkonnější metodě pro vytváření oken, a to
HTMLLoader.createRootWindow(). Pomocí této metody lze určit všechny možnosti vytváření pro nové okno.
Následující kód jazyka JavaScript například vytvoří zjednodušené okno bez systémových prvků operačního systému,
o velikosti 300 x 400 obrazových bodů:
var options = new air.NativeWindowInitOptions();
options.systemChrome = "none";
options.type = "lightweight";
var windowBounds = new air.Rectangle(200,250,300,400);
newHTMLLoader = air.HTMLLoader.createRootWindow(true, options, true, windowBounds);
newHTMLLoader.load(new air.URLRequest("xmpl.html"));
Poznámka: Pokud se obsah načtený novým oknem nachází mimo aplikační karanténu zabezpečení, nemusí mít objekt
window vlastnosti aplikace AIR: runtime, nativeWindow ani htmlLoader.
Okna vytvořená pomocí metody createRootWindow() zůstávají nezávislá na otevíraném okně. Vlastnosti parent a
opener objektu Window v jazyce JavaScript jsou nastaveny na hodnotu null. Otevírané okno má přístup k objektu
Window nového okna pomocí odkazu na objekt HTMLLoader vrácený funkcí createRootWindow(). V kontextu
předchozího příkladu by příkaz newHTMLLoader.window odkazoval na objekt Window v jazyce JavaScript
vytvořeného okna.
Poznámka: Funkci createRootWindow() je možné volat z jazyka JavaScript i z jazyka ActionScript.
Přidávání obsahu do okna
Způsob přidávání obsahu do okna aplikace AIR závisí na typu okna. Je možné vytvořit filmový klip a pomocí časové
osy řídit stav aplikace. V případě HTML lze deklarativně definovat základní obsah okna. Zdroje je možné vložit do
souboru SWF aplikace nebo je lze načíst ze samostatných aplikačních souborů. Obsah Flash a HTML lze vytvářet za
chodu a dynamicky ho přidávat do okna.
Při načítání obsahu SWF nebo obsahu HTML obsahujícího JavaScript, je třeba vzít v úvahu model zabezpečení
aplikace AIR. Jakýkoliv obsah umístěný v aplikační karanténě zabezpečení, tedy obsah instalovaný společně s aplikací,
který lze načíst pomocí schématu URL app:, má veškerá přístupová práva ke všem rozhraním API aplikace AIR.
Jakýkoliv obsah načtený z místa mimo tuto karanténu nemá k rozhraním API aplikace AIR přístup. Obsah v jazyce
JavaScript umístěný mimo aplikační karanténu nemůže používat vlastnosti runtime, nativeWindow ani htmlLoader
objektu Window v jazyce JavaScript.
Jestliže chcete zajistit bezpečné vytváření křížových skriptů, můžete pomocí mostu karantény zajistit omezené
rozhraní mezi aplikačním obsahem a neaplikačním obsahem. V obsahu HTML je rovněž možné mapovat stránky
aplikace do neaplikační karantény a tím kódu na dané stránce umožnit vytváření křížových skriptů s externím
obsahem. Viz sekce „Zabezpečení aplikace AIR“ na stránce 23.
Načtení souboru SWF nebo obrazu
Obsah Flash nebo obrázky lze načíst do souboru zobrazení nativního okna pomocí třídy flash.display.Loader:
package {
import
import
import
import
flash.display.Sprite;
flash.events.Event;
flash.net.URLRequest;
flash.display.Loader;
public class LoadedSWF extends Sprite
{
public function LoadedSWF(){
loader.load(new URLRequest("visual.swf"));
loader.contentLoaderInfo.addEventListener(Event.COMPLETE,loadFlash);
}
private function loadFlash(event:Event):void{
addChild(event.target.loader);
}
}
}
Je možné načíst soubor SWF obsahující kód knihovny pro použití v aplikaci založené na HTML. Nejjednodušší způsob
načtení souboru SWF do okna HTML je použít tag script, lze však také použít přímo rozhraní API objektu Loader.
Poznámka: Starší soubory SWF vytvořené pomocí verze ActionScript 1 nebo 2 sdílejí při načtení do stejného okna
globální stavy, například definice stavů, objekty singleton a globální proměnné. Pokud tento typ souboru SWF spoléhá
na správnou funkčnost nedotčených globálních stavů, nelze jej do stejného okna načíst více než jednou ani jej nelze do
stejného okna načíst jako jiný soubor SWF pomocí překrývajících se definic tříd nebo proměnných. Tento obsah lze načíst
do různých oken.
Načtení obsahu HTML do objektu NativeWindow
Chcete-li načíst obsah HTML do objektu NativeWindow, můžete na pracovní plochu okna přidat objekt
HTMLLoader a načíst obsah HTML do objektu HTMLLoader nebo můžete pomocí metody
HTMLLoader.createRootWindow() vytvořit okno, které již bude objekt HTMLLoader obsahovat. V následujícím
příkladu se obsah HTML zobrazí na ploše nativního okna v oblasti zobrazení o velikosti 300 x 500 obrazových bodů:
//newWindow is a NativeWindow instance
var htmlView:HTMLLoader = new HTMLLoader();
html.width = 300;
html.height = 500;
//set the stage so display objects are added to the top-left and not scaled
newWindow.stage.align = "TL";
newWindow.stage.scaleMode = "noScale";
newWindow.stage.addChild( htmlView );
//urlString is the URL of the HTML page to load
htmlView.load( new URLRequest(urlString) );
Poznámka: Obsah SWF nebo PDF v souboru HTML se nezobrazí, pokud okno používá průhlednost (tj. vlastnost
transparent daného okna je nastavena na hodnotu true) nebo pokud se změní velikost ovladače HTMLLoader.
Přidání obsahu SWF do okna HTML jako překrytí
Vzhledem k tomu, že jsou okna HTML obsažena v instanci objektu NativeWindow, lze přidávat objekty zobrazení
aplikace Flash nad a pod vrstvu HTML v seznamu zobrazení.
Pokud chcete přidat objekt zobrazení nad vrstvu HTML, použijte metodu addChild() vlastnosti
window.nativeWindow.stage. Metoda addChild() přidá obsah navrstvený nad jakýmkoliv existujícím obsahem v
okně.
Jestliže chcete objekt zobrazení přidat pod vrstvu HTML, použijte metodu addChildAt() vlastnosti
window.nativeWindow.stage a předejte do ní nulovou hodnotu pro parametr index. Při umístění objektu do
nulového indexu se existující obsah, včetně zobrazení HTML, posune o jednu vrstvu nahoru a nový obsah se vloží na
nejnižší vrstvu. Aby byl obsah navrstvený pod stránkou HTML viditelný, je potřeba nastavit vlastnost
paintsDefaultBackground objektu HTMLlLoader na hodnotu false. Kromě toho všechny elementy stránky, jež
nastavují barvu pozadí, nebudou průhledné. Bude-li například nastavena barva pozadí pro element těla stránky,
nebude žádná část stránky průhledná.
Následující příklad ilustruje způsob přidávání objektů zobrazení aplikace Flash na stránku HTML jako překrytí nebo
jako podklad. Příklad vytvoří dva objekty jednoduchého tvaru, přičemž přidá jeden z nich pod obsah HTML a druhý
nad něj. Navíc příklad aktualizuje polohu tvaru na základě události enterFrame.
<html>
<head>
<title>Bouncers</title>
<script src="AIRAliases.js" type="text/javascript"></script>
<script language="JavaScript" type="text/javascript">
air.Shape = window.runtime.flash.display.Shape;
function Bouncer(radius, color){
this.radius = radius;
this.color = color;
//velocity
this.vX = -1.3;
this.vY = -1;
//Create a Shape object and draw a circle with its graphics property
this.shape = new air.Shape();
this.shape.graphics.lineStyle(1,0);
this.shape.graphics.beginFill(this.color,.9);
this.shape.graphics.drawCircle(0,0,this.radius);
this.shape.graphics.endFill();
//Set the starting position
this.shape.x = 100;
this.shape.y = 100;
//Moves the sprite by adding (vX,vY) to the current position
this.update = function(){
this.shape.x += this.vX;
this.shape.y += this.vY;
//Keep the sprite within the window
if( this.shape.x - this.radius < 0){
this.vX = -this.vX;
}
if( this.shape.y - this.radius < 0){
this.vY = -this.vY;
}
if( this.shape.x + this.radius > window.nativeWindow.stage.stageWidth){
this.vX = -this.vX;
}
if( this.shape.y + this.radius > window.nativeWindow.stage.stageHeight){
this.vY = -this.vY;
}
};
}
function init(){
//turn off the default HTML background
var bottom = new Bouncer(60,0xff2233);
var top = new Bouncer(30,0x2441ff);
//listen for the enterFrame event
window.htmlLoader.addEventListener("enterFrame",function(evt){
bottom.update();
top.update();
});
//add the bouncing shapes to the window stage
window.nativeWindow.stage.addChildAt(bottom.shape,0);
window.nativeWindow.stage.addChild(top.shape);
}
</script>
<body onload="init();">
<h1>de Finibus Bonorum et Malorum</h1>
<p>Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium
doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore veritatis
et quasi architecto beatae vitae dicta sunt explicabo.</p>
<p style="background-color:#FFFF00; color:#660000;">This paragraph has a background color.</p>
<p>At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis
praesentium voluptatum deleniti atque corrupti quos dolores et quas molestias
excepturi sint occaecati cupiditate non provident, similique sunt in culpa qui
officia deserunt mollitia animi, id est laborum et dolorum fuga.</p>
</body>
</html>
Tento příklad poskytuje základní úvod do některých pokročilých metod, jež v aplikaci AIR překračují hranice mezi
jazyky JavaScript a ActionScript. Nejste-li obeznámeni s použitím objektů zobrazení v jazyce ActionScript, další
informace naleznete v příručce Programování v jazyce ActionScript 3.0 v sekci Programování zobrazení.
Příklad: Vytvoření nativního okna
Následující příklad ilustruje postup při vytváření nativního okna:
public function createNativeWindow():void {
//create the init options
options.type = NativeWindowType.NORMAL;
//create the window
var newWindow:NativeWindow = new NativeWindow(options);
newWindow.title = "A title";
newWindow.width = 600;
newWindow.height = 400;
newWindow.stage.align = StageAlign.TOP_LEFT;
newWindow.stage.scaleMode = StageScaleMode.NO_SCALE;
//activate and show the new window
newWindow.activate();
}
Správa oken
Pomocí vlastností a metod třídy NativeWindow se řídí vzhled, chování a životní cyklus oken pracovní plochy.
Získání instance objektu NativeWindow
Aby bylo možné s oknem pracovat, je nejprve potřeba získat instanci tohoto okna. Instanci okna lze získat z
následujícího umístění:
Konstruktor okna Například konstruktor okna pro nový objekt NativeWindow.
Pracovní plocha okna Například stage.nativeWindow.
Libovolný objekt zobrazení na pracovní ploše Například myDisplayObject.stage.nativeWindow.
Událost okna Vlastnost target objektu události odkazuje na okno, jež tuto událost odeslalo.
Globální vlastnost nativeWindow objektu HTMLLoader nebo okna HTML Například window.nativeWindow.
Objekt NativeApplication NativeApplication.nativeApplication.activeWindow odkazuje na aktivní okno
aplikace (ale vrátí hodnotu null, pokud aktivní okno není okno této aplikace AIR). Pole
NativeApplication.nativeApplication.openedWindows obsahuje všechna okna v aplikaci AIR, jež dosud nebyla
zavřena.
Aktivace, zobrazení a skrývání oken
Jestliže chcete okno aktivovat, vyvolejte metodu activate() objektu NativeWindow. Po aktivaci se okno dostane do
popředí, začne být aktivní pro klávesnici a myš a v případě potřeby se zviditelní obnovením okna nebo nastavením
vlastnosti visible na hodnotu true. Aktivace okna nezmění pořadí zobrazení ostatních oken v aplikaci. Bude-li
vyvolána metoda activate(), okno odešle událost activate.
Pokud chcete zobrazit skryté okno bez toho, aby bylo aktivováno, nastavte vlastnost visible na hodnotu true. Tím
se okno přenese do popředí, ale nebude aktivováno.
Chcete-li zobrazené okno skrýt, nastavte jeho vlastnost visible na hodnotu false. Skrytím okna se potlačí zobrazení
okna, s ním souvisejících ikon hlavního panelu a u systému Mac OS X také položky v nabídce Windows.
Poznámka: V systému Mac OS X není možné zcela skrýt minimalizované okno s ikonou ukotvení. Jestliže je vlastnost
visible nastavena u minimalizovaného okna na hodnotu false, zůstane ikona ukotvení pro toto okno nadále
zobrazena. Po klepnutí na tuto ikonu se okno obnoví do viditelného stavu a zobrazí se.
Změna pořadí zobrazení oken
Aplikace AIR poskytuje několik metod, pomocí nichž lze přímo změnit pořadí zobrazení oken. Okno je možné
posunout v pořadí zobrazení dopředu nebo dozadu; okno lze posunout nad jiné okno nebo za ně. Současně lze okna
aktivovat a tím změnit jejich uspořádání.
Chcete-li, aby bylo okno neustále zobrazeno před ostatními okny, nastavte jeho vlastnost alwaysInFront na hodnotu
true. Pokud bude mít více oken toto nastavení, bude se pořadí jejich zobrazení vzájemně měnit, tato okna však budou
vždy uspořádána nad okny, u nichž bude vlastnost alwaysInFront nastavena na hodnotu. Okna v nejhornější skupině
jsou také vždy zobrazena nad okny jiných aplikací, a to i v případě, že aplikace AIR není aktivní. Vzhledem k tomu, že
toto chování může uživatele rušit, doporučuje se nastavovat vlastnost alwaysInFront na hodnotu true jen tehdy,
když je to nezbytné a vhodné. Příklady oprávněného použití jsou následující:
• Dočasná rozbalovací okna pro ovládací prvky, jako je například bublinová nápověda, rozbalovací seznamy či
kombinovaná pole. Vzhledem k tomu, že by se tato okna měla po deaktivaci zavřít, lze zamezit tomu, aby uživateli
bránila v prohlížení ostatních oken.
• Extrémně naléhavé chybové zprávy a výstrahy Pokud by mohlo dojít k nevratné změně, kdyby uživatel včas
nezareagoval, může být vhodné umístit okno s výstrahou do popředí. Většinu chyb a výstrah je však možné
zpracovat v běžném pořadí zobrazení oken.
• Krátkodobá vysunovací okna
Poznámka: Aplikace AIR neprosazuje správné použití vlastnosti alwaysInFront. Jestliže však bude aplikace narušovat
práci uživatele, s největší pravděpodobností skončí v jeho nádobě na odpadky.
Třída NativeWindow poskytuje následující vlastnosti a metody pro nastavení pořadí zobrazení okna vzhledem k
ostatním oknům:
Člen
Popis
vlastnost alwaysInFront
Určuje, zda je okno zobrazeno v nejhornější skupině oken.
Téměř vždy je nejvhodnějším nastavením hodnota false. Při změně hodnoty z false na true se okno
zobrazí ze všech oken nejvýše (ale neaktivuje se). Při změně hodnoty z true na false se okno umístí za
zbývající okna v nejhornější skupině, ale stále bude umístěno před ostatními okny. Nastavením vlastnosti
na aktuální hodnotu pro okno se pořadí zobrazení oken nezmění.
orderToFront()
Přenese okno do popředí.
orderInFrontOf()
Přenese okno přímo před určité okno.
orderToBack()
Odešle okno za ostatní okna.
orderBehind()
Odešle okno přímo za určité okno.
activate()
Přenese okno do popředí (přičemž okno současně zviditelní a aktivuje).
Poznámka: Je-li okno skryté (vlastnost visible je nastavena na hodnotu false) nebo minimalizované, nebude mít
vyvolání metod pořadí zobrazení žádný účinek.
Zavření okna
Jestliže chcete okno zavřít, použijte metodu NativeWindow.close().
Zavřením okna se zruší zavedení jeho obsahu, pokud však jiné objekty mají odkazy na tento obsah, nebudou objekty
obsahu vymazány. Metoda NativeWindow.close() probíhá asynchronně, aplikace obsažená v okně je v průběhu
procesu zavírání okna stále spuštěná. Jakmile bude operace zavření dokončena, metoda close odešle událost close.
Objekt NativeWindow je, technicky vzato, stále platný, ale pokus o přístup k většině vlastností a metod u zavřeného
okna vyvolá chybu IllegalOperationError. Zavřené okno nelze znovu otevřít. Chcete-li zjistit, zda bylo okno zavřeno,
zkontrolujte jeho vlastnost closed. Pokud chcete zobrazené okno jen skrýt, nastavte vlastnost
NativeWindow.visible na hodnotu false.
V případě, že je vlastnost Nativeapplication.autoExit nastavena na hodnotu true, což je výchozí nastavení, pak
se aplikace ukončí po zavření jejího posledního okna.
Povolení zrušení operací okna
Jestliže okno používá systémové prvky operačního systému, je možné interakci uživatele s oknem zrušit posloucháním
příslušných událostí a zrušením jejich výchozího chování. Když uživatel například v systémových prvcích operačního
systému klepne na tlačítko zavření, odešle se událost closing. Pokud některý ze zaregistrovaných posluchačů vyvolá
metodu preventDefault() této události, okno se nezavře.
V případě, že okno systémové prvky operačního systému nepoužívá, nebudou se před provedením záměrných změn
automaticky odesílat události upozornění na tyto změny. Vyvoláte-li tedy metody pro zavření okna či změnu stavu
okna nebo nastavíte-li některou z vlastností okrajů okna, nebude možné změnu zrušit. Jestliže chcete upozornit
komponenty v aplikaci před tím, než bude v okně provedena změna, může logika aplikace odeslat příslušnou událost
upozornění pomocí metody dispatchEvent() daného okna.
Následující logika například implementuje zrušitelné zpracování události pro tlačítko zavření okna:
public function onCloseCommand(event:MouseEvent):void{
var closingEvent:Event = new Event(Event.CLOSING,true,true);
dispatchEvent(closing);
if(!closingEvent.isDefaultPrevented()){
win.close();
}
}
Metoda dispatchEvent() vrátí hodnotu false, pokud bude metoda preventDefault() události vyvolána
posluchačem. Hodnotu false však může vrátit také z jiných důvodů, proto je vhodnější explicitně použít metodu
isDefaultPrevented() a otestovat, zda má být změna zrušena.
Maximalizace, minimalizace a obnovení okna
Pokud chcete okno maximalizovat, použijte metodu maximize() objektu NativeWindow.
myWindow.maximize();
Jestliže chcete okno minimalizovat, použijte metodu minimize() objektu NativeWindow.
myWindow.minimize();
Chcete-li okno obnovit (tj. vrátit mu velikost, kterou mělo před provedením minimalizace nebo maximalizace),
použijte metodu restore() objektu NativeWindow.
myWindow.restore();
Poznámka: Chování vyplývající z maximalizace okna aplikace AIR se liší od standardního chování systému Mac OS X.
Místo toho, aby se okna aplikace AIR přepínala mezi „standardní“ velikostí definovanou aplikací a poslední velikostí
nastavenou uživatelem, přepínají se mezi poslední velikostí nastavenou aplikací nebo uživatelem a celou využitelnou
oblastí obrazovky.
Příklad: Minimalizace, maximalizace, obnovení a zavření okna
Následující příklad v jazyce ActionScript pro aplikaci Flash vytvoří čtyři textová pole umožňující klepnutí, která spustí
metody minimize(), maximize(), restore() a close() objektu NativeWindow:
package
{
import flash.events.MouseEvent;
import flash.text.TextField;
public class MinimizeExample extends Sprite
{
public function MinimizeExample():void
{
var minTextBtn:TextField = new TextField();
minTextBtn.x = 10;
minTextBtn.y = 10;
minTextBtn.text = "Minimize";
minTextBtn.background = true;
minTextBtn.border = true;
minTextBtn.selectable = false;
addChild(minTextBtn);
minTextBtn.addEventListener(MouseEvent.CLICK, onMinimize);
var maxTextBtn:TextField = new TextField();
maxTextBtn.x = 120;
maxTextBtn.y = 10;
maxTextBtn.text = "Maximize";
maxTextBtn.background = true;
maxTextBtn.border = true;
maxTextBtn.selectable = false;
addChild(maxTextBtn);
maxTextBtn.addEventListener(MouseEvent.CLICK, onMaximize);
var restoreTextBtn:TextField = new TextField();
restoreTextBtn.x = 230;
restoreTextBtn.y = 10;
restoreTextBtn.text = "Restore";
restoreTextBtn.background = true;
restoreTextBtn.border = true;
restoreTextBtn.selectable = false;
addChild(restoreTextBtn);
restoreTextBtn.addEventListener(MouseEvent.CLICK, onRestore);
var closeTextBtn:TextField = new TextField();
closeTextBtn.x = 340;
closeTextBtn.y = 10;
closeTextBtn.text = "Close Window";
closeTextBtn.background = true;
closeTextBtn.border = true;
closeTextBtn.selectable = false;
addChild(closeTextBtn);
closeTextBtn.addEventListener(MouseEvent.CLICK, onCloseWindow);
}
function onMinimize(event:MouseEvent):void
{
this.stage.nativeWindow.minimize();
}
function onMaximize(event:MouseEvent):void
{
this.stage.nativeWindow.maximize();
}
function onRestore(event:MouseEvent):void
{
this.stage.nativeWindow.restore();
}
function onCloseWindow(event:MouseEvent):void
{
this.stage.nativeWindow.close();
}
}
}
Přemísťování a změna velikosti okna
Když okno používá systémové prvky operačního systému, jsou k dispozici ovladače umožňující přemísťování okna po
pracovní ploše a změnu jeho velikosti. V případě, že okno systémové prvky operačního systému nepoužívá, je nezbytné
přidat vlastní ovladače, které uživateli umožní přemísťování a změnu velikosti okna.
Poznámka: Aby bylo možné okno přemístit nebo změnit jeho velikost, je nejprve nutné získat odkaz na instanci objektu
NativeWindow. Informace o způsobu získání odkazu na okno naleznete v sekci „Získání instance objektu
NativeWindow“ na stránce 66.
Změna velikosti okna
Velikost okna je možné změnit pomocí metody startResize() objektu NativeWindow. Když je tato metoda volána
z události mouseDown, operace změny velikosti se řídí podle myši a skončí, jakmile operační systém přijme událost
mouseUp. Při vyvolání metody startResize() se do ní předává argument, který určuje okraj nebo roh, z něhož se má
měnit velikost okna.
Režim změny velikosti plochy určuje, jak se bude při změně velikosti okna chovat pracovní plocha okna a její obsah. Je
třeba mít na paměti, že režimy změny velikosti pracovní plochy jsou určeny pro situace, jako je například webový
prohlížeč, kdy aplikace nemá pod kontrolou velikost nebo poměr stran jeho prostoru zobrazení. Nejlepších výsledků lze
obvykle dosáhnout nastavením vlastnosti scaleMode pracovní plochy na možnost StageScaleMode.NO_SCALE. Pokud
se má měnit velikost obsahu okna, lze přesto nastavit parametry scaleX a scaleY v reakci na změnu okrajů okna.
Přemísťování okna
Chcete-li okno přemístit bez změny jeho velikosti, použijte metodu NativeWindow startMove(). Stejně jako u
metody startResize() i zde platí, že při vyvolání metody startMove() z události mouseDown se proces přemísťování
řídí podle myši a skončí, jakmile operační systém přijme událost mouseUp.
Další informace týkající se metod startResize a startMove naleznete v Referenční příručce jazyka ActionScript 3.0
a jeho komponent (http://www.adobe.com/go/learn_air_aslr_cz).
Příklad: Změna velikosti a přemísťování oken
V následujícím příkladu je znázorněno, jak se pro okno spouští operace změny velikosti a přemístění:
package
{
import flash.display.NativeWindowResize;
public class NativeWindowResizeExample extends Sprite
{
public function NativeWindowResizeExample():void
{
// Fills a background area.
this.graphics.beginFill(0xFFFFFF);
this.graphics.drawRect(0, 0, 400, 300);
this.graphics.endFill();
// Creates a square area where a mouse down will start the resize.
var resizeHandle:Sprite =
createSprite(0xCCCCCC, 20, this.width - 20, this.height - 20);
resizeHandle.addEventListener(MouseEvent.MOUSE_DOWN, onStartResize);
// Creates a square area where a mouse down will start the move.
var moveHandle:Sprite = createSprite(0xCCCCCC, 20, this.width - 20, 0);
moveHandle.addEventListener(MouseEvent.MOUSE_DOWN, onStartMove);
}
public function createSprite(color:int, size:int, x:int, y:int):Sprite
{
var s:Sprite = new Sprite();
s.graphics.beginFill(color);
s.graphics.drawRect(0, 0, size, size);
s.graphics.endFill();
s.x = x;
s.y = y;
this.addChild(s);
return s;
}
public function onStartResize(event:MouseEvent):void
{
this.stage.nativeWindow.startResize(NativeWindowResize.BOTTOM_RIGHT);
}
public function onStartMove(event:MouseEvent):void
{
this.stage.nativeWindow.startMove();
}
}
}
Poslouchání událostí oken
Chcete-li poslouchat události odeslané oknem, zaregistrujte u instance okna posluchače. Jestliže například chcete
poslouchat událost closing, zaregistrujte posluchače pro okno následujícím způsobem:
myWindow.addEventListener(Event.CLOSING, onClosingEvent);
Při odeslání události odkazuje vlastnost target na okno odesílající událost.
Většina událostí okna má dvě související zprávy. První zpráva značí, že brzy dojde ke změně okna (a lze ji zrušit),
zatímco druhá zpráva značí, že byla provedena změna. Když uživatel například klepne na tlačítko zavření okna, odešle
se zpráva události closing. Pokud žádný posluchač tuto událost nezruší, okno se zavře a všem posluchačům se odešle
událost close.
Události upozornění, například closing, se obvykle odesílají jen v případě, že byla událost spuštěna pomocí
systémových prvků operačního systému. Například vyvolání metody close() okna událost closing automaticky
neodesílá – odešle se jen událost close. Lze však vytvořit objekt události closing a odeslat událost pomocí metody
dispatchEvent() okna.
Události okna, které spouští objekt Event, jsou následující:
Událost
Popis
activate
Odešle se při aktivaci okna.
deactivate
Odešle se při deaktivaci okna.
closing
Odešle se těsně před zavřením okna. K tomu dojde automaticky jen při stisknutí tlačítka zavření v systémových
prvcích operačního systému nebo u systému Mac OS X při vyvolání příkazu Konec.
close
Odešle se po zavření okna.
Události okna, které spouští objekt NativeWindowBoundsEvent, jsou následující:
Událost
Popis
moving
Odešle se těsně před tím, než se změní poloha levého horního rohu okna následkem přemístění, změny velikosti
nebo změny stavu zobrazení okna.
move
Odešle se poté, co se změní poloha levého horního rohu.
resizing
Odešle se těsně před tím, než se změní šířka nebo výška okna následkem změny velikosti nebo změny stavu
zobrazení.
resize
Odešle se poté, co se změní velikost okna.
Pro události NativeWindowBoundsEvent lze pomocí vlastností beforeBounds a afterBounds určit ohraničení okna
před blížící se změnou a po provedení změny.
Události okna, které spouští objekt NativeWindowDisplayStateEvent, jsou následující:
Událost
Popis
displayStateChanging
Odešle se těsně před tím, než se změní stav zobrazení okna.
displayStateChange
Odešle se poté, co se změní stav zobrazení okna.
Pro události NativeWindowDisplayStateEvent lze pomocí vlastností beforeDisplayState a afterDisplayState
určit stav zobrazení okna před blížící se změnou a po provedení změny.
Zobrazení oken na celou obrazovku
Po nastavení vlastnosti displayState plochy na možnost StageDisplayState.FULL_SCREEN_INTERACTIVE se
okno přepne do režimu zobrazení na celou obrazovku. V tomto režimu je povolen vstup z klávesnice. (U obsahu SWF
spuštěného v prohlížeči není vstup z klávesnice povolen.) Režim zobrazení na celou obrazovku může uživatel ukončit
stisknutím klávesy Esc.
V následujícím příkladu jazyka ActionScript pro aplikaci Flash je znázorněna simulace jednoduchého terminálu pro
zobrazení textu na celou obrazovku:
import
import
import
import
flash.display.StageDisplayState;
flash.text.TextField;
flash.text.TextFormat;
public class FullScreenTerminalExample extends Sprite
{
public function FullScreenTerminalExample():void
{
var terminal:TextField = new TextField();
terminal.multiline = true;
terminal.wordWrap = true;
terminal.selectable = true;
terminal.background = true;
terminal.backgroundColor = 0x00333333;
this.stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
addChild(terminal);
terminal.width = 550;
terminal.height = 400;
terminal.text = "Welcome to the dumb terminal application. Press the ESC key to
exit.\n_";
var tf:TextFormat = new TextFormat();
tf.font = "Courier New";
tf.color = 0x00CCFF00;
tf.size = 12;
terminal.setTextFormat(tf);
terminal.setSelection(terminal.text.length - 1, terminal.text.length);
}
}
74
Kapitola 11: Obrazovky
Pomocí třídy Screen prostředí Adobe® AIR® získáte přístup k informacím o obrazovkách zobrazujících plochu
připojených k počítači.
Další online informace o obrazovkách
Další informace o třídě Screen a o práci s obrazovkami můžete vyhledat v těchto zdrojích:
Stručné úvody (Adobe AIR Developer Connection)
• Měření virtuální pracovní plochy
Jazykové reference
• Obrazovka
Články a ukázky na webu Adobe Developer Connection
• Adobe AIR Developer Connection pro Flash (vyhledejte „Obrazovky prostředí AIR“)
Základní informace o obrazovkách
Rozhraní API obrazovky obsahuje jednu třídu, Screen, která poskytuje statické členy pro získávání informací o
obrazovkách systému a členech instancí pro popis konkrétní obrazovky.
K počítačovému systému může být připojeno několik monitorů nebo displejů, které mohou odpovídat několika
obrazovkám na ploše rozmístěných ve virtuálním prostoru. Třída Screen prostředí AIR poskytuje informace o
obrazovkách, jejich vzájemném uspořádání a využitelném místě. Je-li na stejnou obrazovku mapováno více monitorů,
pak existuje pouze jedna obrazovka. Pokud je tato obrazovka větší než oblast zobrazení monitoru, nelze zjistit, která
část obrazovky je právě viditelná.
Obrazovka představuje nezávislou oblast zobrazení na pracovní ploše. Obrazovky jsou popisovány jako obdélníky v
rámci virtuální pracovní plochy. Levý horní roh obrazovky určené jako primární displej je počátkem souřadného
systému virtuální pracovní plochy. Všechny hodnoty použité k popisu obrazovky jsou vyjádřeny v obrazových bodech.
Obrazovky
Screen bounds
Virtual screen
Usable bounds
V tomto uspořádání obrazovky se na virtuální pracovní ploše nacházejí dvě obrazovky. Souřadnice levého horního rohu hlavní obrazovky (č.
1) mají vždy hodnotu (0,0). Pokud se uspořádání obrazovky změní tak, že určuje obrazovku č. 2 jako hlavní, pak jsou souřadnice obrazovky č.
1 záporné. Pruhy nabídek, hlavní panely a doky jsou při oznamování využitelného ohraničení obrazovky vyloučeny.
Podrobné informace o třídě rozhraní API obrazovky, metodách, vlastnostech a událostech naleznete v dokumentu
Referenční příručka jazyka ActionScript 3.0 a jeho součástí (http://www.adobe.com/go/learn_air_aslr_cz).
Výčet obrazovek
Výčet obrazovek virtuální pracovní plochy můžete vytvořit pomocí následujících metod a vlastností obrazovek:
Metoda nebo vlastnost
Popis
Screen.screens
Poskytuje pole objektů Screen popisující dostupné obrazovky. Povšimněte si, že pořadí pole není
důležité.
Screen.mainScreen
Poskytuje objekt Screen pro hlavní obrazovku. V operačním systému Mac OS X je hlavní obrazovkou ta,
která zobrazuje pruh nabídek. V operačním systému Windows je hlavní obrazovkou primární obrazovka
určená systémem.
Screen.getScreensForRectangle() Poskytuje pole objektů Screen popisující obrazovky protnuté daným obdélníkem. Obdélník předaný
této metodě je vyjádřen souřadnicemi v obrazových bodech na virtuální pracovní ploše. Pokud žádné
obrazovky neprotínají daný obdélník, pak je pole prázdné. Tuto metodu můžete použít ke zjištění, na
kterých obrazovkách je zobrazeno okno.
Hodnoty vrácené metodami a vlastnostmi třídy Screen není vhodné ukládat. Uživatel nebo operační systém může
kdykoli změnit dostupné obrazovky a jejich uspořádání.
V následujícím příkladu je rozhraní API obrazovky použito k přesouvání okna mezi několika obrazovkami
vyvolanému stisknutím kláves se šipkami. Aby mohlo být okno přesunuto na další obrazovku, je v příkladu získáno
pole screens, které je tříděno vertikálně nebo horizontálně (podle stisknuté klávesy se šipkou). Kód pak prochází
roztříděným polem a porovnává jednotlivé obrazovky se souřadnicemi aktuální obrazovky. Aby byla identifikována
aktuální obrazovka okna, je v příkladu vyvolána metoda Screen.getScreensForRectangle() procházející
ohraničením okna.
Obrazovky
package {
import
import
import
import
import
import
flash.display.Screen;
flash.events.KeyboardEvent;
flash.ui.Keyboard;
flash.display.StageAlign;
flash.display.StageScaleMode;
public class ScreenExample extends Sprite
{
public function ScreenExample()
{
stage.align = StageAlign.TOP_LEFT;
stage.scaleMode = StageScaleMode.NO_SCALE;
stage.addEventListener(KeyboardEvent.KEY_DOWN,onKey);
}
private function onKey(event:KeyboardEvent):void{
if(Screen.screens.length > 1){
switch(event.keyCode){
case Keyboard.LEFT :
moveLeft();
break;
case Keyboard.RIGHT :
moveRight();
break;
case Keyboard.UP :
moveUp();
break;
case Keyboard.DOWN :
moveDown();
break;
}
}
}
private function moveLeft():void{
var currentScreen = getCurrentScreen();
var left:Array = Screen.screens;
left.sort(sortHorizontal);
for(var i:int = 0; i < left.length - 1; i++){
if(left[i].bounds.left < stage.nativeWindow.bounds.left){
stage.nativeWindow.x +=
left[i].bounds.left - currentScreen.bounds.left;
stage.nativeWindow.y += left[i].bounds.top - currentScreen.bounds.top;
}
}
}
private function moveRight():void{
var currentScreen:Screen = getCurrentScreen();
var left:Array = Screen.screens;
left.sort(sortHorizontal);
for(var i:int = left.length - 1; i > 0; i--){
if(left[i].bounds.left > stage.nativeWindow.bounds.left){
stage.nativeWindow.x +=
Obrazovky
left[i].bounds.left - currentScreen.bounds.left;
stage.nativeWindow.y += left[i].bounds.top - currentScreen.bounds.top;
}
}
}
private function moveUp():void{
var top:Array = Screen.screens;
top.sort(sortVertical);
for(var i:int = 0; i < top.length - 1; i++){
if(top[i].bounds.top < stage.nativeWindow.bounds.top){
stage.nativeWindow.x += top[i].bounds.left - currentScreen.bounds.left;
stage.nativeWindow.y += top[i].bounds.top - currentScreen.bounds.top;
break;
}
}
}
private function moveDown():void{
var top:Array = Screen.screens;
top.sort(sortVertical);
for(var i:int = top.length - 1; i > 0; i--){
if(top[i].bounds.top > stage.nativeWindow.bounds.top){
stage.nativeWindow.x += top[i].bounds.left - currentScreen.bounds.left;
stage.nativeWindow.y += top[i].bounds.top - currentScreen.bounds.top;
break;
}
}
}
private function sortHorizontal(a:Screen,b:Screen):int{
if (a.bounds.left > b.bounds.left){
return 1;
} else if (a.bounds.left < b.bounds.left){
return -1;
} else {return 0;}
}
private function sortVertical(a:Screen,b:Screen):int{
if (a.bounds.top > b.bounds.top){
return 1;
} else if (a.bounds.top < b.bounds.top){
return -1;
} else {return 0;}
}
private function getCurrentScreen():Screen{
var current:Screen;
var screens:Array = Screen.getScreensForRectangle(stage.nativeWindow.bounds);
(screens.length > 0) ? current = screens[0] : current = Screen.mainScreen;
return current;
}
}
}
78
Kapitola 12: Práce s nativními nabídkami
Třídy v nativní nabídce rozhraní API slouží k definování nabídek aplikace, nabídek okna, kontextových nabídek a
rozbalovacích nabídek.
Další informace o nativních nabídkách online
Více informací týkajících se nativních nabídek rozhraní API a práce s nativními nabídkami naleznete v následujících
zdrojích:
• Přidávání nativních nabídek do aplikace AIR
• NativeMenu
• NativeMenuItem
• Adobe AIR Developer Connection pro Flash (hledat „nabídky AIR“)
Základní koncepce nabídky AIR
Třídy nativních nabídek umožňují přístup k funkcím nativních nabídek operačního systému, v němž je aplikace
spuštěna. Objekty NativeMenu lze použít pro nabídky aplikace (k dispozici v systému Mac OS X), nabídky okna (k
dispozici v systému Windows), kontextové nabídky a rozbalovací nabídky.
Třídy nabídek AIR
Třídy nabídek aplikace Adobe® AIR™ zahrnují:
Balíček
Třídy
flash.display
•
NativeMenu
•
NativeMenuItem
•
ContextMenu
•
ContextMenuItem
•
Událost
•
ContextMenuEvent
flash.ui
flash.events
Práce s nativními nabídkami
Druhy nabídek
Aplikace AIR podporuje následující typy nabídek:
Nabídky aplikace Nabídka aplikace je globální nabídka, která se vztahuje k celé aplikaci. Nabídky aplikace jsou
podporovány v systému Mac OS X, ale ne v systému Windows. V systému Mac OS X vytvoří operační systém nabídku
aplikace automaticky. Pomocí nabídky rozhraní API aplikace AIR lze do standardních nabídek přidávat položky a
podnabídky. Je možné přidat posluchače pro zpracování existujících příkazů nabídky. Nebo lze odstranit existující
položky.
Nabídky okna Nabídka okna je spojena s jediným oknem a zobrazuje se pod titulním pruhem. Do okna lze přidávat
nabídky vytvořením objektu NativeMenu a jeho přiřazením k vlastnosti menu objektu NativeWindow. Nabídky okna
jsou podporovány v systému Windows, ale ne v systému Mac OS X. Nativní nabídky lze používat pouze u oken, jež
mají standardní systémové prvky.
Kontextové nabídky Kontextové nabídky se otevírají po klepnutí na interaktivní objekt v obsahu SWF nebo na
element dokumentu v obsahu HTML pravým tlačítkem myši nebo se stisknutou klávesou Apple. Kontextovou
nabídku lze vytvořit pomocí třídy NativeMenu aplikace AIR. (Rovněž je možné použít starší třídu ContextMenu
aplikace Adobe® Flash®.) Do obsahu HTML lze kontextové nabídky přidávat pomocí Webkit HTML a rozhraní API v
jazyce JavaScript.
Nabídky ikon ukotvení a hlavního panelu systému Tyto nabídky ikon se podobají kontextovým nabídkám a přiřazují
se k ikoně aplikace v ukotvení systému Mac OS X nebo v oznamovací oblasti systému Windows. Nabídky ikony
ukotvení a hlavního panelu systému používají třídu NativeMenu. V systému Mac OS X se položky v nabídce přidávají
nad standardní položky operačního systému. V systému Windows žádná standardní nabídka neexistuje.
Rozbalovací nabídky Rozbalovací nabídka aplikace AIR je jako kontextová nabídka, ale nemusí být nutně spojena s
určitým objektem nebo komponentou aplikace. Rozbalovací nabídky lze zobrazit kdekoliv v okně vyvoláním metody
display() objektu NativeMenu.
Vlastní nabídky Nativní nabídky kreslí výhradně operační systém a jako takové existují mimo vykreslovací modely
Flash a HTML. Máte možnost vytvářet vlastní nenativní nabídky pomocí jazyka MXML, ActionScript nebo JavaScript.
Třídy nabídek aplikace AIR neposkytují žádné prostředky pro řízení kreslení nativních nabídek.
Výchozí nabídky
Operační systém nebo vestavěná třída AIR poskytuje tyto výchozí nabídky:
• Nabídka aplikace v systému Mac OS X
• Nabídka ikony ukotvení v systému Mac OS X
• Kontextová nabídka pro vybraný text a obrázky v obsahu HTML
• Kontextová nabídka pro vybraný text v objektu TextField (nebo v objektu rozšiřujícím třídu TextField)
Struktura nabídek
Nabídky jsou ve své podstatě hierarchické. Objekty NativeMenu obsahují podřízené objekty NativeMenuItem.
Objekty NativeMenuItem, jež představují podnabídky, zase mohou obsahovat objekty NativeMenu. Objekt nabídky
na nejvyšší nebo kořenové úrovni ve struktuře představuje pruh nabídek pro nabídky aplikace a okna. (Kontextové
nabídky, nabídky ikon a rozbalovací nabídky pruh nabídek nemají.)
Následující schéma znázorňuje strukturu typické nabídky. Kořenová nabídka představuje pruh nabídek a obsahuje
dvě položky nabídky odkazující na podnabídku File a podnabídku Edit. Podnabídka File v této struktuře obsahuje dvě
položky příkazů a jednu položku odkazující na podnabídku Open Recent Menu, která samotná obsahuje tři položky.
Podnabídka Edit obsahuje tři příkazy a oddělovač.
NativeMenu
Root Menu
NativeMenuItem
“File”
NativeMenu
File Menu
NativeMenuItem
“New”
NativeMenuItem
“Save”
NativeMenuItem
“Open Recent”
NativeMenu
NativeMenuItem
NativeMenu
Open Recent Menu
NativeMenuItem
“GreatGatsby.pdf”
NativeMenuItem
“WarAndPeace.pdf”
NativeMenuItem
“Iliad.pdf”
“Edit”
Edit Menu
NativeMenuItem
“Copy”
NativeMenuItem
“Paste”
NativeMenuItem
Separator
NativeMenuItem
“Preferences”
Definice podnabídky vyžaduje objekt NativeMenu i NativeMenuItem. Objekt NativeMenuItem definuje popis
zobrazený v nadřazené nabídce a umožňuje uživateli otevřít podnabídku. Objekt NativeMenu slouží jako kontejner
pro položky v podnabídce. Objekt NativeMenuItem odkazuje na objekt NativeMenu pomocí vlastnosti submenu
objektu NativeMenuItem.
Chcete-li zobrazit vzorový kód, který vytvoří tuto nabídku, přečtěte si sekci „Příklad: Nabídka okna a aplikace“ na
stránce 90.
Události nabídky
Oba objekty NativeMenu i NativeMenuItem odesílají události displaying a select:
Displaying: Těsně před tím, než se zobrazí nabídka, odešle tato nabídka a její položky událost displaying do všech
zaregistrovaných posluchačů. Událost displaying poskytuje možnost aktualizovat obsah nebo vzhled nabídky dříve,
než se zobrazí uživateli. Například v posluchači pro událost displaying nabídky „Open Recent“ lze změnit položky
nabídky, aby odrážely aktuální seznam nedávno prohlížených dokumentů.
Vlastnost target objektu události je vždy nabídka, jež má být zobrazena. currentTarget je objekt, u kterého je
zaregistrován posluchač: buď samotná nabídka, nebo jedna z jejích položek.
Poznámka: Událost displaying se rovněž odešle při každém přístupu do stavu nabídky nebo některé z jejích položek.
Select: Když uživatel zvolí položku příkazu, odešle položka událost select do všech zaregistrovaných posluchačů.
Položky podnabídky a oddělovač není možné vybrat, proto nikdy neodešlou událost select.
Událost select probublá z položky nabídky do nabídky, která ji obsahuje, až ke kořenové nabídce. Události select
lze poslouchat přímo u položky a na vyšších úrovních ve struktuře nabídky. Při poslouchání události select v nabídce
lze určit vybranou položku pomocí vlastnosti target. S tím, jak událost probublává hierarchií nabídky, vlastnost
currentTarget objektu události určuje aktuální objekt nabídky.
Poznámka: Objekty ContextMenu a ContextMenuItem odesílají události menuItemSelect a menuSelect, jakož i
události select a displaying.
Klávesové ekvivalenty příkazů nabídky
K příkazu nabídky je možné přiřadit klávesový ekvivalent (někdy označovaný jako klávesová zkratka). Po stisku této
klávesy nebo kombinace kláves odešle položka nabídky událost select do všech zaregistrovaných posluchačů.
Nabídka obsahující tuto položku musí být součástí nabídky aplikace nebo aktivního okna, aby se příkaz vyvolal.
Klávesové ekvivalenty mají dvě části: řetězec představující primární klávesu a pole modifikačních kláves, které musí
být také stisknuty. Chcete-li přiřadit primární klávesu, nastavte vlastnost keyEquivalent dané položky nabídky na
řetězec s jediným znakem pro tuto klávesu. Použijete-li velké písmeno, přidá se do pole modifikátoru automaticky
klávesa Shift.
V systému Mac OS X je výchozím modifikátorem klávesa Apple (Keyboard.COMMAND). V systému Windows je to
klávesa Ctrl (Keyboard.CONTROL). Tyto výchozí klávesy se automaticky přidají do pole modifikátoru. Jestliže chcete
přiřadit jiné modifikační klávesy, přiřaďte k vlastnosti keyEquivalentModifiers nové pole obsahující požadované
kódy kláves. Výchozí pole se přepíše. Bez ohledu na to, zda použijete výchozí modifikátory nebo přiřadíte vlastní pole
modifikátoru, pokud bude řetězcem přiřazeným k vlastnosti keyEquivalent velké písmeno, přidá se klávesa Shift.
Konstanty pro kódy kláves, které se mají použít pro modifikační klávesy, jsou definovány ve třídě Keyboard.
Přiřazený řetězec klávesového ekvivalentu se automaticky zobrazí vedle názvu položky nabídky. Formát závisí na
operačním systému uživatele a na předvolbách systému.
Poznámka: Jestliže v operačním systému Windows přiřadíte poli modifikační klávesy hodnotu Keyboard.COMMAND,
nezobrazí se v nabídce žádný klávesový ekvivalent. Příkaz nabídky však bude nezbytné aktivovat pomocí klávesy Ctrl.
V následujícím příkladu se položce nabídky přiřadí klávesový ekvivalent Ctrl+Shift+G:
var item:NativeMenuItem = new NativeMenuItem("Ungroup");
item.keyEquivalent = "G";
V tomto příkladu se přiřadí klávesový ekvivalent Ctrl+Shift+G přímo nastavením pole modifikátoru:
var item:NativeMenuItem = new NativeMenuItem("Ungroup");
item.keyEquivalent = "G";
item.keyEquivalentModifiers = [Keyboard.CONTROL];
Poznámka: Klávesové ekvivalenty se spouští pouze u nabídek aplikace a okna. Přidáte-li klávesový ekvivalent ke
kontextové nebo rozbalovací nabídce, zobrazí se klávesový ekvivalent v popisu nabídky, ale připojený příkaz nabídky se
nikdy nevyvolá.
Mnemotechnické značky
Mnemotechnické značky jsou součástí rozhraní klávesnice operačního systému k nabídkám. V obou systémech Mac
OS X i Windows může uživatel otevírat nabídky a volit příkazy pomocí klávesnice, jsou zde však drobné rozdíly. V
systému Mac OS X uživatel zadá první jedno nebo dvě písmena nabídky nebo příkazu a potom zadá zpětnou klávesu.
V systému Windows je významné jen jedno písmeno. Standardně je tímto významným písmenem první znak v popisu,
pokud však přiřadíte položce nabídky mnemotechnickou značku, stane se významným písmenem označené písmeno.
Mají-li dvě položky v nabídce stejný významný znak (bez ohledu na to, zda byla přiřazena mnemotechnická značka či
nikoliv), je interakce mezi klávesnicí uživatele a nabídkou poněkud odlišná. Místo zvolení nabídky nebo příkazu
stisknutím jediného písmene musí uživatel stisknout toto písmeno několikrát podle potřeby, až se zvýrazní
požadovaná položka a potom výběr dokončit stisknutím klávesy Enter. Pro zachování stejného chování je vhodné u
nabídek okna přiřadit jedinečnou mnemotechnickou značku ke každé položce v nabídce.
Zadejte mnemotechnický znak jako index do řetězce popisu. Index prvního znaku v popisu je 0. Aby tedy bylo možné
použít „r“ jako mnemotechnickou značku pro položku nabídky označenou popisem „Format“, je třeba nastavit
vlastnost mnemonicIndex na hodnotu 2.
var item:NativeMenuItem = new NativeMenuItem("Format");
item.mnemonicIndex = 2;
Stav položek nabídky
Položky nabídky mají dvě vlastnosti stavu, checked a enabled:
checked Po nastavení na hodnotu true se vedle popisu položky zobrazí značka zaškrtnutí.
item.checked = true;
enabled Přepínáním mezi hodnotami true a false lze určit, zda je příkaz aktivován. Neaktivní položky jsou
zobrazeny „šedě“ a neodesílají události select.
item.enabled = false;
Přiřazení objektu k položce nabídky
Vlastnost data třídy NativeMenuItem umožňuje vytvoření odkazu na libovolný objekt v jednotlivých položkách.
Například v nabídce „Open Recent“ lze pro jednotlivé dokumenty přiřadit k jednotlivým položkám nabídky objekt File.
var file:File = File.applicationStorageDirectory.resolvePath("GreatGatsby.pdf")
var menuItem:NativeMenuItem = docMenu.addItem(new NativeMenuItem(file.name));
menuItem.data = file;
Vytváření nativních nabídek
V tomto tématu je popsán způsob vytváření různých typů nativních nabídek podporovaných aplikací AIR.
Vytvoření objektu kořenové nabídky
Chcete-li vytvořit objekt NativeMenu, který má sloužit jako kořen nabídky, učiňte tak pomocí konstruktoru
NativeMenu:
var root:NativeMenu = new NativeMenu();
U nabídek aplikace a okna představuje kořenová nabídka pruh nabídek a měla by obsahovat pouze položky, které
otevírají podnabídky. Kontextové a rozbalovací nabídky žádný pruh nabídek nemají, proto může kořenová nabídka
kromě podnabídek obsahovat i příkazy a oddělovače.
Po vytvoření nabídky lze přidat položky nabídky. Položky budou v nabídce zobrazeny ve stejném pořadí, v jakém byly
přidány, pokud jim nebude pomocí metody addItemAt() objektu nabídky přiřazen specifický index.
Nabídku je možné přiřadit jako nabídku aplikace, okna, ikony nebo kontextovou nabídku nebo ji lze zobrazit jako
rozbalovací nabídku, jak je znázorněno v následujících sekcích.
Nastavení nabídky aplikace
NativeApplication.nativeApplication.menu = root;
Poznámka: Systém Mac OS X definuje nabídku obsahující standardní položky pro jednotlivé aplikace. Po přiřazení
nového objektu NativeMenu k vlastnosti menu objektu NativeApplication bude nahrazena standardní nabídka.
Standardní nabídku je rovněž možné místo jejího nahrazení využít.
Nastavení nabídky okna
nativeWindowObject.menu = root;
Nastavení kontextové nabídky u interaktivního objektu
interactiveObject.contextMenu = root;
Nastavení nabídky ikony ukotvení
DockIcon(NativeApplication.nativeApplication.icon).menu = root;
Poznámka: Systém Mac OS X definuje standardní nabídku pro ikonu ukotvení aplikace. Po přiřazení nového objektu
NativeMenu k vlastnosti menu objektu DockIcon budou položky v této nabídce zobrazeny nad standardními položkami.
Standardní položky nabídky není možné odstranit, upravit ani k nim nelze získat přístup.
Nastavení nabídky ikony hlavního panelu systému
SystemTrayIcon(NativeApplication.nativeApplication.icon).menu = root;
Zobrazení nabídky jako rozbalovací nabídky
root.display(stage, x, y);
Vytvoření podnabídky
Chcete-li vytvořit podnabídku, přidáte do nadřazené nabídky objekt NativeMenuItem a potom přiřadíte objekt
NativeMenu definující podnabídku k vlastnosti submenu dané položky. Aplikace AIR poskytuje dva způsoby vytváření
položek podnabídky a s nimi spojených objektů nabídky:
Položku nabídky a s ní spojený objekt nabídky lze vytvořit v jednom kroku pomocí metody addSubmenu():
var editMenuItem:NativeMenuItem = root.addSubmenu(new NativeMenu(), "Edit");
Rovněž je možné vytvořit položku nabídky a přiřadit objekt nabídky k její vlastnosti submenu v samostatných krocích:
var editMenuItem:NativeMenuItem = root.addItem("Edit", false);
editMenuItem.submenu = new NativeMenu();
Vytvoření příkazu nabídky
Jestliže chcete vytvořit příkaz nabídky, přidejte do nabídky objekt NativeMenuItem a přidejte posluchače událostí,
který bude odkazovat na funkci implementující příkaz nabídky:
var copy:NativeMenuItem = new NativeMenuItem("Copy", false);
copy.addEventListener(Event.SELECT, onCopyCommand);
editMenu.addItem(copy);
Událost select je možné poslouchat u samotné položky příkazu (jak je znázorněno v příkladu) nebo lze událost
select poslouchat u objektu nadřazené nabídky.
Poznámka: Položky nabídky představující podnabídky a oddělovače neodesílají události select, proto je nelze použít
jako příkazy.
Vytvoření oddělovače nabídky
Pokud chcete vytvořit oddělovač, vytvořte objekt NativeMenuItem a nastavte v konstruktoru parametr isSeparator
na hodnotu true. Potom přidejte položku oddělovače na požadované místo v nabídce:
var separatorA:NativeMenuItem = new NativeMenuItem("A", true);
editMenu.addItem(separatorA);
Popis určený pro oddělovač, pokud existuje, se nezobrazuje:
Kontextové nabídky
V obsahu SWF lze jakémukoliv objektu, který dědí z objektu InteractiveObject, přidat kontextovou nabídku
přiřazením objektu nabídky k jeho vlastnosti contextMenu. Objekt nabídky přiřazený k vlastnosti contextMenu může
být typu NativeMenu nebo ContextMenu.
U starších tříd kontextové nabídky rozhraní API lze použít existující kód jazyka ActionScript, který již obsahuje
kontextové nabídky. V případě použití třídy ContextMenu je nezbytné spolu s ní použít třídu ContextMenuItem; nelze
přidávat objekty NativeMenuItem k objektu ContextMenu ani objekty ContextMenuItem k objektu NativeMenu.
Hlavní nevýhodou použití kontextové nabídky rozhraní API je to, že nepodporuje podnabídky.
Přestože třída ContextMenu zahrnuje metody, jako je např. addItem(), které jsou zděděné z třídy NativeMenu, tyto
metody přidávají položky k nesprávnému poli položek. V kontextové nabídce musí být všechny položky přidány k poli
customItems, nikoliv k poli položky. Buď použijte objekty NativeMenu pro kontextové nabídky, nebo použijte pouze
nezděděné metody a vlastnosti třídy ContextMenu pro přidávání a správu položek v nabídce.
Následující příklad vytvoří objekt Sprite a přidá jednoduchou kontextovou nabídku pro úpravy:
var sprite:Sprite = new Sprite();
sprite.contextMenu = createContextMenu()
private function createContextMenu():ContextMenu{
var editContextMenu:ContextMenu = new ContextMenu();
var cutItem:ContextMenuItem = new ContextMenuItem("Cut")
cutItem.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, doCutCommand);
editContextMenu.customItems.push(cutItem);
var copyItem:ContextMenuItem = new ContextMenuItem("Copy")
copyItem.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, doCopyCommand);
editContextMenu.customItems.push(copyItem);
var pasteItem:ContextMenuItem = new ContextMenuItem("Paste")
pasteItem.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, doPasteCommand);
editContextMenu.customItems.push(pasteItem);
return editContextMenu
}
private function doCutCommand(event:ContextMenuEvent):void{trace("cut");}
private function doCopyCommand(event:ContextMenuEvent):void{trace("copy");}
private function doPasteCommand(event:ContextMenuEvent):void{trace("paste");}
Poznámka: Na rozdíl od obsahu SWF zobrazeného v prostředí prohlížeče nemají kontextové nabídky v aplikaci AIR
žádné vestavěné příkazy.
Kontextové nabídky v HTML
V obsahu HTML lze pomocí události contextmenu zobrazit kontextovou nabídku. Kontextová nabídka se ve
výchozím nastavení zobrazí automaticky po vyvolání události kontextové nabídky u vybraného textu (klepnutím na
text pravým tlačítkem myši nebo se stisknutou klávesou Apple). Otevření výchozí nabídky je možné zamezit
posloucháním události contextmenu a vyvoláním metody preventDefault() objektu události:
function showContextMenu(event){
event.preventDefault();
}
Potom lze zobrazit vlastní kontextovou nabídku pomocí metod DHTML nebo zobrazením nativní kontextové nabídky
aplikace AIR. V následujícím příkladu se zobrazí nativní kontextová nabídka vyvoláním metody display() nabídky
v odezvě na událost contextmenu HTML:
<html>
<head>
<script src="AIRAliases.js" language="JavaScript" type="text/javascript"></script>
<script language="javascript" type="text/javascript">
function showContextMenu(event){
contextMenu.display(window.nativeWindow.stage, event.clientX, event.clientY);
}
function createContextMenu(){
var menu = new air.NativeMenu();
var command = menu.addItem(new air.NativeMenuItem("Custom command"));
command.addEventListener(air.Event.SELECT, onCommand);
return menu;
}
function onCommand(){
air.trace("Context command invoked.");
}
var contextMenu = createContextMenu();
</script>
</head>
<body>
<p oncontextmenu="showContextMenu(event)" style="-khtml-user-select:auto;">Custom context
menu.</p>
</body>
</html>
Definování nativních nabídek deklarativním způsobem
Kódování vlastností nabídky a položek nabídky může být poměrně pracné. Jelikož však mají nabídky přirozenou
hierarchickou strukturu, je jednodušší napsat funkci, která vytvoří nabídky pomocí definice ve formátu XML.
Následující třída rozšiřuje třídu NativeMenu, pomocí objektu XML ve svém konstruktoru, právě pro provedení této
operace:
package
{
import flash.display.NativeMenu;
import flash.display.NativeMenuItem;
import flash.events.Event;
public class DeclarativeMenu extends NativeMenu
{
public function DeclarativeMenu(XMLMenuDefinition:XML):void
{
super();
addChildrenToMenu(this, XMLMenuDefinition.children());
}
private function addChildrenToMenu(menu:NativeMenu,
children:XMLList):NativeMenuItem
{
var menuItem:NativeMenuItem;
var submenu:NativeMenu;
for each (var child:XML in children)
{
if (String(child.@label).length > 0)
{
menuItem = new NativeMenuItem(child.@label);
menuItem.name = child.name();
}
else
{
menuItem = new NativeMenuItem(child.name());
menuItem.name = child.name();
}
menu.addItem(menuItem);
if (child.children().length() > 0)
{
menuItem.submenu = new NativeMenu();
addChildrenToMenu(menuItem.submenu,child.children());
}
}
return menuItem;
}
} //End class
} //End package
Chcete-li vytvořit nabídku pomocí této třídy, předejte definici nabídky XML následujícím způsobem:
var menuDefinition:XML =
<root>
<FileMenu label='File'>
<NewMenu label='New'>
<NewTextFile label='Text file'/>
<NewFolder label='Folder'/>
<NewProject label='Project'/>
</NewMenu>
<OpenCommand label='Open'/>
<SaveCommand label='Save'/>
</FileMenu>
<EditMenu label='Edit'>
<CutCommand label='Cut'/>
<CopyCommand label='Copy'/>
<PasteCommand label='Paste'/>
</EditMenu>
<FoodItems label='Food Items'>
<Jellyfish/>
<Tripe/>
<Gizzard/>
</FoodItems>
</root>;
var test:DeclarativeMenu = new DeclarativeMenu(menuDefinition);
Jestliže chcete poslouchat události nabídky, je možné poslouchat na úrovni kořenové nabídky a pomocí vlastnosti
event.target.name určit, který příkaz byl zvolen. Rovněž je možné vyhledat položky v nabídce podle názvu a přidat
posluchače jednotlivých událostí.
Zobrazení rozbalovacích nabídek
Kterýkoliv objekt NativeMenu lze zobrazit v libovolném čase a na libovolném místě nad oknem, vyvoláním metody
display() nabídky. Tato metoda vyžaduje odkaz na plochu, proto pouze obsah v aplikační karanténě může zobrazit
nabídku jako rozbalovací.
Následující metoda zobrazí nabídku definovanou objektem NativeMenu s názvem popupMenu v reakci na klepnutí
myší:
private function onMouseClick(event:MouseEvent):void {
popupMenu.display(event.target.stage, event.stageX, event.stageY);
}
Poznámka: Nabídku není nutné zobrazit jako bezprostřední reakci na událost. Funkci display() může vyvolat
kterákoliv metoda.
Zpracování událostí nabídky
Nabídka odesílá události, když uživatel zvolí nabídku nebo když zvolí položku nabídky.
Souhrn událostí pro třídy nabídky
K nabídkám nebo k jednotlivým položkám přidejte posluchače událostí pro zpracování událostí nabídky.
Objekt
Odeslané události
NativeMenu
NativeMenuEvent.DISPLAYING
NativeMenuEvent.SELECT (přenesena z podřízených položek a podnabídek)
NativeMenuItem
NativeMenuEvent.SELECT
NativeMenuEvent.DISPLAYING (přenesena z nadřízené nabídky)
ContextMenu
ContextMenuEvent.MENU_SELECT
ContextMenuItem
ContextMenuEvent.MENU_ITEM_SELECT
NativeMenu.SELECT
Výběr událostí nabídky
Chcete-li zpracovávat klepnutí na položku nabídky, přidejte k objektu NativeMenuItem posluchače událostí pro
událost select:
var menuCommandX:NativeMenuItem = new NativeMenuItem("Command X");
menuCommand.addEventListener(Event.SELECT, doCommandX)
Vzhledem k tomu, že události select probublávají do nabídek, které je obsahují, lze události select poslouchat i v
nadřazené nabídce. Při poslouchání na úrovni nabídky lze určit, který příkaz nabídky byl zvolen, pomocí vlastnosti
target objektu události. V následujícím příkladu se sleduje popis zvoleného příkazu:
var colorMenuItem:NativeMenuItem = new NativeMenuItem("Choose a color");
var colorMenu:NativeMenu = new NativeMenu();
colorMenuItem.submenu = colorMenu;
var red:NativeMenuItem = new NativeMenuItem("Red");
var green:NativeMenuItem = new NativeMenuItem("Green");
var blue:NativeMenuItem = new NativeMenuItem("Blue");
colorMenu.addItem(red);
colorMenu.addItem(green);
colorMenu.addItem(blue);
if(NativeApplication.supportsMenu){
NativeApplication.nativeApplication.menu.addItem(colorMenuItem);
NativeApplication.nativeApplication.menu.addEventListener(Event.SELECT, colorChoice);
} else if (NativeWindow.supportsMenu){
var windowMenu:NativeMenu = new NativeMenu();
this.stage.nativeWindow.menu = windowMenu;
windowMenu.addItem(colorMenuItem);
windowMenu.addEventListener(Event.SELECT, colorChoice);
}
function colorChoice(event:Event):void {
var menuItem:NativeMenuItem = event.target as NativeMenuItem;
trace(menuItem.label + " has been selected");
}
Při použití třídy ContextMenuItem je možné poslouchat buď událost select, nebo událost menuItemSelect. Událost
menuItemSelect poskytuje dodatečné informace o objektu, k němuž kontextová nabídka patří, ale neprobublává do
nabídek, které ji obsahují.
Zobrazení událostí nabídky
Jestliže chcete řídit otevření nabídky, můžete přidat posluchače pro událost displaying, která se odešle před
zobrazením nabídky. Pomocí události displaying lze nabídku aktualizovat například přidáním či odstraněním položek
nebo aktualizací stavů aktivace nebo zvolení jednotlivých položek.
Příklad: Nabídka okna a aplikace
Následující příklad vytvoří nabídku zobrazenou v sekci „Struktura nabídek“ na stránce 79.
Nabídka je vytvořena tak, aby fungovala jak v systému Windows, pro který jsou podporovány nabídky okna, tak i v
systému Mac OS X, pro který jsou podporovány pouze nabídky aplikace. Kvůli jejich rozlišení zaškrtne konstruktor
třídy MenuExample statické vlastnosti supportsMenu tříd NativeWindow a NativeApplication. Pokud je vlastnost
NativeWindow.supportsMenu nastavena na hodnotu true, vytvoří konstruktor pro okno objekt NativeMenu a
potom vytvoří a přidá podnabídky File a Edit. Jestliže je vlastnost NativeApplication.supportsMenu nastavena na
hodnotu true, pak konstruktor vytvoří a přidá nabídky File a Edit do existující nabídky poskytnuté operačním
systémem Mac OS X.
Tento příklad rovněž znázorňuje zpracování událostí nabídky. Událost select se zpracovává na úrovni položky a také
na úrovni nabídky. Na událost select reaguje každá nabídka v řetězci, od nabídky obsahující vybranou položku až po
kořenovou nabídku. Událost displaying se používá u nabídky „Open Recent“. Těsně před otevřením nabídky se
položky v nabídce obnoví z aktuálního pole dokumentů (které se v tomto příkladu ve skutečnosti nezmění). Přestože
to v tomto příkladu není znázorněno, u jednotlivých položek lze rovněž poslouchat události displaying.
package {
import
import
import
import
import
import
import
flash.display.NativeMenu;
flash.display.NativeMenuItem;
flash.display.NativeWindow;
flash.events.Event;
flash.filesystem.File;
flash.desktop.NativeApplication;
public class MenuExample extends Sprite
{
private var recentDocuments:Array =
new Array(new File("app-storage:/GreatGatsby.pdf"),
new File("app-storage:/WarAndPeace.pdf"),
new File("app-storage:/Iliad.pdf"));
public function MenuExample()
{
var fileMenu:NativeMenuItem;
var editMenu:NativeMenuItem;
if (NativeWindow.supportsMenu){
stage.nativeWindow.menu = new NativeMenu();
stage.nativeWindow.menu.addEventListener(Event.SELECT, selectCommandMenu);
fileMenu = stage.nativeWindow.menu.addItem(new NativeMenuItem("File"));
fileMenu.submenu = createFileMenu();
editMenu = stage.nativeWindow.menu.addItem(new NativeMenuItem("Edit"));
editMenu.submenu = createEditMenu();
}
if (NativeApplication.supportsMenu){
NativeApplication.nativeApplication.menu.addEventListener(Event.SELECT,
selectCommandMenu);
fileMenu = NativeApplication.nativeApplication.menu.addItem(new
NativeMenuItem("File"));
fileMenu.submenu = createFileMenu();
editMenu = NativeApplication.nativeApplication.menu.addItem(new
NativeMenuItem("Edit"));
editMenu.submenu = createEditMenu();
}
}
public function createFileMenu():NativeMenu {
var fileMenu:NativeMenu = new NativeMenu();
fileMenu.addEventListener(Event.SELECT, selectCommandMenu);
var newCommand:NativeMenuItem = fileMenu.addItem(new NativeMenuItem("New"));
newCommand.addEventListener(Event.SELECT, selectCommand);
var saveCommand:NativeMenuItem = fileMenu.addItem(new NativeMenuItem("Save"));
saveCommand.addEventListener(Event.SELECT, selectCommand);
var openRecentMenu:NativeMenuItem =
fileMenu.addItem(new NativeMenuItem("Open Recent"));
openRecentMenu.submenu = new NativeMenu();
openRecentMenu.submenu.addEventListener(Event.DISPLAYING,
updateRecentDocumentMenu);
openRecentMenu.submenu.addEventListener(Event.SELECT, selectCommandMenu);
return fileMenu;
}
public function createEditMenu():NativeMenu {
var editMenu:NativeMenu = new NativeMenu();
editMenu.addEventListener(Event.SELECT, selectCommandMenu);
var copyCommand:NativeMenuItem = editMenu.addItem(new NativeMenuItem("Copy"));
copyCommand.addEventListener(Event.SELECT, selectCommand);
copyCommand.keyEquivalent = "c";
var pasteCommand:NativeMenuItem =
editMenu.addItem(new NativeMenuItem("Paste"));
pasteCommand.addEventListener(Event.SELECT, selectCommand);
pasteCommand.keyEquivalent = "v";
editMenu.addItem(new NativeMenuItem("", true));
var preferencesCommand:NativeMenuItem =
editMenu.addItem(new NativeMenuItem("Preferences"));
preferencesCommand.addEventListener(Event.SELECT, selectCommand);
return editMenu;
}
private function updateRecentDocumentMenu(event:Event):void {
trace("Updating recent document menu.");
var docMenu:NativeMenu = NativeMenu(event.target);
for each (var item:NativeMenuItem in docMenu.items) {
docMenu.removeItem(item);
}
for each (var file:File in recentDocuments) {
var menuItem:NativeMenuItem =
docMenu.addItem(new NativeMenuItem(file.name));
menuItem.data = file;
menuItem.addEventListener(Event.SELECT, selectRecentDocument);
}
}
private function selectRecentDocument(event:Event):void {
trace("Selected recent document: " + event.target.data.name);
}
private function selectCommand(event:Event):void {
trace("Selected command: " + event.target.label);
}
private function selectCommandMenu(event:Event):void {
if (event.currentTarget.parent != null) {
var menuItem:NativeMenuItem =
findItemForMenu(NativeMenu(event.currentTarget));
if (menuItem != null) {
trace("Select event for \"" +
event.target.label +
"\" command handled by menu: " +
menuItem.label);
}
} else {
trace("Select event for \"" +
event.target.label +
"\" command handled by root menu.");
}
}
private function findItemForMenu(menu:NativeMenu):NativeMenuItem {
for each (var item:NativeMenuItem in menu.parent.items) {
if (item != null) {
if (item.submenu == menu) {
return item;
}
}
}
return null;
}
}
}
93
Kapitola 13: Ikony na hlavním panelu
Mnohé operační systémy poskytují hlavní panel, např. dock v systému Mac OS X, který může obsahovat ikony
zastupující různé aplikace. Aplikace Adobe® AIR® poskytuje rozhraní pro interakci s ikonami hlavního panelu aplikace
prostřednictvím vlastnosti NativeApplication.nativeApplication.icon.
Doplňující online informace o ikonách na hlavním
panelu
Další informace o práci s hlavními panely můžete získat z následujících zdrojů:
• Používání ikon oznamovací oblasti a doku
• DockIcon
• SystemTrayIcon
Články a Ukázky k Adobe Developer Connection
• Adobe AIR Developer Connection pro Flash (hledání „ikon hlavního panelu aplikace AIR“)
O ikonách na hlavním panelu
Aplikace AIR automaticky vytvoří objekt NativeApplication.nativeApplication.icon. Typ objektu je buď
DockIcon nebo SystemTrayIcon, podle operačního systému. Můžete určit, které z těchto podtříd InteractiveIcon,
které aplikace AIR podporuje na aktuálním operačním systému používajícím vlastnosti
NativeApplication.supportsDockIcon a NativeApplication.supportsSystemTrayIcon. Základní třída
InteractiveIcon poskytuje vlastnosti width, height a bitmaps, které můžete použít ke změně obrazu používaného pro
ikonu. Avšak přístup k vlastnostem náležejícím k třídě DockIcon, resp. SystemTrayIcon v nesprávném operačním
systému generuje chybu za běhu.
Chcete-li nastavit obraz pro použití pro ikonu, nastavte pole obsahující jeden nebo více obrazů a přiřaďte je k vlastnosti
NativeApplication.nativeApplication.icon.bitmaps. Velikost ikon na hlavním panelu může být v různých
operačních systémech různá. Chcete-li se vyhnout zhoršení kvality vlivem změny velikosti, můžete do pole bitmaps
přidat více velikostí příslušných obrazů. Poskytnete-li více než jeden obraz, aplikace AIR zvolí velikost nejbližší
aktuální velikosti zobrazení ikony na hlavním panelu a tuto velikost změní pouze v případě nutnosti. V následujícím
příkladu je nastaven obraz pro ikonu hlavního panelu pomocí dvou obrazů:
NativeApplication.nativeApplication.icon.bitmaps =
[bmp16x16.bitmapData, bmp128x128.bitmapData];
Chcete-li změnit obraz ikony, přiřaďte k vlastnosti bitmaps pole obsahující nový obraz nebo obrazy. Ikonu můžete
animovat změnou jejího obrazu v odpovědi na událost enterFrame nebo timer.
Ikony na hlavním panelu
Chcete-li odstranit ikonu z oznamovací oblasti systému Windows nebo obnovit výchozí vzhled ikony v systému Mac
OS X, nastavte vlastnost bitmaps na prázdné pole:
NativeApplication.nativeApplication.icon.bitmaps = [];
Ikony doku
Aplikace AIR podporuje ikony doku, když je vlastnost NativeApplication.supportsDockIcon nastavena na
hodnotu true. Vlastnost NativeApplication.nativeApplication.icon představuje aplikační ikonu v doku (ne
ikona doku okna).
Poznámka: Aplikace AIR nepodporuje změnu ikon okna na doku v systému Mac OS X. Změny u aplikační ikony doku
také platí, pouze dokud aplikace běží – jakmile je aplikace ukončena, ikona obnoví svůj běžný vzhled.
Nabídky ikon doku
Do standardní nabídky doku můžete přidávat příkazy tak, že vytvoříte objekt NativeMenu obsahující příkazy a
přiřadíte jej k vlastnosti NativeApplication.nativeApplication.icon.menu. Položky v nabídce jsou zobrazeny
nad standardními položkami nabídky ikony doku.
Poskakování doku
Vyvoláním metody NativeApplication.nativeApplication.icon.bounce() můžete ikonu doku přimět, aby
poskočila. Nastavíte-li parametr bounce() priorityna informační, ikona jednou poskočí. Nastavíte-li jej na kritický,
ikona bude poskakovat, dokud uživatel příslušnou aplikaci neaktivuje. Konstanty pro parametr priority jsou
definovány ve třídě NotificationType.
Poznámka: Ikona neposkočí, je-li aplikace již aktivní.
Události ikony doku
Jakmile klepnete na ikonu doku, objekt NativeApplication odešle událost invoke. Jestliže aplikace neběží, systém ji
spustí. Jinak bude událost invoke doručena instanci běžící aplikace.
Ikony oznamovací oblasti
Aplikace AIR podporuje ikony oznamovací oblasti, když je vlastnost
NativeApplication.supportsSystemTrayIcon nastavena na hodnotu true, což je v současné době pouze případ
Windows. V systému Windows jsou ikony oznamovací oblasti zobrazeny v oznamovací oblasti hlavního panelu.
Implicitně tam není zobrazena žádná ikona. Chcete-li v oblasti zobrazit nějakou ikonu, přiřaďte vlastnosti bitmaps
ikony pole obsahující objekty BitmapData. Chcete-li změnit obraz ikony, přiřaďte k vlastnosti bitmaps pole obsahující
nové obrazy. Chcete-li ikonu odstranit, nastavte vlastnost bitmaps na hodnotu null.
Nabídky ikony oznamovací oblasti
K ikoně oznamovací oblasti můžete přidat nabídku tak, že vytvoříte objekt NativeMenu a přiřadíte jej k vlastnosti
NativeApplication.nativeApplication.icon.menu (operační systém neposkytuje žádnou výchozí nabídku). Do
nabídky ikony oznamovací oblasti se dostanete, když klepnete pravým tlačítkem myši.
Tipy nástrojů ikony oznamovací oblasti
Přidejte k ikoně tip nástroje nastavením vlastnosti tipu nástroje:
NativeApplication.nativeApplication.icon.tooltip = "Application name";
Události ikony oznamovací oblasti
Objekt SystemTrayIcon, na který se odkazuje vlastnost NativeApplication.nativeApplication.icon, odešle událost
ScreenMouseEvent pro události click, mouseDown, mouseUp, rightClick, rightMouseDown a rightMouseUp. Tyto
události, spolu s nabídkou ikony, můžete použít, chcete-li uživatelům umožnit interakci s vaší aplikací, když nemá
žádná viditelná okna.
Příklad: Vytvoření aplikace bez oken
V následujícím příkladu je vytvořena aplikace AIR, která má ikonu oznamovací oblasti, ale žádná viditelná okna. Ikona
oznamovací oblasti má nabídku s jediným příkazem pro ukončení aplikace.
package
{
import
import
import
import
import
import
import
import
import
import
flash.display.Loader;
flash.display.NativeMenu;
flash.display.NativeMenuItem;
flash.desktop.DockIcon;
flash.desktop.SystemTrayIcon;
flash.events.Event;
public class SysTrayApp extends Sprite
{
public function SysTrayApp():void{
NativeApplication.nativeApplication.autoExit = false;
var icon:Loader = new Loader();
var iconMenu:NativeMenu = new NativeMenu();
var exitCommand:NativeMenuItem = iconMenu.addItem(new NativeMenuItem("Exit"));
exitCommand.addEventListener(Event.SELECT, function(event:Event):void {
NativeApplication.nativeApplication.icon.bitmaps = [];
NativeApplication.nativeApplication.exit();
});
if (NativeApplication.supportsSystemTrayIcon) {
NativeApplication.nativeApplication.autoExit = false;
icon.contentLoaderInfo.addEventListener(Event.COMPLETE, iconLoadComplete);
icon.load(new URLRequest("icons/AIRApp_16.png"));
var systray:SystemTrayIcon =
NativeApplication.nativeApplication.icon as SystemTrayIcon;
systray.tooltip = "AIR application";
systray.menu = iconMenu;
}
if (NativeApplication.supportsDockIcon){
icon.contentLoaderInfo.addEventListener(Event.COMPLETE,iconLoadComplete);
icon.load(new URLRequest("icons/AIRApp_128.png"));
var dock:DockIcon = NativeApplication.nativeApplication.icon as DockIcon;
dock.menu = iconMenu;
}
stage.nativeWindow.close();
}
private function iconLoadComplete(event:Event):void
{
NativeApplication.nativeApplication.icon.bitmaps =
[event.target.content.bitmapData];
}
}
}
Poznámka: V příkladu se předpokládá, že v podadresáři icons dané aplikace jsou obrazy s názvy AIRApp_16.png a
AIRApp_128.png. (Ukázkové soubory ikony, které můžete zkopírovat do vaší projektové složky, jsou zahrnuty v SDK AIR.)
Ikony hlavního panelu a tlačítka okna
Zastoupení oken zmenšené na ikony jsou běžně zobrazena v oblasti okna hlavního panelu nebo doku, aby umožňovala
uživateli snadný přístup k pozadí nebo minimalizovaným oknům. V doku systému Mac OS X je zobrazena ikona pro
vaši aplikaci spolu s ikonami pro jednotlivá minimalizovaná okna. Na hlavním panelu systému Windows je zobrazeno
tlačítko obsahující ikonu programu a název pro každé okno normálního typu ve vaší aplikaci.
Zvýraznění tlačítka okna hlavního panelu
Když je okno v pozadí, můžete uživateli oznámit, že se vyskytla nějaká zajímavá událost týkající se daného okna. V
systému Mac OS X můžete uživatele informovat poskočením aplikační ikony doku (jak je popsáno v části
„Poskakování doku“ na stránce 94). V systému Windows můžete zvýraznit tlačítko hlavního panelu okna vyvoláním
metody notifyUser() instance NativeWindow. Naléhavost příslušného oznámení určuje parametr type předaný
metodě:
•
NotificationType.CRITICAL: ikona okna bude blikat, dokud uživatel nepřepne příslušné okno do popředí.
•
NotificationType.INFORMATIONAL: ikona okna bude zvýrazněna měnící se barvou.
Následující příkaz zvýrazní tlačítko hlavního panelu okna:
stage.nativeWindow.notifyUser(NotificationType.CRITICAL);
Vyvolání metody NativeWindow.notifyUser() v operačním systému, který nepodporuje oznamování na úrovni
okna, nebude mít žádný účinek. Vlastnost NativeWindow.supportsNotification slouží k určení, zda je
podporováno oznamování okna.
Vytváření oken bez tlačítek nebo ikon hlavního panelu
V operačním systému Windows se okna vytvořená s typy utility nebo lightweight nezobrazují na hlavním panelu. Na
hlavním panelu se neobjevují ani neviditelná okna.
Protože počáteční okno je nutně typu normal, aby byla vytvořena aplikace bez oken, která by se objevila na hlavním
panelu, musíte počáteční okno buď zavřít nebo je ponechat neviditelné. Chcete-li zavřít všechna okna ve vaší aplikaci
bez ukončení aplikace, nastavte před zavřením posledního okna vlastnost autoExit objektu NativeApplication na
hodnotu false. Chcete-li jen zabránit, aby se počáteční okno stalo neviditelným, přidejte kód
<visible>false</visible> k elementu <initalWindow> souboru deskriptoru aplikace (a nenastavujte vlastnost
visible na hodnotu true ani nevolejte metodu activate() daného okna).
V nových oknech otevřených aplikací nastavte vlastnost type objektu NativeWindowInitOption předaného
konstruktoru okna na hodnotu NativeWindowType.UTILITY nebo NativeWindowType.LIGHTWEIGHT.
V systému Mac OS X jsou okna, která jsou minimalizována, zobrazena na hlavním panelu doku. Chcete-li zabránit,
aby byla minimalizovaná ikona zobrazena, tak okno skryjte, místo abyste jej minimalizovali. V následujícím příkladu
je poslouchána událost změny vlastnosti nativeWindowDisplayState, která je zrušena, dojde-li k minimalizaci okna.
Místo toho program zpracování nastaví vlastnost visible příslušného okna na hodnotu false:
private function preventMinimize(event:NativeWindowDisplayStateEvent):void{
if(event.afterDisplayState == NativeWindowDisplayState.MINIMIZED){
event.target.visible = false;
}
}
Je-li okno minimalizováno v doku systému Mac OS X, když nastavíte vlastnost visible na hodnotu false, nebude
ikona doku odstraněna. Uživatel může přesto klepnout na ikonu a okno se znovu objeví.
98
Kapitola 14: Práce se systémem souborů
Třídy obsažené v systému souborů Adobe® AIR™ API pro přístup k systému souborů hostitelského počítače. Pomocí
těchto tříd můžete přistupovat k adresářům a souborům a provádět jejich správu, vytvářet adresáře a soubory,
zapisovat do souborů data atd.
Další online informace o souborovém API aplikace AIR
Další informace o používání souborových tříd API naleznete na těchto odkazech:
Stručný úvod (Adobe AIR Developer Connection)
• Vytváření textového editorů
• Soubor
• Datový tok souboru
• Režim souboru
Články a Ukázky Adobe Developer Connection
• Adobe AIR Developer Connection pro Flash (hledejte 'souborový systém AIR')
Základy souborů aplikace AIR
Aplikace Adobe AIR poskytuje třídy, které můžete používat pro přístup, vytváření a správu souborů a adresářů. Tyto
třídy obsažení v balíku flash.filesystem jsou použity takto:
Třídy File
Popis
Soubor
Objekt File představuje cestu k souboru nebo adresáři. Objekt file můžete použít pro vytvoření ukazatele na soubor
nebo složku a aktivovat tak interakci se souborem nebo složkou.
FileMode
Třída FileMode definuje konstanty řetězce použité v parametru fileMode metod open() a openAsync() třídy
FileStream. Parametr fileMode těchto metod stanoví možnosti dostupné v objektu FileStream, jakmile je soubor
otevřen, což zahrnuje zápis, čtení, připojování a aktualizaci.
FileStream
Objekt FileStream se používá pro otevírání souborů pro čtení a zápis. Jakmile vytvoříte objekt File, který ukazuje na
nový nebo stávající soubor, předáte tento ukazatel objektu FileStream tak, že budete moci otevřít a pak
manipulovat s daty v rámci souboru.
Některé metody třídy File mají synchronní i asynchronní verzi:
•
File.copyTo() a File.copyToAsync()
•
File.deleteDirectory() a File.deleteDirectoryAsync()
•
File.deleteFile() a File.deleteFileAsync()
•
File.getDirectoryListing() a File.getDirectoryListingAsync()
Práce se systémem souborů
•
File.moveTo() a File.moveToAsync()
•
File.moveToTrash() a File.moveToTrashAsync()
Operace FileStream také pracují synchronně nebo asynchronně v závislosti na tom, zda objekt FileStream soubor
otevře: zavoláním metody open() nebo metody openAsync().
Asynchronní verze umožňuje inicializovat proces, který je spouštěn na pozadí a odesílá události po dokončení (nebo
když dojde k chybové události). Jiný kód je možné spustit v době, kdy probíhají tyto asynchronní procesy na pozadí.
V případě asynchronní verze operací musíte nastavit funkce posluchačů událostí pomocí metody
addEventListener() objektu File nebo FileStream, který funkci volá.
Synchronní verze umožňuje zapisovat jednodušší kód, které se zcela nespoléhá na nastavení posluchačů událostí.
Protože však jiný kód není možné vykonat během spouštění synchronní metody, mohou být pozastaveny důležité
procesy, jako jsou například vykreslování objektů zobrazení a animace.
Práce s objekty File
Objekt File je ukazatelem souboru nebo adresáře v systému souborů.
Třída File rozšiřuje třídu FileReference. Třída FileReference, která je dostupná v aplikaci Adobe® Flash® Player stejně
jako v aplikaci AIR, představuje ukazatel souboru, ale třída File přidává vlastnosti a metody, které nejsou v aplikaci
Flash Player volně přístupné (v SWF spuštěném v prohlížeči); důvodem je zabezpečení.
O třídě File
Třídu File můžete použít pro následující:
• Získání cesty do speciálních adresářů, včetně uživatelských adresářů, adresářů uživatelských dokumentů, adresáře,
ze které byla spuštěna aplikace a adresáře samotné aplikace.
• Kopírování souborů a adresářů
• Přesouvání souborů a adresářů
• Odstraňování souborů a adresářů (nebo jejich přesouvání do koše)
• Vypisování seznamu souborů a adresářů umístěných v adresáři
• Vytváření dočasných souborů a adresářů
Jakmile objekt File ukazuje na cestu souboru, můžete jej použít pro načtení a zápis dat souboru pomocí třídy
FileStream.
Objekt File může ukazovat na cestu souboru a adresáře, který ještě neexistuje. Takový objekt File můžete použít pro
vytváření souboru nebo adresáře.
Cesty objektu File
Každý objekt File má dvě vlastnosti, které definují dráhu:
Vlastnost
Popis
nativePath
Specifikujte cestu k souboru, specifickou pro danou platformu. Například u systému Windows může být cesta
„c:\Vzorový_adresář\test.txt“, zatímco u systému Mac OS může být cesta „/Vzorový_adresář/test.txt“. Vlastnost
nativePath používá jako oddělovač adresářů zpětné lomítko (\) u systému Windows a lomítko (/) u systému
Mac OS.
url
Schéma URL souboru může být použito pro odkázání na soubor. Například u systému Windows může být cesta
„file:///c:/Vzorový%20adresář/test.txt“, zatímco u systému Mac OS může být cesta
„file:///Vzorový%20adresář/test.txt“. Spuštění programu zahrnuje další speciální schémata URL kromě file,
která jsou popsána v kapitole „Podporovaná schémata URL“ na stránce 104
Třída File zahrnuje vlastnosti pro odkázání na standardní adresáře u systémů Mac i Windows.
Odkázání objektu File na adresář
Existují různé způsoby, jak nastavit objekt File, aby ukazoval na adresář.
Odkázání na domovský adresář uživatele
Objekt File můžete odkázat na domovský adresář uživatele. V systému Windows je domovský adresář uživatele
nadřazený adresář pro „Moje dokumenty“ (například „C:\Documents and Settings\jméno_uživatele\Moje
dokumenty“). U systému Mac OS se jedná o adresář Users/jméno_uživatele. Následující kód nastavuje objekt File tak,
aby ukazoval na podadresář AIR test v domovském adresáři:
var file:File = File.userDirectory.resolvePath("AIR Test");
Odkázání na adresář dokumentů uživatele
Objekt File můžete odkázat na adresář dokumentů uživatele. V systému Windows se typicky jedná o adresář „Moje
dokumenty“ (například „C:\Documents and Settings\jméno_uživatele\Moje dokumenty“). U systému Mac OS se
jedná o adresář Users/jméno_uživatele/Documents. Následující kód nastavuje objekt File tak, aby ukazoval na
podadresář AIR test v adresáři dokumentů:
var file:File = File.documentsDirectory.resolvePath("AIR Test");
Odkázání na adresář plochy
Objekt File můžete odkázat na plochu. Následující kód nastavuje objekt File tak, aby odkazoval na podadresář AIR test
plochy:
var file:File = File.desktopDirectory.resolvePath("AIR Test");
Odkázání na adresář uložení dat aplikace
Objekt File můžete odkázat na adresář uložení dat aplikace. Pro aplikaci AIR existuje jedinečná přiřazená cesta, která
definuje adresář uložení dat aplikace. Tento adresář je jedinečný pro každou aplikaci a uživatele. Můžete tento adresář
použít pro uložení dat specifických pro uživatele nebo aplikaci (například uživatelská data nebo soubory předvoleb).
Například následující kód odkazuje objekt File na soubor předvoleb, prefs.xml, obsažený v adresáři uložení dat
aplikace:
var file:File = File.applicationStorageDirectory;
file = file.resolvePath("prefs.xml";
Místo adresáře uložení dat aplikace je založeno na jménu uživatele, ID aplikace a ID vydavatele:
• U systému Mac OS v:
/Users/jméno_uživatele/Library/Preferences/applicationID.publisherID/Local Store/
Například:
/Users/babbage/Library/Preferences/com.example.TestApp.02D88EEED35F84C264A183921344EEA353
A629FD.1/Local Store
• U systému Windows—V adresáři Documents and Settings, v:
jméno_uživatele/Application Data/applicationID.publisherID/Local Store/
Například:
C:\Documents and Settings\babbage\Application
Data\com.example.TestApp.02D88EEED35F84C264A183921344EEA353A629FD.1\Local Store
URL (a vlastnost url) pro soubor File vytvořený s File.applicationStorageDirectory používá schéma URL appstorage (viz „Podporovaná schémata URL“ na stránce 104), jako v následujícím příkladu:
var dir:File = File.applicationStorageDirectory;
dir = dir.resolvePath("preferences");
trace(dir.url); // app-storage:/preferences
Odkázání na adresář aplikace
Objekt File můžete odkázat na adresář, ve kterém byla aplikace nainstalována, kterému se říká adresář aplikace. Tento
adresář můžete odkazovat pomocí vlastnosti File.applicationDirectory. Tento adresář můžete také použít pro
prověření popisovacího souboru aplikace, nebo jiných zdrojů nainstalovaných s aplikací. Například následující kód
odkazuje objekt File na adresář pojmenovaný images v adresáři aplikace:
var dir:File = File.applicationDirectory;
dir = dir.resolvePath("images");
URL (a vlastnost url) pro soubor File vytvořený s File.applicationDirectory používá schéma URL app (viz
„Podporovaná schémata URL“ na stránce 104), jako v následujícím příkladu:
var dir:File = File.applicationDirectory;
dir = dir.resolvePath("images");
trace(dir.url); // app:/images
Odkázání na kořenový adresář systému souborů
Metoda File.getRootDirectories() uvádí všechny kořenové svazky, například C: a připojené svazky v počítači se
systémem Windows. V systému Mac tato metoda vždy vrací jedinečný kořenový adresář pro počítač (adresář „/“).
Odkázání na výslovně definovaný adresář
Objekt File můžete odkázat na výslovně definovaný adresář nastavením vlastnosti nativePath objektu File, jako v
následujícím příkladu (systém Windows):
var file:File = new File();
file.nativePath = "C:\\AIR Test\";
Navigace relativních cest
Metodu resolvePath() můžete použít pro získání cesty relativní vzhledem k jiné dané cestě. Například následující
kód nastavuje objekt File tak, aby odkazoval na podadresář „AIR test“ v domovském adresáři uživatele:
var file:File = File.userDirectory;
file = file.resolvePath("AIR Test");
Můžete také použít vlastnost url objektu File tak, aby odkazoval na adresář založený na řetězci URL, jako v
následujícím příkladu:
var urlStr:String = "file:///C:/AIR Test/";
var file:File = new File()
file.url = urlStr;
Další informace, viz „Modifikování cest souboru“ na stránce 104.
Umožnění uživateli procházením vybírat adresář
Třída File zahrnuje metodu browseForDirectory(), která zobrazuje systémové dialogové okno, ve kterém může
uživatel volit adresář pro přiřazení k objektu. Metoda browseForDirectory() je asynchronní. Odesílá událost
select v případě, že uživatel zvolí adresář a klepne na tlačítko Otevřít, nebo odešle událost cancel v případě, že
uživatel klepne na tlačítko Zrušit.
Například následující kód umožňuje uživateli vybrat adresář a po vybrání odešle na výstup cestu adresáře:
file.addEventListener(Event.SELECT, dirSelected);
file.browseForDirectory("Select a directory");
function dirSelected(e:Event):void {
trace(file.nativePath);
}
Odkázání na adresář, ze kterého byla aplikace vyvolána
Můžete získat umístění adresáře, ze kterého byla vyvolána aplikace, a to zkontrolováním vlastnosti
currentDirectory objektu InvokeEvent, odeslaného, když byla aplikace vyvolána. Podrobnosti viz také „Zachycení
argumentů příkazového řádku“ na stránce 260.
Odkázání objektu File na soubor
Existují různé způsoby, jak nastavit soubor, na který objekt File ukazuje.
Odkázání na explicitní cestu souboru
Metodu resolvePath() můžete použít pro získání cesty relativní vzhledem k jiné dané cestě. Například následující
kód nastavuje objekt File tak, aby odkazoval na soubor log.txt v adresáři ukládání dat aplikace:
var file:File = File.applicationStorageDirectory;
file = file.resolvePath("log.txt");
Můžete použít vlastnost url objektu File tak, aby odkazoval na soubor nebo adresář založený na řetězci URL, jako v
var urlStr:String = "file:///C:/AIR Test/test.txt";
var file:File = new File()
file.url = urlStr;
Můžete také předat adresu URL funkci konstruktoru File(), jako v následujícím příkladu.
var urlStr:String = "file:///C:/AIR Test/test.txt";
var file:File = new File(urlStr);
Vlastnost url vždy vrací verzi adresy URL zakódovanou URI (například prázdný znak je nahrazen symbolem "%20):
file.url = "file:///c:/AIR Test";
trace(file.url); // file:///c:/AIR%20Test
Můžete také použít vlastnost nativePath objektu File a nastavit explicitní cestu. Například následující kód, po
spuštění v systému Windows, nastaví objekt File na soubor test.txt v podadresáři AIR Test na jednotce C:
file.nativePath = "C:/AIR Test/test.txt";
Můžete také předat tuto cestu funkci konstruktoru File(), jako v následujícím příkladu.
var file:File = new File("C:/AIR Test/test.txt");
V systému Windows můžete použít dopředné lomítko (/) nebo zpětné lomítko (\) jako oddělovač cesty pro vlastnost
nativePath. U systému Mac OS použijte dopředné lomítko (/) jako oddělovač cesty pro vlastnost nativePath:
var file:File = new File(/Users/dijkstra/AIR Test/test.txt");
Další informace, viz „Modifikování cest souboru“ na stránce 104.
Vypsání souborů v adresáři
Metodu getDirectoryListing() objektu File můžete použít pro získání objektů File odkazujících na soubory a
podadresáře v kořenové úrovni adresáře. Další informace naleznete v kapitole „Vypsání adresářů“ na stránce 108.
Umožnění uživateli procházením vybírat soubor
Třída File zahrnuje následující metody, které zobrazují systémové dialogové okno, ve kterém může uživatel volit
adresář pro přiřazení k objektu.
•
browseForOpen()
•
browseForSave()
•
browseForOpenMultiple()
Tyto metody jsou všechny asynchronní. Metody browseForOpen() a browseForSave() odesílají událost select, když
uživatel zvolí soubor (nebo cílovou cestu, v případě metody browseForSave()). Pomocí metod browseForOpen() a
browseForSave() po výběru cíle objekt File odkáže na vybrané soubory. Metoda browseForOpenMultiple() odesílá
událost selectMultiple, když uživatel zvolí soubory. Událost selectMultiple je typu FileListEvent, která má
vlastnost files, která je polem objektů File (odkazujících na vybrané soubory).
Například následující kód předkládá uživateli dialogové okno “Otevřít”, ve kterém může uživatel volit soubor:
var fileToOpen:File = File.documentsDirectory;
selectTextFile(fileToOpen);
function selectTextFile(root:File):void
{
var txtFilter:FileFilter = new FileFilter("Text", "*.as;*.css;*.html;*.txt;*.xml");
root.browseForOpen("Open", [txtFilter]);
root.addEventListener(Event.SELECT, fileSelected);
}
function fileSelected(event:Event):void
{
trace(fileToOpen.nativePath);
}
Pokud má aplikace otevřené jiné dialogové okno prohlížeče, když zavoláte metodu browse, chod aplikace odešle
výjimku Error.
Modifikování cest souboru
Můžete také změnit cestu stávajícího objektu File zavoláním metody resolvePath() nebo modifikováním objektu
nativePath nebo vlastnosti url objektu, jako v následujícím příkladu (v systému Windows):
var file1:File = File.documentsDirectory;
file1 = file1.resolvePath("AIR Test");
trace(file1.nativePath); // C:\Documents and Settings\userName\My Documents\AIR Test
file2 = file2.resolvePath("..");
trace(file2.nativePath); // C:\Documents and Settings\userName
file3.nativePath += "/subdirectory";
trace(file3.nativePath); // C:\Documents and Settings\userName\My Documents\subdirectory
var file4:File = new File();
file4.url = "file:///c:/AIR Test/test.txt";
trace(file4.nativePath); // C:\AIR Test\test.txt
Při použití vlastnosti nativePath můžete použít dopředné lomítko (/) nebo zpětné lomítko (\) jako oddělovač
adresářů v systému Windows; v systému Mac OS použijte dopředné lomítko (/). V systému Windows nezapomeňte
zadat znak zpětného lomítka dvakrát v řetězcové konstantě.
Podporovaná schémata URL
Můžete použít kterékoliv z následujících schémat URl při definování vlastnosti url objektu File:
schéma URL
Popis
file
Používá se pro specifikování cesty relativní vzhledem ke kořenu systému souborů. Například:
file:///c:/AIR Test/test.txt
Standardní URL specifikuje, že URL souboru má tvar file://<host>/<path>. Speciální případ je, kdy <host>
může být prázdný řetězec, což je interpretováno jako „počítač, ze kterého je adresa URl interpretována.“ Z tohoto
důvodu URL souboru často mohou mít tři lomítka (///).
app
Slouží z určení relativní cesty do kořenového adresáře nainstalované aplikace (adresář, který obsahuje soubor
application.xml pro nainstalovanou aplikaci). Například následující cesta ukazuje na podadresář obrázků v adresáři
nainstalované aplikace:
app:/images
app-storage
Slouží k určení cesty vzhledem k ukládacímu adresáři aplikace. Aplikace AIR definuje pro každou instalovanou
aplikaci jedinečný odkládací adresář aplikace, který je užitečný při ukládání dat specifických pro danou aplikaci.
Například následující cesta vede k souboru prefs.xml v podadresáři nastavení ukládacího adresáře aplikace.
app-storage:/settings/prefs.xml
Vyhledání relativní cesty mezi dvěma soubory
Metodu getRelativePath() můžete použít pro vyhledání relativní cesty mezi dvěma soubory:
var file1:File = File.documentsDirectory.resolvePath("AIR Test");
var file2:File = File.documentsDirectory
file2 = file2.resolvePath("AIR Test/bob/test.txt");
trace(file1.getRelativePath(file2)); // bob/test.txt
Druhý parametr metody getRelativePath(), parametr useDotDot, umožňuje navrácení následující .. syntaxe ve
výsledcích, které indikují nadřízené adresáře:
file1 = file1.resolvePath("AIR Test");
file2 = file2.resolvePath("AIR Test/bob/test.txt");
file3 = file3.resolvePath("AIR Test/susan/test.txt");
trace(file2.getRelativePath(file1, true)); // ../..
trace(file3.getRelativePath(file2, true)); // ../../bob/test.txt
Získání kanonických verzí názvů souborů
Názvy souboru a cesty obvykle nerozlišují malá a velká písmena. V následujícím příkladu dva objekty File odkazují na
stejný soubor:
File.documentsDirectory.resolvePath("test.txt");
File.documentsDirectory.resolvePath("TeSt.TxT");
Nicméně názvy dokumentů a adresářů malá a velká písmena rozlišují. Následující příklad předpokládá, že existuje
složka pojmenovaná AIR Test v adresáři dokumentů, jako na následujícím příkladu:
var file:File = File.documentsDirectory.resolvePath("AIR test");
trace(file.nativePath); // ... AIR test
file.canonicalize();
trace(file.nativePath); // ... AIR Test
Metoda canonicalize převádí objekt nativePath pro použití správné velikosti písmen pro název souboru nebo
adresáře.
Metodu canonicalize() můžete také použít pro převod krátkých názvů souboru (názvy „8.3“) na dlouhé názvy
systému Windows, jako v následujících příkladech:
var path:File = new File();
path.nativePath = "C:\\AIR~1";
path.canonicalize();
trace(path.nativePath); // C:\AIR Test
Práce s balíčky a symbolickými odkazy
Různé operační systémy podporují balíčky souborů a soubory se symbolickými odkazy:
BalíčkyV systémech Mac OS lze adresáře označit jako balíčky a zobrazit ve vyhledávači jako jeden soubor namísto
adresáře.
Symbolické odkazySymbolické odkazy umožňují souboru ukázat na jiný soubor nebo adresář na disku. I když jsou
podobné, symbolické odkazy nejsou shodné jako aliasy. Alias (zástupce) je vždy hlášen jako soubor (spíše než adresář)
a čtení nebo zápis aliasu nebo zástupce nikdy neovlivňuje původní soubor nebo adresář, na které odkazují. Na druhou
stranu se symbolický odkaz chová přesně jako soubor nebo adresář, na který odkazuje. Může být hlášen jako soubor
nebo adresář, a čtení nebo zápis do symbolického odkazu ovlivňuje soubor nebo adresář, na který odkazuje, ale nikoliv
samotný symbolický odkaz.
Třída File zahrnuje vlastnosti isPackage a isSymbolicLink pro kontrolu, zda objekt File odkazuje balíček nebo
symbolický odkaz.
Následující kód provádí iterace adresáře pracovní plochy uživatele, vypisuje podadresáře, které nejsou balíčky:
var desktopNodes:File = File.desktopDirectory.getDirectoryListing();
for (var i:uint = 0; i < desktopNodes.length; i++)
{
if (desktopNodes[i].isDirectory && !!desktopNodes[i].isPackage)
{
trace(desktopNodes[i].name);
}
}
Následující kód provádí iterace adresáře pracovní plochy uživatele, vypisuje soubory a adresáře, které nejsou
symbolickými odkazy:
{
if (!desktopNodes[i].isSymbolicLink)
{
trace(desktopNodes[i].name);
}
}
Metoda canonicalize() mění cestu symbolického odkazu tak, aby směřoval na soubor nebo adresář, na který odkaz
ukazuje. Následující kód provádí iterace adresáře pracovní plochy uživatele a hlásí cesty odkazované soubory, které
jsou symbolickými odkazy:
{
if (desktopNodes[i].isSymbolicLink)
{
var linkNode:File = desktopNodes[i] as File;
linkNode.canonicalize();
trace(linkNode.nativePath);
}
}
Stanovení prostoru dostupného ve svazku
Vlastnost spaceAvailable objektu File popisuje prostor dostupný pro použití v umístění souboru File v bajtech.
Například následující kód kontroluje prostor dostupný v adresáři uložení dat aplikace:
trace(File.applicationStorageDirectory.spaceAvailable);
Pokud objekt File odkazuje na adresář, udává vlastnost spaceAvailable volné místo v adresáři, které mohou soubory
využít. Pokud objekt File odkazuje na soubor, udává vlastnost spaceAvailable volné místo pro růst tohoto souboru.
Pokud toto umístění souboru neexistuje, má vlastnost spaceAvailable hodnotu 0. Pokud objekt File odkazuje na
symbolický odkaz, udává vlastnost spaceAvailable volné místo dostupné v umístění, na které ukazuje symbolický
odkaz.
Obvykle se volné dostupné místo pro adresář nebo soubor shoduje s dostupným volným místem v jednotce, která
tento adresář nebo složku obsahuje. Dostupné místo ale může brát v úvahu i kvóty účtu a omezení jednotlivých
adresářů.
Když přidáváte soubor nebo adresář do nějaké jednotky, obvykle se vyžaduje víc volného místa, než je skutečná
velikost tohoto souboru nebo velikost obsahu tohoto adresáře. Například pro uložení informací indexu může operační
systém vyžadovat více volného místa. Také požadované sektory disku mohou využívat dodatečné volné místo. Kromě
toho se dostupné volné místo dynamicky mění. Z těchto důvodů nemůžete očekávat, že alokujete pro úložiště souborů
veškeré hlášené volné místo. Informace o zápisu do systému souborů naleznete v kapitole „Čtení a zápis souborů“ na
stránce 112.
Získání informací o systému souborů
Třída File zahrnuje následující statické vlastnosti, které poskytují některé užitečné informace o systému souborů:
Vlastnost
Popis
File.lineEnding
Posloupnost znaků zakončujících řádek, použitá hostitelským operačním systémem. V systémech Mac OS se
jedná o znak posuvu o řádek (LF). V systémech Windows se jedná o znak návratu vozíku tiskárny (CR),
následovaný znakem posuvu o řádek (LF).
File.separator
Oddělovací znak součásti cesty hostitelského operačního systému. V systémech Mac OS se jedná o znak
dopředného lomítka (/). V systémech Windows se jedná o znak zpětného lomítka (\).
File.systemCharset
Výchozí kódování použité pro soubory hostitelským operačním systémem. Toto se týká znakové sady použité
operačním systémem, která odpovídá jeho jazyku.
Třída Capabilities rovněž zahrnuje užitečné systémové informace, které mohou být užitečné při práci se soubory:
Vlastnost
Popis
Capabilities.hasIME
Určuje, zda je přehrávač spuštěný v systému, který obsahuje (true) nebo neobsahuje (false) nainstalovaný
editor vstupní metody IME (input method editor).
Capabilities.language
Určuje jazykový kód systému, na kterém je spuštěný přehrávač.
Capabilities.os
Určuje aktuální operační systém.
Práce s adresáři
Chod aplikace poskytne možnosti práce s adresáři v místním systému souborů.
Podrobnosti o vytváření objektů File, které odkazují na adresáře, viz také „Odkázání objektu File na adresář“ na
stránce 100.
Vytváření adresářů
Metoda File.createDirectory() umožňuje vytvářet adresář. Například následující kód vytváří adresář
pojmenovaný AIR Test jako podadresář uživatelského výchozího adresáře:
var dir:File = File.userDirectory.resolvePath("AIR Test");
dir.createDirectory();
Pokud adresáře existuje, metoda createDirectory() nic neprovede.
V některých režimech objekt FileStream vytváří adresáře při otevření souborů. Chybějící adresáře jsou vytvářeny při
konkretizaci instance FileStream parametrem fileMode konstruktoru FileStream() nastaveným na
FileMode.APPEND nebo FileMode.WRITE. Další informace viz „Pracovní kroky při čtení a zápisu souborů“ na
stránce 112.
Vytváření dočasného adresáře
Třída File zahrnuje metodu createTempDirectory(), která vytváří adresář v dočasném adresáři systému, jako v
var temp:File = File.createTempDirectory();
Metoda createTempDirectory() automaticky vytvoří jedinečný dočasný adresář (úspora práce při stanovení
nového jedinečného umístění).
Můžete použít dočasný adresář pro dočasné uložení dočasných souborů pro relaci aplikace. Povšimněte si, že existuje
metoda createTempFile() pro vytváření nových, jedinečných dočasných souborů v dočasném adresáři systému.
Dočasný adresář můžete odstranit před uzavřením aplikace, protože není odstraňován automaticky.
Vypsání adresářů
Můžete použít metodu getDirectoryListing() nebo getDirectoryListingAsync() objektu File k získání pole
objektů File, odkazujících na soubory a podsložky v adresáři.
Například následující kód uvádí obsah adresáře dokumentů uživatele (bez prověření podadresářů):
var directory:File = File.documentsDirectory;
var contents:Array = directory.getDirectoryListing();
for (var i:uint = 0; i < contents.length; i++)
{
trace(contents[i].name, contents[i].size);
}
Při použití asynchronní verze metody má objekt události directoryListing vlastnost files, která je polem objektů
File, týkajících se adresářů:
var directory:File = File.documentsDirectory;
directory.getDirectoryListingAsync();
directory.addEventListener(FileListEvent.DIRECTORY_LISTING, dirListHandler);
function dirListHandler(event:FileListEvent):void
{
var contents:Array = event.files;
for (var i:uint = 0; i < contents.length; i++)
{
trace(contents[i].name, contents[i].size);
}
}
Kopírování a přesouvání adresářů
Adresář můžete zkopírovat nebo přesunout pomocí stejných metod, jako při kopírování souboru. Například,
následující kód kopíruje adresář synchronně:
var sourceDir:File = File.documentsDirectory.resolvePath("AIR Test");
var resultDir:File = File.documentsDirectory.resolvePath("AIR Test Copy");
sourceDir.copyTo(resultDir);
Když specifikujete hodnotu true pro parametr overwrite metody copyTo(), všechny soubory a složky ve stávajícím
cílovém adresáři budou odstraněny a nahrazeny soubory ve zdrojovém adresáři (i v případě, že cílový soubor ve
zdrojovém adresáři neexistuje).
Adresář, který zadáte jako parametr newLocation metody copyTo() stanoví cestu do výsledného adresáře;
nespecifikujenadřízený adresář, který bude obsahovat výsledný adresář.
Podrobnosti naleznete v kapitole „Kopírování a přesouvání souborů“ na stránce 110.
Odstraňování obsahu adresáře
Třída File zahrnuje metodu deleteDirectory() a deleteDirectoryAsync(). Tyto metody odstraňují adresáře,
přičemž první pracuje synchronně, druhá asynchronně (viz „Základy souborů aplikace AIR“ na stránce 98). Obě
metody zahrnují parametr deleteDirectoryContents (který přebírá booleovskou hodnotu); když je tento parametr
nastaven na hodnotu true (výchozí hodnota je false), volání metody odstraní adresáře, které nejsou prázdné; jinak
jsou odstraněny pouze prázdné adresáře.
Například následující kód synchronně odstraní podadresář AIR Test v adresáři dokumentů uživatele:
var directory:File = File.documentsDirectory.resolvePath("AIR Test");
directory.deleteDirectory(true);
Následující kód asynchronně odstraní podadresář AIR Test v adresáři dokumentů uživatele:
var directory:File = File.documentsDirectory.resolvePath("AIR Test");
directory.addEventListener(Event.COMPLETE, completeHandler)
directory.deleteDirectoryAsync(true);
function completeHandler(event:Event):void {
trace("Deleted.")
}
Součástí jsou rovněž metody moveToTrash() a moveToTrashAsync(), které můžete použít pro přesunutí adresáře do
koše. Podrobnosti viz „Přesouvání souborů do koše“ na stránce 112.
Práce se soubory
Pomocí souborového rozhraní API aplikace AIR můžete do vaší aplikace přidat základní možnosti interakce se
soubory. Například můžete číst a zapisovat, kopírovat a odstraňovat soubory atd. Protože vaše aplikace mohou
přistupovat k místnímu systému souborů, viz také kapitola „Zabezpečení aplikace AIR“ na stránce 23, pokud jste si ji
ještě neprostudovali.
Poznámka: Můžete připojit typ souborů k aplikaci AIR (tak, že poklepáním aplikaci otevřete). Podrobnosti viz také
„Správa asociací souboru“ na stránce 267.
Získání informací o souboru
Třída File zahrnuje následující vlastnosti, které poskytují informace o souboru nebo adresáři, na který objekt File
odkazuje:
Vlastnost File
Popis
creationDate
Datum vytvoření souboru na lokálním disku.
creator
Zastaralé—použijte vlastnost extension. (Tato vlastnost hlásí typ tvůrce souboru v počítači Macintosh, který je
používán pouze ve verzích Mac OS před Mac OS X.)
exists
Informace, zda existuje odkazovaný soubor nebo adresář.
extension
Přípona souboru je část názvu následující za poslední tečkou („.“, tečka není součástí přípony). Pokud v názvu
souboru není tečka, je přípona null.
icon
Objekt Icon obsahující ikony definované pro soubor.
isDirectory
Informace, zda odkaz objektu File směřuje na adresář.
modificationDate
Datum poslední změny souboru nebo adresáře na lokálním disku.
name
Název souboru nebo adresáře (včetně přípon, pokud existuje) na místním disku.
nativePath
Úplná cesta ve vyjádření hostitelského operačního systému. Viz také „Cesty objektu File“ na stránce 99.
parent
Složka, která obsahuje složku nebo soubor představovaný objektem File. Tato vlastnost je null v případě, že
objekt File odkazuje na soubor nebo adresář v kořenu systému souborů.
size
Velikost souboru na lokálním disku v bytech.
type
Zastaralé—použijte vlastnost extension. (V počítači Macintosh tato vlastnost je čtyřznakový typ souboru, který
je používán pouze ve verzi Mac OS před Mac OS X.)
url
Adresa URL pro soubor nebo adresář. Viz také „Cesty objektu File“ na stránce 99.
Podrobnosti o těchto vlastnostech, viz také záznam třídy File v Referenční příručka jazyka ActionScript 3.0
(http://www.adobe.com/go/learn_air_aslr_cz).
Kopírování a přesouvání souborů
Třída File zahrnuje dvě metody pro kopírování souborů nebo adresářů: copyTo() a copyToAsync(). Třída File
zahrnuje dvě metody pro přesouvání souborů nebo adresářů: moveTo() a moveToAsync(). Metody copyTo() a
moveTo() pracují synchronně a metody copyToAsync() a moveToAsync() pracují asynchronně (viz „Základy
souborů aplikace AIR“ na stránce 98).
Chcete-li kopírovat nebo přesouvat soubor, nastavujete dva objekty File. Jeden ukazuje na soubor pro kopírování nebo
přesouvání, a je to objekt, který volá metodu copy nebo move druhý ukazuje na cílovou cestu.
Následující kód kopíruje soubor test.txt z podadresáře AIR Test adresáře dokumentů uživatele do souboru
pojmenovaného copy.txt ve stejném adresáři:
var original:File = File.documentsDirectory.resolvePath("AIR Test/test.txt");
var newFile:File = File.resolvePath("AIR Test/copy.txt");
original.copyTo(newFile, true);
V tomto příkladu je hodnota parametru overwrite metody copyTo() (druhý parametr) nastavena na true.
Nastavením tohoto parametru na hodnotu true, je stávající cílový soubor přepsán. Tento parametr je nepovinný.
Pokud nastavíte hodnotu false (výchozí hodnota), operace odešle událost IOErrorEvent v případě, že cílový soubor
existuje (a soubor není nakopírován).
Verze “Async” metod copy a move pracuje asynchronně. Metodu addEventListener() použijte pro sledování
dokončení úkolu nebo chybového stavu, jako v následujícím kódu:
var original = File.documentsDirectory;
original = original.resolvePath("AIR Test/test.txt");
var destination:File = File.documentsDirectory;
destination = destination.resolvePath("AIR Test 2/copy.txt");
original.addEventListener(Event.COMPLETE, fileMoveCompleteHandler);
original.addEventListener(IOErrorEvent.IO_ERROR, fileMoveIOErrorEventHandler);
original.moveToAsync(destination);
function fileMoveCompleteHandler(event:Event):void {
trace(event.target); // [object File]
}
function fileMoveIOErrorEventHandler(event:IOErrorEvent):void {
trace("I/O Error.");
}
Třída File rovněž zahrnuje metody File.moveToTrash() a File.moveToTrashAsync(), které přesouvají soubor
nebo adresář do koše.
Odstranění souboru
Třída File zahrnuje metodu deleteFile() a deleteFileAsync(). Tyto metody odstraňují soubory, přičemž první
pracuje synchronně, druhá asynchronně (viz „Základy souborů aplikace AIR“ na stránce 98).
Například následující kód synchronně odstraní soubor test.txt v adresáři dokumentů uživatele:
var file:File = File.documentsDirectory.resolvePath("test.txt");
file.deleteFile();
Následující kód asynchronně odstraní soubor test.txt v adresáři dokumentů uživatele:
file.addEventListener(Event.COMPLETE, completeHandler)
file.deleteFileAsync();
trace("Deleted.")
}
Součástí jsou rovněž metody moveToTrash() a moveToTrashAsync(), které můžete použít pro přesunutí souboru
nebo adresáře do koše. Podrobnosti viz „Přesouvání souborů do koše“ na stránce 112.
Přesouvání souborů do koše
Třída File zahrnuje metodu moveToTrash() a moveToTrashAsync(). Tyto metody odesílají soubor nebo adresář do
koše, první pracuje synchronně, druhý pracuje asynchronně (viz „Základy souborů aplikace AIR“ na stránce 98).
Například následující kód synchronně přesouvá soubor test.txt v adresáři dokumentace uživatele do koše:
file.moveToTrash();
Vytváření dočasného souboru
Třída File zahrnuje metodu createTempFile(), která vytváří soubor v dočasném adresáři systému, jako v
var temp:File = File.createTempFile();
Metoda createTempFile() automaticky vytvoří jedinečný dočasný soubor (úspora práce při stanovení nového
jedinečného umístění).
Můžete použít dočasný soubor pro dočasné uložení informací pro relaci aplikace. Povšimněte si, že existuje metoda
createTempDirectory() pro vytváření jedinečných dočasných adresářů v dočasném adresáři systému.
Dočasný soubor můžete odstranit před uzavřením aplikace, protože není odstraňován automaticky.
Čtení a zápis souborů
Třída FileStream umožňuje aplikacím AIR číst a zapisovat do systému souborů.
Pracovní kroky při čtení a zápisu souborů
Pracovní kroky pro čtení a zápis souborů jsou následující.
Inicializace objektu File, který ukazuje cestu.
Toto je cesta souboru, se kterým chcete pracovat (nebo souboru, který vytvoříte později).
var file:File = File.documentsDirectory;
file = file.resolvePath("AIR Test/testFile.txt");
Tento příklad používá vlastnost File.documentsDirectory a metodu resolvePath() objektu File pro inicializaci
objektu File. Nicméně existuje mnoho jiných způsobů pro odkázání objektu File na soubor. Další informace viz
„Odkázání objektu File na soubor“ na stránce 102.
Inicializace objektu FileStream.
Zavolejte metodu open() nebo openAsync() objektu FileStream.
Volaná metoda závisí na tom, zda chcete otevřít soubor pro synchronní nebo asynchronní operace. Použijte objekt File
jako parametr file metody open. Pro parametr fileMode specifikujte konstantu z třídy FileMode, která specifikuje
způsob, kterým budete soubor používat.
Například následující kód inicializuje objekt FileStream, který se používá pro vytvoření souboru a přepsání všech
stávajících dat:
var fileStream:FileStream = new FileStream();
fileStream.open(file, FileMode.WRITE);
Další informace viz „Inicializace objektu FileStream a otevření a uzavření souborů“ na stránce 114 a „Režimy open
objektu FileStream“ na stránce 113.
Pokud jste otevřeli soubor asynchronně (pomocí metody openAsync()), přidejte a nastavte posluchače událostí
pro objekt FileStream.
Tyto posluchače událostí odpovídají na události odeslané objektem FileStream v různých situacích, například při
načtení dat ze souboru, když se vyskytnou chyby I/O, nebo když je nutné zapsat celý objem dat.
Podrobnosti viz také „Asynchronnní programování a události generované objektem FileStream otevřeným
asynchronně“ na stránce 118 .
Zahrňte kód pro čtení a zápis dat podle potřeby.
Existuje mnoho metod třídy FileStream související s čtením a zápisem. (Všechny začínají „read“ nebo „write“.)
Zvolená metoda použitá pro čtení nebo zápis dat závisí na formátu dat v cílovém souboru.
Pokud například data v cílovém souboru budou textem v kódování UTF, můžete použít metody readUTFBytes() a
writeUTFBytes(). Pokud chcete pracovat s daty formou bajtových polí, můžete použít metody readByte(),
readBytes(), writeByte() a writeBytes(). Podrobnosti viz také kapitola „Datové formáty a výběr metody čtení a
zápisu“ na stránce 118.
Pokud otevřete soubor asynchronně, zajistěte, aby pro zavolání metody read byl k dispozici dostatek dat. Podrobnosti
viz také „Vyrovnávací paměť čtení a vlastnost bytesAvailable objektu FileStream“ na stránce 116.
Před zápisem do souboru, pokud chcete zkontrolovat objem dostupného diskového prostoru, si můžete ověřit
vlastnost spaceAvailable objektu File. Další informace viz „Stanovení prostoru dostupného ve svazku“ na stránce 106.
Jakmile jste dokončili práci se souborem, zavolejte metodu close() objektu FileStream.
To soubor zpřístupní pro ostatní aplikace.
Podrobnosti viz „Inicializace objektu FileStream a otevření a uzavření souborů“ na stránce 114.
Chcete-li shlédnout ukázku využívající třídy FileStream k načtení a zápisu souborů, viz následující články ve
vývojářském středisku Adobe AIR Developer Center:
• Vytváření textového editorů
Práce s objekty FileStream
Třída FileStream definuje metody pro otevírání, čtení a zápis souborů.
Režimy open objektu FileStream
Metody open() a openAsync() objektu FileStream zahrnují parametr fileMode, který definuje některé vlastnosti
datového toku souboru, včetně následujících:
• Schopnost číst ze souboru
• Schopnost zápisu do souboru
• Zda data budou vždy připojena na konec souboru (při zápisu)
• Co udělat, když soubor neexistuje (a kdy neexistují nadřízené adresáře)
Následující jsou různé režimy souboru (což můžete specifikovat jako parametr fileMode metod open() a
openAsync()):
Režim souboru
Popis
FileMode.READ
Stanoví, že soubor je otevřený pouze pro čtení.
FileMode.WRITE
Stanoví, že soubor je otevřený pouze pro zápis. Pokud soubor neexistuje, je vytvořen při otevření objektu
FileStream. Pokud soubor existuje, jsou stávající data odstraněna.
FileMode.APPEND
Stanoví, že soubor je otevřený pouze pro připojení. Soubor je vytvořen, pokud neexistuje. Pokud soubor existuje,
stávající data nejsou přepsána a veškeré zápisy začínají na konci souboru.
FileMode.UPDATE
Stanoví, že soubor je otevřený pro čtení a zápis. Pokud soubor neexistuje, je vytvořen. Specifikujte tento režim pro
náhodný přístup k zápisu/čtení souboru. Můžete číst z libovolné pozice souboru a při zápisu do souboru přepíší
stávající bajty pouze zapsané bajty (všechny ostatní bajty zůstanou nezměněné).
Inicializace objektu FileStream a otevření a uzavření souborů
Když otevřete objekt FileStream, zpřístupníte jej ke čtení a zápisu dat do souboru. Objekt FileStream otevřete
předáním objektu File metodě open() nebo openAsync() objektu FileStream:
var myFile:File = File.documentsDirectory.resolvePath("AIR Test/test.txt");
var myFileStream:FileStream = new FileStream();
myFileStream.open(myFile, FileMode.READ);
Parametr fileMode (druhý parametr metody open() a openAsync()), specifikuje režim, ve kterém se soubor otevírá:
pro čtení, zápis, připojení nebo aktualizaci. Podrobnosti viz také předchozí kapitola, „Režimy open objektu
FileStream“ na stránce 113.
Pokud použijete metodu openAsync() k otevření souboru pro asynchronní operace se souborem, nastavte posluchače
událostí ke zpracování asynchronních událostí:
myFileStream.addEventListener(Event.COMPLETE, completeHandler);
myFileStream.addEventListener(ProgressEvent.PROGRESS, progressHandler);
myFileStream.addEventListener(IOErrorEvent.IOError, errorHandler);
// ...
}
function progressHandler(event:ProgressEvent):void {
// ...
}
function errorHandler(event:IOErrorEvent):void {
// ...
}
Soubor je otevřen pro synchronní nebo asynchronní operace, v závislosti na tom, zda použijete metodu open() nebo
openAsync(). Podrobnosti viz „Základy souborů aplikace AIR“ na stránce 98.
Pokud nastavíte parametr fileMode na FileMode.READ nebo FileMode.UPDATE v metodě open objektu FileStream,
data jsou načtena do vyrovnávací paměti čtení, jakmile otevřete objekt FileStream. Podrobnosti viz také „Vyrovnávací
paměť čtení a vlastnost bytesAvailable objektu FileStream“ na stránce 116.
Metodu close() objektu FileStream můžete uzavřít související soubor, čímž jej zpřístupníte pro použití pro ostatní
aplikace.
Vlastnost position objektu FileStream
Vlastnost position objektu FileStream stanoví, zda jsou data načtena nebo zapsána následující metodou čtení nebo
zápisu.
Před operací čtení nebo zápisu nastavte vlastnost position na libovolnou platnou polohu v souboru.
Například následující kód zapíše řetězec „hello" (v kódování UTF) v poloze 8 v souboru:
myFileStream.open(myFile, FileMode.UPDATE);
myFileStream.position = 8;
myFileStream.writeUTFBytes("hello");
Když poprvé otevřete objekt FileStream, vlastnost position je nastavena na 0.
Před operací čtení musí být hodnota position alespoň 0 a nižší než počet bajtů v souboru (což jsou pozice v souboru).
Hodnota vlastnosti position je změněna pouze za následujících podmínek:
• Když výslovně nastavíte vlastnost position.
• Když zavoláte metodu read.
• Když zavoláte metodu write.
Když zavoláte metodu read nebo write objektu FileStream, vlastnost position je ihned zvýšena o počet bajtů, které
načtete nebo zapíšete. V závislosti na metodě čtení, kterou použijete, vlastnost position se zvýší o počet bajtů
specifikovaných k načtení, nebo o počet dostupných bajtů. Když poté zavoláte metodu read nebo write dojde k načtení
nebo zápisu počínaje novou polohou.
myFileStream.open(myFile, FileMode.UPDATE);
trace(myFileStream.position); // 4000
myFileStream.writeBytes(myByteArray, 0, 200);
Existuje však jedna výjimka: pro FileStream otevřený v režimu připojení se vlastnost position nemění po zavolání
metody write. (V režimu připojení jsou data vždy zapsána na konec souboru, nezávisle na hodnotě vlastnosti
position.)
Pro soubor otevřený pro asynchronní operace nebude operace zápisu dokončena před vykonáním následující řádky
kódu. Nicméně můžete zavolat několik asynchronních metod po sobě, a za běhu je program vykoná v pořadí:
myFileStream.openAsync(myFile, FileMode.WRITE);
myFileStream.writeUTFBytes("hello");
myFileStream.writeUTFBytes("world");
myFileStream.addEventListener(Event.CLOSE, closeHandler);
myFileStream.close();
trace("started.");
closeHandler(event:Event):void
{
trace("finished.");
}
Sledování výstupu tohoto kódu je následující:
started.
finished.
Můžete specifikovat hodnotu position ihned poté, co zavoláte metodu read nebo write (nebo kdykoliv), a následující
operace čtení nebo zápisu proběhne počínaje touto polohou. Například si povšimněte, že následující kód nastavuje
vlastnost position ihned po zavolání operace writeBytes() a position je nastavena na hodnotu (300) i poté, co
byla operace zápisu dokončena:
myFileStream.openAsync(myFile, FileMode.UPDATE);
myFileStream.writeBytes(myByteArray, 0, 200);
Vyrovnávací paměť čtení a vlastnost bytesAvailable objektu FileStream
Když je otevřen objekt FileStream s možností čtení (ve kterém je parametr fileMode metody open() nebo
openAsync() nastavený na READ nebo UPDATE), program za chodu uloží data do vnitřní vyrovnávací paměti. Objekt
FileStream začne načítat data do vyrovnávací pamětí, jakmile otevřete soubor (zavoláním metody open() nebo
openAsync() objektu FileStream).
Pro soubor otevřený pro synchronní operace (pomocí metodyopen()), můžete vždy nastavit ukazatel position na
kteroukoliv platnou polohu (v rámci mezí souboru) a začít čtení kteréhokoliv objemu dat (v rámci mezí souboru), jak
je vidět v následujícím kódu (který předpokládá, že sobor obsahuje alespoň 100 bajtů):
myFileStream.readBytes(myByteArray, 0, 20);
myFileStream.readBytes(myByteArray, 0, 10);
Když je soubor otevřen pro synchronní nebo asynchronní operace, metody read vždy čtou z „dostupných“ bajtů,
představovaných vlastností bytesAvalable. Při synchronním čtení jsou všechny bajty souboru kdykoliv dostupné.
Při asynchronním čtení se zpřístupní bajty počínaje polohou stanovené vlastností position, v řadě asynchronních
naplnění vyrovnávací paměti signalizovaných událostmi progress.
Pro soubory otevřené pro synchronní operace je vlastnost bytesAvailable nastavena tak, aby vyjadřovala počet bajtů
z vlastnosti position na konci souboru (všechny bajty v souboru jsou vždy k dispozici pro čtení).
Pro soubory otevření pro asynchronní operace musíte zajistit, aby vyrovnávací paměť čtení spotřebovala dostatek
volání metody read. Pro soubor otevíraný asynchronně, v průběhu operace čtení, data ze souboru, počínaje v pozici
specifikované při spuštění operace čtení, jsou přidána do vyrovnávací paměti a vlastnost bytesAvailable zvýší svou
hodnotu s každým načteným bajtem. Vlastnost bytesAvailable označuje dostupné bajty počínaje bajtem na pozici
stanovené vlastností position na konci vyrovnávací paměti. Pravidelně pak objekt FileStream odesílá událost
progress.
Pro soubor otevíraný asynchronně, když jsou data dostupná ve vyrovnávací paměti, objekt FileStream pravidelně
odesílá událost progress. Například následující kód načte data do objektu ByteArray, bytes, když jsou načítána do
vyrovnávací paměti.
var bytes:ByteArray = new ByteArray();
myFileStream.openAsync(myFile, FileMode.READ);
function progressHandler(event:ProgressEvent):void
{
myFileStream.readBytes(bytes, myFileStream.position, myFileStream.bytesAvailable);
}
Pro soubor otevíraný asynchronně mohou být načítána pouze data ve vyrovnávací paměti. Dále, když načtete data,
jsou odebrána z vyrovnávací paměti. Pro operace čtení musíte zajistit, aby data byla k dispozici ve vyrovnávací paměti
ještě před zavoláním operace čtení. Například následující kód načte 8000 bajtů dat, počínaje pozici 4000 v souboru:
myFileStream.addEventListener(Event.COMPLETE, completed);
var str:String = "";
function progressHandler(event:Event):void
{
if (myFileStream.bytesAvailable > 8000 )
{
str += myFileStream.readMultiByte(8000, "iso-8859-1");
}
}
Během operace zápisu objekt FileStream nenačte data do vyrovnávací paměti. Když je operace zápisu dokončena
(všechna data ve vyrovnávací paměti jsou zapsána do souboru), objekt FileStream začne načítat novou vyrovnávací
paměti (předpokládá se, že přidružený objekt FileStream byl otevřen se schopností čtení) a dále začne načítat data do
vyrovnávací paměti, počínaje polohou stanovenou ve vlastnosti position. Vlastnost position může být polohou
posledního zapsaného bajtu, nebo se může jednat o jinou polohu, pokud uživatel stanoví jinou hodnotu pro objekt
position po operaci načtení.
Asynchronnní programování a události generované objektem FileStream otevřeným
asynchronně
Když je soubor otevřen asynchronně (pomocí metody openAsync()), čtení nebo zápis souborů je proveden
asynchronně. Když jsou data načtena do vyrovnávací paměti a výstupní data jsou zapsána, může být spuštěn jiný kód
jazyka ActionScript.
To znamená, že musíte registrovat události generované objektem FileStream otevřené asynchronně.
Zaregistrováním události progress můžete být informováni o dostupnosti nových dat pro čtení, jako v následujícím
kódu:
function progressHandler(event:ProgressEvent):void
{
str += myFileStream.readMultiByte(myFileStream.bytesAvailable, "iso-8859-1");
}
Můžete načíst všechna data zaregistrováním události complete, jako v následujícím kódu.
function completeHandler(event:Event):void
{
str = myFileStream.readMultiByte(myFileStream.bytesAvailable, "iso-8859-1");
}
Stejným způsobem, kterým jsou vstupní data ukládána do vyrovnávací paměti, aby bylo možné provést asynchronní
čtení, zapsaná data v asynchronním datovém toku jsou uložena do vyrovnávací paměti a zapsána do souboru
asynchronně. Když jsou data zapsána do souboru, objekt FileStream pravidelně odesílá objekt
OutputProgressEvent. Objekt OutputProgressEvent zahrnuje vlastnost bytesPending, která je nastavena na
počet bajtů zbývajících k zápisu. Můžete zaregistrovat informování o události outputProgress, protože vyrovnávací
paměti je ve skutečnosti zapisována do souboru, patrně pro zobrazení dialogového okna průběhu. Nicméně obecně
toto není nutné provádět. Obzvláště můžete zavolat metodu close() bez starosti o nezapsané bajty. Objekt FileStream
bude i nadále zapisovat data a událost close bude doručena po zapsání koncového bajtu do souboru a příslušný
soubor je uzavřen.
Datové formáty a výběr metody čtení a zápisu
Každý soubor je souborem bajtů na disku. Ve skriptu ActionScript mohou být data ze soubory vždy vyjádřena pomocí
ByteArray. Například následující kód načte data ze souboru do objektu ByteArray pojmenovaného bytes:
myFileStream.addEventListener(Event.COMPLETE, completeHandler);
{
myFileStream.readBytes(bytes, 0, myFileStream.bytesAvailable);
}
Podobně následující kód zapisuje data z objektu ByteArray pojmenovaného bytes do souboru:
myFileStream.open(myFile, FileMode.WRITE);
myFileStream.writeBytes(bytes, 0, bytes.length);
Nicméně, často nebudete chtít ukládat data do objektu ByteArray skriptu ActionScript. A často data souboru budou
ve specifikovaném formátu souboru.
Například data v souboru mohou být v textovém formátu a můžete požadovat vyjádření těchto dat objektem String.
Z tohoto důvodu třída FileStream zahrnuje metody read a write pro čtení a zápis dat do jiných typů objektů ByteArray
nebo z nich. Například metoda readMultiByte() umožňuje načítat data ze souboru a uložit je do řetězce, jako v
následujícím kódu:
{
str = myFileStream.readMultiByte(myFileStream.bytesAvailable, "iso-8859-1");
}
Druhý parametr metody readMultiByte() specifikuje textový formát, který jazyk ActionScript používá pro
interpretaci dat (v příkladu „iso-8859-1“). Jazyk ActionScript podporuje běžné kódování znakových sad, které jsou
uvedeny v Referenční příručce jazyka ActionScript 3.0 (viz Podporované jazykové sadyPodporované jazykové sady na
adrese http://livedocs.macromedia.com/flex/2/langref/charset-codes.html).
Třída FileStream rovněž zahrnuje metodu readUTFBytes(), která načte data z vyrovnávací paměti čtení do řetězce
pomocí znakové sady UTF-8. Protože znaky ve znakové sadě UTF-8 jsou proměnné délky, nepoužívejte
readUTFBytes() v metodě, která odpovídá na událost progress, protože data na konci vyrovnávací paměti čtení
mohou představovat neúplný znak. (To je pravda při použití metody readMultiByte() s kódováním znaků
proměnné délky.) Z tohoto důvodu načtěte celou sadu dat, když objekt FileStream odešle událost complete.
Existují také podobné metody zápisu, writeMultiByte() a writeUTFBytes(), pro práci s objekty String a textovými
soubory.
Metody readUTF() a writeUTF() (nezaměňovat s readUTFBytes() a writeUTFBytes()) také načítají a zapisují
textová data do souboru, ale předpokládají, že textovým datům předchází data specifikující délku textových dat, což
není u standardních textových souborů běžné.
Některé textové soubory s kódováním UTFzačínají znakem „UTF-BOM“ (značka pořadí bajtů), který definuje
zakončení a také formát kódování (například UTF-16 nebo UTF-32).
Například čtení nebo zápis textového souboru, viz také „Příklad: Čtení souboru XML v objektu XML“ na stránce 120.
readObject() a writeObject() jsou pohodlné způsoby uložení a načtení dat pro komplexní objekty jazyka
ActionScript. Data jsou zakódovaná ve formátu AMF (ActionScript Message Format). Tento formát je vlastním
formátem jazyka ActionScript. Aplikace jiné než AIR, Flash Player, Flash Media Server a Flex Data Services nemají
vestavěné rozhraní API pro práci s daty v tomto formátu.
Existují některé jiné metody čtení a zápisu (jako například readDouble() a writeDouble()). Pokud je však použijete,
ujistěte se, že formát souboru odpovídá formátu definovanému těmito metodami.
Formáty souborů jsou často složitější, než jednoduché textové formáty. Například soubor MP3 obsahuje
komprimovaná data, která mohou být pouze interpretována s dekompresními a dekódovacími algoritmy,
specifickými pro soubory MP3. Soubory MP3 mohou také zahrnovat značky ID3, které obsahuje informace
metaznaček o souboru (například název a interpret skladby). Existují různé verze formátu ID3, ale nejjednodušší (ID3
verze 1) je popsána v kapitole „Příklad: čtení a zápis dat s náhodným přístupem“ na stránce 121.
Ostatní formáty souborů (pro obrázky, databáze, dokumenty aplikací atd.) mají jiné struktury a pro práci s jejich daty
v jazyce ActionScript musíte porozumět, jak jsou data strukturovaná.
Příklad: Čtení souboru XML v objektu XML
Následující příklady ukazují, jak číst a zapisovat textové soubory obsahující data XML.
Chcete-li načíst obsah souboru, inicializujte objekty File a FileStream, zavolejte metodu readUTFBytes() objektu
FileStream a převeďte řetězec na objekt XML:
var file:File = File.documentsDirectory.resolvePath("AIR Test/preferences.xml");
fileStream.open(file, FileMode.READ);
var prefsXML:XML = XML(fileStream.readUTFBytes(fileStream.bytesAvailable));
fileStream.close();
Podobně zápis dat do souboru je snadný, stejně jako nastavení příslušných objektů File a FileStream, a pak zavolání
metody objektu FileStream. Předejte verzi řetězce dat XML metodě write, jako v následujícím kódu:
var prefsXML:XML = <prefs><autoSave>true</autoSave></prefs>;
fileStream = new FileStream();
var outputString:String = '<?xml version="1.0" encoding="utf-8"?>\n';
outputString += prefsXML.toXMLString();
fileStream.writeUTFBytes(outputString);
fileStream.close();
Tyto příklady používají metody readUTFBytes() a writeUTFBytes(), protože předpokládají, že soubory jsou ve
formátu UTF-8. Pokud tomu tak není, může být nutné použít jiný způsob (viz „Datové formáty a výběr metody čtení
a zápisu“ na stránce 118).
Předchozí příklad používají objekty FileStream otevření pro synchronní operaci. Můžete také otevřít soubory pro
asynchronní operace (které se při reakci na události spoléhají na funkce posluchače událostí). Například následující
kód ukazuje, jak číst soubor XML asynchronně:
fileStream.addEventListener(Event.COMPLETE, processXMLData);
fileStream.openAsync(file, FileMode.READ);
var prefsXML:XML;
function processXMLData(event:Event):void
{
prefsXML = XML(fileStream.readUTFBytes(fileStream.bytesAvailable));
fileStream.close();
}
Metoda processXMLData() je vyvolána v případě, že celý soubor je načten do vyrovnávací paměti (když objekt
FileStream odešle událost complete). Volá metodu readUTFBytes(), aby získal verzi řetězce načtených dat a vytvoří
objekt XML, prefsXML, na základě tohoto řetězce.
Příklad: čtení a zápis dat s náhodným přístupem
Soubory MP3 mohou zahrnovat značky ID3, což jsou oddíly na začátku nebo konci souboru, který obsahuje metadata
identifikující záznam. Formát značky ID3 samotný má různé revize. Tento příklad popisuje, jak číst a zapisovat ze
souboru MP3 obsahujícího nejjednodušší formát ID3 (ID3 verze 1.0) pomocí „náhodného přístupu k datům souboru“,
což znamená, že čte a zapisuje do různých míst souboru.
Soubor MP3, který obsahuje značku ID3 verze 1 zahrnuje data ID3 na konci souboru, v konečných 128 bajtech.
Během přístupu k souboru pro náhodný zápis/čtení je důležité specifikovat FileMode.UPDATE jako parametr
fileMode pro metodu open() nebo openAsync():
var file:File = File.documentsDirectory.resolvePath("My Music/Sample ID3 v1.mp3");
var fileStr:FileStream = new FileStream();
fileStr.open(file, FileMode.UPDATE);
To umožňuje číst i zapisovat do souboru.
Po otevření souboru můžete nastavit polohu ukazatele do umístění 128 bajtů před koncem souboru:
fileStr.position = file.size - 128;
Tento kód nastavuje vlastnost position na toto umístění v souboru, protože formát ID3 VB.0 specifikuje, že data
značky ID3 jsou uložena v posledních 128 bajtech souboru. Specifikace rovněž definuje následující:
• První 3 bajty značky obsahují řetězec „BAG".
• Následujících 30 znaků obsahuje název skladby MP3, jako řetězec.
• Následujících 30 znaků obsahuje jméno interpreta, jako řetězec.
• Následujících 30 znaků obsahuje jméno alba, jako řetězec.
• Následující 4 znaky obsahují rok, jako řetězec.
• Následujících 30 znaků obsahuje poznámku, jako řetězec.
• Následující bajt obsahuje kód žánru skladby.
• Všechna data jsou ve formátu ISO 8859-1.
Metoda id3TagRead() kontroluje data poté, co jsou načtena (po události complete):
function id3TagRead():void
{
if (fileStr.readMultiByte(3, "iso-8859-1").match(/tag/i))
{
var id3Title:String = fileStr.readMultiByte(30, "iso-8859-1");
var id3Artist:String = fileStr.readMultiByte(30, "iso-8859-1");
var id3Album:String = fileStr.readMultiByte(30, "iso-8859-1");
var id3Year:String = fileStr.readMultiByte(4, "iso-8859-1");
var id3Comment:String = fileStr.readMultiByte(30, "iso-8859-1");
var id3GenreCode:String = fileStr.readByte().toString(10);
}
}
Můžete provést čtení souboru s náhodným přístupem. Například můžete analyzovat proměnnou id3Title a ujistit
se, že má správná velká písmena (pomocí metod třídy String), a pak zapsat do souboru modifikovaný řetězec, nazvaný
newTitle, jako v následujícím kódu:
fileStr.position = file.length - 125;
// 128 - 3
fileStr.writeMultiByte(newTitle, "iso-8859-1");
Pro splnění požadavků standardu ID3 verze 1 by dálka řetězce newTitle měla být 30 znaků, doplněných na konci
kódem 0 (String.fromCharCode(0)).
123
Kapitola 15: Přetažení
Třídy v API přetažení slouží k podpoře gest přetažení uživatelského rozhraní. Gesto v tomto významu je akce uživatele,
zprostředkovaná operačním systémem a vaší aplikací, vyjadřující úmysl kopírovat, přesunout nebo propojit odkazem
informace. Gesto tažení ven se vyskytne, když uživatel táhne objekt ven z komponenty nebo aplikace. Gesto tažení
dovnitř se vyskytne, když uživatel táhne objekt z vnějšího prostředí do komponenty nebo aplikace.
Díky API přetažení můžete uživateli umožnit přetahovat data mezi aplikacemi a mezi komponentami v rámci aplikace.
Mezi podporované formáty přenosu patří:
• Bitmapy
• Soubory
• Text ve formátu HTML
• Text
• Data ve formátu RTF
• URL
• Serializované objekty
• Objektové odkazy (platné pouze v rámci iniciující aplikace)
Doplňující online informace o přetahování myší
Další informace o práci s API přetažení můžete získat z těchto zdrojů:
• Podpora přetahování a kopírování a vkládání
• NativeDragManager
• NativeDragOptions
• Clipboard
• NativeDragEvent
• Adobe AIR Developer Connection pro Flash (hledání pro „přetažení AIR“)
Základy přetažení
API přetažení obsahuje následující třídy.
Přetažení
Balíček
Třídy
flash.desktop
•
NativeDragManager
•
NativeDragOptions
•
Schránka
•
NativeDragActions
•
ClipboardFormat
•
ClipboardTransferModes
Konstanty používané s API přetažení jsou definovány v následujících třídách:
flash.events
•
NativeDragActions
•
ClipboardFormat
•
ClipboardTransferModes
NativeDragEvent
Fáze gesta přetažení
Gesto přetažení má následující tři fáze:
Zahájení Uživatel zahájí operaci přetažení táhnutím z komponenty nebo položky v komponentě, přičemž drží stisknuté
tlačítko myši. Komponenta, která je zdrojem tažené položky, je většinou navržena jako iniciátor tažení a odesílá
události nativeDragStart a nativeDragComplete. Aplikace Adobe® AIR™ zahájí operaci tažení vyvoláním metody
NativeDragManager.doDrag() v odpovědi na událost mouseDown nebo mouseMove.
Tažení Uživatel drží stisknuté tlačítko myši a současně přesouvá kurzor myši k jiné komponentě, aplikaci nebo na
plochu. Aplikace AIR během tažení volitelně zobrazí zástupný obraz. Dokud probíhá tažení, objekt iniciátoru odesílá
události nativeDragUpdate. Když uživatel přejíždí kurzorem přes možný cíl upuštění v aplikaci AIR, cíl upuštění
odešle událost nativeDragEnter. Manipulační program události může zkontrolovat objekt události, aby určil, zda
jsou tažená data k dispozici ve formátu, který cíl přijímá, a pokud ano, umožní uživateli upustit data na tento cíl
vyvoláním metody NativeDragManager.acceptDragDrop().
Dokud zůstává nad interaktivním objektem gesto tažení, odesílá daný objekt události nativeDragOver. Jakmile gesto
tažení interaktivní objekt opustí, ten odešle událost nativeDragExit.
Upuštění Uživatel uvolní tlačítko myši nad vhodným cílem upuštění. Je-li cíl aplikací AIR nebo komponentou, tak
komponenta odešle událost nativeDragDrop. Manipulační program události má k přeneseným datům přístup z
objektu události. Je-li cíl mimo aplikaci AIR, zpracuje upuštění operační systém nebo jiná aplikace. V obou případech
odešle iniciující objekt událost nativeDragComplete (pokud bylo tažení zahájeno v aplikaci AIR).
Třída NativeDragManager ovládá gesto tažení dovnitř i tažení ven. Všechny členy třídy NativeDragManager jsou
statické, nevytvářejí instance této třídy.
Objekt Clipboard
Data, která jsou tažena do nebo z aplikace nebo komponenty, jsou obsažena v objektu Clipboard. Jeden objekt
Clipboard může zpřístupnit různá zastoupení stejných informací, aby se zvýšila pravděpodobnost, že jiná aplikace
může datům rozumět a použít je. Například obraz by mohl být vložen jako obrazová data, serializovaný objekt Bitmap
nebo jako soubor. Vykreslení dat ve formátu může být odloženo do funkce vykreslení, která nebude vyvolána, dokud
nebudou data načtena.
Přetažení
Jakmile bylo zahájeno gesto tažení, k objektu Clipboard je přístup pouze z manipulačního programu události pro
události nativeDragEnter, nativeDragOver a nativeDragDrop. Po ukončení gesta tažení již nelze objekt Clipboard
číst ani znovu použít.
Objekt aplikace lze přenést jako odkaz a jako serializovaný objekt. Objektové odkazy jsou platné pouze v rámci
iniciující aplikace. Přenosy serializovaných objektů jsou platné mezi aplikacemi AIR, ale lze je použít pouze s objekty,
které zůstanou platné i po deserializaci serializovaných objektů. Objekty, které jsou serializované, jsou převedeny do
formátu Action Message Format for ActionScript 3 (AMF3), což je formát přenosu dat na bázi řetězců..
Práce s rámcem Flex
Ve většině případů je lepší použít při vytváření aplikací Flex API přetažení Adobe® Flex™. Rámec Flex poskytuje
ekvivalentní nastavení funkce, když je aplikace Flex spuštěna v AIR (používá vlastnost NativeDragManager AIR
interně). Aplikace Flex také podporuje více omezenou sadu funkcí, když aplikace nebo komponenta běží v
omezenějším prostředí prohlížeče. Třídy AIR nelze použít v komponentách nebo aplikacích, které běží mimo
prostředí chodu programu AIR.
Podpora gesta tažení ven
Chcete-li podporu gesta přetažení, musíte vytvořit objekt Clipboard v odpovědi na událost mouseDown a odeslat jej do
metody NativeDragManager.doDrag(). Vaše aplikace pak může poslouchat událost nativeDragComplete na
iniciujícím objektu a určit, jakou akci provést, když uživatel dokončí nebo zruší gesto.
Příprava dat na přenos
Chcete-li připravit data na přenos, vytvořte objekt Clipboard a přidejte informace, které mají být přeneseny, v jednom
nebo více formátech. Můžete použít standardní formáty dat pro předání dat, která lze přenášet automaticky do
nativních formátů schránky a formáty definované aplikací pro předávání objektů. Je-li převod přenášených informací
do určitého formátu výpočetně náročný, můžete dodat název funkce manipulačního programu, která převod provede.
Tato funkce bude vyvolána, pokud přijímající komponenta nebo aplikace přečte přidružený formát. Další informace
viz „Schránka:formáty dat“ na stránce 143.
Následující příklad ukazuje, jak vytvořit objekt Clipboard obsahující bitmapu v několika formátech: objekt Bitmap,
nativní formát bitmapy a formát seznamu souborů obsahující soubor, ze kterého byla bitmapa původně načtena:
import flash.desktop.Clipboard;
import flash.display.Bitmap;
import flash.filesystem.File;
public function createClipboard(image:Bitmap, sourceFile:File):Clipboard{
var transfer:Clipboard = new Clipboard();
transfer.setData("CUSTOM_BITMAP", image, true); //Flash object by value and by reference
transfer.setData(ClipboardFormats.BITMAP_FORMAT, image.bitmapData, false);
transfer.setData(ClipboardFormats.FILE_LIST_FORMAT, new Array(sourceFile), false);
return transfer;
}
Zahájení operace tažení ven
Chcete-li zahájit operaci tažení, vyvolejte metodu NativeDragManager.doDrag() v odpovědi na událost poslední
klepnutí myši. Metoda doDrag() je statická metoda, která přebírá následující parametry:
Přetažení
Parametr
Popis
iniciátor
Objekt, ze kterého začíná tažení a který odesílá události dragStart a dragComplete. Iniciátor musí být
interaktivní objekt.
schránka
Objekt Clipboard obsahující data k přenesení. Na objekt Clipboard jsou odkazy v objektech NativeDragEvent
odeslaných během posloupnosti tažení a upuštění.
dragImage
(Volitelné) Objekt BitmapData k zobrazení během tažení. Obraz může určovat hodnotu alfa. (Poznámka:
Microsoft Windows používá na obraz tažení vždy pevný útlum alfa.)
posun
(Volitelné) Objekt Point udávající posun obrazu tažení od aktivního bodu myši. Chcete-li přesunout obraz
tažení nahoru a doleva vzhledem ke kurzoru myši, použijte záporné souřadnice. Není-li zadán žádný posun, je
levý horní roh taženého obrazu umístěn na aktivním bodu myši.
actionsAllowed
(Volitelné) Objekt NativeDragOptions udávající, které akce (kopírování, přesun nebo odkaz) jsou platné pro
operaci tažení. Není-li zadán žádný argument, jsou povoleny všechny akce. Na objekt DragOptions jsou
odkazy v objektech NativeDragEvent umožňující, aby potenciální cíl tažení zkontroloval, zda jsou povolené
akce kompatibilní s obsahem cílové komponenty. Například komponenta „trash“ by mohla přijímat pouze
gesta, která umožňují akci přesunutí.
Následující příklad ukazuje, jak zahájit operaci tažení u objektu bitmapy načteného ze souboru. V příkladu je načten
obraz a při události mouseDown začne operace tažení.
package
{
import flash.desktop.NativeDragManager;
import mx.core.UIComponent;
import flash.display.Loader;
import flash.system.LoaderContext;
import flash.geom.Point;
import flash.display.Bitmap;
public class DragOutExample extends UIComponent Sprite {
protected var fileURL:String = "app:/image.jpg";
protected var display:Bitmap;
private function init():void {
loadImage();
}
private function onMouseDown(event:MouseEvent):void {
var bitmapFile:File = new File(fileURL);
var transferObject:Clipboard = createClipboard(display, bitmapFile);
NativeDragManager.doDrag(this,
transferObject,
display.bitmapData,
new Point(-mouseX,-mouseY));
}
public function createClipboard(image:Bitmap, sourceFile:File):Clipboard {
transfer.setData("bitmap",
image,
true);
Přetažení
// ActionScript 3 Bitmap object by value and by reference
transfer.setData(ClipboardFormats.BITMAP_FORMAT,
image.bitmapData,
false);
// Standard BitmapData format
transfer.setData(ClipboardFormats.FILE_LIST_FORMAT,
new Array(sourceFile),
false);
// Standard file list format
return transfer;
}
private function loadImage():void {
var url:URLRequest = new URLRequest(fileURL);
loader.load(url,new LoaderContext());
loader.contentLoaderInfo.addEventListener(Event.COMPLETE, onLoadComplete);
}
private function onLoadComplete(event:Event):void {
display = event.target.loader.content;
var flexWrapper:UIComponent = new UIComponent();
flexWrapper.addChild(event.target.loader.content);
addChild(flexWrapper);
flexWrapper.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
}
}
}
Dokončení přenosu tažení ven
Jakmile uživatel upustí taženou položku uvolněním tlačítka myši, objekt iniciátoru odešle událost
nativeDragComplete. Můžete zkontrolovat vlastnost dropAction a poté provést příslušnou akci. Například je-li
akce NativeDragAction.MOVE, mohli byste odstranit zdrojovou položku z jejího původního umístění. Uživatel může
zrušit gesto tažení uvolněním tlačítka myši, přičemž je kurzor mimo vhodného cíle upuštění. Správce tažení nastaví
vlastnost dropAction zrušeného gesta na hodnotu NativeDragAction.NONE.
Podpora gesta tažení dovnitř
Chcete-li podporu gesta tažení dovnitř, vaše aplikace (nebo spíše viditelná komponenta vaší aplikace) musí reagovat
na události nativeDragEnter nebo nativeDragOver.
Postup při typické operaci upuštění
Pro operaci upuštění je typická následující posloupnost událostí:
1 Uživatel táhne objekt schránky nad nějakou komponentu.
2 Komponenta odešle událost nativeDragEnter.
3 Manipulační program události nativeDragEnter prověří dostupné formáty dat a povolené akce objektu události.
Jestliže komponenta dokáže zpracovat operaci upuštění, vyvolá metodu
NativeDragManager.acceptDragDrop().
4 Objekt NativeDragManager změní kurzor myši tak, aby označoval, že objekt lze upustit.
Přetažení
5 Uživatel upustí objekt nad danou komponentou.
6 Přijímající komponenta odešle událost nativeDragDrop.
7 Přijímající komponenta přečte data v požadovaném formátu z objektu Clipboard uvnitř objektu události.
8 Jestliže gesto tažení vzniklo v aplikaci AIR, odešle iniciující interaktivní objekt událost nativeDragComplete.
Jestliže gesto vzniklo mimo aplikaci AIR, není vyslána žádná odezva.
Potvrzení gesta tažení dovnitř
Jakmile uživatel vtáhne položku schránky do mezí vizuální komponenty, odešle komponenta události
nativeDragEnter a nativeDragOver. Chcete-li určit, zda může komponenta přijmout položku schránky,
manipulační programy pro tyto události mohou zkontrolovat vlastnosti clipboard a allowedActions objektu
události. Schopnost komponenty přijmout upuštění je signalizována tak, že manipulační program vyvolá metodu
NativeDragManager.acceptDragDrop()) a současně předá odkaz na přijímající komponentu. Pokud více než jeden
registrovaný posluchač události vyvolá metodu acceptDragDrop(),přednost bude mít poslední posluchač v seznamu.
Volání metody acceptDragDrop() zůstane v platnosti, dokud myš neopustí hranice přijímajícího objektu a nespustí
událost nativeDragExit.
Je-li v parametru allowedActions předávanému metodě doDrag() povolena více než jedna akce, může uživatel
přidržením klávesy modifikátoru určit, kterou z povolených akcí má v úmyslu provést. Správce tažení změní obraz
kurzoru, aby uživateli sdělil, která akce bude provedena, pokud dokončí upuštění. Zamýšlenou akci oznamuje
vlastnost dropAction objektu NativeDragEvent. Akce nastavená pro gesto tažení je pouze doporučení. Komponenty
zapojené do přenosu musí implementovat příslušné chování. Například chcete-li dokončit akci přesunu, iniciátor
tažení by mohl odstranit taženou položku a cíl upuštění by ji mohl přidat.
Váš cíl tažení může omezit akci upuštění na jednu ze tří možných akcí nastavením vlastnosti dropAction třídy
NativeDragManager. Jestliže se uživatel pomocí klávesnice pokusí zvolit jinou akci, objekt NativeDragManager
zobrazí nepoužitelný kurzor. Nastavte vlastnost dropAction v manipulačních programech pro události
nativeDragEnter a nativeDragOver.
Následující příklad ukazuje manipulační program události pro událost nativeDragEnter nebo nativeDragOver.
Tento manipulační program přijme gesto tažení dovnitř, obsahuje-li tažená schránka data v textovém formátu.
import flash.desktop.NativeDragManager;
import flash.events.NativeDragEvent;
public function onDragIn(event:NativeDragEvent):void{
NativeDragManager.dropAction = NativeDragActions.MOVE;
if(event.clipboard.hasFormat(ClipboardFormats.TEXT_FORMAT)){
NativeDragManager.acceptDragDrop(this); //'this' is the receiving component
}
}
Dokončení upuštění
Jakmile uživatel upustí taženou položku na interaktivní objekt, který toto gesto přijal, interaktivní objekt odešle
událost nativeDragDrop. Manipulační program pro tuto událost může vyjmout data z vlastnosti clipboard objektu
události.
Když schránka obsahuje formát definovaný aplikací, parametr transferMode předaný metodě getData() objektu
Clipboard určí, zda správce tažení vrátí odkaz nebo serializovanou verzi objektu.
Následující příklad ukazuje manipulační program události pro událost nativeDragDrop:
Přetažení
import flash.events.NativeDragEvent;
public function onDrop(event:NativeDragEvent):void {
if (event.clipboard.hasFormat(ClipboardFormats.TEXT_FORMAT)) {
var text:String =
String(event.clipboard.getData(ClipboardFormats.TEXT_FORMAT,
ClipboardTransferMode.ORIGINAL_PREFERRED));
}
Jakmile manipulační program události skončí, objekt Clipboard ztratí platnost. Jakýkoli pokus o přístup k objektu
nebo jeho datům vyvolá chybu.
Aktualizace vizuálního vzhledu komponenty
Komponenta může aktualizovat svůj vizuální vzhled na základě událostí NativeDragEvent. V následující tabulce je
popis typů změn, které by typická komponenta provedla v odpovědi na různé události:
Událost
Popis
nativeDragStart
Iniciující interaktivní objekt může pomocí události nativeDragStart poskytnout vizuální odezvu, že gesto
tažení pochází z daného interaktivního objektu.
nativeDragUpdate
Iniciující interaktivní objekt může během gesta pomocí události nativeDragUpdate aktualizovat svůj stav.
nativeDragEnter
Potenciální přijímající interaktivní objekt se může pomocí této události aktivovat pro vstup nebo vizuálně
udávat, zda může nebo nemůže přijmout upuštění.
nativeDragOver
Potenciální přijímající interaktivní objekt může pomocí této události reagovat na pohyb myši uvnitř
interaktivního objektu, např. když kurzor myši vstoupí do „aktivní“ oblasti složité komponenty, jako je
zobrazení pouliční mapy.
nativeDragExit
Potenciální přijímající interaktivní objekt může pomocí této události obnovit svůj stav, když se gesto tažení
přesune mimo jeho hranice.
nativeDragComplete
Iniciující interaktivní objekt může pomocí této události aktualizovat svůj přidružený model dat, např.
odstraněním určité položky ze seznamu, a obnovit svůj vizuální stav.
Sledování pozice myši během gesta tažení dovnitř
Dokud gesto tažení zůstává nad komponentou, odesílá příslušná komponenta události nativeDragOver. Tyto
události jsou odesílány každých pár milisekund a také při každém pohybu myši. Objekt události nativeDragOver je
možno použít k určení pozice myši nad komponentou. Přístup k pozici myši může být užitečný v situacích, kdy je
přijímající komponenta složitá, ale není složená z dílčích komponent. Například když vaše aplikace zobrazila bitmapu
obsahující pouliční mapu a vy chcete na mapě zvýraznit zóny, když do nich uživatel vtáhne informace, můžete použít
souřadnice myši udané v události nativeDragOver ke sledování pozice myši v mapě.
Přetažení HTML
Chcete-li táhnout data do a z aplikací na bázi HTML (nebo do a z obsahu HTML zobrazeného v objektu
HTMLLoader), můžete použít události přetažení HTML. API přetažení HTML umožňuje táhnout do a z elementů
DOM v obsahu HTML.
Přetažení
Poznámka: Také můžete použít API NativeDragEvent a NativeDragManager aplikace AIR posloucháním událostí na
objektu HTMLLoader obsahujícím obsah HTML. Avšak API HTML je lépe integrované s rozhraním HTML DOM a
poskytuje kontrolu nad výchozím chováním.
Výchozí chování tažení
Prostředí HTML poskytuje výchozí chování pro gesta přetažení zahrnující text, obrazy a URL. Při použití výchozího
chování můžete tyto typy dat vždy vytáhnout ven z elementu. Text však můžete táhnout pouze do elementu a pouze
do elementů v upravitelné oblasti stránky. Když táhnete text mezi upravitelnými oblastmi nebo uvnitř upravitelných
oblastí stránky, výchozí chování provede akci přesunutí. Když táhnete text do upravitelné oblasti z neupravitelné
oblasti mimo aplikaci, výchozí chování provede akci kopírování.
Výchozí chování můžete potlačit tak, že budete události přetažení zpracovávat sami. Chcete-li zrušit výchozí chování,
musíte vyvolat metody preventDefault() objektů odeslaných pro události přetažení. Pro provedení zvolené akce
můžete poté dle potřeby vložit data do cíle pro upuštění a odstranit data ze zdroje tažení.
Implicitně může uživatel vybrat a táhnout libovolný text a také táhnout obrázky a odkazy. Chcete-li ovládat způsob
výběru libovolného elementu HTML, můžete použít vlastnost WebKit CSS, -webkit-user-select. Například
nastavíte-li -webkit-user-select na hodnotu none, obsah elementu nebude zvolitelný, a proto ho nebude možné
přetáhnout. Také můžete použít vlastnost -webkit-user-drag CSS k ovládání, zda může být přetažen určitý element
jako celek. Obsah elementu je však zpracováván zvlášť. Uživatel by i tak mohl přetáhnout vybranou část textu. Další
informace viz „Rozšíření pro jazyk CSS“ na stránce 205.
Události přetažení v HTML
Události odesílané elementem iniciátoru, ze kterého data pocházejí, jsou následující:
Událost
Popis
dragstart
Odeslána, jakmile uživatel zahájí gesto tažení. Manipulační program pro tuto událost může v případě nutnosti
zabránit tažení vyvoláním metody preventDefault() objektu události. Chcete-li ovládat, zda mohou být
přetažená data zkopírována, propojena odkazem nebo přesunuta, nastavte vlastnost effectAllowed. Vybraný
text, obrazy a odkazy jsou výchozím chováním vloženy do schránky, ale pro gesto tažení můžete nastavit jiná
data pomocí vlastnosti dataTransfer objektu události.
tažení
Odesílána nepřetržitě během gesta tažení.
dragend
Odeslána, jakmile uživatel uvolní tlačítko myši a ukončí tak gesto tažení.
Události odesílané cílem tažení jsou následující:
Událost
Popis
dragover
Odesílána nepřetržitě, dokud gesto tažení zůstává v rámci hranic elementu. Manipulační program pro tuto
událost by měl nastavit vlastnost dataTransfer.dropEffect tak, aby označovala, zda bude mít upuštění za
následek akci kopírování, přesunutí nebo vytvoření odkazu, až uživatel uvolní tlačítko myši.
dragenter
Odeslána, jakmile gesto tažení překročí dovnitř hranice elementu.
Změníte-li kterékoli vlastnosti objektu dataTransfer v manipulačním programu události dragenter, budou
tyto změny rychle potlačeny následující událostí dragover. Na druhou stranu existuje krátké zpoždění mezi
událostí dragenter a první událostí dragover, které může způsobit, že bude kurzor blikat, jsou-li nastaveny
různé vlastnosti. V mnoha případech můžete použít pro obě události stejný manipulační program události.
dragleave
Odeslána, jakmile gesto tažení opustí hranice elementu.
upuštění
Odeslána, jakmile uživatel upustí data na element. K taženým datům je přístup pouze v rámci manipulačního
programu pro tuto událost.
Přetažení
Objekt události odeslaný v odpovědi na tyto události je podobný události myši. Chcete-li určit pozici myši, můžete
použít vlastnosti události mouse (např. clientX, clientY) a (screenX, screenY).
Nejdůležitější vlastností události tažení je dataTransfer, která obsahuje právě tažená data. Samotný objekt
dataTransfer má následující vlastnosti a metody:
Popis
effectAllowed
Účinek povolený zdrojem tažení. Tuto hodnotu obvykle nastavuje manipulační program pro událost
dragstart. Viz „Účinky tažení v HTML“ na stránce 132.
dropEffect
Účinek zvolený cílem nebo uživatelem. Nastavíte-li vlastnost dropEffect v manipulačním programu
události dragover nebo dragenter, aplikace AIR aktualizuje kurzor myši tak, aby označoval účinek, který se
vyskytne, když uživatel uvolní tlačítko myši. Jestliže se nastavení vlastnosti dropEffect neshoduje s jedním
z povolených účinků, není povoleno žádné upuštění a je zobrazen kurzor unavailable. Jestliže jste nenastavili
vlastnost dropEffect v odpovědi na poslední událost dragover nebo dragenter, může si uživatel vybrat
z povolených účinků se standardními klávesami modifikátoru operačního systému.
Konečný účinek je oznámen vlastností dropEffect objektu odeslaného pro událost dragend. Jestliže se
uživatel vyhne upuštění tak, že uvolní tlačítko myši mimo vhodný cíl, bude vlastnost dropEffect nastavena
na hodnotu none.
typy
Pole obsahující řetězce typu MIME pro každý formát dat přítomný v objektu dataTransfer.
getData(mimeType)
Získá data ve formátu určeném parametrem mimeType.
Metodu getData() lze vyvolat pouze v odpovědi na událost drop.
setData(mimeType)
Přidá data k vlastnosti dataTransfer ve formátu určeném parametrem mimeType. Vyvoláním metody
setData() pro každý typ MIME můžete přidat data do více formátů. Veškerá data umístěná do objektu
dataTransfer výchozím chováním tažení budou vymazána.
Metodu setData() lze vyvolat pouze v odpovědi na událost dragstart.
clearData(mimeType)
Vymaže veškerá data ve formátu určeném parametrem mimeType.
setDragImage(image,
offsetX, offsetY)
Nastaví vlastní obraz tažení. Metodu setDragImage() lze vyvolat pouze v odpovědi na událost dragstart.
Typy MIME pro přetažení HTML
Typy MIME pro použití s objektem dataTransfer události přetažení HTML zahrnují:
Formát dat
typ MIME
Text
„text/plain“
HTML
„text/html“
URL
„text/uri-list“
Bitmapa
„image/x-vnd.adobe.air.bitmap“
Seznam souborů
„application/x-vnd.adobe.air.file-list“
Také můžete použít jiné řetězce MIME, včetně řetězců definovaných aplikací. Avšak jiné aplikace nemusí být schopny
přenesená data rozpoznat či použít. Je vaší odpovědností přidat data do objektu dataTransfer v očekávaném
formátu.
Důležité: K upuštěným souborům má přístup pouze kód běžící v karanténě aplikace. Pokus o čtení nebo nastavení
kterékoli vlastnosti objektu File uvnitř neaplikační karantény vygeneruje chybu zabezpečení. Další informace viz
„Manipulace se soubory upuštěnými v neaplikačních karanténách HTML“ na stránce 135.
Přetažení
Účinky tažení v HTML
Iniciátor gesta tažení může omezit povolené účinky tažení nastavením vlastnosti dataTransfer.effectAllowed v
manipulačním programu pro událost dragstart. Je možno použít následující hodnoty řetězce:
Hodnota řetězce
Popis
„žádná“
Nejsou povoleny žádné operace tažení.
„kopie“
Data budou zkopírována na místo určení a originál bude ponechán na místě.
„link“
Data budou sdílena s cílem pro upuštění pomocí odkazu zpět na originál.
„přemístění”
Data budou zkopírována na místo určení a odstraněna z původního umístění.
„copyLink“
Data lze kopírovat nebo propojit odkazem.
„copyMove“
Data lze kopírovat nebo přesunout.
„linkMove“
Data lze propojit odkazem nebo přesunout.
„all“
Data lze kopírovat, přesunout nebo propojit odkazem. All je výchozí účinek, když bráníte výchozímu chování.
Cíl gesta tažení může nastavit vlastnost dataTransfer.dropEffect tak, aby označovala akci, která bude provedena,
jakmile uživatel dokončí upuštění. Je-li účinek upuštění jedna z povolených akcí, systém zobrazí příslušný kurzor
kopírování, přesunu nebo odkazu. Pokud ne, systém odešle kurzor unavailable. Jestliže není cílem nastaven žádný
účinek upuštění, může si uživatel vybrat z povolených akcí s klávesami modifikátoru.
Nastavte hodnotu vlastnosti dropEffect v manipulačních programech pro obě události dragover a dragenter:
function doDragStart(event) {
event.dataTransfer.setData("text/plain","Text to drag");
event.dataTransfer.effectAllowed = "copyMove";
}
function doDragOver(event) {
event.dataTransfer.dropEffect = "copy";
}
function doDragEnter(event) {
event.dataTransfer.dropEffect = "copy";
}
Poznámka: I když byste měli vždy nastavit vlastnost dropEffect v manipulačním programu pro událost dragenter,
uvědomte si, že následující událost dragover nastaví tuto vlastnost zpět na její výchozí hodnotu. Nastavte vlastnost
dropEffect v odpovědi na obě události.
Tažení dat z elementu HTML
Výchozí chování umožňuje, aby byla většina obsahu na stránce HTML zkopírována tažením. Obsah povolený k tažení
můžete ovládat pomocí vlastností CSS -webkit-user-select a -webkit-user-drag.
Potlačte výchozí chování tažení ven v manipulačním programu pro událost dragstart. Chcete-li vložit svá vlastní
data do gesta tažení, vyvolejte metodu setData() vlastnosti dataTransfer objektu události.
Chcete-li označit, které účinky tažení zdrojový objekt podporuje, když se nespoléháte na výchozí chování, nastavte
vlastnost dataTransfer.effectAllowed objektu události odeslaného pro událost dragstart. Můžete si zvolit
libovolnou kombinaci účinků. Například podporuje-li zdrojový element účinky copy i link, nastavte danou vlastnost
na „copyLink".
Přetažení
Nastavení tažených dat
Přidejte data pro gesto tažení v manipulačním programu pro událost dragstart s vlastností dataTransfer. Pomocí
metody dataTransfer.setData() vložte data do schránky, přičemž předáte typ MIME dat k přenesení.
Například jestliže jste měli ve své aplikaci obrazový element s id imageOfGeorge, mohli byste použít následující
manipulační program události dragstart. V tomto příkladu jsou předána zastoupení fotografie Georgea v několika
formátech dat, což zvyšuje pravděpodobnost, že jiné aplikace budou moci přetažená data použít.
function dragStartHandler(event){
event.dataTransfer.effectAllowed = "copy";
var dragImage = document.getElementById("imageOfGeorge");
var dragFile = new air.File(dragImage.src);
event.dataTransfer.setData("text/plain","A picture of George");
event.dataTransfer.setData("image/x-vnd.adobe.air.bitmap", dragImage);
event.dataTransfer.setData("application/x-vnd.adobe.air.file-list",
new Array(dragFile));
}
Poznámka: Když vyvoláte metodu setData() objektu dataTransfer, chování přetažení nepřidá implicitně žádná
data.
Tažení dat do elementu HTML
Výchozí chování povoluje, aby byl text přetažen pouze do upravitelných oblastí stránky. Můžete určit, že určitý
element a jeho potomci mohou být učiněni upravitelnými zahrnutím atributu contenteditable do úvodního tagu
daného elementu. Také můžete učinit celý dokument upravitelným nastavením vlastnosti designMode objektu
dokumentu na „on".
Náhradní chování na stránce můžete podpořit zpracováním událostí dragenter, dragover a drop pro libovolné
elementy, které mohou přijímat přetažená data.
Povolení tažení dovnitř
Chcete-li zpracovat gesto tažení dovnitř, musíte nejprve zrušit výchozí chování. Poslouchejte události dragenter a
dragover na libovolných elementech HTML, které chcete použít jako cíle upuštění. V manipulačních programech pro
tyto události vyvolejte metodu preventDefault() odeslaného objektu události. Zrušení výchozího chování
umožňuje, aby neupravitelné oblasti přijímaly upuštění.
Získání upuštěných dat
K upuštěným datům v manipulačním programu pro událost ondrop máte přístup:
function doDrop(event){
droppedText = event.dataTransfer.getData("text/plain");
}
Pomocí metody dataTransfer.getData() přečtěte data do schránky, přičemž předáte typ MIME formátu dat k
přečtení. Dostupnost formátů dat můžete zjistit pomocí vlastnosti types objektu dataTransfer. Pole types obsahuje
řetězec typu MIME každého dostupného formátu.
Když zrušíte výchozí chování v událostech dragenter nebo dragover, budete zodpovědní za vložení jakýchkoli
upuštěných dat na správné místo v dokumentu. Neexistuje žádné API pro převod pozice myši na textový kurzor uvnitř
elementu. Toto omezení může ztížit implementaci gest tažení typu textového kurzoru.
Přetažení
Příklad: Potlačení výchozího chování tažení dovnitř HTML
V tomto příkladu je implementován cíl upuštění, který zobrazuje tabulku se všemi formáty dat dostupnými v upuštěné
položce.
Výchozí chování slouží k povolení tažení textu, odkazů a obrazů v rámci aplikace. V příkladu je potlačeno výchozí
chování tažení dovnitř pro element div, který slouží jako cíl upuštění. Klíčovým krokem k povolení neupravitelného
obsahu pro přijetí gesta tažení dovnitř je volání metody preventDefault() objektu události odeslaného pro události
dragenter a dragover. V odpovědi na událost drop manipulační program převede přenesená data do řádkového
elementu HTML a vloží řádek do tabulky k zobrazení.
<html>
<head>
<title>Drag-and-drop</title>
<script language="javascript" type="text/javascript" src="AIRAliases.js"></script>
<script language="javascript">
function init(){
var target = document.getElementById('target');
target.addEventListener("dragenter", dragEnterOverHandler);
target.addEventListener("dragover", dragEnterOverHandler);
target.addEventListener("drop", dropHandler);
var source = document.getElementById('source');
source.addEventListener("dragstart", dragStartHandler);
source.addEventListener("dragend", dragEndHandler);
emptyRow = document.getElementById("emptyTargetRow");
}
function dragStartHandler(event){
event.dataTransfer.effectAllowed = "copy";
}
function dragEndHandler(event){
air.trace(event.type + ": " + event.dataTransfer.dropEffect);
}
function dragEnterOverHandler(event){
}
var emptyRow;
function dropHandler(event){
for(var prop in event){
air.trace(prop + " = " + event[prop]);
}
var row = document.createElement('tr');
row.innerHTML = "<td>" + event.dataTransfer.getData("text/plain") + "</td>" +
"<td>" + event.dataTransfer.getData("text/html") + "</td>" +
"<td>" + event.dataTransfer.getData("text/uri-list") + "</td>" +
"<td>" + event.dataTransfer.getData("application/x-vnd.adobe.air.file-list") +
"</td>";
var imageCell = document.createElement('td');
if((event.dataTransfer.types.toString()).search("image/x-vnd.adobe.air.bitmap") > 1){
imageCell.appendChild(event.dataTransfer.getData("image/x-
Přetažení
vnd.adobe.air.bitmap"));
}
row.appendChild(imageCell);
var parent = emptyRow.parentNode;
parent.insertBefore(row, emptyRow);
}
</script>
</head>
<body onLoad="init()" style="padding:5px">
<div>
<h1>Source</h1>
<p>Items to drag:</p>
<ul id="source">
<li>Plain text.</li>
<li>HTML <b>formatted</b> text.</li>
<li>A <a href="http://www.adobe.com">URL.</a></li>
<li><img src="icons/AIRApp_16.png" alt="An image"/></li>
<li style="-webkit-user-drag:none;">
Uses "-webkit-user-drag:none" style.
</li>
<li style="-webkit-user-select:none;">
Uses "-webkit-user-select:none" style.
</li>
</ul>
</div>
<div id="target" style="border-style:dashed;">
<h1 >Target</h1>
<p>Drag items from the source list (or elsewhere).</p>
<table id="displayTable" border="1">
<tr><th>Plain text</th><th>Html text</th><th>URL</th><th>File list</th><th>Bitmap
Data</th></tr>
<tr
id="emptyTargetRow"><td> </td><td> </td><td> </td><td> </td><td> </
td></tr>
</table>
</div>
</div>
</body>
</html>
Manipulace se soubory upuštěnými v neaplikačních karanténách HTML
Neaplikační obsah nemá přístup k objektům File, které jsou výsledkem tažení souborů do aplikace AIR. Ani není
možné předat jeden z těchto objektů File do obsahu aplikace prostřednictvím mostu karantény. (Vlastnosti objektu
musíte použít během serializace.) Avšak stále můžete upustit soubory ve vaší aplikaci posloucháním událostí
nativeDragDrop AIR na objektu HTMLLoader.
Obvykle jestliže uživatel upustí soubor do rámce, který hostí neaplikační obsah, událost upuštění se nerozšíří z
potomka na rodiče. Avšak protože posluchače odeslané objektem HTMLLoader (který je kontejnerem pro veškerý
obsah HTML v aplikaci AIR) nejsou součástí toku události HTML, můžete i tak přijmout událost upuštění v obsahu
aplikace.
Chcete-li obdržet událost pro upuštění souboru, nadřazený dokument přidá posluchač události do objektu
HTMLLoader pomocí odkazu poskytnutého vlastností window.htmlLoader:
Přetažení
window.htmlLoader.addEventListener("nativeDragDrop",function(event){
var filelist = event.clipboard.getData(air.ClipboardFormats.FILE_LIST_FORMAT);
air.trace(filelist[0].url);
});
V následujícím příkladu je použitý nadřazený dokument, který načítá podřízenou stránku do vzdálené karantény
(http://localhost/). Rodič poslouchá událost nativeDragDrop na objektu HTMLLoader a vypracovává URL soubor.
<html>
<head>
<title>Drag-and-drop in a remote sandbox</title>
<script language="javascript">
window.htmlLoader.addEventListener("nativeDragDrop",function(event){
var filelist = event.clipboard.getData(air.ClipboardFormats.FILE_LIST_FORMAT);
air.trace(filelist[0].url);
});
</script>
</head>
<body>
<iframe src="child.html"
sandboxRoot="http://localhost/"
documentRoot="app:/"
frameBorder="0" width="100%" height="100%">
</iframe>
</body>
</html>
Podřízený dokument musí poskytnout platný cíl upuštění zabráněním metodě preventDefault() objektu Event v
manipulačních programech událostí dragenter a dragover HTML, jinak nikdy nedojde k události upuštění.
<html>
<head>
<title>Drag and drop target</title>
function preventDefault(event){
}
</script>
</head>
<body ondragenter="preventDefault(event)" ondragover="preventDefault(event)">
<div>
<h1>Drop Files Here</h1>
</div>
</body>
</html>
Další informace viz „Programování v jazycích HTML a JavaScript“ na stránce 207.
137
Kapitola 16: Kopírování a vkládání
Chcete-li kopírovat informace do a ze systémové schránky, použijte třídy v API schránce. Formáty dat je možno
přenášet do i z aplikace Adobe® AIR™, včetně:
• Bitmapy
• Soubory
• Text
• Text ve formátu HTML
• data ve formátu Rich Text Format
• řetězce URL
• Serializované objekty
• Objektové odkazy (platné pouze v rámci vznikající aplikace)
Doplňující online informace o kopírování a vkládání
Další informace o kopírování a vkládání můžete získat z následujících zdrojů:
• Podpora přetahování a kopírování a vkládání
• Clipboard
• ClipboardFormats
• ClipboardTransferMode
Více informací
• Adobe AIR Developer Connection for Flash (hledání „kopírování a vkládání v AIR“)
Základy kopírování a vkládání
API pro kopírování a vkládání obsahuje následující třídy.
Kopírování a vkládání
Balíček
Třídy
flash.desktop
•
Clipboard
•
ClipboardFormats
•
Konstanty používané s API pro kopírování a vkládání jsou definovány v následujících třídách:
•
ClipboardFormats
•
Statická vlastnost Clipboard.generalClipboard představuje schránku operačního systému. Třída Clipboard
poskytuje metody pro čtení a zápis dat do objektů schránky. Je možno vytvářet i nové objekty Clipboard pro přenášení
dat prostřednictvím API pro přetahování.
Prostředí HTML poskytuje alternativní API pro kopírování a vkládání. Obě API mohou využít kód běžící v karanténě
zabezpečení aplikace, ale pouze API HTML lze použít v neaplikačním obsahu. (Viz „Kopírování a vkládání v HTML“
na stránce 139.)
Třídy HTMLLoader a TextField implementují výchozí chování pro běžné klávesové zkratky kopírování a vkládání.
Chcete-li implementovat chování zkratek pro kopírování a vkládání pro vlastní komponenty, můžete poslouchat
přímo stisknutí těchto kláves. Můžete také použít nativní příkazy nabídky spolu s ekvivalenty kláves jako nepřímé
reagování na stisknutí kláves.
V jediném objektu Clipboard lze zpřístupnit různé reprezentace stejných informací ke zvýšení schopnosti jiných
aplikací, rozumět těmto datům a používat je. Například obraz může být vložen jako obrazová data, serializovaný objekt
Bitmap a jako soubor. Vykreslení dat ve formátu může být odloženo, takže daný formát vlastně nebude vytvořen,
dokud nebudou přečtena data v tomto formátu.
Poznámka: Není zaručeno, že data zapsaná do schránky zůstanou přístupná i po ukončení aplikace AIR.
Operace čtení a zápis se systémovou schránkou
Chcete-li číst ze schránky operačního systému, vyvolejte metodu getData() objektu
Clipboard.generalClipboard, přičemž předáte název formátu, který se má číst:
import flash.desktop.ClipboardFormats;
if(Clipboard.generalClipboard.hasFormat(ClipboardFormats.TEXT_FORMAT)){
var text:String = Clipboard.generalClipboard.getData(ClipboardFormats.TEXT_FORMAT);
}
Chcete-li něco zapsat do schránky, přidejte data do objektu Clipboard.generalClipboard v jednom nebo více
formátech. Existující data ve stejném formátu budou automaticky přepsána. Před zápisem nových dat do systémové
schránky je však dobré vymazat i ji, aby bylo zajištěno, že budou smazána také nesouvisející data ve všech ostatních
formátech.
import flash.desktop.ClipboardFormats;
var textToCopy:String = "Copy to clipboard.";
Clipboard.generalClipboard.clear();
Clipboard.generalClipboard.setData(ClipboardFormats.TEXT_FORMAT, textToCopy, false);
Poznámka: Pouze kód běžící v karanténě aplikace má přímý přístup k systémové schránce. V případě jiného obsahu než
HTML máte ke schránce přístup pouze prostřednictvím vlastnosti clipboardData objektu události odeslaného jednou
z událostí kopírování nebo vložení HTML.
Kopírování a vkládání v HTML
Prostředí HTML poskytuje svou vlastní sadu událostí a výchozího chování pro funkce kopírování a vkládání. Pouze
kód běžící v karanténě aplikace má přístup k systémové schránce přímo prostřednictvím objektu AIR
Clipboard.generalClipboard. Kód JavaScript v neaplikační karanténě má přístup ke schránce prostřednictvím
objektu události odeslané jako odpověď na jednu z událostí kopírování nebo vložení odeslaných nějakým elementem
v dokumentu HTML.
K událostem kopírování a vložení patří: copy, cut a paste. Objekt odeslaný pro tyto události poskytuje přístup ke
schránce prostřednictvím vlastnosti clipboardData.
Výchozí chování
Při výchozím nastavení kopíruje aplikace AIR vybrané položky v odpovědi na příkaz kopírování, vygenerovaný buď
klávesovou zkratkou nebo kontextovou nabídkou. Uvnitř upravitelných oblastí aplikace AIR v odpovědi na příkaz
vyjmutí vyjme text nebo v odpovědi na příkaz vložení vloží text na pozici kurzoru nebo výběru.
Chcete-li se vyhnout výchozímu chování, může váš posluchač událostí vyvolat metodu preventDefault()
odeslaného objektu události.
Použití vlastnosti clipboardData nebo objektu události
Vlastnost clipboardData objektu události odeslaného jako výsledek jedné z událostí kopírování nebo vložení
umožňuje provádět čtení a zápis dat ze/do schránky.
Chcete-li něco zapsat do schránky při zpracovávání události kopírování nebo vyjmutí, použijte metodu setData()
objektu clipboardData, přičemž předáte data ke zkopírování a typ MIME:
function customCopy(event){
event.clipboardData.setData("text/plain", "A copied string.");
}
Chcete-li použít vkládaná data, můžete použít metodu getData() objektu clipboardData, přičemž předáte typ
MIME daného formátu dat. Dostupné formáty jsou oznamovány vlastností types.
function customPaste(event){
var pastedData = event.clipboardData("text/plain");
}
K metodě getData() a vlastnosti types je přístup pouze v objektu události odeslaném událostí event.
Následující příklad ukazuje, jak potlačit výchozí chování kopírování a vkládání na stránce HTML. Zpracování události
copy převede kopírovaný text do kurzívy a zkopíruje jej do schránky jako text HTML. Zpracování události cut
zkopíruje vybraná data do schránky a odstraní je z dokumentu. Zpracování události paste vloží obsah schránky jako
HTML a nastaví styl vloženého textu na tučný.
<html>
<head>
<title>Copy and Paste</title>
function onCopy(event){
var selection = window.getSelection();
event.clipboardData.setData("text/html","<i>" + selection + "</i>");
}
function onCut(event){
event.clipboardData.setData("text/html","<i>" + selection + "</i>");
var range = selection.getRangeAt(0);
range.extractContents();
}
function onPaste(event){
var insertion = document.createElement("b");
insertion.innerHTML = event.clipboardData.getData("text/html");
var range = selection.getRangeAt(0);
range.insertNode(insertion);
}
</script>
</head>
<body onCopy="onCopy(event)"
onPaste="onPaste(event)"
onCut="onCut(event)">
<p>Sed ut perspiciatis unde omnis iste natus error sit voluptatem accusantium
doloremque laudantium, totam rem aperiam, eaque ipsa quae ab illo inventore
veritatis et quasi architecto beatae vitae dicta sunt explicabo. Nemo enim ipsam
voluptatem quia voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur
magni dolores eos qui ratione voluptatem sequi nesciunt.</p>
</body>
</html>
Příkazy nabídky a stisknutí kláves pro kopírování a
vkládání
Funkce kopírování a vkládání se obvykle spouští prostřednictvím příkazů nabídky a klávesových zkratek. V systému
OS X operační systém automaticky vytvoří nabídku pro úpravy s příkazy kopírování a vkládání, ale k těmto příkazům
je třeba přidat posluchače, které budou zachytávat vaše vlastní funkce kopírování a vkládání. V systému Windows
můžete přidat nativní nabídku pro úpravy ke každému oknu, které používá standardní systémové prvky. (Pomocí
jazyka Flex a ActionScript můžete vytvořit i jiné než nativní nabídky nebo v obsahu HTML můžete použít DHTML,
ale to již překračuje rozsah této diskuse.)
Funkce kopírování a vkládání se obvykle spouští prostřednictvím příkazů nabídky a klávesových zkratek. V systému
OS X operační systém automaticky vytvoří nabídku pro úpravy s příkazy kopírování a vkládání, ale k těmto příkazům
je třeba přidat posluchače, které budou zachytávat vaše vlastní funkce kopírování a vkládání. V systému Windows
můžete přidat nativní nabídku pro úpravy ke každému oknu, které používá standardní systémové prvky. (Pomocí
jazyka ActionScript můžete vytvořit i jiné než nativní nabídky nebo v obsahu HTML můžete použít DHTML, ale to již
překračuje rozsah této diskuse.)
Chcete-li spustit příkazy kopírování a vložení v odpovědi na klávesové zkratky, můžete buď přiřadit ekvivalenty kláves
příslušným příkazovým položkám v nativní nabídce aplikace nebo okna, nebo můžete poslouchat přímo stisknutí
daných kláves.
Zahájení operace kopírování nebo vložení pomocí příkazu nabídky
Chcete-li spustit operaci kopírování nebo vložení pomocí příkazu nabídky, musíte přidat posluchače pro událost
select na položkách nabídky, které vyvolávají vaše funkce zpracování.
Jakmile je vyvolána vaše funkce zpracování, můžete najít objekt, který má být kopírován nebo vložen, pomocí
vlastnosti focus vymezené plochy. Poté můžete vyvolat příslušnou metodu aktivního objektu (nebo obecnou zpětně
volanou metodu, není-li aktivní žádný objekt) pro provedení logické operace kopírování, vyjmutí nebo vložení.
Například následující zpracování události copy zkontroluje, zda je aktivní objekt správného typu, v tomto případě
třída s názvem Scrap, a následně vyvolá metodu doCopy() daného objektu.
function copyCommand(event:Event):void{
if(NativeApplication.nativeApplication.activeWindow.stage.focus is Scrap){
Scrap(NativeApplication.nativeApplication.activeWindow.stage.focus).doCopy();
} else {
NativeApplication.nativeApplication.copy();
}
}
Jestliže metoda copyCommand() v příkladu nerozpozná třídu aktivního objektu, vyvolá metodu copy() třídy
NativeApplication. Metoda copy() třídy NativeApplication vyšle do aktivního objektu interní příkaz kopírování.
Tento interní příkaz rozpoznají pouze objekty TextArea a HTMLLoader. Podobné příkazy jsou dostupné pro vyjmutí,
vložení, výběr všech položek a pouze pro TextArea, vymazání, zpět a znovu.
Poznámka: Ve vlastní komponentě není k dispozici žádné API pro reagování na tyto interní příkazy. Musíte buď rozšířit
třídu TextArea nebo HTMLLoader nebo zahrnout jeden z těchto objektů do vaší vlastní komponenty. Zahrnete-li objekt
TextArea nebo HTMLLoader, musí vaše komponenta spravovat aktivaci pro vstup tak, aby objekt TextArea nebo
HTMLLoader zůstával stále aktivní, dokud je aktivní i samotná komponenta.
V obsahu HTML může být výchozí chování kopírování a vkládání spuštěno pomocí příkazů pro úpravy
NativeApplication. V následujícím příkladu je vytvořena nabídka pro úpravy pro upravitelný dokument HTML:
V předchozím příkladu byla nahrazena nabídka aplikace v systému Mac OS X, můžete však také využít výchozí
nabídku Úpravy tak, že vyhledáte stávající položky a přidáte k nim posluchače událostí.
Jestliže vyvoláte příkaz kopírovat nebo vložit pomocí kontextové nabídky, můžete použít vlastnost
contextMenuOwner objektu ContextMenuEvent odeslaného při otevření nabídky nebo při výběru položky pro určení,
který objekt je pravým cílem příkazu kopírovat nebo vložit.
Vyhledání výchozích položek nabídky v systému Mac OS X
Chcete-li vyhledat výchozí položky nabídky úprav a položky specifických příkazů kopírovat, vyjmout a vložit v nabídce
aplikace v systému Mac OS X, můžete prohledat hierarchii nabídky pomocí vlastnosti label objektů
NativeMenuItem. Například následující funkce přebere název a vyhledá položku s odpovídajícím popisem v nabídce:
private function findItemByName(menu:NativeMenu,
name:String,
recurse:Boolean = false):NativeMenuItem{
var searchItem:NativeMenuItem = null;
for each (var item:NativeMenuItem in menu.items){
if(item.label == name){
searchItem = item;
break;
}
if((item.submenu != null) && recurse){
searchItem = findItemByName(item.submenu, name, recurse);
}
if(searchItem != null){ break; }
}
return searchItem;
}
Můžete nastavit parametr recurse na hodnotu true, a zahrnout tak do hledání i dílčí nabídky, nebo na hodnotu
false pro zahrnutí pouze předané nabídky.
Spuštění příkazu kopírovat nebo vložit stisknutím klávesy
Jestliže vaše aplikace používá nativní okno nebo nabídky aplikace pro kopírování a vkládání, můžete přidáním
ekvivalentů kláves k položkám nabídky implementovat klávesové zkratky. Jinak můžete poslouchat stisknutí
příslušných kláves sami, jak ukazuje následující příklad:
private function init():void{
stage.addEventListener(KeyboardEvent.KEY_DOWN, keyListener);
}
private function keyListener(event:KeyboardEvent):void{
if(event.ctrlKey){
switch(String.fromCharCode(event.charCode)){
case "c":
NativeApplication.nativeApplication.copy();
break;
case "x":
NativeApplication.nativeApplication.cut();
break;
case "v":
NativeApplication.nativeApplication.paste();
break;
case "a":
NativeApplication.nativeApplication.selectAll();
break;
case "z":
NativeApplication.nativeApplication.undo();
break;
case "y":
NativeApplication.nativeApplication.redo();
break;
}
}
}
V obsahu HTML jsou klávesové zkratky pro příkazy kopírování a vkládání implementovány standardně. Není možné
zachytit všechna stisknutí kláves běžně používaných pro kopírování a vkládání pomocí posluchače události kláves.
Potřebujete-li potlačit výchozí chování, lepší strategie je poslouchat samotné události kopírování a vložení.
Schránka:formáty dat
Formáty Clipboard popisují data umístěná do objektu Clipboard. Aplikace AIR automaticky přeloží standardní
formáty dat mezi typy dat ActionScript a formáty systémové schránky. Objekty aplikace lze navíc přesunout v rámci
aplikace AIR a mezi aplikacemi AIR pomocí formátů definovaných aplikací.
Objekt Clipboard může obsahovat zastoupení stejných informací v různých formátech. Například objekt Clipboard
představující pohyblivý symbol by mohl zahrnovat formát odkazu pro použití ve stejné aplikaci, specializovaný formát
pro použití jinou aplikací AIR, formát bitmapy pro použití v editoru obrazu a formát seznamu souborů, třeba s
odloženým vykreslením pro kódování souboru PNG, pro kopírování nebo přetažení zastoupení pohyblivého symbolu
do systému souborů.
Standardní formáty dat
Konstanty definující standardní názvy formátů jsou zahrnuty v třídě ClipboardFormats:
Konstanta
Popis
TEXT_FORMAT
Data v textovém formátu se překládají do a z třídy String jazyka ActionScript.
HTML_FORMAT
Text se značkami HTML.
RICH_TEXT_FORMAT
Data ve formátu RTF se překládají do a z třídy ByteArray jazyka ActionScript. Značky RTF se nijak neinterpretují
ani nepřekládají.
BITMAP_FORMAT
Data ve formátu bitmap se překládají do a z třídy BitmapData jazyka ActionScript.
FILE_LIST_FORMAT
Data ve formátu seznamu souborů se překládají do a z pole objektů File jazyka ActionScript.
URL_FORMAT
Data ve formátu URL se překládají do a z třídy String jazyka ActionScript.
Poznámka: Data ve formátu RTF v současné době nepodporují žádné textové ovládací prvky ani komponenty programu
Flash. Chcete-li vložit data RTF do ovládání, nejprve přeložte označení RTF na označení HTML (nebo prostý text).
Podobně chcete-li kopírovat data RTF do schránky, převeďte text nebo řetězec HTML na objekt ByteArray doplněný
správným označením RTF. Jazyk Flash neposkytuje žádnou třídu utility pro převod dat RTF na jiný formát.
Při kopírování a vkládání dat v odpovědi na událost copy, cut nebo paste v obsahu HTML je třeba místo řetězců
ClipboardFormat použít typy MIME. Platné typy MIME dat jsou:
typ MIME
Popis
Text
„text/plain“
URL
„text/uri-list“
Bitmapa
„image/x-vnd.adobe.air.bitmap“
Seznam souborů
„application/x-vnd.adobe.air.file-list“
Poznámka: Data ve formátu RTF nejsou dostupná z vlastnosti clipboardData objektu události odeslaného jako
výsledek události paste v obsahu HTML.
Vlastní formáty dat
Vlastní formáty definované aplikací můžete použít k převodu objektů jako odkazů nebo jako serializovaných kopií.
Odkazy jsou platné pouze v rámci stejné aplikace AIR. Serializované objekty lze převádět mezi aplikacemi Adobe AIR,
ale lze je použít pouze s objekty, které zůstávají při serializaci a deserializaci v platnosti. Objekty mohou být obvykle
serializovány, pokud jsou jejich vlastnosti buď jednoduché typy nebo serializovatelné objekty.
Chcete-li přidat serializovaný objekt do objektu Clipboard, nastavte serializovatelný parametr při volání metody
Clipboard.setData() na hodnotu true. Název formátu může být jeden ze standardních formátů nebo libovolný
řetězec definovaný vaší aplikací.
Režimy přenosu
Když je objekt zapsán do schránky pomocí vlastního formátu dat, data v objektu je možno číst ze schránky buď jako
odkaz nebo jako serializovanou kopii původního objektu. Aplikace AIR definuje režimy přenosu, které určují, zda
budou objekty přenášeny jako odkazy nebo serializované kopie:
Režim přenosu
Popis
ClipboardTransferModes.ORIGINAL_ONLY
Bude vrácen pouze odkaz. Není-li k dispozici žádný odkaz, bude vrácena hodnota
null.
ClipboardTransferModes.ORIGINAL_PREFFERED
Bude vrácen odkaz, je-li k dispozici. Jinak bude vrácena serializovaná kopie.
ClipboardTransferModes.CLONE_ONLY
Bude vrácena pouze serializovaná kopie. Není-li žádná serializovaná kopie k
dispozici, bude vrácena hodnota null.
ClipboardTransferModes.CLONE_PREFFERED
Bude vrácena serializovaná kopie, je-li k dispozici. Jinak bude vrácen odkaz.
Čtení a zápis vlastních formátů dat
Při zápisu objektu do schránky můžete použít libovolný řetězec, který nezačíná vyhrazenou předponou air: pro
parametr formátu. Chcete-li objekt číst, použijte stejný řetězec jako formát. Následující příklady ukazují, jak číst a
zapisovat objekty ze a do schránky:
public function createClipboardObject(object:Object):Clipboard{
transfer.setData("object", object, true);
}
Chcete-li vyjmout serializovaný objekt z objektu schránky (po operaci přetažení nebo vložení), použijte stejný název
formátu a režim přenosu cloneOnly nebo clonePreferred.
var transfer:Object = clipboard.getData("object", ClipboardTransferMode.CLONE_ONLY);
Do objektu Clipboard bude vždy přidán odkaz. Chcete-li vyjmout odkaz z objektu schránky (po přetažení nebo
vložení), použijte místo serializované kopie režim přenosu originalOnly nebo originalPreferred.
var transferredObject:Object =
clipboard.getData("object", ClipboardTransferMode.ORIGINAL_ONLY);
Odkazy jsou platné, pouze pokud objekt Clipboard pochází z aktuální aplikace AIR. Prostřednictvím režimu přenosu
originalPreferred máte přístup k odkazu, je-li k dispozici, a k serializovanému klonu, pokud není k dispozici
odkaz.
Odložené vykreslení
Je-li vytváření formátu dat náročné na výpočet, můžete použít odložené vykreslení poskytnutím funkce, která dodává
data na vyžádání. Tato funkce se vyvolává, pouze pokud přijímač operace přetažení vyžaduje data v odloženém
formátu.
Funkce vykreslení se přidává do objektu Clipboard pomocí metody setDataHandler(). Funkce musí vracet data v
příslušném formátu. Vyvoláte-li například metodu setDataHandler(ClipboardFormat.TEXT_FORMAT,
writeText), tak funkce writeText() musí vrátit řetězec.
Je-li do objektu Clipboard přidán formát dat stejného typu pomocí metody setData(), data budou mít přednost před
odloženou verzí (funkce vykreslení nebude vyvolána). Funkce vykreslení může nebo nemusí být znovu vyvolána, jsouli podruhé použita stejná data schránky.
Poznámka: V systému Mac OS X se odložené vykreslení při používání standardních formátů schránky AIR nevyskytuje.
Funkce vykreslení je vyvolána okamžitě.
Vkládání textu pomocí funkce odloženého vykreslení
Následující příklad ukazuje, jak implementovat funkci odloženého vykreslení.
Po stisknutí tlačítka Kopírovat v příkladu vymaže aplikace systémovou schránku, aby se zajistilo, že po předchozích
operacích se schránkou v ní nezůstanou žádná data, dále vloží na schránku funkci renderData() s metodou
setDataHandler().
Jakmile je stisknuto tlačítko Vložit, aplikace vstoupí do schránky a nastaví cílový text. Protože textový formát dat na
schránce byl nastaven s funkcí a ne s řetězcem, schránka vyvolá funkci renderData() . Funkce renderData() vrátí
text ve zdrojovém textu, který je následně přiřazen k cílovému textu.
Všimněte si, že jestliže před stisknutím tlačítka Vložit text upravujete, úpravy se projeví ve vloženém textu, i když k
nim dojde až po stisknutí tlačítka pro kopírování. Je to z toho důvodu, že funkce vykreslení nekopíruje zdrojový text,
dokud nedojde ke stisknutí tlačítka. (Při použití odloženého vykreslení v reálné aplikaci možná budete chtít zdrojová
data uložit nebo nějakým způsobem zabezpečit, abyste se tomuto problému vyhnuli.)
package
{
import
import
import
import
import
flash.desktop.Clipboard;
flash.desktop.ClipboardFormats;
flash.events.MouseEvent;
public class DeferredRenderingExample extends Sprite
{
var sourceTxt:TextField;
var destinationTxt:TextField;
public function DeferredRenderingExample():void
{
sourceTxt = createTextField(10, 10, 210, 380, false);
addChild(sourceTxt);
sourceTxt.text = "Neque porro quisquam est qui dolorem "
+ "ipsum quia dolor sit amet, consectetur, adipisci velit."
destinationTxt = createTextField(330, 10, 210, 380, false);
addChild(destinationTxt);
var copyBtn:TextField = createTextField(230, 50, 90, 20, true);
copyBtn.text = "Copy";
addChild(copyBtn);
copyBtn.addEventListener(MouseEvent.CLICK, onCopy);
var pasteBtn:TextField = createTextField(230, 80, 90, 20, true);
pasteBtn.text = "Paste";
addChild(pasteBtn);
pasteBtn.addEventListener(MouseEvent.CLICK, onPaste);
}
private function createTextField(x:Number, y:Number,
width:Number, height:Number, isBtn:Boolean = false):TextField
{
var newTxt:TextField = new TextField();
newTxt.x = x;
newTxt.y = y;
newTxt.height = height;
newTxt.width = width;
newTxt.border = true;
newTxt.background = true;
if (isBtn)
{
newTxt.backgroundColor = 0xDDDDDDEE;
newTxt.selectable = false;
}
else
{
newTxt.multiline = true;
newTxt.wordWrap = true;
newTxt.backgroundColor = 0xEEEEEEEE;
}
return newTxt;
}
public function onCopy(event:MouseEvent):void
{
Clipboard.generalClipboard.clear();
Clipboard.generalClipboard.setDataHandler(ClipboardFormats.TEXT_FORMAT,
renderData);
}
public function onPaste(event:MouseEvent):void
{
destinationTxt.text =
Clipboard.generalClipboard.getData(ClipboardFormats.TEXT_FORMAT) as String;
}
public function renderData():String
{
trace("Rendering data");
var sourceStr:String = sourceTxt.text;
if (sourceTxt.selectionEndIndex > sourceTxt.selectionBeginIndex)
{
// something is selected
return sourceStr.substring(sourceTxt.selectionBeginIndex,
sourceTxt.selectionEndIndex);
}
else
{
return sourceStr;
}
}
}
}
148
Kapitola 17: Práce s bytovými poli
Třída ByteArray umožňuje čtení a zapisování do binárního streamu dat, což je v podstatě pole bytů. Pomocí této třídy
lze získat přístup k datům na nejzákladnější úrovni. Vzhledem k tomu, že počítačová data jsou složena z bytů neboli
skupin po 8 bitech, schopnost číst data v bytech znamená, že lze přistupovat k datům, pro něž neexistují třídy a metody
přístupu. Pomocí třídy ByteArray lze analyzovat jakýkoliv stream dat, od bitmapy až po stream dat přenášených po
síti, na úrovni bytu.
Pomocí metody writeObject() je možné zapsat objekt v serializovaném formátu AMF (Action Message Format) do
třídy ByteArray, zatímco pomocí metody readObject() lze načíst serializovaný objekt ze třídy ByteArray do
proměnné původního datového typu. Serializovat lze libovolný objekt kromě objektů zobrazení, což jsou objekty,
které lze umístit na seznam zobrazení. Serializované objekty je rovněž možné přiřadit zpět k instancím vlastní třídy,
pokud je vlastní třída k dispozici pro běhový modul. Po převedení objektu na AMF jej lze efektivně přenášet přes síťové
připojení nebo uložit do souboru.
Zde popsaná vzorová aplikace Adobe® AIR™ přečte soubor .zip jako příklad zpracování streamu dat, přičemž vyjme
seznam souborů obsažených v souboru .zip a zapíše je na plochu.
Čtení a zapisování do objektu ByteArray
Třída ByteArray je součástí balíčku flash.utils. Chcete-li v aplikaci ActionScript 3.0 vytvořit objekt ByteArray,
importujte třídu ByteArray a vyvolejte konstruktor, jak je znázorněno v následujícím příkladu.
import flash.utils.ByteArray;
var stream:ByteArray = new ByteArray();
Metody třídy ByteArray
Každý smysluplný datový stream je uspořádán do formátu, který lze analyzovat za účelem nalezení požadovaných
informací. Například záznam v jednoduchém souboru zaměstnance by pravděpodobně obsahoval číslo ID, jméno,
adresu, telefonní číslo atd. Zvukový soubor MP3 obsahuje tag ID3, který určuje název, autora, album, datum vydání a
žánr stahovaného souboru. Podle tohoto formátu lze zjistit pořadí, v němž je možné očekávat data v datovém streamu.
To umožňuje inteligentní čtení datového streamu.
Třída ByteArray zahrnuje několik metod usnadňujících čtení a zapisování do datového streamu. K těmto metodám
patří například readBytes() a writeBytes(), readInt() a writeInt(), readFloat() a writeFloat(),
readObject() a writeObject() nebo readUTFBytes() a writeUTFBytes(). Pomocí těchto metod lze načítat data
z datového streamu do proměnných určitých datových typů a zapisovat z určitých datových typů přímo do binárního
datového streamu.
Následující kód například načte jednoduché pole řetězců a čísel s plovoucí čárkou a zapíše každý element do objektu
ByteArray. Díky uspořádání pole může kód vyvolat příslušné metody třídy ByteArray (writeUTFBytes() a
writeFloat()) k zápisu dat. Opakující se datová struktura umožňuje čtení pole pomocí smyčky.
Práce s bytovými poli
// The following example reads a simple Array (groceries), made up of strings
// and floating-point numbers, and writes it to a ByteArray.
// define the grocery list Array
var groceries:Array = ["milk", 4.50, "soup", 1.79, "eggs", 3.19, "bread" , 2.35]
// define the ByteArray
// for each item in the array
for (var i:int = 0; i < groceries.length; i++) {
bytes.writeUTFBytes(groceries[i++]); //write the string and position to the next item
bytes.writeFloat(groceries[i]);// write the float
trace("bytes.position is: " + bytes.position);//display the position in ByteArray
}
trace("bytes length is: " + bytes.length);// display the length
Vlastnost position
Vlastnost position uloží aktuální polohu kurzoru, která indexuje objekt ByteArray během čtení nebo zapisování.
Počáteční hodnota vlastnosti position je nula (0), jak je znázorněno v následujícím kódu:
trace("bytes.position is initially: " + bytes.position); // 0
Při čtení a zapisování do objektu ByteArray použitá metoda aktualizuje vlastnost position, aby ukazovala na místo
bezprostředně následující po posledním přečteném nebo zapsaném bytu. Následující kód například zapíše do objektu
ByteArray řetězec a vlastnost position pak ukazuje na byt následující bezprostředně po řetězci v objektu ByteArray:
bytes.writeUTFBytes("Hello World!");
trace("bytes.position is now: " + bytes.position);// 12
Stejně tak operace čtení navyšuje vlastnost position počtem přečtených bytů.
bytes.writeUTFBytes("Hello World!");
trace("bytes.position is now: " + bytes.position);// 12
bytes.position = 0;
trace("The first 6 bytes are: " + (bytes.readUTFBytes(6)));//Hello
trace("And the next 6 bytes are: " + (bytes.readUTFBytes(6)));// World!
Všimněte si, že vlastnost position je možné nastavit na určité místo v objektu ByteArray, aby čtení nebo zapisování
začalo s tímto odsazením.
Vlastnosti bytesAvailable a length
Podle vlastností length a bytesAvailable poznáte, jak je objekt ByteArray dlouhý a kolik v něm zbývá bytů od
aktuální polohy do konce. Následující příklad ilustruje, jak lze tyto vlastnosti použít. V tomto příkladu se do objektu
ByteArray zapíše řetězec textu a potom se objekt ByteArray čte po jednotlivých bytech, dokud kód nenarazí na znak
„a“ nebo na konec (bytesAvailable <= 0).
var text:String = "Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Vivamus etc.";
bytes.writeUTFBytes(text); // write the text to the ByteArray
trace("The length of the ByteArray is: " + bytes.length);// 70
bytes.position = 0; // reset position
while (bytes.bytesAvailable > 0 && (bytes.readUTFBytes(1) != 'a')) {
//read to letter a or end of bytes
}
if (bytes.position < bytes.bytesAvailable) {
trace("Found the letter a; position is: " + bytes.position); // 23
trace("and the number of bytes available is: " + bytes.bytesAvailable);// 47
}
Vlastnost endian
Počítače mohou používat různé způsoby ukládání multibytových čísel, tedy čísel, jejichž uložení vyžaduje více než 1
byt paměti. Celé číslo může například zabrat 4 byty nebo 32 bytů paměti. Některé počítače ukládají na první místo (na
nejnižší adresu paměti) nejdůležitější byt čísla, jiné ukládají na první místo nejméně důležitý byt. Tento atribut
počítače neboli řazení bytů se označuje jako big endian (nejdůležitější byt na prvním místě) nebo little endian (nejméně
důležitý byt na prvním místě). Například číslo 0x31323334 by bylo v řazení bytů big endian a little endian uloženo
následujícím způsobem, kde a0 představuje nejnižší adresu paměti o velikosti 4 byty a a3 představuje nejvyšší adresu:
Big Endian
Big Endian
Big Endian
Big Endian
a0
a1
a2
a3
31
32
33
34
Little Endian
Little Endian
Little Endian
Little Endian
a0
a1
a2
a3
34
33
32
31
Pomocí vlastnosti endian třídy ByteArray lze označit toto pořadí bytů u zpracovávaných multibytových čísel.
Přijatelné hodnoty pro tuto vlastnost jsou buď "bigEndian", nebo "littleEndian" a třída Endian definuje
konstanty BIG_ENDIAN a LITTLE_ENDIAN pro nastavení vlastnosti endian pomocí těchto řetězců.
Metody compress() a uncompress()
Pomocí metody compress() lze komprimovat objekt ByteArray podle komprimačního algoritmu určeného jako
parametr. Pomocí metody uncompress() lze dekomprimovat zkomprimovaný objekt ByteArray podle
komprimačního algoritmu. Po vyvolání metod compress() a uncompress() se určí nová délka bytového pole a
vlastnost position se nastaví na konec.
Třída CompressionAlgorithm definuje konstanty, pomocí nichž lze určit komprimační algoritmus. Aplikace AIR
podporuje algoritmus deflate i zlib. Komprimační algoritmus deflate se používá u řady kompresních formátů, např.
zlib, gzip a u některých implementací zip. Formát komprimovaných dat zlib je popsán na adrese
http://www.ietf.org/rfc/rfc1950.txt a komprimační algoritmus deflate je popsán na adrese
http://www.ietf.org/rfc/rfc1951.txt.
Následující příklad ilustruje kompresi objektu ByteArray s názvem bytes pomocí algoritmu deflate:
bytes.compress(CompressionAlgorithm.DEFLATE);
Následující příklad ilustruje dekompresi zkomprimovaného objektu ByteArray pomocí algoritmu deflate:
bytes.uncompress(CompressionAlgorithm.DEFLATE);
Čtení a zapisování objektů
Metody readObject() a writeObject() přečtou a zapíší objekt do třídy ByteArray, zakódovaný v serializovaném
formátu AMF (Action Message Format). AMF je patentovaný protokol zpráv vytvořený společností Adobe, který se
používá v různých třídách aplikace ActionScript 3.0, včetně Netstream, NetConnection, NetStream, LocalConnection
a Shared Objects.
Jednobytová značka typu popisuje typ zakódovaných dat, jež následují. AMF používá následujících 13 datových typů:
value-type = undefined-marker | null-marker | false-marker | true-marker | integer-type |
double-type | string-type | xml-doc-type | date-type | array-type | object-type |
xml-type | byte-array-type
Zakódovaná data následující po značce typu, pokud značka nepředstavuje jedinou možnou hodnotu (např. nula, true
nebo false), kdy se nic dalšího nekóduje.
Existují dvě verze AMF: AMF0 a AMF3. AMF 0 podporuje posílání složitých objektů pomocí odkazu a povoluje
koncové body za účelem obnovení vztahů mezi objekty. AMF 3 vylepšuje AMF 0 o posílání řetězců a vlastností objektů
pomocí odkazu, kromě odkazů na objekty, a o podporu nových datových typů, jež byly zavedeny v aplikaci
ActionScript 3.0. Vlastnost ByteArray.objectEcoding určuje verzi AMF použitou ke kódování dat objektu. Třída
flash.net.ObjectEncoding definuje konstanty pro určení verze AMF: ObjectEncoding.AMF0 a
ObjectEncoding.AMF3.
import flash.filesystem.*;
// Label component must be in Library
import fl.controls.Label;
var myLabel:Label = new Label();
myLabel.move(150, 150);
myLabel.width = 200;
addChild(myLabel);
var myXML:XML =
<order>
<item id='1'>
<menuName>burger</menuName>
<price>3.95</price>
</item>
<item id='2'>
<menuName>fries</menuName>
<price>1.45</price>
</item>
</order>
// Write XML object to ByteArray
bytes.writeObject(myXML);
bytes.position = 0;//reset position to beginning
bytes.compress(CompressionAlgorithm.DEFLATE);// compress ByteArray
outFile("order", bytes);
myLabel.text = "Wrote order file to desktop!";
function outFile(fileName:String, data:ByteArray):void {
var outFile:File = File.desktopDirectory; // dest folder is desktop
outFile = outFile.resolvePath(fileName); // name of file to write
var outStream:FileStream = new FileStream();
// open output file stream in WRITE mode
outStream.open(outFile, FileMode.WRITE);
// write out the file
outStream.writeBytes(data, 0, data.length);
// close it
outStream.close();
}
Metoda readObject() načte objekt v serializovaném AMF ze třídy ByteArray a uloží jej do objektu určeného typu. V
následujícím příkladu se z plochy načte soubor order do třídy ByteArray (inBytes), dekomprimuje se a pomocí
metody readObject() se uloží do objektu XML orderXML. V příkladu se pomocí konstrukce smyčky for each() do
textové oblasti určené k zobrazení přidají jednotlivé uzly. V příkladu se rovněž zobrazí hodnota vlastnosti
objectEncoding spolu se záhlavím pro obsah souboru order.
// TextArea component must be in Library
import fl.controls.TextArea;
var inBytes:ByteArray = new ByteArray();
// define text area for displaying XML content
var myTxt:TextArea = new TextArea();
myTxt.width = 550;
myTxt.height = 400;
addChild(myTxt);
//display objectEncoding and file heading
myTxt.text = "Object encoding is: " + inBytes.objectEncoding + "\n\n" + "order file: \n\n";
readFile("order", inBytes);
inBytes.position = 0; // reset position to beginning
inBytes.uncompress(CompressionAlgorithm.DEFLATE);
inBytes.position = 0;//reset position to beginning
// read XML Object
var orderXML:XML = inBytes.readObject();
//for each node in orderXML
for each(var child:XML in orderXML) {
// append child node to text area
myTxt.text += child + "\n";
}
// read specified file into byte array
function readFile(fileName:String, data:ByteArray) {
var inFile:File = File.desktopDirectory; // source folder is desktop
inFile = inFile.resolvePath(fileName); // name of file to read
var inStream:FileStream = new FileStream();
inStream.open(inFile, FileMode.READ);
inStream.readBytes(data, 0, data.length);
inStream.close();
}
Příklad ByteArray: Čtení souboru .zip
Tento příklad ilustruje, jakým způsobem lze přečíst jednoduchý soubor .zip obsahující několik souborů různých typů.
Toho se docílí vyjmutím příslušných dat z metadat pro jednotlivé soubory, dekompresí jednotlivých souborů do třídy
ByteArray a zapsáním souboru na plochu.
Obecná struktura souboru .zip je založena na specifikaci vytvořené společností PKWARE Inc., která je udržována na
adrese http://www.pkware.com/documents/casestudies/APPNOTE.TXT. Na prvním místě se nachází záhlaví
souboru a data souboru pro první soubor v archivu .zip, po nichž následuje dvojice záhlaví-data souboru pro každý
další soubor. (Struktura záhlaví souboru bude popsána později.) Dále může soubor .zip zahrnovat záznam deskriptoru
dat (obvykle při vytvoření výstupního souboru .zip v paměti místo jeho uložení na disku). Pak může následovat
několik dalších elementů: záhlaví dekódování archivu, záznam dodatečných dat archivu, struktura ústředního
adresáře, záznam konce ústředního adresáře Zip64, lokalizátor konce ústředního adresáře Zip64 a záznam konce
ústředního adresáře.
Kód v tomto příkladu je napsán jen pro analýzu souborů zip neobsahujících složky a neočekává záznamy deskriptorů
dat. Ignoruje veškeré informace následující za posledními daty souboru.
Formát záhlaví souboru pro jednotlivé soubory je následující:
podpis záhlaví souboru
4 byty
vyžadovaná verze
2 byty
univerzální bitový příznak
2 byty
metoda komprese
2 byty (8=DEFLATE; 0=UNCOMPRESSED)
čas poslední úpravy souboru
2 byty
datum poslední úpravy souboru
2 byty
crc-32
4 byty
komprimovaná velikost
4 byty
nekomprimovaná velikost
4 byty
délka názvu souboru
2 byty
délka dodatečného pole
2 byty
název souboru
proměnná
dodatečné pole
proměnná
Za záhlavím souboru následují vlastní data souboru, jež mohou být v závislosti na příznaku metody komprese buď
komprimovaná, nebo nekomprimovaná. Hodnota příznaku je nula (0) pro nekomprimovaná data souboru, 8 pro data
komprimovaná pomocí algoritmu DEFLATE či jiná pro další komprimační algoritmy.
Uživatelské rozhraní pro tento příklad se skládá z popisu a textové oblasti (taFiles). Pro každý soubor, který bude v
souboru .zip nalezen, zadá aplikace do textové oblasti následující údaje: název souboru, komprimovaná velikost a
nekomprimovaná velikost.
Na začátku programu se provedou následující úlohy:
• Import požadovaných tříd
• Definice uživatelského rozhraní
import fl.controls.*;
//requires TextArea and Label components in the Library
var taFiles = new TextArea();
var output = new Label();
taFiles.setSize(320, 150);
taFiles.move(10, 30);
output.move(10, 10);
output.width = 150;
output.text = "Contents of HelloAir.zip";
addChild(taFiles);
addChild(output);
• Definice objektu ByteArray bytes
• Definice proměnných pro ukládání metadat ze záhlaví souboru
//
var
var
var
var
var
var
var
var
variables for reading fixed portion of file header
fileName:String = new String();
flNameLength:uint;
xfldLength:uint;
offset:uint;
compSize:uint;
uncompSize:uint;
compMethod:int;
signature:int;
• Definice objektů File (zfile) a FileStream (zStream) představujících soubor .zip a určení umístění souboru .zip,
z něhož se soubory vyjímají – soubor s názvem „HelloAIR.zip“ v adresáři plochy.
// File variables for accessing .zip file
var zfile:File = File.desktopDirectory.resolvePath("HelloAIR.zip");
var zStream:FileStream = new FileStream();
Program začne otevřením souboru .zip v režimu READ (čtení).
zStream.open(zfile, FileMode.READ);
Potom nastaví vlastnost endian objektu bytes na LITTLE_ENDIAN, což značí, že v pořadí bytů číselných polí je na
prvním místě uveden nejméně důležitý byt.
bytes.endian = Endian.LITTLE_ENDIAN;
Následně příkaz while() zahájí smyčku, která bude pokračovat tak dlouho, dokud aktuální poloha ve streamu
souborů nebude větší nebo rovna velikosti souboru.
while (zStream.position < zfile.size)
{
První příkaz ve smyčce načte prvních 30 bytů streamu souborů do objektu ByteArray bytes. Prvních 30 bytů tvoří část
záhlaví prvního souboru s pevnou šířkou.
// read fixed metadata portion of local file header
zStream.readBytes(bytes, 0, 30);
Potom kód načte z prvních bytů 30 bytového záhlaví celé číslo (signature). Definice formátu ZIP určuje, že podpis
pro každé záhlaví souboru je hexadecimální hodnota 0x04034b50. Pokud se podpis liší, znamená to, že se kód posunul
za souborovou část souboru .zip a že již neexistují žádné další soubory k vyjmutí. V takovém případě kód okamžitě
ukončí smyčku while místo toho, aby čekal na konec bytového pole.
bytes.position = 0;
signature = bytes.readInt();
// if no longer reading data files, quit
if (signature != 0x04034b50)
{
break;
}
Následující část kódu přečte byt záhlaví v poloze odsazení 8 a uloží tuto hodnotu do proměnné compMethod. Tento
byt obsahuje hodnotu značící metodu komprese, jež byla použita ke kompresi tohoto souboru. Je povoleno několik
metod komprese, v praxi však téměř všechny soubory .zip používají komprimační algoritmus DEFLATE. Pokud je
aktuální soubor zkomprimovaný pomocí komprese DEFLATE, má metoda compMethod hodnotu 8. Jestliže je soubor
nezkomprimovaný, má metoda compMethod hodnotu 0.
bytes.position = 8;
compMethod = bytes.readByte();
// store compression method (8 == Deflate)
Za prvními 30 byty následuje část záhlaví délky proměnné, která obsahuje název souboru a případně i dodatečné pole.
Velikost této části se uloží v proměnné offset. Tato velikost se vypočítá jako součet délky názvu souboru a délky
dodatečného pole, která se načte ze záhlaví v odsazení 26 a 28.
offset = 0;// stores length of variable portion of metadata
bytes.position = 26; // offset to file name length
flNameLength = bytes.readShort();// store file name
offset += flNameLength; // add length of file name
bytes.position = 28;// offset to extra field length
xfldLength = bytes.readShort();
offset += xfldLength;// add length of extra field
Potom program načte část záhlaví souboru délky proměnné, kde je vyznačen počet bytů uložených v proměnné
offset.
// read variable length bytes between fixed-length header and compressed file data
zStream.readBytes(bytes, 30, offset);
Program načte z části záhlaví délky proměnné název souboru a spolu s komprimovanou (v souboru zip) a
nezkomprimovanou (původní) velikostí souboru jej zobrazí v textové oblasti.
bytes.position = 30;
fileName = bytes.readUTFBytes(flNameLength); // read file name
taFiles.appendText(fileName + "\n"); // write file name to text area
bytes.position = 18;
compSize = bytes.readUnsignedInt(); // store size of compressed portion
taFiles.appendText("\tCompressed size is: " + compSize + '\n');
bytes.position = 22; // offset to uncompressed size
uncompSize = bytes.readUnsignedInt(); // store uncompressed size
taFiles.appendText("\tUncompressed size is: " + uncompSize + '\n');
V příkladu se načte zbytek souboru ze streamu souborů do objektu bytes v délce určené komprimovanou velikostí,
přičemž se přepíše záhlaví souboru v prvních 30 bytech. Komprimovaná velikost je přesná i v případě, že soubor není
zkomprimovaný, neboť v takovém případě se komprimovaná velikost rovná nekomprimované velikosti souboru.
// read compressed file to offset 0 of bytes; for uncompressed files
// the compressed and uncompressed size is the same
zStream.readBytes(bytes, 0, compSize);
Dále kód v příkladu dekomprimuje zkomprimovaný soubor a vyvolá funkci outfile(), která jej zapíše do streamu
výstupních souborů. Funkci outfile() se předá název souboru a bytové pole obsahující data souboru.
if (compMethod == 8) // if file is compressed, uncompress
{
bytes.uncompress(CompressionAlgorithm.DEFLATE);
}
outFile(fileName, bytes);
// call outFile() to write out the file
Koncová složená závorka značí konec smyčky while a kódu aplikace, kromě metody outFile(). Provádění se vrátí
zpět na začátek smyčky while a bude pokračovat ve zpracování následujících bytů v souboru .zip – buď se vyjme další
soubor, nebo se zpracování souboru .zip ukončí, pokud již byl poslední soubor zpracován.
} // end of while loop
Funkce outfile() otevře výstupní soubor na ploše v režimu WRITE (zápis) a přiřadí mu název určený parametrem
filename. Potom zapíše data z parametru data do streamu výstupních souborů (outStream) a soubor zavře.
function outFile(fileName:String, data:ByteArray):void
{
var outFile:File = File.desktopDirectory; // destination folder is desktop
outFile = outFile.resolvePath(fileName); // name of file to write
var outStream:FileStream = new FileStream();
// open output file stream in WRITE mode
outStream.open(outFile, FileMode.WRITE);
// write out the file
outStream.writeBytes(data, 0, data.length);
// close it
outStream.close();
}
157
Kapitola 18: Práce s lokálními databázemi
SQL
Program Adobe AIR zahrnuje možnost vytvoření lokálních databází SQL a práce s nimi. Runtime zahrnuje modul
databáze SQL umožňující podporu mnoha standardních funkcí SQL, pomocí systému databáze otevřeného zdroje
SQLite. Lokální databáze SQL lze použít pro ukládání místních trvalých dat. Lze je například použít pro data aplikace,
uživatelské nastavení aplikace, dokumenty a jiné další typy dat, které chcete aplikací místně uložit.
Další online dostupné informace o lokálních databázích
SQL
Více informací o práci s lokálními databázemi SQL naleznete v těchto zdrojích:
Rychlý začátek (Připojení pro vývojáře Adobe AIR)
• SQLCollationType
• SQLColumnNameStyle
• SQLColumnSchema
• SQLConnection
• SQLError
• SQLErrorEvent
• SQLErrorOperation
• SQLEvent
• SQLIndexSchema
• SQLMode
• SQLResult
• SQLSchema
• SQLSchemaResult
• SQLStatement
• SQLTableSchema
• SQLTransactionLockType
• SQLTriggerSchema
• SQLUpdateEvent
• SQLViewSchema
Práce s lokálními databázemi SQL
Články a Ukázky aplikace Adobe Developer Connection
• Adobe AIR Developer Connection AIR pro Flash (hledejte výraz ‚AIR SQL )
O lokálních databázích SQL
Program Adobe AIR zahrnuje modul vztahové databáze vycházející z SQL, který je spuštěn v době běhu, s daty lokálně
umístěnými v souborech databáze na počítači, na kterém je spuštěna aplikace AIR (například na pevném disku
počítače). Protože databáze běží a datové soubory jsou uloženy lokálně, může být databáze použita aplikací AIR bez
ohledu na to, zda je dostupné síťové připojení. Proto modul lokální databáze SQL doby běhu poskytuje výhodný
mechanismus pro ukládání trvalých lokálních dat aplikace, zvláště pokud máte zkušenosti s databázemi SQL a
vztahovými databázemi.
Použití lokálních databází SQL
Funkce lokálních databází SQL programu AIR lze použít za jakýmkoliv účelem. Můžete si tedy přát uchovat data
aplikací na místním počítači uživatele. Program Adobe AIR obsahuje několik mechanismů pro lokální ukládání dat.
Každý z těchto mechanismů má různé výhody. Následují možná použití lokální databáze SQL ve vaší aplikaci AIR:
• Pro aplikace orientované na data (například adresář) lze databázi použít k ukládání hlavních dat aplikace.
• Pro aplikace orientované na dokumenty, kde mohou uživatelé vytvářet dokumenty k uložení a možnému sdílení,
by měl být každý dokument uložen jako soubor databáze, a to v uživatelem určeném umístění. (Nicméně
upozorňujeme, že jakákoliv aplikace AIR by byla schopná otevřít soubor databáze, takže pro potenciálně citlivé
dokumenty doporučujeme použít samostatný mechanismus kódování.)
• Pro aplikaci detekující síť lze databázi použít k ukládání lokální vyrovnávací paměti dat aplikace nebo k dočasnému
ukládání dat, pokud připojení k síti není dostupné. Pro synchronizaci lokální databáze s ukládáním dat na síti lze
vytvořit mechanismus.
• Databázi lze v libovolné aplikaci použít pro uložení jednotlivých uživatelských nastavení aplikace, například voleb
uživatele nebo informací aplikace, jako je velikost a poloha okna.
O databázích programu AIR a souborech databáze
Jednotlivé lokální databáze SQL programu Adobe AIR jsou uloženy jako jediný soubor v systému souborů počítače.
Runtime zahrnuje modul SQL databáze, který ovládá vytváření a strukturování souborů databáze a jejich manipulaci
a načítání dat ze souboru databáze. Runtime neurčuje jak nebo kde jsou data databáze uložena v systému souborů;
každá databáze je spíše uložena kompletně v jediném souboru. Umístění v systému souborů, kde je soubor databáze
uložen, lze určit. Jediná databáze AIR může získat přístup k jedné nebo více samostatným databázím (tj. samostatným
souborům databáze). Protože runtime uloží každou databázi jako jediný soubor v systému souborů, databázi můžete
umístit dle své potřeby díky provedení své aplikace a omezení přístupu souborů operačního systému. Každý uživatel
může mít samostatný soubor databáze pro svá specifická data, nebo soubor databáze může být přístupný všem
uživatelům aplikace na jediném počítači pro sdílená data. Protože jsou data ve vztahu k jednomu počítači lokální,
nejsou automaticky sdílena mezi uživateli na odlišných počítačích. Modul lokální databáze SQL neposkytuje žádnou
možnost spuštění příkazů SQL oproti vzdálené nebo ze serveru vycházející databáze.
O vztahových databázích
Vztahová databáze je mechanismus pro ukládání (a načítání) dat na počítači. Data jsou organizována do tabulek: řádky
představují záznamy nebo položky a sloupce (někdy nazývané „pole“) rozdělují každý záznam do jednotlivých hodnot.
Aplikace adresáře by mohla například obsahovat tabulku „přátelé“. Každý řádek v tabulce by představoval jednoho
přítele uloženého v databázi. Sloupce tabulky by představovaly data, například jméno, příjmení, datum narození, atd.
Pro každý řádek přítele v tabulce uchovává databáze pro každý sloupec samostatnou hodnotu.
Vztahové databáze jsou navrženy k ukládání komplexních dat, kde je jedna položka přiřazena k položce jiného typu,
nebo s ní souvisí. Ve vztahové databázi by měla být jakákoliv data, která mají vztah „jeden k mnoha“—kde se může
jeden záznam vztahovat k několika záznamům různého typu—rozdělena do odlišných tabulek. Předpokládejme
například, že si přejete, aby vaše aplikace adresáře uložila pro každého přítele několik telefonních čísel; to je vztah
„jeden k mnoha“. Tabulka „přátelé“ by pro každého přítele obsahovala všechny osobní informace. Samostatná tabulka
„telefonní čísla“ by obsahovala všechna telefonní čísla pro všechny přátele.
Mimo ukládání dat o přátelích a telefonních číslech by každá tabulka potřebovala určitou informaci pro sledování
vztahu mezi dvěma tabulkami—pro spárování záznamů jednotlivých přátel s jejich telefonními čísly. Tato data jsou
známá jako primární klíč—jedinečný identifikátor, který odlišuje každý řádek v tabulce od jiných řádků dané tabulky.
Primární klíč může být „přirozený klíč“, to znamená jedna z položek dat, která přirozeně rozlišují každý záznam v
tabulce. Pokud v tabulce „přátelé“ víte, že nikdo z vašich přátel nesdílí datum narození, mohli byste použít sloupec data
narození jako primární klíč (přirozený klíč) tabulky „přátelé“. Jestliže žádný přirozený klíč neexistuje, mohli byste
vytvořit samostatný sloupec, například „ID přítele“ —umělou hodnotu, kterou aplikace používá pro odlišení řádků.
Pomocí primárního klíče můžete nastavit vztahy mezi více tabulkami. Předpokládejme například, že tabulka „přátelé“
má sloupec „ID přítele“, který pro každý řádek (každého přítele) obsahuje jedinečné číslo. Související tabulku
„telefonní čísla“ lze strukturovat se dvěma sloupci:jeden s „ID přítelem“ přítele, ke kterému dané telefonní číslo patří
a jeden se samotným telefonním číslem. Tím lze bez ohledu na počet telefonních čísel, která jednotliví přátelé mají,
uložit všechna čísla v tabulce „telefonní čísla“ a lze je propojit s příslušnými přáteli pomocí primárního klíče „ID
přítele“. Když je primární klíč z jedné tabulky použit v související tabulce k určení propojení mezi záznamy, je hodnota
v související tabulce známá jako cizí klíč. Na rozdíl od mnoha databází vám modul lokální databáze AIR neumožňuje
vytvořit vazby cizího klíče, které automaticky zkontrolují, že hodnotě vloženého nebo aktualizovaného cizího klíče
odpovídá řádek v tabulce primárního klíče. Vztahy cizího klíče jsou nicméně důležitou částí struktury vztahové
databáze a tyto cizí klíče byste ve své databázi měli použit při vytváření vztahů mezi tabulkami.
O SQL
Structured Query Language (SQL-jazyk strukturovaného dotazu) se u vztahových databází používá k manipulaci a
načítání dat. SQL je spíše než procedurální jazyk jazyk deskriptivní. Namísto zadání počítači omezení způsobu načtení
dat popisuje příkaz SQL množinu dat, kterou požadujete. Modul databáze určuje způsob načtení daných dat.
Jazyk SQL byl standardizován institutem American National Standards Institute (ANSI). Lokální databáze SQL
programu Adobe AIR poporují většinu standardu SQL-92. Specifické popisy jazyka SQL podporovaného v programu
Adobe AIR naleznete v příloze „SQL podpora v lokálních databázích“ v Referenční příručce jazyka ActionScript 3.0 a
jeho komponent.
O třídách databází SQL
Pro práci s lokálními databázemi SQL v jazyce ActionScript 3.0 použijte instance těchto tříd v balíku flash.data:
Třída
Popis
flash.data.SQLConnection
Poskytuje prostředky pro vytváření a otevírání databází (souborů databáze) i metody pro provádění operací
na úrovni databáze a pro ovládání transakcí databáze.
flash.data.SQLStatement
Představuje jediný příkaz SQL (jediný dotaz nebo příkaz), který je na databázi spuštěn, včetně definice textu
příkazu a nastavení hodnot parametru.
flash.data.SQLResult
Poskytuje způsob získávání informací o spuštění příkazu nebo o výsledcích spuštění příkazu, například
výsledné řádky z příkazu SELECT, počet řádků ovlivněných příkazem UPDATE nebo DELETE, atd.
K získání informací popisujících strukturu databáze použijete tyto třídy v balíku flash.data:
Třída
flash.data.SQLSchemaResult
Popis
Slouží jako kontejner pro schéma výsledků databáze vytvořených voláním metody
SQLConnection.loadSchema().
flash.data.SQLTableSchema
Poskytuje informace popisující jedinou tabulku v databázi.
flash.data.SQLViewSchema
Poskytuje informace popisující jediný náhled v databázi.
flash.data.SQLIndexSchema
Poskytuje informace popisující jediný sloupec tabulky nebo náhled v databázi.
flash.data.SQLTriggerSchema Poskytuje informace popisující jediný spouštěč v databázi.
Jiné třídy v balíku flash.data poskytují konstanty, které jsou používány s třídou SQLConnection a třídou
SQLColumnSchema:
Třída
Popis
flash.data.SQLMode
Definuje množinu konstant představující možné hodnoty pro parametr openMode metod
SQLConnection.open() a SQLConnection.openAsync().
flash.data.SQLColumnNameStyle
Definuje množinu konstant představující možné hodnoty pro vlastnost
SQLConnection.columnNameStyle.
flash.data.SQLTransactionLockType
Definuje množinu konstant představující možné hodnoty pro parametr volby metody
SQLConnection.begin().
flash.data.SQLCollationType
Definuje množinu konstant představující možné hodnoty pro vlastnost
SQLColumnSchema.defaultCollationType a parametr defaultCollationType
konstruktoru SQLColumnSchema().
Mimo to následující třídy v balíku flash.events představují události (a podpůrné konstanty), které používáte:
Třída
Popis
flash.data.SQLEvent
Definuje události, které instance SQLConnection nebo SQLStatement odešle, pokud se jakékoliv z jejích
operací úspěšně dokončí. Každá operace má přiřazenou konstantu typu události, která je definovaná ve třídě
SQLEvent.
flash.data.SQLErrorEvent
Definuje událost, kterou instance SQLConnection nebo SQLStatement odešle, pokud jakékoliv z jejích operací
vygeneruje chybu.
flash.data.SQLUpdateEvent
Definuje událost, kterou instance SQLConnection odešle, když se data tabulky z jedné z jejích připojených
databází po provedení příkazu SQL INSERT, UPDATEneboDELETE změní.
Následující třídy v balíku flash.errors poskytují informace o chybách operací databáze.
Třída
Popis
flash.data.SQLError
Poskytuje informace o chybách operací databáze včetně operace, u které došlo k pokusu o přístup, a příčiny
chyby.
flash.data.SQLErrorEvent
Definuje množinu konstant představující možné hodnoty vlastnosti třídy SQLErroroperationoznačující
operaci databáze, která vygenerovala chybu.
O synchronním a asynchronním režimu spuštění
Při zápisu kódu, který bude pracovat s lokální databází SQL, určíte, že operace databáze se spustí v jednom ze dvou
režimů spuštění: asynchronním nebo synchronním režimu spuštění. Ukázky kódů obecně ukazují způsob provedení
každé operace dvěma způsoby, takže můžete použít ukázku, která je pro vaše potřeby nejvhodnější.
V asynchronním režimu spuštění dáte runtime pokyn a runtime odešle při dokončení vámi požadované operace, nebo
pokud tato operace selže, událost. Nejprve sdělíte modulu databáze, aby provedl operaci. Modul databáze pracuje na
pozadí, zatímco aplikace stále běží. Nakonec po dokončení operace (nebo pokud operace selže) modul databáze odešle
událost. Váš kód, spuštěný událostí, provede následující operace. Tento přístup má významnou výhodu: runtime
provede operace databáze na pozadí, zatímco hlavní kód aplikace je dále prováděn. Jestliže operace databáze trvá
výrazně dlouho, aplikace i nadále běží. Co je nejdůležitější, uživatel může i nadále pracovat s aplikací, bez zamrznutí
obrazovky. Kód asynchronní operace může být nicméně složitější pro zápis než jiný kód. Tato složitost je obvyklá v
případech, kdy musí být více závislých operací rozděleno mezi různé metody poslouchače události.
Koncepčně je jednodušší kódovat operace jako jedinou sekvenci kroků—sadu synchronních operací—spíše než sadu
operací rozdělených do několika metod poslouchače události. Vedle asynchronních operací databáze vám program
Adobe AIR také umožňuje spustit operace databáze synchronně. V synchronním režimu spuštění neběží operace na
pozadí. Namísto toho běží ve stejné sekvenci spuštění jako všechny ostatní kódy aplikace. Sdělíte modulu databáze,
aby provedl operaci. Kód se poté v daném bodu zastaví, zatímco modul databáze pracuje. Po dokončení operace
pokračuje provádění s dalším řádkem vašeho kódu.
Asynchronní nebo synchronní spuštění se nastavuje na úrovni SQLConnection. Pomocí jediného připojení databáze
nemůžete spustit některé operace nebo příkazy synchronně a jiné asynchronně. To, zda SQLConnection pracuje v
synchronním nebo asynchronním režimu spuštění, určíte voláním metody SQLConnection pro otevření databáze.
Jestliže voláte SQLConnection.open(), připojení probíhá v synchronním režimu spuštění, a jestliže voláte
SQLConnection.openAsync(), dojde k připojení v asynchronním režimu. Jakmile je instance SQLConnection
připojena k databázi pomocí open() nebo openAsync(), je nastavena na synchronní nebo asynchronní režim
spuštění, pokud neuzavřete a znovu neotevřete připojení k databázi.
Každý režim spuštění má své výhody. Zatímco je většina aspektů každého režimu podobná, existují určité rozdíly,
které je vhodné si při práci s daným režimem zapamatovat. Více informací o těchto tématech a návrhy pro práci v
každém režimu naleznete v tématu „Použití synchronních a asynchronních operací databáze“ na stránce 181.
Vytváření a úpravy databáze
Před tím, než může vaše aplikace přidat nebo načíst data, musí existovat databáze s tabulkami, které jsou v ní
definované, a ke kterým může daná aplikace získat přístup. Zde jsou popsány úlohy vytvoření databáze a vytvoření
datové struktury uvnitř databáze. I když se tyto úlohy používají méně častěji než vkládání a načítání dat, jsou pro
většinu aplikací nezbytné.
Vytváření databáze
Pro vytvoření souboru databáze nejprve vytvořte instanci SQLConnection. Voláním metody open() instanci otevřete
v synchronním režimu spuštění a voláním metody openAsync() ji otevřete v asynchronním režimu. Metody open()
a openAsync() se používají k otevření připojení k databázi. Jestliže předáte instanci File, která odkazuje na neexistující
umístění souboru pro parametr reference (první parametr), metoda open() nebo openAsync() vytvoří soubor
databáze v daném umístění souboru a otevře připojení k nově vytvořené databázi.
Ať pro vytvoření databáze voláte metodu open() nebo metodu openAsync(), název souboru databáze může být
jakýkoli platný název souboru s libovolnou příponou souboru. Jestliže voláte metodu open() nebo openAsync() s
hodnotou null pro parametr reference, vytvoří se spíše nová databáze v paměti než soubor databáze na disku.
Následující příklad kódu ukazuje proces vytvoření souboru databáze (nová databáze) pomocí asynchronního režimu
spuštění. V tomto případě je soubor databáze uložen v adresáři uložení aplikace s názvem „DBSample.db“:
import flash.data.SQLConnection;
import flash.events.SQLErrorEvent;
import flash.events.SQLEvent;
var conn:SQLConnection = new SQLConnection();
conn.addEventListener(SQLEvent.OPEN, openHandler);
conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
var dbFile:File = File.applicationStorageDirectory.resolvePath("DBSample.db");
conn.openAsync(dbFile);
function openHandler(event:SQLEvent):void
{
trace("the database was created successfully");
}
function errorHandler(event:SQLErrorEvent):void
{
trace("Error message:", event.error.message);
trace("Details:", event.error.details);
}
Pro synchronní provedení operací volejte při otevření připojení databáze pomocí instance SQLConnection metodu
open(). Následující příklad ukazuje způsob vytvoření a otevření instance SQLConnection, která své operace spustí
synchronně:
try
{
conn.open(dbFile);
trace("the database was created successfully");
}
catch (error:SQLError)
{
trace("Error message:", error.message);
trace("Details:", error.details);
}
Vytváření tabulek databáze
Vytvoření tabulky v databázi zahrnuje spuštění příkazu SQL na dané databázi, pomocí stejného procesu, který můžete
použít pro spuštění příkazu SQL, například SELECT, INSERT, atd. Pro vytvoření tabulky použijte příkaz CREATE
TABLE, který zahrnuje definice sloupců a vazeb pro novou tabulku. Více informací o spuštění příkazů SQL naleznete
v části „Práce s příkazy SQL“ na stránce 166.
Následující příklad ukazuje vytvoření tabulky pojmenované „zaměstnanci“ v existujícím souboru databáze, pomocí
asynchronního režimu spuštění. Upozorňujeme, že tento kód předpokládá existenci instance SQLConnection
pojmenované conn, která je již konkretizovaná a je již připojena k databázi.
import flash.data.SQLStatement;
// ... create and open the SQLConnection instance named conn ...
var createStmt:SQLStatement = new SQLStatement();
createStmt.sqlConnection = conn;
var sql:String =
"CREATE TABLE IF NOT EXISTS employees (" +
"
empId INTEGER PRIMARY KEY AUTOINCREMENT, " +
"
firstName TEXT, " +
"
lastName TEXT, " +
"
salary NUMERIC CHECK (salary > 0)" +
")";
createStmt.text = sql;
createStmt.addEventListener(SQLEvent.RESULT, createResult);
createStmt.addEventListener(SQLErrorEvent.ERROR, createError);
createStmt.execute();
function createResult(event:SQLEvent):void
{
trace("Table created");
}
function createError(event:SQLErrorEvent):void
{
}
Následující příklad ukazuje způsob vytvoření tabulky pojmenované „zaměstnanci“ v existujícím souboru databáze,
pomocí synchronního režimu spuštění. Upozorňujeme, že tento kód předpokládá existenci instance SQLConnection
pojmenované conn, která je již konkretizovaná a je již připojena k databázi.
var createStmt:SQLStatement = new SQLStatement();
createStmt.sqlConnection = conn;
var sql:String =
"CREATE TABLE IF NOT EXISTS employees (" +
"
empId INTEGER PRIMARY KEY AUTOINCREMENT, " +
"
firstName TEXT, " +
"
lastName TEXT, " +
"
salary NUMERIC CHECK (salary > 0)" +
")";
createStmt.text = sql;
try
{
createStmt.execute();
trace("Table created");
}
{
}
Manipulace s daty databází SQL
Existují určité běžné úlohy, které při práci s lokálními databázemi SQL provedete. Tyto úlohy zahrnují připojení k
databázi, přidání dat a načtení dat z tabulek v databázi. Během provádění těchto úloh, například při práci s datovými
typy a zpracovávání chyb, je dobré pamatovat na několik aspektů.
Všimněte si, že existuje také několik úloh databází, se kterými přijdete do styku méně častěji, ale bude je často třeba
provést před provedením těchto běžnějších úloh. Například před připojením k databázi a načtením dat z tabulky
budete potřebovat vytvořit databázi a v tabulkách vytvořit tabulkovou strukturu. Tyto méně časté úlohy počátečního
nastavení jsou vysvětleny v části „Vytváření a úpravy databáze“ na stránce 161.
Můžete si zvolit asynchronní provedení operací databáze, což znamená, že modul databáze běží na pozadí a úspěšné
dokončení operace, nebo naopak její selhání, vám oznámí odesláním události. Tyto operace můžete také provést
synchronně. V tomto případě jsou operace databáze provedeny postupně a celá aplikace (včetně aktualizacích na
obrazovce) před spuštěním dalšího kódu počká na dokončení operací. Příklady v této části ukazují způsob provedení
operací asynchronně i synchronně. Více informací o práci v asynchronním nebo synchronním režimu spuštění
naleznete v části „Použití synchronních a asynchronních operací databáze“ na stránce 181.
Připojení k databázi
Před tím, než můžete provést jakoukoliv operaci databáze, je třeba nejprve otevřít připojení k souboru databáze.
Instance SQLConnection se používá k reprezentaci připojení k jedné nebo více databázím. První databáze, která je
připojena pomocí instance SQLConnection, je známá jako „hlavní“ databáze. Tato databáze je připojena pomocí
metody open() (pro synchronní režim spuštění) nebo metody openAsync() (pro asynchronní režim spuštění).
Jestliže otevřete databázi pomocí asynchronní operace openAsync(), zaregistrujte se pro událost instance
SQLConnectionopen, abyste věděli, kdy se operace openAsync() dokončí. Zaregistrujte se pro událost instance
SQLConnection error, abyste určili případné selhání operace.
Následující příklad ukazuje způsob otevření stávajícího souboru databáze pro asynchronní spuštění. Soubor databáze
je pojmenován „DBSample.db“ a je umístěn v adresáři pro ukládání aplikace uživatele.
import flash.data.SQLMode;
conn.addEventListener(SQLEvent.OPEN, openHandler);
conn.addEventListener(SQLErrorEvent.ERROR, errorHandler);
conn.openAsync(dbFile, SQLMode.UPDATE);
function openHandler(event:SQLEvent):void
{
trace("the database opened successfully");
}
{
}
Následující příklad ukazuje způsob otevření stávajícího souboru databáze pro synchronní spuštění. Soubor databáze
je pojmenován „DBSample.db“ a je umístěn v adresáři pro ukládání aplikace uživatele.
import flash.data.SQLMode;
try
{
conn.open(dbFile, SQLMode.UPDATE);
trace("the database opened successfully");
}
{
}
Všimněte si, že ve volání metody openAsync() v asynchronním příkladu a volání metody open() v synchronním
příkladu, je druhý argument konstanta SQLMode.UPDATE. Určení SQLMode.UPDATE pro druhý parametr (openMode)
způsobí, že runtime odešle chybu, jestliže určený soubor neexistuje. Jestliže předáte SQLMode.CREATE pro parametr
openMode (nebo jestliže vynecháte parametr openMode), runtime se pokusí vytvořit soubor databáze, jestliže určení
soubor neexistuje. Můžete také určit SQLMode.READ pro parametr openMode k otevření stávající databáze v režimu
určenému pouze ke čtení. V tomto případě lze data z databáze načíst, ale žádná data nelze přidat, smazat nebo změnit.
Práce s příkazy SQL
Jednotlivý příkaz SQL (dotaz nebo příkaz) je znázorněn v runtime jako objekt SQLStatement. Pro vytvoření a spuštění
příkazu SQL postupuje dle těchto kroků:
Vytvořte instanci SQLStatement.
Objekt SQLStatement představuje příkaz SQL ve vaší aplikaci.
var selectData:SQLStatement = new SQLStatement();
Určete, oproti které databázi dotaz běží.
Pro toto určení nastavte vlastnost objektu SQLStatement sqlConnection na instanci SQLConnection, která je
připojena k požadované databázi.
// A SQLConnection named "conn" has been created previously
selectData.sqlConnection = conn;
Určete vlastní příkaz SQL.
Vytvořte text příkazu jako řetězec a přiřaďte jej k vlastnosti instance SQLStatement text.
selectData.text = "SELECT col1, col2 FROM my_table WHERE col1 = :param1";
Definujte funkce, které zpracují výsledek operace spuštění (pouze v režimu asynchronního spuštění).
Pomocí metody addEventListener() zaregistrujte funkce jako posluchače událostí instanceresult a error.
// using listener methods and addEventListener();
selectData.addEventListener(SQLEvent.RESULT, resultHandler);
selectData.addEventListener(SQLErrorEvent.ERROR, errorHandler);
function resultHandler(event:SQLEvent):void
{
// do something after the statement execution succeeds
}
{
// do something after the statement execution fails
}
Metody posluchače můžete také určit pomocí objektu Responder. V tomto příkladě vytvořte instanci Responder a
připojte k ní metody posluchače.
// using a Responder (flash.net.Responder)
var selectResponder = new Responder(onResult, onError);
function onResult(result:SQLResult):void
{
// do something after the statement execution succeeds
}
function onError(error:SQLError):void
{
// do something after the statement execution fails
}
Jestliže text příkazu zahrnuje definice parametrů, přiřaďte těmto parametrům hodnoty.
Pro přiřazení hodnot parametrů použijte vlastnost asociativního pole instance SQLStatement parameters.
selectData.parameters[":param1"] = 25;
Spuštění příkazu SQL
Volání metody instance SQLStatementexecute().
// using synchronous execution mode
// or listener methods in asynchronous execution mode
selectData.execute();
Pokud používáte třídu Responder namísto posluchačů události v asynchronním režimu spuštění, předejte instanci
Responder metodě execute().
// using a Responder in asynchronous execution mode
selectData.execute(-1, selectResponder);
Specifické příklady, které tyto kroky ukazují, naleznete v následujících tématech:
„Načítání dat z databáze“ na stránce 169
„Vkládání dat“ na stránce 174
„Změna nebo mazání dat“ na stránce 177
Používání parametrů v příkazech
Parametr příkazu SQL vám umožňuje vytvořit příkaz SQL, který lze použít opakovaně. Při používání parametrů
příkazu se mohou hodnoty uvnitř příkazu změnit (například hodnoty přidané v příkazu INSERT), ale základní text
příkazu zůstává nezměněn. Tím získáte lepší výkon a i kódování aplikace bude snazší.
Chápání parametrů příkazu
Aplikace často používá jediný příkaz SQL několikrát, s menší odchylkou. Vezměme například aplikaci sledující
inventář, kde uživatel může přidat nové položky inventáře do databáze. Kód aplikace, který přidá položku inventáře
do databáze, spustí příkaz SQL INSERT, který vlastně přidá data do databáze. Při každém provedení příkazu nicméně
dojde k menší odchylce. Zvláště skutečné hodnoty vložené do tabulky se liší, protože jsou specifické pro přidávanou
položku inventáře.
U příkazů SQL, který je použit několikrát s několika hodnotami v příkaze, nejlepším přístupem je použít příkaz SQL,
který zahrnuje parametry spíše než hodnoty literálu v textu SQL. Parametr je vyhrazené místo v textu příkazu, které je
při každém spuštění příkazu nahrazeno skutečnou hodnotou. Pro použití parametrů v příkazu SQL vytvořte jako
obvykle instanci SQLStatement. Pro skutečný vlastní SQL přiřazený k vlastnosti text použijte vyhrazené místo
parametru spíše než hodnoty literálů. Poté definujte hodnotu pro každý parametr nastavením hodnoty elementu ve
vlastnosti instance SQLStatement parameters. Vlastnost parametrů je asociativní pole, takže určitou hodnotu
nastavíte pomocí následující syntaxe:
statement.parameters[parameter_identifier] = value;
parameter_identifier je řetězec, pokud používáte pojmenovaný parametr nebo index celého čísla, jestliže používáte
nepojmenovaný parametr.
Používání pojmenovaných parametrů
Parametr může být pojmenovaným parametrem. Pojmenovaný parametr má určitý název, který databáze používá pro
spárování hodnoty parametru s jejím vyhrazeným místem v textu příkazu. Název parametru se skládá ze znaků „:“
nebo „@“ následovaným názvem, viz následující příklad:
:itemName
@firstName
Následující příklad kódu ukazuje použití pojmenovaných parametrů:
var sql:String =
"INSERT INTO inventoryItems (name, productCode)" +
"VALUES (:name, :productCode)";
var addItemStmt:SQLStatement = new SQLStatement();
addItemStmt.sqlConnection = conn;
addItemStmt.text = sql;
// set parameter values
addItemStmt.parameters[":name"] = "Item name";
addItemStmt.parameters[":productCode"] = "12345";
addItemStmt.execute();
Používání nepojmenovaných parametrů
Jako alternativu použití pojmenovaného parametru můžete také použít nepojmenované parametry. Pro použití
nepojmenovaného parametru označíte parametr v příkazu SQL pomocí znaku „?“ znak. Každému parametru je
přiřazen numerický index, podle pořadí parametrů v příkazu, které začíná indexem 0 pro první parametr. Následující
příklad ukazuje verzi předchozího příkladu pomocí nepojmenovaných parametrů:
var sql:String =
"INSERT INTO inventoryItems (name, productCode)" +
"VALUES (?, ?)";
var addItemStmt:SQLStatement = new SQLStatement();
addItemStmt.sqlConnection = conn;
addItemStmt.text = sql;
addItemStmt.parameters[0] = "Item name";
addItemStmt.parameters[1] = "12345";
addItemStmt.execute();
Výhody používání parametrů
Používání parametrů v příkazu SQL poskytuje následující výhody:
Vyšší výkon Instance SQLStatement používající parametry může mít o mnoho vyšší výkon v porovnání s instancí, která
dynamicky vytvoří text SQL při každém spuštění. Důvodem vyššího výkonu je to, že je příkaz proveden jednou a může
být poté proveden několikrát použitím hodnot odlišného parametru, bez potřeby znovu kompilovat příkaz SQL.
Explicitní typování dat Parametry jsou používány pro umožnění typovaného nahrazení hodnot, které jsou neznámé v
době vytváření příkazu SQL. Použití parametrů je jediný způsob, jak zaručit třídu ukládání hodnoty, předané do
databáze. Nejsou-li používány parametry, runtime se pokusí převést všechny hodnoty z jejich textového znázornění
na třídu uložení, a to na základě podobnosti přiřazeného typu sloupce. Více informace o kategoriích ukládání a
podobnosti sloupců naleznete v části „Podpora datového typu“ v příloze „SQL podpora v lokálních databázích “ v
Referenční příručce jazyka ActionScript 3.0 a jeho komponent .
Větší zabezpečení Používání parametrů vám pomůže zabránit problémové technice známé jako vnucení SQL. Při
vnucení SQL zadá uživatel kód SQL do jemu přístupnému umístění (například do pole pro zadání dat). Pokud vytváří
aplikační kód příkaz SQL přímo zřetězením vstupu uživatele do textu SQL, bude kód SQL zadaný uživatelem proveden
na databázi. Následuje příklad spojení vstupu uživatele do textu SQL. Tuto techniku nepoužívejte:
// assume the variables "username" and "password"
// contain user-entered data
var sql:String =
"SELECT userId " +
"FROM users " +
"WHERE username = '" + username + "' " +
"
AND password = '" + password + "'";
var statement:SQLStatement = new SQLStatement();
statement.text = sql;
Používání parametrů příkazu namísto spojení uživatelem zadaných hodnot do textu příkazu zabraňuje vnucení SQL.
K vnucení SQL nedojde, protože hodnoty parametru jsou explicitně zpracovány jako nahrazené hodnoty a nestávají
se částí textu příkazu literálu. Následuje doporučená alternativa předcházejícího seznamu:
// assume the variables "username" and "password"
// contain user-entered data
var sql:String =
"SELECT userId " +
"FROM users " +
"WHERE username = :username " +
"
AND password = :password";
var statement:SQLStatement = new SQLStatement();
statement.text = sql;
statement.parameters[":username"] = username;
statement.parameters[":password"] = password;
Načítání dat z databáze
Načítání dat z databáze zahrnuje dva kroky. Nejprve spusťte příkaz SQL SELECTpopisující množinu dat, kterou z
databáze požadujete. Dále získejte přístup k načteným datům a dle potřeb své aplikace je zobrazte nebo s nimi
manipulujte.
Spuštění příkazu SELECT
Pro načtení stávajících dat z databáze použijte instanci SQLStatement. Přiřaďte příslušný příkaz SQL SELECT vlastnosti
instance text a poté volejte její metodu execute().
Podrobnosti o syntaxi příkazu SELECT naleznete v příloze „SQL podpora v lokálních databázích “ v Referenční
příručce jazyka ActionScript 3.0 a jeho komponent .
Následující příklad ukazuje spuštění příkazu SELECT pro načtení dat z tabulky pojmenované „produkty“, pomocí
asynchronního režimu spuštění:
var selectStmt:SQLStatement = new SQLStatement();
selectStmt.sqlConnection = conn;
selectStmt.text = "SELECT itemId, itemName, price FROM products";
// The resultHandler and errorHandler are listener methods are
// described in a subsequent code listing
selectStmt.addEventListener(SQLEvent.RESULT, resultHandler);
selectStmt.addEventListener(SQLErrorEvent.ERROR, errorHandler);
selectStmt.execute();
Následující příklad ukazuje spuštění příkazu SELECT pro načtení dat z tabulky pojmenované „produkty“, pomocí
asynchronního režimu spuštění:
selectStmt.text = "SELECT itemId, itemName, price FROM products";
// This try..catch block is fleshed out in
// a subsequent code listing
try
{
// accessing the data is shown in a subsequent code listing
}
{
// error handling is shown in a subsequent code listing
}
Když příkaz v asynchronním režimu spuštění dokončí provádění, instance SQLStatement odešle
událostresult(SQLEvent.RESULT), která udává, že příkaz byl úspěšně spuštěn. Alternativně, pokud je objekt
Responder předán jako argument ve volání execute(), je volána funkce zpracování výsledku objektu Responder. V
synchronním režimu spuštění je spuštění přerušeno, dokud operace execute() není dokončena a poté se bude
pokračovat s dalším řádkem kódu.
Přístup k výsledným datům příkazu SELECT
Jakmile příkaz SELECT dokončil provádění, je dalším krokem získání přístupu k datům, která byla načtena. Každý
řádek dat ve výsledné množině SELECT se stane instancí Object. Daný objekt má vlastnosti, jejichž názvy se shodují s
názvy sloupců množin výsledků. Vlastnosti obsahují hodnoty ze sloupců množiny výsledků. Předpokládejme
například, že příkaz SELECT určuje množinu výsledků se třemi sloupci pojmenovanými „ID položky“, „Název
položky“ a „cena“. Pro každý řádek v množině výsledků je vytvořena instance Object s vlastnostmi pojmenovanými
itemId, itemNamea price. Tyto vlastnosti obsahují hodnoty ze svých příslušných sloupců.
Následující příklad kódu navazuje na kód předcházejí pro načtení dat v režimu asynchronního spuštění. Ukazuje, jak
získat přístup k načteným datům v rámci metody posluchače události výsledků.
function resultHandler(event:SQLEvent):void
{
var result:SQLResult = selectStmt.getResult();
var numResults:int = result.data.length;
for (var i:int = 0; i < numResults; i++)
{
var row:Object = result.data[i];
var output:String = "itemId: " + row.itemId;
output += "; itemName: " + row.itemName;
output += "; price: " + row.price;
trace(output);
}
}
{
// Information about the error is available in the
// event.error property, which is an instance of
// the SQLError class.
}
Následující příklad kódu rozšiřuje předcházející kód pro načtení dat v režimu synchronního spuštění. Rozšíří blok
try..catch v předcházejícím příkladu synchronního spuštění a ukáže, jak získat přístup k načteným datům.
try
{
var numResults:int = result.data.length;
for (var i:int = 0; i < numResults; i++)
{
var row:Object = result.data[i];
var output:String = "itemId: " + row.itemId;
output += "; itemName: " + row.itemName;
output += "; price: " + row.price;
trace(output);
}
}
{
// Information about the error is available in the
// error variable, which is an instance of
// the SQLError class.
}
Jak ukazuje předchozí příklad kódu, jsou výsledné objekty obsaženy v poli, které je dostupné jako vlastnost instance
SQLResult data. Jestliže asynchronní provedení s posluchačem události používáte k načtení dané instance SQLResult,
voláte metodu instance SQLStatement getResult(). Jestliže určíte argument Responder ve volání execute(), je
instance SQLResult předána funkci zpracování výsledku jako argument. V asynchronním režimu spuštění voláte
metodu instance SQLStatement getResult() kdykoliv po volání metody execute(). V jakémkoliv případě můžete
po získání objektu SQLResult získat přístup k řádkům výsledků pomocí vlastnosti pole data.
Následující příklad kódu definuje instanci SQLStatement, jejíž text je příklad SELECT. Tento příklad načte řádky
obsahující hodnoty sloupců firstName a lastName všech řádků tabulky pojmenované zam stnanci. Tento příklad
používá asynchronní režim spuštění. Po dokončení spuštění je volána metoda selectResult() a výsledné řádky dat
jsou přístupné pomocí metody SQLStatement.getResult() a zobrazeny pomocí metody trace(). Upozorňujeme,
že tento kód předpokládá existenci instance SQLConnection pojmenované conn, která je již konkretizovaná a je již
připojena k databázi. Předpokládá také, že tabulka „zaměstnanci“ již byla vytvořena a je vyplněna daty.
import flash.data.SQLResult;
// create the SQL statement
// define the SQL text
var sql:String =
"SELECT firstName, lastName " +
"FROM employees";
selectStmt.text = sql;
// register listeners for the result and error events
selectStmt.addEventListener(SQLEvent.RESULT, selectResult);
selectStmt.addEventListener(SQLErrorEvent.ERROR, selectError);
// execute the statement
function selectResult(event:SQLEvent):void
{
// access the result data
var numRows:int = result.data.length;
for (var i:int = 0; i < numRows; i++)
{
var output:String = "";
for (var columnName:String in result.data[i])
{
output += columnName + ": " + result.data[i][columnName] + "; ";
}
trace("row[" + i.toString() + "]\t", output);
}
}
function selectError(event:SQLErrorEvent):void
{
}
Následující příklad kódu ukazuje stejné techniky jako předcházející příklad, ale používá synchronní režim spuštění.
Následující příklad kódu definuje instanci SQLStatement, jejíž text je příkaz SELECT. Tento příklad načte řádky
obsahující hodnoty sloupců firstName a lastName všech řádků tabulky pojmenované zam stnanci. Výsledné řádky
dat jsou přístupné pomocí metody SQLStatement.getResult() a jsou zobrazeny pomocí metody trace().
Upozorňujeme, že tento kód předpokládá existenci instance SQLConnection pojmenovanéconn, která je již
konkretizovaná a je již připojena k databázi. Předpokládá také, že tabulka „zaměstnanci“ již byla vytvořena a je
vyplněna daty.
var sql:String =
"SELECT firstName, lastName " +
"FROM employees";
selectStmt.text = sql;
try
{
// access the result data
var numRows:int = result.data.length;
for (var i:int = 0; i < numRows; i++)
{
var output:String = "";
for (var columnName:String in result.data[i])
{
output += columnName + ": " + result.data[i][columnName] + "; ";
}
trace("row[" + i.toString() + "]\t", output);
}
}
{
}
Určení datového typu výsledných dat příkazu SELECT
Každý řádek vrácený příkazem SELECT je implicitně vytvořen jako instance Object s vlastnostmi pojmenovanými pro
názvy sloupců množiny výsledků a s hodnotou každého sloupce jako hodnotou své asociované vlastnosti. Nicméně
před provedením příkazu SQL SELECT můžete vlastnost itemClass instance SQLStatement nastavit na třídu.
Nastavením vlastnosti itemClass je každý řádek vrácený příkazem SELECT vytvořen jako instance určené třídy.
Runtime přiřadí výsledné hodnoty sloupce k hodnotám vlastnosti spárováním názvů sloupců v množině výsledků
SELECT s názvy vlastností ve třídě itemClass.
Jakákoliv třída přiřazená jako hodnota vlastnosti itemClass musí mít konstruktor, který nevyžaduje žádné
parametry. Navíc musí mít třída jedinou vlastnost pro každý sloupec vrácený příkazem SELECT. Jestliže nemá sloupec
v seznamu SELECT odpovídající název vlastnosti ve třídě itemClass, je to považováno za chybu.
Částečné načítání výsledků příkazu SELECT.
Provedení příkazu SELECT implicitně načte všechny řádky výsledné množiny najednou. Jakmile je příkaz dokončen,
načtená data obvykle nějakým způsobem zpracujete. Například vytvořením objektů nebo zobrazením dat na
obrazovce. Jestliže příkaz vrátí větší počet řádků, může být zpracování všech dat najednou náročné pro počítač, což
způsobí, že se uživatelské rozhraní znovu nenakreslí.
Vnímaný výkon své aplikace můžete vylepšit tím, že runtime nařídíte vrátit vždy specifický počet výsledných řádků.
Tím se budou počáteční výsledná data vracet rychleji. Budete také moct rozdělit výsledné řádky do množin a
uživatelské rozhraní bude tak po zpracování každé množiny řádků aktualizováno. Upozorňujeme, že tuto techniku je
praktické použít pouze v asynchronním režimu spuštění.
Pro částečné načtení výsledků SELECT určete hodnotu pro první parametr metody SQLStatement.execute()
(parametr prefetch). Parametr prefetch určuje počet řádků, které budou načteny při prvním provedení příkazu. Při
volání metody instance SQLStatement execute() určete hodnotu parametru prefetch. Načteno bude pouze tolik
řádků:
var stmt:SQLStatement = new SQLStatement();
stmt.sqlConnection = conn;
stmt.text = "SELECT ...";
stmt.addEventListener(SQLEvent.RESULT, selectResult);
stmt.execute(20); // only the first 20 rows (or fewer) are returned
Příkaz odešle událost result určující, že první množina řádků je dostupná. Výsledná vlastnost instance SQLResult
data obsahuje řádky dat a její vlastnostcomplete určuje, zda jsou k načtení určeny dodatečné řádky výsledků. Pro
načtení dodatečných řádků výsledků volejte metodu instance SQLStatement next(). Jako v případě metody
execute() je první parametr metody next() použit pro označení počtu řádků, které se mají při dalším odeslání
události výsledku načíst.
function selectResult(event:SQLEvent):void
{
var result:SQLResult = stmt.getResult();
if (result.data != null)
{
// ... loop through the rows or perform other processing ...
if (!result.complete)
{
stmt.next(20); // retrieve the next 20 rows
}
else
{
stmt.removeEventListener(SQLEvent.RESULT, selectResult);
}
}
}
SQLStatement odešle událost result pokaždé, kdy metoda next() vrátí následnou množinu řádků výsledků:
Následně lze stejnou funkci posluchače použít k pokračování ve zpracovávání výsledků (z volání next()), dokud
nejsou načteny všechny řádky.
Více informací naleznete v referenčních popisech jazyka pro metodu SQLStatement.execute()(popis parametru
prefetch) a metodu SQLStatement.next().
Vkládání dat
Načítání dat z databáze zahrnuje provedení příkazu SQL INSERT. Ihned po dokončení provádění příkazu máte přístup
k primárnímu klíči pro nově vložený řádek, jestliže byl klíč vygenerován databází.
Provádění příkazu INSERT
Pro přidání dat do tabulky v databázi vytvořte a spusťte instanci SQLStatement, jejíž text je příkaz SQL INSERT.
Následují příklad používá instanci SQLStatement k přidání řádku dat k již existující tabulce zaměstnanců. Tento
příklad ukazuje vkládání dat pomocí režimu asynchronního spuštění. Upozorňujeme, že tento kód předpokládá
existenci instance SQLConnection pojmenované conn, která je již konkretizovaná a je již připojena k databázi.
Předpokládá také, že tabulka „zaměstnanci“ již byla vytvořena.
var insertStmt:SQLStatement = new SQLStatement();
insertStmt.sqlConnection = conn;
var sql:String =
"INSERT INTO employees (firstName, lastName, salary) " +
"VALUES ('Bob', 'Smith', 8000)";
insertStmt.text = sql;
// register listeners for the result and failure (status) events
insertStmt.addEventListener(SQLEvent.RESULT, insertResult);
insertStmt.addEventListener(SQLErrorEvent.ERROR, insertError);
insertStmt.execute();
function insertResult(event:SQLEvent):void
{
trace("INSERT statement succeeded");
}
function insertError(event:SQLErrorEvent):void
{
}
Následující příklad přidá řádek dat k již existující tabulce zaměstnanců pomocí synchronního režimu spuštění.
Upozorňujeme, že tento kód předpokládá existenci instance SQLConnection pojmenované conn, která je již
konkretizovaná a je již připojena k databázi. Předpokládá také, že tabulka „zaměstnanci“ již byla vytvořena.
var insertStmt:SQLStatement = new SQLStatement();
insertStmt.sqlConnection = conn;
var sql:String =
"INSERT INTO employees (firstName, lastName, salary) " +
"VALUES ('Bob', 'Smith', 8000)";
insertStmt.text = sql;
try
{
trace("INSERT statement succeeded");
}
{
}
Načítání databází vygenerovaného primárního klíče vloženého řádku
Váš kód potřebuje po vložení řádku dat do tabulky často vědět databází vygenerovaný primární klíč nebo hodnotu
identifikátoru řádku pro nově vložený řádek. Například po vložení řádku do tabulky si můžete přát vložit řádky do
související tabulky. V takovém případě je třeba vložit hodnotu primárního klíče do související tabulky jako cizí klíč.
Primární klíč nově vloženého řádku lze načíst pomocí objektu SQLResult vygenerovaného provedením příkazu. Jedná
se o stejný objekt, který je použit pro přístup k výsledným datům po provedení příkazu SELECT. Stejně jako v případě
libovolného příkazu SQL vytvoří runtime po dokončení provádění příkazu INSERT instanci SQLResult. K instanci
SQLResult lze získat přístup voláním metody objektu getResult(), jestliže používáte posluchač události nebo
používáte režim synchronního spuštění. Jestliže používáte režim asynchronního spuštění a předáte instanci Responder
k volání execute(), je instance SQLResult předána jako argument funkce zpracovávající výsledky. V jakémkoliv
příkladě má instance SQLResult vlastnost lastInsertRowID, která obsahuje identifikátor řádku nejnověji vloženého
řádku, jestliže je provedený příkaz SQL příkaz INSERT.
Následující příklad ukazuje přístup k primárnímu klíči vloženého řádku v režimu asynchronního spuštění:
insertStmt.text = "INSERT INTO ...";
insertStmt.addEventListener(SQLEvent.RESULT, resultHandler);
private function resultHandler(event:SQLEvent):void
{
// get the primary key
var result:SQLResult = insertStmt.getResult();
var primaryKey:Number = result.lastInsertRowID;
// do something with the primary key
}
Následující příklad ukazuje přístup k primárnímu klíči vloženého řádku v režimu synchronního spuštění:
insertStmt.text = "INSERT INTO ...";
insertStmt.addEventListener(SQLEvent.RESULT, resultHandler);
try
{
// get the primary key
var result:SQLResult = insertStmt.getResult();
var primaryKey:Number = result.lastInsertRowID;
// do something with the primary key
}
{
// respond to the error
}
Upozorňujeme, že identifikátor řádku může a nemusí být hodnotou sloupce, který je určen jako sloupec primárního
klíče v definici tabulky, podle následujícího pravidla:
• Jestliže je tabulka definována pomocí sloupce primárního klíče, jehož podobnost (datový typ sloupce) je INTEGER,
obsahuje vlastnost lastInsertRowID hodnotu, která byla do dané řádky vložena (nebo hodnotu vygenerovanou
runtime, jestliže se jedná o sloupec AUTOINCREMENT).
• Jestliže je tabulka definována pomocí více sloupců primárního klíče (složený klíč) nebo pomocí jednoho sloupce
primárního klíče, jehož podobnost není INTEGER, vytvoří databáze v pozadí pro daný řádek hodnotu identifikátoru
řádku. Tato vygenerovaná hodnota je hodnotou vlastnosti lastInsertRowID.
• Hodnota je vždy identifikátorem nejnověji vloženého řádku. Jestliže příkaz INSERT způsobí aktivaci spouštěče,
který vloží řádek, vlastnost lastInsertRowID obsahuje identifikátoru řádku posledního řádku vloženého
spouštěčem, nikoliv řádku vytvořeného příkazem INSERT. Pokud si tedy přejete mít explicitně definovaný sloupec
primárního klíče, jehož hodnota je dostupná po příkazu INSERT díky vlastnosti SQLResult.lastInsertRowID,
musí být sloupec definován jako sloupec INTEGER PRIMARY KEY. Nicméně upozorňujeme, že i když vaše tabulka
neobsahuje explicitní sloupec INTEGER PRIMARY KEY, je také přijatelná pro použití databází vytvořeného
identifikátoru řádku jako primární klíč pro vaší tabulku ve smyslu definování vztahů se souvisejícími tabulkami.
Hodnota sloupce identifikátoru řádku je dostupná v libovolném příkazu SQL pomocí jednoho ze speciálních názvů
sloupce ROWID, _ROWID_neboOID. Sloupec cizího klíče můžete vytvořit v související tabulce a použít hodnotu
identifikátoru řádku jako hodnotu sloupce cizího klíče, stejně jako v případě explicitně deklarovaného sloupce
INTEGER PRIMARY KEY. Jestliže tedy používáte libovolný primární klíč spíše než přirozený klíč a pokud vám
nevadí, že hodnotu primárního klíče pro vás generuje runtime, je velice malý rozdíl mezi použitím sloupce INTEGER
PRIMARY KEY nebo systémem vytvořeného identifikátoru řádku jako primárního klíče tabulky pro určení vztahu
cizího klíče mezi dvěma tabulkami.
Více informací o primárních klíčích a vygenerovaných identifikátorech řádku naleznete v částech nazvaných
„CREATE TABLE” a „Výrazy” v příloze „SQL podpora v lokálních databázích” v referenční příručce jazyka
ActionScript 3.0 a jeho komponent .
Změna nebo mazání dat
Proces provádění operací jiných než operací manipulace s daty je shodný s procesem použitým k provedení příkazu
SQL SELECT nebo INSERT. Jednoduše nahraďte odlišný příkaz SQL ve vlastnosti instance SQLStatementtext:
• Pro změnu stávajících dat v tabulce použijte příkaz UPDATE.
• Pro odstranění jednoho nebo více řádků z tabulky použijte příkaz DELETE.
Popis těchto příkazů naleznete v příloze „SQL podpora v lokálních databázích” v referenční příručce jazyka
ActionScript 3.0 a jeho komponent .
Práce s více databázemi
Metodu SQLConnection.attach() lze použít pro otevření spojení s dodatečnými databázemi na instanci
SQLConnection, která již má otevřenou databázi. Přiřazenou databázi můžete pojmenovat pomocí parametru názvu
ve volání metody attach(). Při zapisování příkazů pro manipulaci s danou databází můžete poté použít dané jméno
v předponě (pomocí formy database-name.table-name) pro kvalifikaci libovolných názvů tabulky ve svých
příkazech ve svých SQL. Určíte tak runtime, že danou tabulku lze nelézt v pojmenovaných databázích.
Můžete provést jediný příkaz SQL, který zahrnuje tabulky z více databází připojených ke stejné instanci
SQLConnection. Jestliže je na instanci SQLConnection vytvořena transakce, použije se daná transakce na všechny
příkazy SQL, které jsou provedeny pomocí instance SQL. To je platné bez ohledu na to, na které připojené databázi
příklad běží.
Alternativně můžete také vytvořit více instancí SQLConnection v aplikaci, kde je každá z nich připojena k jedné nebo
více databázím. Jestliže používáte více databází připojení ke stejné databázi, zapamatujte si, že transakce databáze není
sdílena mezi instancemi SQLConnection. Následně jestliže připojíte stejný soubor databáze pomocí více instancí
SQLConnection, nemůžete se spolehnout na to, že změny dat na obou připojeních budou použity očekávaným
způsobem. Jestliže jsou například dva příkazy UPDATE nebo DELETE spuštěny oproti stejné databázi prostřednictvím
rozdílných instancí SQLConnection a po provedení jedné operace dojde k chybě aplikace, data databáze lze ponechat
v okamžitém stavu, který není vratný a může ovlivnit integritu databáze (a následně i aplikace).
Zpracovávání chyb databáze
Obecně je zpracovávání chyb databáze podobné zpracovávání jiných chyb v době běhu. Měli byste zapsat kód, který je
připraven pro chyby, ke kterým může dojít, a který na chyby reaguje, spíše než aby ponechal řešení runtime. V
obecném smyslu lze možné chyby databáze rozdělit do tří kategorií: chyby připojení, chyby syntaxe SQL a chyby
omezení.
Chyby připojení
Většina chyb databáze jsou chyby připojení a může k nim dojít během jakékoliv operace. Ačkoliv existují strategie pro
zabránění chybám připojení, málokdy existuje jednoduchý způsob napravení chyby připojení, jestliže je databáze
důležitou částí vaší aplikace.
Většina chyb připojení souvisí se způsobem, jakým runtime vzájemně reaguje s operačním systémem, se systémem
souborů a se souborem databáze. K chybě připojení například dojde, jestliže uživatel nemá povolení vytvořit soubor
databáze v určitém umístění v systému souborů. Následující strategie vám pomáhají předcházet chybám připojení:
Používejte soubory databáze specifické pro daného uživatele Spíše než používání jediného souboru databáze pro
všechny uživatele, kteří aplikaci používají na jediném počítači, přidělte každému uživateli jejich vlastní soubor
databáze. Soubor by měl být umístěn v adresáři, který je přiřazen k účtu uživatele. Mohl by být například umístěn v
adresáři aplikace pro ukládání, složce v dokumentech uživatele, na ploše uživatele, atd.
Vezměte v úvahu různé typy uživatelů Testujte svou aplikaci s různými typy uživatelských účtů, na různých
operačních systémech. Nepředpokládejte, že má uživatel na počítači oprávnění administrátora. Nepředpokládejte
také, že osoba, která aplikaci instalovala, je uživatel, který jí spouští.
Vezměte v úvahu různá umístění souboru Jestliže umožníte uživateli určit, kde má být uložen soubor databáze, nebo
vybrat soubor pro otevření, zvažte možná umístění souboru, která může uživatel použít. Dále zvažte také definující
omezení pro umístění, kde mohou uživatelé ukládat (nebo odkud mohou otevírat) soubory databáze. Například
můžete uživatelům povolit otvírat pouze soubory, které jsou v úložišti jejich uživatelského účtu.
Jestliže dojde k chybě připojení, dojde k ní nejčastěji při prvním pokusu o vytvoření nebo otevření databáze. To
znamená, že daný uživatel nemůže v aplikaci provádět operace související s databází. Pro určité typy chyb, například
typ pouze ke čtení nebo chyby povolení, je jednou možnou technikou nápravy zkopírování souboru databáze do jiného
umístění. Aplikace může zkopírovat soubor databáze do odlišného umístění tam, kde má uživatel povolení k vytváření
souborů a k zápisu do souborů a místo toho použije dané umístění.
Chyby syntaxe
K chybě syntaxe dojde, je-li příkaz SQL nesprávně formátovaný a aplikace se pokusí daný příkaz provést. Protože jsou
příkazy lokální databáze SQL vytvářeny jako řetězce, kontrola syntaxe SQL v době kompilace není možná. Všechny
příkazy SQL musí být pro kontrolu jejich syntaxe provedeny. Pro předcházení chyb syntaxe SQL použijte následující
strategie:
Důkladně otestujte všechny příkazy SQL Je-li to možné, otestujte při vyvíjení aplikace své příkazy SQL odděleně před
jejich zakódováním jako textu příkazu do kódu aplikace. Mimo to použijte přístup kód-test, například testování
jednotky pro vytvoření sady testů, které provedou každou možnou volbu a variaci v kódu.
Používejte parametry příkazu a vyhněte se řetězení (dynamickému vytváření) SQL Používání parametrů a vyhýbání
se dynamickému vytváření příkazů SQL znamená, že se stejný text příkazu SQL použije při každém provedení příkazu.
Následně je o mnoho snazší testovat vaše příkazy a omezit možné variace. Jestliže musíte dynamicky vytvořit příkaz
SQL, udržte dynamické části příkazu na minimu. Také důkladně ověřte jakýkoliv uživatelský vstup a ujistěte se, že
nezpůsobí chyby syntaxe.
Pro nápravu chyby syntaxe by aplikace potřebovala kompletní logiku, aby prozkoumala příkaz SQL a opravila jeho
syntaxi. Pokud se budete řídit výše uvedenými pokyny pro předcházení chyb syntaxe, může váš kód identifikovat v
době běhu jakékoliv potenciální zdroje chyb syntaxe SQL (například vstup uživatele použitý v příkazu). Pro nápravu
chyby syntaxe poskytněte uživateli rady. Označte, co je třeba opravit, aby se příkaz provedl správně.
Chyby omezení
K chybám omezení dochází, pokud se příkaz INSERT nebo UPDATE pokusí přidat data do sloupce. K této chybě dojde,
pokud nová data poruší jedno z omezení definovaných pro tabulku nebo sloupec. Sada možných omezení zahrnuje:
Jedinečné omezení Určuje, že na všech řádcích tabulky nemohou být v jednom sloupci duplicitní hodnoty. Při
kombinování více sloupců do jedinečného omezení nesmí být kombinace hodnot v těchto sloupcích duplicitní. Jinak
řečeno, mluvíme-li o určeném jedinečném sloupci nebo sloupcích, musí být každý řádek jiný.
Omezení primárního klíče Ve vztahu k datům, které omezení povoluje a nepovoluje, je omezení primárního klíče
identické s jedinečným omezením.
Nenulové omezení Určuje, že jediný sloupec nemůže uchovávat hodnotu NULL a následně, že v každém řádku musí
mít sloupec hodnotu.
Omezení kontroly Umožňuje vám určit libovolné omezení na jedné nebo více tabulkách. Běžné omezení kontroly je
pravidlo, které definuje, že hodnota sloupce musí ležet uvnitř určité hranice (například, že 0). Další typ omezení
kontroly určuje vztah mezi hodnotami sloupce (například, že se hodnota sloupce musí lišit od hodnoty jiného sloupce
ve stejném řádku).
Omezení datového typu (shodnost sloupce) Runtime uplatňuje datový typ hodnot sloupce a jestliže je proveden
pokus o uložení hodnoty nesprávného typu do sloupce, dojde k chybě. Hodnoty jsou nicméně v mnoha podmínkách
převedeny, aby odpovídaly deklarovanému datovému typu sloupce. Více informací naleznete v tématu „Práce s
datovými typy databáze“ na stránce 181.
Runtime neuplatňuje omezení na hodnoty cizího klíče. Jinak řečeno, není vyžadováno, aby se hodnoty cizího klíče
shodovaly se stávající hodnotu primárního klíče.
Vedle předem definovaných typů omezení podporuje modul SQL runtime použití spouštěčů. Spouštěč se podobá
objektu pro zpracování události. Jedná se o předem definovanou sadu pokynů, které jsou provedeny, pokud dojde k
určité akci. Mohl by být například definován spouštěč, který běží, když jsou do určité tabulky vložena data, nebo jsou
z ní odstraněna. Jedno možné použití spouštěče je prozkoumat změny dat a pokud nejsou splněny určené podmínky,
vygenerovat chybu. Proto může spouštěč sloužit ke stejnému účelu jako omezení a strategie pro předcházení chybám
omezení a pro jejich nápravu platí také pro chyby generované spouštěčem. Nicméně ID chyby pro chyby vygenerované
spouštěčem se liší od ID chyby pro chyby omezení.
Množina omezení, která jsou platné pro určitou tabulku, je určena při navrhování aplikace. Pokud budete vědomě
navrhovat omezení, bude lehčí navrhnout vaši aplikaci tak, aby předcházela chybám omezení a napravovala je.
Systematické předvídání a prevence chyb omezení je nicméně obtížné. Předvídání je obtížné, protože k chybám
omezení nedojde, dokud nejsou přidána data aplikace. K chybám omezení dojde s přidáním dat do databáze po jejím
vytvoření. Tyto chyby jsou často výsledkem vztahu mezi novými daty a daty, které již v dané databázi existují.
Následující strategie vám mohou pomoct vyhnout se mnoha chybám omezení:
Opatrné plánování struktury databáze a omezení Účelem omezení je uplatňovat pravidla aplikace a napomáhat
ochraně integrity dat databáze. Při plánování aplikace zvažte, jak databázi strukturovat, aby vaši aplikaci podporovala.
Jako součást procesu identifikujte pro svá data pravidla, například zda jsou vyžadovány určité hodnoty, zda má
hodnota výchozí nastavení, zda jsou povoleny duplicitní hodnoty, atd. Tato pravidla vás povedou procesem definování
omezení databáze.
Explicitně určete názvy sloupců Příkaz INSERT může být zapsán bez explicitního určení sloupců, do kterých mají být
hodnoty vloženy, ale vystavujete se tím zbytečnému riziku. Explicitním pojmenováním sloupců, do kterých mají být
vloženy hodnoty, můžete umožnit automaticky vygenerované hodnoty, sloupce s výchozími hodnotami a sloupce,
které umožňují hodnoty NULL. Dále tím můžete zajistit, že všechny sloupce NOT NULL mají vloženou explicitní
hodnotu.
Použijte výchozí hodnoty Kdykoliv určíte omezení NOT NULL pro sloupec, určete výchozí hodnotu v definici sloupce.
Kód aplikace může také poskytnout výchozí hodnoty. Například váš kód může zkontrolovat, zda je proměnná String
null a může ji přiřadit hodnotě před jejím použitím pro nastavení hodnoty parametru příkazu.
Ověřte uživatelem zadaná data Dopředu zkontrolujte uživatelem zadaná data a ujistěte se, zda se řídí limity určenými
omezeními, zvláště v případě omezeníNOT NULL a CHECK. Omezení UNIQUE je přirozeně pro kontrolu složitější, protože
by kontrola vyžadovala provedení dotazu SELECT pro určení, zda jsou údaje jedinečné.
Použijte spouštěče Můžete zapsat spouštěč, který ověří (a možná nahradí) vložená data nebo provede jiné akce pro
opravení neplatných dat. Toto ověření a opravení může předejít chybě omezení.
Předcházení chybám omezení je v mnoha způsobech obtížnější, než předcházení jiným typům chyb. Naštěstí existuje
několik strategií napravení chyb omezení způsoby, které nebudou mít za následek nestabilní nebo nepoužitelnou
aplikaci.
Používejte algoritmy konfliktu Při definování omezení na sloupci a při vytváření příkazu INSERT nebo UPDATE máte
možnost určit algoritmus konfliktu. Algoritmus konfliktu definuje akci, kterou databáze provede, pokud dojde k
porušení omezení. Existuje několik možných akcí, které může modul databáze provést. Modul databáze může ukončit
jediný příkaz nebo celou transakci. Může chybu ignorovat. Může odstranit stará data a nahradit je daty, které se kód
pokouší uložit.
Více informací o kategoriích naleznete v části „ON CONFLICT (algoritmy konfliktu)” v příloze „SQL podpora v
lokálních databázích” v Referenční příručce jazyka ActionScript 3.0 a jeho komponent .
Poskytněte korektivní zpětnou vazbu Sada omezení, která může ovlivnit určitý příkaz SQL, může být identifikována
dopředu. Následně můžete očekávat chybu omezení, která může být způsobena příkazem. Díky této znalosti můžete
vytvořit logiku aplikace, která bude na chybu omezení reagovat. Předpokládejme například, že aplikace zahrnuje
formulář pro zápis dat k zadávání nových produktů. Jestliže je sloupec názvu produktu v aplikaci definován omezením
UNIQUE, může akce vložení nového řádku produktu do databáze způsobit chybu omezení. Proto je aplikace navržena
tak, aby chyby omezení očekávala. Pokud k chybě dojde, aplikace uživatele upozorní a sdělí, že určený název produktu
je již použit a požádá uživatele, aby vybral jiný název. Další možnou reakcí je umožnit uživateli zobrazit informace o
jiných produktech se stejným názvem.
Práce s datovými typy databáze
Když je v databázi vytvořena tabulka, příkaz SQL pro vytvoření tabulky definuje pro každý sloupec podobnost nebo
datový typ. Ačkoliv lze deklarace podobnosti vypustit, je dobré explicitně deklarovat podobnost sloupců ve vašich SQL
příkazech CREATE TABLE.
Jako obecné pravidlo je libovolný objekt, který uložíte v databázi pomocí příkazu INSERT, vrácen jako instance
stejného datového typu, a to když provedete příkaz SELECT. Datový typ načtené hodnoty se nicméně může lišit v
závislosti na podobnosti sloupce databáze, ve kterém je hodnota uložena. Když je ve sloupci uložena hodnota, pokud
její datový typ neodpovídá podobnosti sloupce, pokusí se databáze převést hodnotu tak, aby se s podobností sloupce
shodovala. Například jestliže je sloupec databáze deklarován pomocí podobnosti NUMERIC, pokusí se databáze před
uložením dat převést vložená data do číselné třídy uložení (INTEGER nebo REAL). Jestliže data nelze převést, vygeneruje
databáze chybu. Podle tohoto pravidla, jestliže je řetězec „12345“ vložen do sloupceNUMERIC, databáze jej před
uložením automaticky převede na hodnotu celého čísla 12345. Když je hodnota načtena s příkazem SELECT, je vrácena
jako instance číselného datového typu (například Number), spíše než jako instance String.
Pokud chcete předejít nevhodnému převedení datového typu, je nelepší se řídit dvěma pravidly. Zaprvé: definujte
každý sloupec s podobností, která se shoduje s typem dat, který má být uložen. Poté vložte pouze hodnoty, jejichž
datový typ odpovídá definované podobnosti. Dodržováním těchto pravidel získáte dvě výhody. Data nejsou při vložení
neočekávaně převedena (a následkem toho neztratí svůj zamýšlený význam). Dále při načítání dat jsou data vrácena
se svým původním datovým typem.
Více informací o dostupných typech podobnosti sloupců a používání datových typů v příkazech SQL naleznete v části
„Podpora datového typu” v příloze „SQL podpora v lokálních databázích” v Referenční příručce jazyka ActionScript
3.0 a jeho komponent .
Použití synchronních a asynchronních operací databáze
Předcházející části popisovaly běžné operace databází, například načítání, vkládání, aktualizace a mazání dat, i
vytváření souborů a tabulek databáze a jiných objektů v rámci databáze. Příklady ukázaly, jak tyto operace provést
asynchronně i synchronně.
Abychom připomněli, v režimu asynchronního spouštění přikazujete modulu databáze provést operaci. Modul
databáze poté pracuje na pozadí, zatímco aplikace nadále běží. Po dokončení operace odešle modul databáze událost,
která vás na dokončení upozorní. Klíčovou výhodou asynchronního spuštění je to, že runtime provede operace
databáze na pozadí, zatímco hlavní kód aplikace se provádí dále. To je zvláště cenné, pokud spuštění operace trvá velice
dlouho.
Naopak v režimu synchronního spuštění operace neběží na pozadí. Sdělíte modulu databáze, aby provedl operaci. Kód
se poté v daném bodu zastaví, zatímco modul databáze pracuje. Po dokončení operace pokračuje provádění s dalším
řádkem vašeho kódu.
Pomocí jediného připojení databáze nemůžete spustit některé operace nebo příkazy synchronně a jiné asynchronně.
To, zda SQLConnection pracuje v synchronním nebo asynchronním režimu, určíte při otevření připojení k databázi.
Jestliže voláte SQLConnection.open(), připojení probíhá v synchronním režimu spuštění, a jestliže voláte
SQLConnection.openAsync(), dojde k připojení v asynchronním režimu. Jakmile je instance SQLConnection
připojena k databázi pomocí open() nebo openAsync(), je pevně nastavena na synchronní nebo asynchronní
spuštění.
Používání synchronních operací databáze
Vlastní kód, který používáte k provedení operací i k reakci na ně v synchronním spuštění se v porovnání s kódem pro
režim asynchronního spuštění liší jen málo. Klíčové rozdíly mezi těmito dvěma přístupy spadají do dvou oblastí. První
je provedení operace, která závisí na jiné operaci (např. řádky výsledků SELECT nebo primární klíč řádku přidaného
příkazem INSERT). Druhou oblastí rozdílu je zpracovávání chyb.
Zapisování kódu pro synchronní operace
Klíčovým rozdílem mezi synchronním a asynchronním spuštěním je to, že v synchronním režimu zapisujete kód jako
jedinou sérii kroků. Oproti tomu v asynchronním kódu registrujete posluchače události a operace často dělíte mezi
metody posluchače. Je-li databáze připojena v režimu synchronního spuštění, můžete postupně provést sérii operací
databáze v rámci jediného bloku kódu. Tato technika je ukázána v následujícím příkladě:
// open the database
conn.open(dbFile, OpenMode.UPDATE);
// start a transaction
conn.begin();
// add the customer record to the database
var insertCustomer:SQLStatement = new SQLStatement();
insertCustomer.sqlConnection = conn;
insertCustomer.text =
"INSERT INTO customers (firstName, lastName) " +
"VALUES ('Bob', 'Jones')";
insertCustomer.execute();
var customerId:Number = insertCustomer.getResult().lastInsertRowID;
// add a related phone number record for the customer
var insertPhoneNumber:SQLStatement = new SQLStatement();
insertPhoneNumber.sqlConnection = conn;
insertPhoneNumber.text =
"INSERT INTO customerPhoneNumbers (customerId, number) " +
"VALUES (:customerId, '800-555-1234')";
insertPhoneNumber.parameters[":customerId"] = customerId;
insertPhoneNumber.execute();
// commit the transaction
conn.commit();
Jak můžete vidět, voláte stejné metody pro provedení operací databáze, ať používáte synchronní nebo asynchronní
spouštění. Klíčovými rozdíly mezi těmito dvěma přístupy jsou provedení operace, která závisí na jiné operaci, a
zpracovávání chyb.
Spuštění operace, která závisí na jiné operaci.
Když používáte režim synchronního spuštění, nepotřebujete zapsat kód poslouchající událost pro určení, zda se
operace dokončí. Namísto toho můžete předpokládat, že jestliže se operace v jednom řádku kódu úspěšně dokončí,
provádění bude pokračovat na dalším řádku kódu. Proto pro provedení operace, která závisí na úspěchu jiné operace,
jednoduše zapište závislý kód ihned po operaci, na které je závislý. Například pro kódování aplikace pro zahájení
transakce proveďte příkaz INSERT, načtěte primární klíč vloženého řádku, vložte daný primární klíč do dalšího řádku
jiné tabulky a nakonec proveďte transakci. Celý kód lze zapsat jako sérii příkazů. Následující příklad tyto operace
ukazuje:
conn.begin();
"INSERT INTO customers (firstName, lastName) " +
"INSERT INTO customerPhoneNumbers (customerId, number) " +
// commit the transaction
conn.commit();
Zpracovávání chyb v synchronním spuštění
V režimu synchronního spuštění neposloucháte událost chyby pro určení, zda byla operace neúspěšná. Namísto toho
ohraničíte libovolný kód, který by mohl spustit chyby v sadě bloků kódu try..catch..finally. Kód generující
chybu zabalíte do bloku try. Akce, které budou provedeny jako odpověď na každý typ chyby, zapište do samostatných
bloků catch. Umístěte libovolný kód, který budete chtít vždy provést bez ohledu na úspěch nebo selhání (například
uzavření připojení databáze, které již není třeba) do bloku finally. Následující příklad ukazuje použití bloku
try..catch..finally pro zpracovávání chyb. Navazuje na předchozí příklad přidáním kódu pro zpracování chyby:
conn.begin();
try
{
"INSERT INTO customers (firstName, lastName)" +
"INSERT INTO customerPhoneNumbers (customerId, number)" +
// if we've gotten to this point without errors, commit the transaction
conn.commit();
}
{
// rollback the transaction
conn.rollback();
}
Pochopení modelu asynchronního spuštění
Jedním běžným aspektem používání režimu asynchronního spuštění je předpoklad, že nemůžete zahájit provádění
instance SQLStatement, jestliže je jiná instance SQLStatement aktuálně prováděna oproti stejnému připojení databáze.
Tento předpoklad není vlastně správný. Zatímco se instance SQLStatement provádí, nemůžete změnit vlastnost
textpříkazu. Nicméně jestliže používáte samostatnou instanci SQLStatement pro každý odlišný příkaz SQL, který si
přejete provést, můžete volat metodu execute() SQLStatement, zatímco další instance SQLStatement je stále
prováděna bez způsobení chyby.
Interně, pokud provádíte operace databáze pomocí režimu asynchronního spuštění, má každé připojení databáze
(každá instance SQLConnection ) svou vlastní frontu nebo seznam operací, které mají být provedeny. Runtime
provede každou operaci v sekvenci v pořadí, ve kterém jsou přidány do fronty. Když vytvoříte instanci SQLStatement
a voláte její metodu execute(), operace spuštění daného příkazu je přidána do fronty pro připojení. Jestliže na dané
instanci SQLConnection není aktuálně spuštěna žádná operace, příkaz se začne provádět na pozadí. Předpokládejme,
že v rámci stejného bloku kódu vytvoříte další instanci SQLStatement a také voláte metodu execute() dané metody.
Operace spuštění druhého příkazu je přidána do fronty za první příkaz. Jakmile je dokončeno spuštění prvního
příkazu, posune se runtime na další operaci ve frontě. Ke zpracování následujících operací ve frontě dochází na pozadí,
i když je událost result pro první operaci odesílána v hlavním kódu aplikace. Tato technika je ukázána v následujícím
kódu:
// Using asynchronous execution mode
var stmt1:SQLStatement = new SQLStatement();
stmt1.sqlConnection = conn;
// ... Set statement text and parameters, and register event listeners ...
stmt1.execute();
// At this point stmt1's execute() operation is added to conn's execution queue.
var stmt2:SQLStatement = new SQLStatement();
stmt2.sqlConnection = conn;
// ... Set statement text and parameters, and register event listeners ...
stmt2.execute();
// At this point stmt2's execute() operation is added to conn's execution queue.
// When stmt1 finishes executing, stmt2 will immediately begin executing
// in the background.
Automatické spuštění následných příkazů umístěných do fronty databází má důležitý vedlejší vliv. Jestliže příkaz závisí
na výsledku jiné operace, nemůžete daný příkaz přidat do fronty (jinak řečeno, nemůžete volat jeho metodu
execute()) dokud není dokončena první operace. Důvodem je to, že pokud jste volali metodu execute() druhého
příkazu, nemůžete změnit vlastnosti příkazu text nebo parameters. V tomto případě musíte před zahájením další
operace počkat na událost, která určuje dokončení první operace. Pokud si například přejete provést příkaz v kontextu
transakce, závisí provedení příkazu na operaci otevření transakce. Po volání metody SQLConnection.begin() pro
otevření transakce musíte počkat, až instance SQLConnection odešle svou hodnotu begin. Pouze poté můžete volat
metodu instance SQLStatement execute(). V tomto příkladě je nejjednodušším způsobem organizování aplikace pro
zajištění řádného provedení aplikace vytvoření metody, která je zaregistrována jako posluchač pro událostbegin. Kód
pro volání metody SQLStatement.execute() je umístěn uvnitř metody posluchače.
Strategie pro práci s databázemi SQL
Existují různé způsoby, jak může aplikace získat přístup k lokální databázi SQL a pracovat s ní. Provedení aplikace se
může lišit co do způsobu organizování kódu aplikace, sekvence a načasování provedení operací, atd. Vámi vybrané
techniky mohou ovlivnit to, jak snadno lze vaši aplikaci vyvinout. Mohou ovlivnit to, jak snadné je upravit aplikaci v
budoucích aktualizacích. Mohou také ovlivnit kvalitu výkonu aplikace z perspektivy uživatele.
Distribuce a zaplnění databází předem
Jestli ve své aplikaci používáte lokální databázi SQL AIR, očekává aplikace databázi s určitou strukturou tabulek,
sloupců, atd. Některé aplikace také očekávají předem vyplnění určitých dat do souboru databáze. Jedním způsobem
pro zajištění správné struktury databáze je vytvoření databáze v kódu aplikace. Když se aplikace načte, zkontroluje
existenci svého souboru databáze v určitém umístění. Jestliže soubor neexistuje, aplikace provede sadu příkazů pro
vytvoření souboru databáze, vytvoření struktury databáze a vyplnění tabulek počátečními daty.
Kód, který vytváří databázi a její tabulky, je často složitý. Často je použit pouze jednou v instalovaném životním cyklu
aplikace, ale přesto zvětšuje velikost a složitost aplikace. Jako alternativu k programatickému vytvoření databáze,
struktury a dat můžete distribuovat předem vyplněnou databázi pomocí své aplikace. Pro distribuci předem
definované databáze zahrňte soubor databáze do balíku aplikace AIR.
Jako všechny soubory, které jsou zahrnuty do balíku AIR, je přibalený soubor databáze instalován v adresáři aplikace
(adresář představovaný vlastností File.applicationDirectory). Soubory v daném adresáři jsou nicméně určeny
pouze ke čtení. Soubor z balíku AIR použijte jako „šablonovou“ databázi. Při prvním spuštění aplikace zkopírujte
původní soubor databáze do adresáře pro ukládání uživatelské aplikace (nebo jiného umístění) a použijte danou
databázi v rámci aplikace.
Vylepšení výkonu databáze
Několik technik vestavěných do programu Adobe AIR vám umožňuje zlepšit výkon operací databáze ve vaší aplikaci.
Vedle zde popsaných technik může způsob zapsání příkazu SQL také ovlivnit výkon databáze. Často existuje více
způsobů pro zapsání příkazu SQL SELECT k načtení určité sady výsledků. V některých případech vyžadují odlišné
přístupy více či méně úsilí od modulu databáze. Tento aspekt vylepšení výkonu databáze—navrhování příkazů SQL
pro lepší výkon—není obsahem dokumentace programu Adobe AIR.
Pro každý příkaz SQLStatement použijte jednu instanci SQL
Před provedením jakéhokoliv příkazu jej SQL připraví (kompiluje) k určení kroků, které jsou provedeny interně pro
provedení příkazu. Když voláte SQLStatement.execute() na instanci SQLStatement, která nebyla dříve provedena,
příkaz je před provedením automaticky připraven. U dalších volání metody execute(), dokud nebyla vlastnost
SQLStatement.text změněna, je příkaz stále připraven. Proto je proveden rychleji.
Pro získání maximálních výhod díky opětovnému použití příkazů, jestliže je třeba mezi provedeními příkazu změnit
hodnoty, použijte parametry příkazu pro vlastní nastavení příkazu. (Parametry příkazu jsou určeny pomocí vlastnosti
asociativního poleSQLStatement.parameters.) Oproti změně vlastnosti instance SQLStatement textse při změně
hodnoty parametrů příkazu nevyžaduje od runtime opětovné připravení příkazu. Více informací o používání
parametrů v příkazech naleznete v části „Používání parametrů v příkazech“ na stránce 167.
Protože příprava a provedení příkazu je operace, která je potenciálně náročná, je dobrou strategií předem načíst
počáteční data a poté provést jiné příkazy na pozadí. Načtení dat, která aplikace potřebuje nejdříve. Po dokončení
počátečních spouštěcích operací aplikace nebo při dalším „nečinném“ čase v aplikaci proveďte další příkazy. Například
jestliže vaše aplikace nemá přístup k databázi na všech úrovních pro zobrazení počáteční obrazovky, počkejte dokud
se daná obrazovka nezobrazí, poté otevřete připojení databáze, vytvořte instance SQLStatement a proveďte jakoukoliv
z nich, kterou můžete. Alternativně předpokládejme, že aplikace při spuštění okamžitě zobrazí některá data, například
výsledek určitého dotazu. V tomto případě pokračujte a pro daný dotaz proveďte instanci SQLStatement. Po načtení
a zobrazení počátečních dat vytvořte instance SQLStatement pro další operace databáze a je-li to možné, proveďte jiné
příkazy, které jsou potřeba později.
Když opětovně používáte instanci SQLStatement, potřebuje vaše aplikace uchovat referenci na instanci SQLStatement
po jejím připravení. Po uchování reference na danou instanci deklarujte danou proměnou jako proměnou rozsahu
třídy, nikoliv jako proměnnou rozsahu funkce. Jedním dobrým způsobem je strukturovat vaši aplikaci tak, že je příkaz
SQL zabalen do jediné třídy. Skupina příkazů, které jsou provedeny v kombinaci, může být také zabalena do jediné
třídy. Definováním instance nebo instancí SQLStatement jako členových proměnných dané třídy zůstanou tyto tak
dlouho, dokud instance třídy objektu zabalení existuje v aplikaci. Minimálně můžete jednoduše definovat proměnou
obsahující instanci SQLStatement mimo funkci, takže je instance uchována v paměti. Instanci SQLStatement
deklarujte například jako členovou proměnnou ve třídě ActionScript nebo jako ne-funkční proměnnou v souboru
JavaScript. Poté můžete nastavit hodnoty parametru příkazů a volat jeho metodu execute(), pokud si přejete dotaz
skutečně spustit.
Seskupení více operací do skupiny
Předpokládejme, že provádíte velký počet příkazů SQL, které zahrnují přidání nebo změnu dat (příkazy INSERT nebo
UPDATE). Můžete významně vylepšit výkon, a to provedením všech příkazů v rámci explicitní transakce. Jestliže
explicitně nezahájíte transakci, každý z příkazů běží ve vlastní automaticky vytvořené transakci. Po dokončení spuštění
každé transakce (každého příkazu) zapíše runtime výsledná data do souboru databáze na disk. Na druhou stranu
zvažte, co se stane, pokud explicitně vytvoříte transakci a provedete příkazy v kontextu dané transakce. Runtime
provede všechny změny v paměti a poté je všechny najedou zapíše do souboru databáze při spuštění transakce. Zapsání
dat na disk obvykle zabírá nejvíce času z operace. Proto zapisování na disk najednou spíše než pro každý příkaz SQL
může výrazně zlepšit výkon.
Minimalizování zpracovávání v době běhu
Použití následujících technik může předcházet nepotřebné práci na části modulu databáze a aplikace tak budou mít
lepší výkon:
• V příkazu vždy výslovně určete názvy databáze společně s názvy tabulky. (Použijte „hlavní“, jedná-li se o hlavní
databázi). Například použijte SELECT employeeId FROM hlavní.zam stnanci spíše než SELECT employeeId
FROM zam stnanci. Explicitní určení názvu databáze zabraňuje runtime v kontrole každé databáze pro vyhledání
shodné tabulky. Zabraňuje také tomu, že runtime zvolí špatnou databázi. Tímto pravidlem se řiďte, i pokud je
SQLConnection pouze připojena k jediné databázi, protože SQLConnection je v pozadí také připojena k přechodné
databázi, které je přístupná pomocí příkazů SQL.
• Vždy explicitně určete názvy sloupců v příkazu SELECT nebo INSERT.
• Rozdělte řádky vrácené příkazem SELECT, který načte velké množství řádků: viz „Částečné načítání výsledků
příkazu SELECT.“ na stránce 173.
Vyhněte se změnám schématu
Je-li to možné, vyhněte se po vložení dat do tabulek databáze změně schématu (struktury tabulky) databáze. Běžně je
soubor databáze strukturován s definicemi tabulky na začátku souboru. Když otevřete připojení k databázi, runtime
načte tyto definice. Když přidáte data do tabulek databáze, data jsou přidána do souboru za definiční data tabulky.
Pokud nicméně schéma změníte, například přidáte sloupec do tabulky nebo přidáte novou tabulku, nová definiční
data se smíchají s daty tabulky v souboru databáze. Jestliže definiční data tabulky nejsou všechna na začátku souboru
databáze, otevření spojení k databázi trvá déle, protože runtime čte definiční data tabulky z různých částí souboru.
Potřebujete-li změnit schéma, můžete po dokončení změn volat metodu SQLConnection.compact(). Tato operace
změní strukturu souboru databáze tak, že definiční data tabulky budou všechna umístěna na začátku souboru. Operace
compact() může nicméně zabrat mnoho času, zvláště při narůstající velikosti souboru databáze.
Nejlepší způsoby pro práci s lokálními databázemi SQL
Následující seznam je sada navržených technik, které můžete použít pro zlepšení výkonu, zabezpečení a usnadnění
údržby svých aplikací při práci s lokálními databázemi SQL. Další techniky vylepšení aplikací databáze naleznete v
tématu „Vylepšení výkonu databáze“ na stránce 186.
Vytvoření připojení databáze předem
I když vaše aplikace neprovede při prvním načtení žádné příkazy, konkretizujte objekt SQLConnection a volejte jeho
metodu open() nebo openAsync() dostatečně dopředu (například po úvodním spuštění aplikace), abyste se vyhnuli
zpožděním při spouštění příkazů. Viz. „Připojení k databázi“ na stránce 164.
Opětovné použití připojení databáze
Jestliže přistupujete k určité databázi během času provedení vaší aplikace, uchovejte si referenci na danou instanci
SQLConnection a znovu ji použijte v celé aplikaci, namísto toho, abyste spojení uzavřeli a znovu otevřeli. Viz.
„Připojení k databázi“ na stránce 164.
Upřednostněte asynchronní režim spuštění
Při zapisování kódu přístupu k datům může být lákavé provést operace synchronně spíše než asynchronně, protože
používání synchronních operací často vyžaduje kratší a méně složitý kód. Jak je nicméně popsáno v tématu „Použití
synchronních a asynchronních operací databáze“ na stránce 181, synchronní operace mohou mít vliv na výkonnost,
což nepříznivě ovlivňuje zážitek uživatelů s aplikací. Objem času, který jednotlivá operace zabere, se liší podle operace
a zvláště podle množství dat, které operace zahrnuje. Například příkaz SQL INSERT , který do databáze přidá pouze
jednu řádku zabere méně času než příkaz SELECT, který dosadí tisíce řádků dat. Pokud ale používáte pro provedení
více operací synchronní spuštění, operace jsou obvykle zřetězeny dohromady. I v případě, že doba trvání každé jediné
operace je velice krátká, aplikace zamrzne, dokud nejsou všechny synchronní operace dokončeny. Výsledkem je to, že
kumulativní doba více operaci zřetězených dohromady může stačit k zablokování vaší aplikace.
Jako standardní přístup použijte asynchronní operace, zvláště u operací, které zahrnují velké množství řádků. Existuje
technika pro rozdělení zpracování velkých sad výsledků příkazuSELECT, která je popsaná v tématu „Částečné načítání
výsledků příkazu SELECT.“ na stránce 173. Tato technika může být nicméně použita pouze v asynchronním režimu
spuštění. Synchronní operace používejte pouze v případě, kdy nemůžete dosáhnout určité funkce pomocí
asynchronního programování, poté, co jste zvážili rozdíly ve výkonu, kterými budou uživatelé vaší aplikace ovlivněni
a svoji aplikaci jste otestovali a víte, jak bude výkon aplikace ovlivněn. Používání asynchronního spuštění může
zahrnovat složitější kódování. Nicméně pamatujte, že kód je třeba zapsat pouze jednou, ale uživatelé aplikace jej musí
používat opakovaně, rychle nebo pomalu.
V mnoha případech může být použitím samostatné instance SQLStatement pro každý příkaz SQL určený k provedení
nahromaděno více operací SQL najednou do fronty, čímž se asynchronní kód podobá synchronnímu kódu, co se týče
způsobu zapsání kódu. Více informací naleznete v tématu „Pochopení modelu asynchronního spuštění“ na
stránce 184.
Použijte samostatné příkazy SQL a neměňte vlastnost textu SQLStatement
Pro jakýkoliv příkaz SQL, který je v aplikaci proveden více než jednou, vytvořte pro každý příkaz SQL samostatnou
instanci SQLStatement. Tuto instanci SQLStatement použijte při každém provedení příkazu SQL. Předpokládejme
například, že vytváříte aplikaci, která zahrnuje čtyři odlišné operace SQL provedené několikrát. V tomto případě
vytvořte čtyři samostatné instance SQLStatement a pro spuštění volejte metodu execute() každého segmentu.
Vyhněte se použití jediné instance SQLStatement pro všechny příkazy SQL a novému definování její vlastnosti text
pokaždé před spuštěním příkazu. Více informací naleznete v tématu „Pro každý příkaz SQLStatement použijte jednu
instanci SQL“ na stránce 186.
Používání parametrů příkazu
Používejte parametry SQLStatement—nikdy nespojujte vstup uživatele do textu příkazu. Díky použití parametrů bude
vaše aplikace lépe zabezpečena, protože tím zabráníte možnému vnucení SQL. Bude tak možné použít objekty v
dotazech (spíše než pouze hodnoty literálu SQL). Příkazy budou také prováděny účinněji, protože je lze opětovně
použít bez potřeby je znovu kompilovat při každém spuštění. Více informací naleznete v tématu „Používání parametrů
v příkazech“ na stránce 167.
Používání konstant pro názvy sloupců a parametrů
Jestliže pro příkaz SQLStatement neurčíteitemClass, definujte konstanty String obsahující názvy sloupců tabulky.
Vyhnete se tak chybám při psaní. Tyto konstanty použijte v textu příkazu a pro názvy vlastnosti při načítání hodnot z
výsledných objektů. Konstanty použijte také pro názvy parametrů.
190
Kapitola 19: Ukládání šifrovaných dat
Modul runtime prostředí Adobe® AIR™ poskytuje trvalé šifrované místní úložiště pro jednotlivé aplikace prostředí AIR
nainstalované v počítači uživatele. To umožňuje ukládat a načítat data uložená na místním pevném disku v šifrovaném
formátu, který nemohou jiné aplikace nebo uživatelé snadno dešifrovat. Oddělené šifrované místní úložiště se používá
pro jednotlivé aplikace prostředí AIR a každá aplikace AIR používá oddělená šifrovaná místní úložiště pro jednotlivé
uživatele.
V některých případech je vhodné použít šifrované místní úložiště k ukládání informací, které musí být zabezpečeny,
například oprávnění pro přihlášení k webovým službám.
Aplikace AIR používá rozhraní DPAPI v operačním systému Windows a KeyChain v operačním systému Mac OS k
přiřazení šifrovaného místního úložiště ke každé aplikaci a uživateli. Šifrované místní úložiště používá 128bitové
šifrování AES-CBC.
Informace v šifrovaném místním úložišti jsou dostupné pro obsah aplikací AIR v karanténě zabezpečení aplikace.
Statické metody setItem() a removeItem() třídy EncryptedLocalStore slouží k uložení a načtení dat z místního
úložiště. Data jsou uložena v tabulce hash, jako klíče jsou použity řetězce a samotná data jsou uložena jako bajtová pole.
Následující kód ukládá řetězec do šifrovaného místního úložiště:
var str:String = "Bob";
bytes.writeUTFBytes(str);
EncryptedLocalStore.setItem("firstName", bytes);
var storedValue:ByteArray = EncryptedLocalStore.getItem("firstName");
trace(storedValue.readUTFBytes(storedValue.length)); // "Bob"
Třetí parametr metody setItem() parametr stronglyBound je volitelný. Jestliže je tento parametr nastaven na
hodnotu true, šifrované místní úložiště poskytne vyšší úroveň zabezpečení tím, že vytvoří vazbu uložené položky k
digitálnímu podpisu a bitům ukládající aplikace AIR a k ID vydavatele aplikace, pokud platí:
var str:String = "Bob";
bytes.writeUTFBytes(str);
EncryptedLocalStore.setItem("firstName", bytes, true);
Pro položku, která je uložena s parametrem stronglyBound nastaveným na hodnotu true, budou následná vyvolání
metody getItem() úspěšná pouze v případě, že vyvolávající aplikace AIR bude shodná s ukládající aplikací (v
souborech v adresáři aplikace se nezměnila žádná data). Pokud se vyvolávající aplikace AIR liší od ukládající aplikace
a budete vyvolávat metodu getItem() pro pevně svázanou položku, aplikace vyvolá výjimku chyby. Budete-li svou
aplikaci aktualizovat, nebude schopna číst pevně svázaná data zapsaná dříve do šifrovaného místního úložiště.
Aplikace AIR ve výchozím nastavení nemůže číst ze šifrovaného místního úložiště jiné aplikace. Nastavení
stronglyBound zajišťuje další vazbu (s daty v bitech aplikace), která aplikaci útočníka znemožní čtení ze šifrovaného
místního úložiště vaší aplikace, pokud se pokusí o krádež ID vydavatele vaší aplikace.
Jestliže aktualizujete aplikaci, aby používala jiný podpisový certifikát (pomocí podpisu přesunutí), aktualizovaná verze
nebude mít přístup k žádné položce v původním úložišti ani v případě, že bude parametr stronglyBound nastaven na
hodnotu false. Další informace naleznete v části „Změna certifikátů“ na stránce 288.
Ukládání šifrovaných dat
Odstranění hodnoty ze šifrovaného místního úložiště je možné pomocí metody
EncryptedLocalStore.removeItem() jako v následujícím příkladu:
EncryptedLocalStore.removeItem("firstName");
Chcete-li ze šifrovaného místního úložiště vymazat veškerá data, můžete vyvolat metodu
EncryptedLocalStore.reset() jako v následujícím příkladu:
EncryptedLocalStore.reset();
Když ladíte aplikaci v programu ADL (AIR Debug Launcher), aplikace používá jiné šifrované místní úložiště než to,
které bylo používáno v nainstalované verzi aplikace.
Pokud uložená data přesahují 10MB, šifrované místní úložiště může pracovat pomaleji.
Jestliže odinstalujete aplikaci AIR, odinstalační program neodstraní data uložená v šifrovaném místním úložišti.
Data z šifrovaného místního úložiště jsou přemístěna do podadresáře v adresáři dat aplikací uživatele. Cesta k
podadresáři je Adobe/AIR/ELS/ s připojeným ID aplikace.
192
Kapitola 20: Prostředí HTML
Prostředí Adobe®AIR™ využívá modul WebKit (www.webkit.org), který je rovněž používán webovým prohlížečem
Safari, k analýze, rozvržení a vykreslení obsahu HTML a JavaScript. Používání rozhraní API prostředí AIR v obsahu
HTML je volitelné. K programování obsahu objektu HTMLLoader nebo okna HTML zcela postačí jazyk HTML a
JavaScript. Většinu stávajících stránek a aplikací HTML by mělo být možné spouštět pouze s několika změnami (za
předpokladu, že používají funkce jazyků HTML, CSS, DOM a JavaScript kompatibilní s modulem WebKit).
Protože jsou aplikace AIR spouštěny přímo na pracovní ploše a mají plný přístup k systému souborů, model
zabezpečení obsahu HTML je přísnější než model zabezpečení obvyklých webových prohlížečů. V prostředí AIR je do
aplikační karantény umísťován pouze obsah načtený z instalačního adresáře aplikace. Aplikační karanténa má nejvyšší
úroveň oprávnění a umožňuje přístup k rozhraním API prostředí AIR. Prostředí AIR umísťuje ostatní obsah do
izolovaných karantén na základě místa jeho původu. Soubory načtené ze systému souborů jsou ukládány do místní
karantény a soubory načtené ze sítě prostřednictvím protokolu http: nebo https: do příslušné karantény založené na
doméně vzdáleného serveru. Obsah v těchto neaplikačních karanténách má zakázán přístup ke všem rozhraním API
prostředí AIR a je spouštěn v podstatě stejně jako v obvyklých webových prohlížečích.
Prostředí AIR využívá modul WebKit(www.webkit.org), který je rovněž používán webovým prohlížečem Safari, k
analýze, rozvržení a vykreslení obsahu HTML a JavaScript. Vestavěné třídy a objekty hostitele prostředí AIR poskytují
rozhraní API pro funkce tradičně spojované s aplikacemi na ploše. K těmto funkcím patří čtení a zapisování souborů
a správa oken. Prostředí Adobe AIR rovněž dědí rozhraní API z přehrávače Adobe® Flash® Player, která zahrnují
funkce, jako je zvukový a binární soket.
Pokud jsou použita nastavení alfa, změny měřítka nebo průhlednosti, v obsahu HTML v prostředí AIR se nezobrazí
obsah SWF a PDF. Další informace naleznete v části Opatření při načítání obsahu SWF nebo PDF na stránku HTML
a „Průhlednost okna“ na stránce 58.
Přehled prostředí HTML
Adobe AIR poskytuje úplné prostředí JavaScript podobné prohlížeči, včetně vykreslovacího modulu HTML, modelu
DOM a překladače jazyka JavaScript. Prostředí JavaScript je reprezentováno třídou HTMLLoader prostředí AIR.
Objekt HTMLLoader v oknech HTML zahrnuje veškerý obsah HTML a zároveň je obsažen v objektu NativeWindow.
V obsahu SWF může být třída HTMLLoader, která rozšiřuje třídu Sprite, přidána do seznamu zobrazení plochy jako
kterýkoli jiný objekt zobrazení. Vlastnosti jazyka ActionScript™ pro tuto třídu jsou popsány v části „Skriptování
kontejneru HTML“ na stránce 231 a v dokumentu Referenční příručka jazyka ActionScript pro aplikaci Flex 3.
Prostředí JavaScript a jeho vztah k prostředí AIR
Následující schéma ilustruje vztah mezi prostředím JavaScript a běhovým prostředím AIR. Ačkoli je zobrazeno pouze
jedno nativní okno, aplikace AIR může obsahovat více oken. (A jedno okno může obsahovat více objektů
HTMLLoader.)
Prostředí HTML
AIR Run-time Environment
NativeWindow
HTMLLoader
window
JavaScript
Environment
window
window
body
head
htmlLoader
native4Window
runtime
h1
div
table
p
Prostředí JavaScript má své vlastní objekty Document (Dokument) a Window (Okno). Kód jazyka JavaScript může spolupracovat s běhovým
prostředím AIR prostřednictvím vlastností runtime, nativeWindow a htmlLoader. Kód jazyka ActionScript může spolupracovat s prostředím
JavaScript prostřednictvím vlastnosti okna objektu HTMLLoader, což je odkaz na objekt Window (Okno) jazyka JavaScript. Objekty jazyků
ActionScript a JavaScript mohou také naslouchat událostem vyslaným objekty prostředí AIR i jazyka JavaScript.
Vlastnost runtime poskytuje přístup k třídám rozhraní API prostředí AIR a umožňuje vytváření nových objektů AIR
a členů tříd pro přístup (označovaných také jako statické členy). Chcete-li získat přístup k rozhraní API prostředí AIR,
přidejte k vlastnosti runtime název třídy včetně balíčku. Chcete-li například vytvořit objekt File (Soubor), použijte
tento příkaz:
var file = new window.runtime.filesystem.File();
Poznámka: Sada AIR SDK obsahuje soubor JavaScript AIRAliases.js, který definuje vhodnější aliasy pro většinu
běžně používaných tříd AIR. Při importu tohoto souboru můžete namísto tvaru window.runtime.package.Class použít
kratší tvar air.Class. Například objekt File (Soubor) můžete vytvořit pomocí řetězce new air.File().
Objekt NativeWindow poskytuje vlastnosti pro ovládání okna na ploše. Ze stránky HTML je možné získat přístup k
nadřazenému objektu NativeWindow pomocí vlastnosti window.nativeWindow.
Objekt HTMLLoader poskytuje vlastnosti, metody a události pro ovládání způsobu načtení a vykreslení obsahu. Ze
stránky HTML je možné získat přístup k nadřazenému objektu HTMLLoader pomocí vlastnosti
window.nativeWindow.
Prostředí HTML
Důležité: Pouze stránky nainstalované jako součást aplikace mají vlastnost htmlLoader, nativeWindow nebo runtime,
a to pouze v případě, že byly načteny jako dokument nejvyšší úrovně. Tyto vlastnosti nejsou přidávány, pokud byl
dokument načten do elementu frame nebo iframe. (Podřízený dokument může mít přístup k těmto vlastnostem v
nadřazeném dokumentu, pokud se nachází ve stejné zabezpečené karanténě. Například dokument načtený do elementu
frame může získat přístup k vlastnosti runtime svého nadřazeného dokumentu pomocí vlastnosti·parent.runtime.)
Zabezpečení
Prostředí AIR spouští celý kód v zabezpečené karanténě podle domény původu. Obsah aplikace, který je omezen na
obsah načtený z instalačního adresáře aplikace, je umístěn do aplikační karantény. Přístup k běhovému prostředí a
rozhraním API prostředí AIR je k dispozici pouze pro HTML a JavaScript spuštěné v této karanténě. Současně je
většina dynamických vyhodnocení a spouštění jazyka JavaScript blokována v aplikační karanténě poté, co byly vráceny
všechny manipulační programy události na tení stránky.
Stránku aplikace můžete mapovat do neaplikační karantény načtením do prvku frame nebo iframe a nastavením
atributů sandboxRoot a documentRoot rámce specifických pro prostředí AIR. Nastavením hodnoty vlastnosti
sandboxRoot na skutečnou vzdálenou doménu můžete povolit, aby obsah umístěný v karanténě provedl křížové
skriptování obsahu v této doméně. Mapování stránek tímto způsobem může být užitečné při načítání a skriptování
vzdáleného obsahu, jako je tomu v hybridní webové aplikaci.
Jiným způsobem, jak lze povolit obsahu aplikace a obsahu mimo aplikaci, aby provedly vzájemné křížové skriptování,
a jediným způsobem, jak umožnit obsahu mimo aplikaci přístup k rozhraním API prostředí AIR, je vytvořit most
karantény. Most typu nadřazený–podřízený umožňuje obsahu v podřízeném elementu frame či iframe nebo v okně
získat přístup k vybraným metodám a vlastnostem definovaným v aplikační karanténě. Naopak most typu podřízený–
nadřazený umožňuje obsahu aplikace přístup k vybraným metodám a vlastnostem definovaným v karanténě
podřízeného prvku. Mosty karantén se vytvářejí nastavením vlastností parentSandboxBridge a
childSandboxBridge objektu okna. Další informace naleznete v části „Zabezpečení HTML“ na stránce 29 a
„Elementy HTML frame a iframe“ na stránce 202.
Zásuvné moduly a vložené objekty
Prostředí AIR podporuje zásuvný modul Adobe® Acrobat®. Pro zobrazení obsahu PDF musí mít uživatelé k dispozici
aplikaci Acrobat nebo Adobe® Reader® 8.1 (nebo novější). Objekt HTMLLoader poskytuje vlastnost pro zjištění, zda
může uživatelův počítač zobrazit PDF. Obsah souboru SWF je možné zobrazit také v prostředí HTML, ale tato funkce
je zabudována do prostředí AIR a nepoužívá vnější zásuvný modul.
V prostředí AIR nejsou podporovány žádné další zásuvné moduly Webkit.
Viz také
„Zabezpečení HTML“ na stránce 29
„Karantény HTML“ na stránce 195
„Elementy HTML frame a iframe“ na stránce 202
„Objekt Window (Okno) jazyka JavaScript“ na stránce 200
„Objekt XMLHttpRequest“ na stránce 196
„Přidávání obsahu PDF“ na stránce 245
Prostředí HTML
Rozšíření prostředí AIR a modulu Webkit
Prostředí Adobe AIR používá modul Webkit s otevřeným zdrojovým kódem používaný rovněž ve webovém prohlížeči
Safari. Prostředí AIR přidává několik rozšíření, která umožňují přístup k třídám a objektům runtime a slouží k
zabezpečení. Samotný modul Webkit navíc doplňuje funkce, které nejsou obsaženy ve standardech W3C pro HTML,
CSS a JavaScript.
Zde jsou popsány pouze doplňky prostředí AIR a nejdůležitější rozšíření modulu Webkit. Další dokumentaci k
nestandardním jazykům HTML, CSS a JavaScript naleznete na stránkách www.webkit.org a developer.apple.com.
Informace o standardech naleznete na stránkách konsorcia W3C. Rovněž nadace Mozilla poskytuje cenné obecné
informace k tématům HTML, CSS a DOM (moduly Webkit a Mozilla samozřejmě nejsou identické).
Poznámka: Prostředí AIR nepodporuje následující standardní a rozšířené funkce modulu WebKit: metodu print()
objektu Window (Okno) jazyka JavaScript; zásuvné moduly kromě aplikací Acrobat a Adobe Reader 8.1+; formát SVG
(Scalable Vector Graphics) a vlastnost krytí jazyka CSS.
JavaScript v prostředí AIR
Prostředí AIR provádí několik změn typického chování běžných objektů jazyka JavaScript. Mnoho těchto změn bylo
provedeno s cílem usnadnit psaní zabezpečených aplikací v prostředí AIR. Tyto rozdíly v chování zároveň znamenají,
že některé obvyklé kódovací vzory jazyka JavaScript a stávající webové aplikace využívající tyto vzory nemusí vždy v
prostředí AIR fungovat podle očekávání. Informace o opravách těchto typů chyb naleznete v části „Zamezení vzniku
chyb jazyka JavaScript souvisejících se zabezpečením“ na stránce 208.
Karantény HTML
Prostředí AIR umísťuje obsah do karantén podle jeho původu. Pravidla karantény jsou konzistentní se zásadami
stejného původu implementovanými většinou webových prohlížečů a s pravidly pro karantény implementovanými
přehrávačem Adobe Flash Player. Prostředí AIR dále poskytuje nový typ aplikační karantény, který slouží k ukládání
a ochraně jejich obsahu. Další informace o typech karantén, se kterými se můžete setkat při vývoji aplikací AIR,
naleznete v části „Karantény zabezpečení“ na stránce 26.
Přístup k běhovému prostředí a rozhraním API prostředí AIR je k dispozici pouze pro HTML a JavaScript spuštěné v
této aplikační karanténě. Současně je však dynamické vyhodnocení a provedení jazyka JavaScript v jeho různých
formách uvnitř aplikační karantény z bezpečnostních důvodů značně omezeno. Tato omezení jsou uplatňována bez
ohledu na to, zda vaše aplikace skutečně načítá informace přímo ze serveru či nikoli. (Dokonce i obsah souboru,
vložené řetězce a data přímo vložená uživatelem mohou být nedůvěryhodné.)
Karanténa, do které je obsah na stránce odesílán, je určena původem obsahu. Do aplikační karantény je umísťován
pouze obsah načtený z adresáře aplikace (instalačního adresáře uvedeného ve schématu app: adresy URL). Obsah
načtený ze systému souborů je umístěn do místní z hlediska systému souborů nebo místně důvěryhodné karantény, což
umožňuje přístup a interakci s obsahem v místním systému souborů, ale nikoli se vzdáleným obsahem. Obsah načtený
ze sítě je umístěn do vzdálené karantény odpovídající doméně původu obsahu.
Aby mohla stránka aplikace bez omezení spolupracovat s obsahem ve vzdálené karanténě, musí být mapována do
stejné domény jako vzdálený obsah. Jestliže například napíšete aplikaci, která zobrazuje data mapování z internetové
služby, stránka vaší aplikace, která načítá a zobrazuje obsah z této služby, může být namapována do domény služby.
Atributy mapování stránek do vzdálené karantény a domény jsou novými atributy přidanými do elementů HTML
frame a iframe.
Prostředí HTML
Chcete-li umožnit, aby obsah v neaplikační karanténě bezpečně využíval funkce prostředí AIR, můžete nastavit
nadřízený most karantény. Aby mohl mít obsah aplikace možnost bezpečného vyvolání metod a měl přístup k
vlastnostem obsahu v jiných karanténách, můžete nastavit podřízený most karantény. Bezpečnost zde znamená, že
vzdálený obsah nemůže nedopatřením získat odkazy na objekty, vlastnosti nebo metody, které nejsou výslovně
zpřístupněny. Přes most mohou projít pouze jednoduché typy dat a anonymní objekty. I nadále se však musíte vyhýbat
výslovnému zpřístupnění potenciálně nebezpečných funkcí. Pokud byste například zpřístupnili rozhraní, které
umožňuje vzdálenému obsahu číst a zapisovat soubory kdekoli v systému uživatele, pak byste pravděpodobně
vzdálenému obsahu poskytli možnosti způsobovat uživatelům značné škody.
Funkce eval() jazyka JavaScript
Použití funkce eval() je v aplikační karanténě po dokončení načtení stránky omezeno. Některé způsoby použití jsou
povoleny, aby mohla být bezpečně analyzována data ve formátu JSON, ale jakékoli vyhodnocení, jehož výsledkem jsou
spustitelné příkazy, vyvolá chybu. V části „Omezení kódu pro obsah v různých karanténách zabezpečení“ na
stránce 31 jsou popsány povolené způsoby použití funkce eval().
Konstruktory Function (Funkce)
V aplikační karanténě lze před dokončením načtení stránky použít konstruktory funkce. Po dokončení všech
manipulačních programů události na tení stránky nelze vytvářet nové funkce.
Načítání externích skriptů
Stránky HTML v aplikační karanténě nemohou používat tag skript k načtení souborů JavaScript z umístění mimo
adresář aplikace. Aby mohla stránka ve vaší aplikaci načíst skript z umístění mimo adresář aplikace, musí být
mapována do neaplikační karantény.
Objekt XMLHttpRequest
Prostředí AIR zahrnuje objekt XMLHttpRequest (XHR), který může být využíván aplikacemi k vytváření požadavků
na data. V následujícím příkladu je popsán jednoduchý požadavek na data:
xmlhttp = new XMLHttpRequest();
xmlhttp.open("GET", "http:/www.example.com/file.data", true);
xmlhttp.onreadystatechange = function() {
if (xmlhttp.readyState == 4) {
//do something with data...
}
}
xmlhttp.send(null);
Prostředí AIR na rozdíl od prohlížeče umožňuje obsahu spuštěnému v aplikační karanténě požadovat data z kterékoli
domény. Výsledek požadavku XHR obsahující řetězec JSON může být vyhodnocením převeden na datové objekty,
pokud zároveň neobsahuje spustitelný kód. Jsou-li ve výsledku požadavku XHR přítomny spustitelné příkazy, dojde k
chybě a pokus o vyhodnocení se nezdaří.
Aby nebyl nedopatřením vložen kód ze vzdálených zdrojů, synchronní požadavky XHR, pokud byly vytvořeny před
dokončením načtení stránky, vrátí prázdný výsledek. Asynchronní požadavky XHR jsou po načtení stránky vždy
vráceny.
Prostředí AIR ve výchozím nastavení blokuje požadavky XMLHttpRequest mezi doménami v neaplikačních
karanténách. Nadřazené okno v aplikační karanténě může povolit požadavky mezi doménami v podřízeném rámci s
obsahem v neaplikační karanténě po nastavení atributu allowCrossDomainXHR přidaného prostředím AIR v
nadřazeném prvku frame nebo iframe na hodnotu true:
Prostředí HTML
<iframe id="mashup"
src="http://www.example.com/map.html"
allowCrossDomainXHR="true"
</iframe>
Poznámka: Třída URLStream prostředí AIR může být ve vhodných případech rovněž použita ke stažení dat.
Pokud odešlete požadavek XMLHttpRequest na vzdálený server z elementu frame nebo iframe zahrnujícího obsah
aplikace, který byl namapován do vzdálené karantény, přesvědčte se, že adresa URL mapování nemaskuje adresu
serveru použitou v požadavku XHR. Zvažte například následující definici elementu iframe, která mapuje obsah
aplikace do vzdálené karantény pro doménu example.com:
<iframe id="mashup"
documentRoot="app:/sandbox/"
sandboxRoot="http://www.example.com/"
</iframe>
Protože atribut sandboxRoot přemapuje kořenovou adresu URL adresy www.example.com, všechny požadavky
budou načteny z adresáře aplikace a nikoli ze vzdáleného serveru. Požadavky jsou přemapovány, ať jsou odvozeny z
navigace stránky nebo z požadavku XMLHttpRequest.
Aby nebyly nedopatřením blokovány požadavky na data určené příslušnému vzdálenému serveru, mapujte atribut
sandboxRoot do podadresáře adresy URL a nikoli do kořenového adresáře. Tento adresář nemusí nutně existovat.
Chcete-li například povolit požadavky na server www.example.com na stahování ze vzdáleného serveru a nikoli z
adresáře aplikace, změňte předchozí element iframe na tento:
<iframe id="mashup"
sandboxRoot="http://www.example.com/air/"
</iframe>
V takovém případě bude místně načten pouze obsah podadresáře air.
Další informace o mapování karantény naleznete v části „Elementy HTML frame a iframe“ na stránce 202 a
„Zabezpečení HTML“ na stránce 29.
Objekt Canvas (Plátno)
Objekt Canvas (Plátno) určuje rozhraní API pro kreslení geometrických tvarů, jako jsou čáry, oblouky, elipsy a
mnohoúhelníky. Chcete-li použít rozhraní API plátna, nejprve přidejte do dokumentu element plátno a pak v něm
kreslete pomocí rozhraní API Canvas (Plátno) jazyka JavaScript. Ve většině ostatních ohledů se objekt Canvas (Plátno)
chová jako obraz.
V následujícím příkladu je pomocí objektu Canvas (Plátno) kreslen trojúhelník:
Prostředí HTML
<html>
<body>
<canvas id="triangleCanvas" style="width:40px; height:40px;"></canvas>
<script>
var canvas = document.getElementById("triangleCanvas");
var context = canvas.getContext("2d");
context.lineWidth = 3;
context.strokeStyle = "#457232";
context.beginPath();
context.moveTo(5,5);
context.lineTo(35,5);
context.stroke();
</script>
</body>
</html>
Další dokumenty týkající se rozhraní API Canvas (Plátno)naleznete na stránce Safari JavaScript Reference (Příručka
jazyka JavaScript pro webový prohlížeč Safari) společnosti Apple. Povšimněte si, že se nedávno v rámci projektu
Webkit za účelem standardizace začalo měnit rozhraní API Canvas (Plátno), jak je uvedeno v dokumentu HTML 5
Working Draft (Pracovní návrh HTML 5) předloženém skupinou WHATWG (Web Hypertext Application
Technology Working Group) a konsorciem W3C. Výsledkem je, že některé dokumenty příručky jazyka JavaScript pro
webový prohlížeč Safari mohou být nekonzistentní s verzí objektu Canvas (Plátno) v rámci prostředí AIR.
Soubory cookie
V aplikacích AIR může soubory cookie využívat pouze obsah ve vzdálených karantén (obsah načtený ze zdrojů http:
a https:) (vlastnost document.cookie. V aplikační karanténě poskytují rozhraní API prostředí AIR další prostředky
pro ukládání trvalých dat (například třídy EncryptedLocalStore a FileStream).
Objekt Clipboard (Schránka)
Rozhraní API Clipboard (Schránka) modulu WebKit je řízeno těmito událostmi: copy (kopírování), cut (vyjmutí) a
paste (vložení). Objekt události předaný prostřednictvím těchto událostí poskytuje přístup ke schránce
prostřednictvím vlastnosti clipboardData. Následující metody objektu clipboardData lze použít ke čtení nebo
zápisu dat schránky:
Metoda
Popis
clearData(mimeType)
Vymaže data schránky. Parametr mimeType nastavte na typ MIME dat určených k vymazání.
getData(mimeType)
Slouží k získání dat schránky. Tuto metodu je možné vyvolat pouze do manipulačního programu události
paste (vložení). Parametr mimeType nastavte na typ MIME dat určených k vrácení.
setData(mimeType, data)
Slouží ke kopírování dat do schránky. Parametr mimeType nastavte na typ MIME požadovaných dat.
Kód jazyka JavaScript mimo aplikační karanténu může získat přístup ke schránce pouze prostřednictvím těchto
událostí. Avšak obsah v aplikační karanténě může získat přístup ke schránce systému přímo pomocí třídy Clipboard
(Schránka) prostředí AIR. K získání dat v textovém formátu umístěných ve schránce je například možné použít
následující příkaz:
var clipping = air.Clipboard.generalClipboard.getData("text/plain",
air.ClipboardTransferMode.ORIGINAL_ONLY);
Platné typy MIME dat jsou tyto:
Prostředí HTML
Typ MIME
Hodnota
Text
"text/plain"
HTML
"text/html"
URL
"text/uri-list"
Bitmapa
"image/x-vnd.adobe.air.bitmap"
Seznam souborů
"application/x-vnd.adobe.air.file-list"
Důležité: Přístup k datům obsaženým ve schránce může získat pouze obsah v aplikační karanténě. Pokud se o přístup k
objektu souboru ze schránky pokusí obsah mimo aplikaci, dojde k chybě zabezpečení.
Další informace o používání schránky naleznete v části „Kopírování a vkládání“ na stránce 137 a na stránce Using the
Pasteboard from JavaScript (Používání pracovní plochy prostřednictvím jazyka JavaScript) (Apple Developer Center).
Přetažení
Gesty přetažení do HTML a z HTML jsou vytvářeny následující události DOM: dragstart, drag, dragend,
dragenter, dragover, dragleave a drop. Objekt události předaný v těchto událostech poskytuje přístup k
přetaženým datům prostřednictvím vlastnosti dataTransfer. Vlastnost dataTransfer odkazuje na objekt, který
poskytuje stejné metody jako objekt clipboardData asociovaný s událostí schránky. Následující funkci můžete
například použít k získání dat v textovém formátu z události drop (vložení):
function onDrop(dragEvent){
return dragEvent.dataTransfer.getData("text/plain",
air.ClipboardTransferMode.ORIGINAL_ONLY);
}
Objekt dataTransfer obsahuje následující důležité členy:
Člen
Popis
clearData(mimeType)
Vymaže data. Parametr mimeType nastavte na typ MIME reprezentace dat určené k vymazání.
getData(mimeType)
Slouží k získání přetažených dat. Tuto metodu je možné vyvolat pouze do manipulačního programu události
drop (vložení). Parametr mimeType nastavte na typ MIME dat, která chcete získat.
setData(mimeType, data)
Slouží k nastavení dat určených k přetažení. Parametr mimeType nastavte na typ MIME požadovaných dat.
types
Pole řetězců obsahující typy MIME všech reprezentací dat aktuálně dostupných v objektu dataTransfer.
effectsAllowed
Určuje, zda přetažená data mohou být kopírována, přesunuta, propojena, nebo zpracována některou
kombinací těchto operací. Vlastnost effectsAllowed nastavte v manipulačním programu události
dragstart.
dropEffect
Určuje, které z povolených efektů vložení jsou podporovány cílem přetažení. Vlastnost dropEffect nastavte
v manipulačním programu události dragEnter. Během přetažení se kurzor mění a udává efekt, který by mělo
uvolnění myši uživatelem. Není-li určena žádná událost dropEffect, bude vybrán účinek vlastnosti
effectsAllowed. Efekt kopírování má přednost před efektem přesunutí, který má přednost před efektem
vazby. Uživatel může změnit výchozí prioritu pomocí klávesnice.
Další informace o přidávání podpory přetažení do aplikace AIR naleznete v části „Přetažení“ na stránce 123 a na
stránce Using the Drag-and-Drop from JavaScript (Používání funkce přetažení prostřednictvím jazyka JavaScript)
(Apple Developer Center).
Prostředí HTML
Vlastnosti innerHTML a outerHTML
Prostředí AIR uplatňuje omezení použití vlastností innerHTML a outerHTML pro obsah spuštěný v aplikační
karanténě. Před událostí načtení stránky a během spouštění jakýchkoli manipulačních programů události načtení je
použití vlastností innerHTML a outerHTML neomezené. Avšak jakmile je stránka načtena, můžete pro přidání
statického obsahu do dokumentu použít pouze vlastnost innerHTML nebo outerHTML. Jakýkoli příkaz v řetězci
přiřazeném k vlastnosti innerHTML nebo outerHTML, který se vyhodnocuje na spustitelný kód, je ignorován. Pokud
například zahrnete do definice elementu atribut zpětného vyvolání události, nebude přidán posluchač události.
Obdobně nebudou vyhodnoceny vložené tagy <script>. Další informace naleznete v části „Zabezpečení HTML“ na
stránce 29.
Metody Document.write() a Document.writeln()
Použití metod write() a writeln() není v aplikační karanténě před událostí na tení stránky omezeno. Avšak
jakmile je stránka načtena, vyvolání kterékoli z těchto metod stránku nevymaže ani nevytvoří novou. V neaplikační
karanténě, jako ve většině webových prohlížečů, vyvolání metody document.write() nebo writeln() po dokončení
načtení stránky vymaže aktuální stránku a otevře novou, prázdnou.
Vlastnost Document.designMode
Nastavíte-li vlastnost document.designMode na hodnotu on, elementy v dokumentu bude možné upravit. Podpora
vestavěného editoru zahrnuje úpravy, kopírování, vložení a přetažení textu. Nastavení vlastnosti designMode na
hodnotu on a nastavení vlastnosti contentEditable elementu body na hodnotu true jsou ekvivalentní. Vlastnost
contentEditable lze použít u většiny elementů HTML k určení částí dokumentu, které bude možné upravit. Další
informace naleznete v části „Atribut contentEditable jazyka HTML“ na stránce 205.
Události unload (odstranění z paměti) (pro objekty body a frameset)
V tagu nejvyšší úrovně sady rámc nebo hlavní ást okna (včetně hlavního okna aplikace) nepoužívejte událost
unload (odstranění z paměti) pro reakci na zavření okna (nebo ukončení aplikace). Namísto ní použijte událost
ukon ení objektu NativeApplication (ke zjištění okamžiku ukončování aplikace). Také můžete použít událost
zavírání objektu NativeWindow (ke zjištění okamžiku zavírání okna). Například následující kód jazyka JavaScript
zobrazí zprávu("Goodbye."), když uživatel ukončuje aplikaci:
var app = air.NativeApplication.nativeApplication;
app.addEventListener(air.Event.EXITING, closeHandler);
function closeHandler(event)
{
alert("Goodbye.");
}
Avšak skripty mohou úspěšně reagovat na událost unload (odstranění z paměti) způsobenou navigací elementu frame,
iframe nebo obsahu okna nejvyšší úrovně.
Poznámka: Tato omezení mohou být v budoucí verzi prostředí Adobe AIR odstraněna.
Objekt Window (Okno) jazyka JavaScript
Objekt okno zůstává v kontextu provádění jazyka JavaScript globálním objektem. V aplikační karanténě přidává
prostředí AIR nové vlastnosti objektu Window (Okno) jazyka JavaScript, aby poskytlo přístup k vestavěným třídám
prostředí AIR a důležitým objektům hostitele. Kromě toho se některé metody a vlastnosti chovají rozdílně podle toho,
zda jsou nebo nejsou uvnitř aplikační karantény.
Vlastnost window.runtime Vlastnost runtime umožňuje vytvářet instance a používat vestavěné třídy runtime z
prostředí aplikační karantény. Tyto třídy zahrnují rozhraní API prostředí AIR a programu Flash Player (ale nikoli
například rámec Flex). Následující příkaz například vytvoří objekt souboru prostředí AIR:
Prostředí HTML
var preferencesFile = new window.runtime.flash.filesystem.File();
Soubor AIRAliases.js obsažený v sadě AIR SDK zahrnuje definice aliasů, které umožňují zkrátit takovéto odkazy.
Pokud je například soubor AIRAliases.js importován na stránku, objekt File (Soubor) může být vytvořen pomocí
následujícího příkazu:
var preferencesFile = new air.File();
Vlastnost window.runtime je definována pouze pro obsah v aplikační karanténě a pouze pro nadřazený dokument
stránky s elementy frame a iframe.
Viz část „Použití souboru AIRAliases.js“ na stránce 213.
Vlastnost Window.nativeWindow Vlastnost nativeWindow poskytuje odkaz na základní objekt nativního okna.
Pomocí této vlastnosti můžete vytvořit skript funkcí okna a vlastností, jako je poloha, velikost a viditelnost obrazovky,
a zpracovávat události okna, například zavření, změnu velikosti a přesunutí. Například následující příkaz slouží k
zavření okna:
window.nativeWindow.close();
Poznámka: Funkce ovládání okna zajištěné objektem NativeWindow překryje funkce dodané objektem Window (Okno)
jazyka JavaScript. V takových případech můžete použít metodu, která se jeví jako nejvhodnější.
Vlastnost window.nativeWindow je definována pouze pro obsah v aplikační karanténě a pouze pro nadřazený
dokument stránky s elementy frame a iframe.
Vlastnost Window.htmlLoader Vlastnost HTMLLoader poskytuje odkaz na objekt HTMLLoader prostředí AIR, v němž
se nachází obsah HTML. Pomocí této vlastnosti můžete vytvářet skripty vzhledu a chování prostředí HTML.
Například vlastnost htmlLoader.paintsDefaultBackground můžete použít k určení, zda bude ovládací prvek
malovat výchozí bílé pozadí:
Poznámka: Objekt HTMLLoader sám o sobě má vlastnost window (okno), která odkazuje na objekt Window (Okno)
jazyka JavaScript obsahu HTML, který zahrnuje. Tuto vlastnost můžete použít pro přístup k prostředí jazyka JavaScript
prostřednictvím odkazu na nadřazený objekt HTMLLoader.
Vlastnost window.htmlLoader je definována pouze pro obsah v aplikační karanténě a pouze pro nadřazený
dokument stránky s elementy frame a iframe.
Vlastnosti Window.parentSandboxBridge a Window.childSandboxBridge Vlastnosti parentSandboxBridge a
childSandboxBridge umožňují definovat rozhraní mezi nadřazeným a podřízeným elementem frame. Další
informace naleznete v části „Vytváření křížových skriptů pro obsah v různých karanténách zabezpečení“ na
stránce 221.
Funkce Window.setTimeout() a Window.setInterval() Prostředí AIR uplatňuje bezpečnostní omezení pro používání
funkcí setTimeout() a setInterval() v rámci aplikační karantény. Kód, který má být spuštěn, nelze při vyvolání
funkce setTimeout() nebo setInterval() definovat jako řetězec. Je nutné použít odkaz funkce. Další informace
naleznete v části „setTimeout() a setInterval()“ na stránce 211.
Funkce Window.open() Pokud je metoda open() vyvolána kódem spuštěným v neaplikační karanténě, otevře okno
pouze je-li vyvolána v důsledku interakce uživatele (například klepnutí myší nebo stisknutí klávesy). Nadpis okna
obsahuje předponu názvu aplikace (aby nedošlo k otevření oken vzdáleným obsahem z oken zosobnění otevřených
pomocí aplikace). Další informace naleznete v části „Omezení pro volání metody JavaScript window.open()“ na
stránce 33.
Prostředí HTML
Objekt air.NativeApplication
Objekt NativeApplication poskytuje informace o stavu aplikace, odesílá některé důležité události na úrovni aplikace a
nabízí užitečné funkce pro ovládání chování aplikace. Jednotlivá instance objektu NativeApplication je vytvořena
automaticky a lze k ní získat přístup prostřednictvím vlastnosti NativeApplication.nativeApplication
definované pomocí třídy.
Pro přístup k objektu z kódu jazyka JavaScript můžete použít:
var app = window.runtime.flash.desktop.NativeApplication.nativeApplication;
Nebo, pokud byl importován skript AIRAliases.js, můžete použít kratší tvar:
var app = air.NativeApplication.nativeApplication;
Objekt NativeApplication je přístupný pouze zevnitř aplikační karantény. Interakce s operačním systémem„Práce s
runtime a informacemi operačního systému“ na stránce 267 podrobně popisuje objekt NativeApplication.
Schéma adresy URL v jazyce JavaScript
Spouštění kódu definovaného ve schématu adresy URL jazyka JavaScript (jako v případě
href="javascript:alert('Test')") je blokováno uvnitř aplikační karantény. Nedošlo k žádné chybě.
Rozšíření pro jazyk HTML
Prostředí AIR a modul WebKit definují několik nestandardních elementů a atributů HTML, mimo jiné:
„Elementy HTML frame a iframe“ na stránce 202
„Element Canvas (Plátno) jazyka HTML“ na stránce 204
„Manipulační programy událostí elementů HTML“ na stránce 204
Elementy HTML frame a iframe
Prostředí AIR přidává nové atributy elementům frame a iframe obsahu v aplikační karanténě:
Atribut sandboxRoot Atribut sandboxRoot určuje alternativní doménu (nikoli doménu aplikace) původu souboru
určeného atributem src elementu frame. Soubor je načten do neaplikační karantény odpovídající určené doméně.
Obsah v souboru a obsah načtený z určené domény mohou vzájemně vytvářet křížové skripty.
Důležité: Pokud nastavíte hodnotu atributu sandboxRoot na základní adresu URL domény, všechny požadavky na
obsah z této domény budou načteny z adresáře aplikace a nikoli ze vzdáleného serveru (ať již je požadavek výsledkem
navigace stránky, objektu XMLHttpRequest, nebo jakéhokoli jiného prostředku pro načtení obsahu).
Atribut documentRoot Atribut documentRoot určuje místní adresář, z něhož mají být načteny adresy URL, které
budou přeloženy na soubory v umístění určeném atributem sandboxRoot.
Při překladu adres URL, buď v atributu src elementu frame, nebo v obsahu načteném do elementu frame, je část
adresy URL odpovídající hodnotě určené v atributu sandboxRoot nahrazena hodnotou určenou v atributu
documentRoot. Tímto způsobem v následujícím tagu rámce:
<iframe
src="http://www.example.com/air/child.html"
sandboxRoot="http://www.example.com/air/"/>
je soubor child.html načten z podadresáře sandbox instalační složky aplikace. Relativní adresy URL v souboru
child.html jsou přeloženy podle adresáře sandbox. Povšimněte si, že žádné soubory na vzdáleném serveru na adrese
www.example.com/air nejsou dostupné v rámci, protože pak by se prostředí AIR pokusilo je načíst z adresáře
app:/sandbox/.
Prostředí HTML
Atribut allowCrossDomainXHR Zahrnete-li řetězec allowCrossDomainXHR="allowCrossDomainXHR" do
počátečního tagu, povolíte, aby obsah v rámci odeslal požadavky XMLHttpRequest na libovolnou vzdálenou doménu.
Ve výchozím nastavení může obsah mimo aplikaci vytvářet takové požadavky pouze na svou vlastní doménu původu.
S požadavky XHR mezi doménami souvisejí vážné bezpečnostní aspekty. Kód na stránce je schopen vyměňovat si data
s libovolnou doménou. Pokud je na stránku nějakým způsobem vložen nebezpečný obsah, bezpečnost veškerých dat
dostupných pro kód v aktuální karanténě může být ohrožena. Povolte pouze požadavky XHR mezi doménami, které
vytváříte a ovládáte, a pouze pokud je načítání dat mezi doménami skutečně nezbytné. Rovněž pečlivě ověřujte
platnost všech dat načítaných stránkou, abyste zabránili vkládání kódů a jiným formám útoků.
Důležité: Jestliže je atribut allowCrossDomainXHR obsažen v elementu frame nebo iframe, požadavky XHR mezi
doménami jsou povoleny (pokud přiřazená hodnota není „0“ nebo nezačíná písmenem „f“ nebo „n“). Nastavíte-li
například atribut allowCrossDomainXHR na hodnotu "deny", požadavky XHR mezi doménami budou přesto povoleny.
Nechcete-li povolit požadavky mezi doménami, ponechte atribut zcela mimo deklaraci elementu.
Atribut ondominitialize Určuje manipulační program události pro událost dominitialize rámce. Tato událost je
specifická pro prostředí AIR a spouští se poté, co byly vytvořeny objekty okno a dokument rámce, ale před tím, než
byly analyzovány jakékoli skripty byly vytvořeny elementy Dokument.
Rámec odešle událost dominitialize dostatečně brzy v sekvenci načítání, aby mohl libovolný skript na podřízené
stránce odkazovat na objekty, proměnné a funkce přidané do podřízeného dokumentu manipulačním programem
události dominitialize. Nadřízená stránka se musí nacházet ve stejné karanténě jako podřízená stránka, aby bylo
možné přímo přidat nebo získat přístup k libovolným objektům v podřízeném dokumentu. Avšak nadřazený prvek v
aplikační karanténě může vytvořit most karantény pro komunikaci s obsahem v neaplikační karanténě.
Následující příklady ilustrují použití tagu iframe v prostředí AIR:
Umístěte soubor child.html do vzdálené karantény bez mapování do skutečné domény na vzdáleném serveru:
<iframe
src="http://localhost/air/child.html"
sandboxRoot="http://localhost/air/"/>
Umístěte soubor child.html do vzdálené karantény a povolte požadavky XMLHttpRequest pouze na server
www.example.com:
<iframe
sandboxRoot="http://www.example.com/air/"/>
Umístěte soubor child.html do vzdálené karantény a povolte požadavky XMLHttpRequest na libovolnou vzdálenou
doménu:
<iframe
allowCrossDomainXHR="allowCrossDomainXHR"/>
Umístěte soubor child.html do karantény místního vzhledem k systému souborů:
<iframe
src="file:///templates/child.html"
sandboxRoot="app-storage:/templates/"/>
Umístěte soubor child.html do vzdálené karantény a pomocí události dominitialize vytvořte most karantény:
Prostředí HTML
<html>
<head>
<script>
var bridgeInterface = {};
bridgeInterface.testProperty = "Bridge engaged";
function engageBridge(){
document.getElementById("sandbox").parentSandboxBridge = bridgeInterface;
}
</script>
</head>
<body>
<iframe id="sandbox"
ondominitialize="engageBridge()"/>
</body>
</html>
Následující dokument child.html ilustruje způsob, jakým může podřízený obsah získat přístup k nadřazenému
mostu karantény:
<html>
<head>
<script>
document.write(window.parentSandboxBridge.testProperty);
</script>
</head>
<body></body>
</html>
Další informace naleznete v části „Vytváření křížových skriptů pro obsah v různých karanténách zabezpečení“ na
stránce 221 a „Zabezpečení HTML“ na stránce 29.
Element Canvas (Plátno) jazyka HTML
Definuje kreslicí oblast, kterou lze použít s rozhraním API Canvas (Plátno) modulu Webkit. Příkazy grafiky nemohou
být určeny v samotném tagu. Chcete-li kreslit na plátno, vyvolejte metody kreslení na plátno prostřednictvím jazyka
JavaScript.
<canvas id="drawingAtrium" style="width:300px; height:300px;"></canvas>
Další informace naleznete v části „Objekt Canvas (Plátno)“ na stránce 197.
Manipulační programy událostí elementů HTML
Objekty DOM v prostředí AIR a v modulu Webkit odesílají některé události, které se nenacházejí ve standardním
modelu události DOM. V následující tabulce jsou uvedeny související atributy událostí, které můžete použít k určení
manipulačních programů pro tyto události:
Název atributu zpětného vyvolání
Popis
oncontextmenu
Vyvolá se po otevření kontextové nabídky, například klepnutím pravým tlačítkem myši nebo
klepnutím na vybraný text se stisknutou klávesou Apple.
oncopy
Vyvolá se po zkopírování výběru v elementu.
oncut
Vyvolá se po vyjmutí výběru v elementu.
Prostředí HTML
Název atributu zpětného vyvolání
Popis
ondominitialize
Vyvolá se po vytvoření modelu DOM dokumentu načteného do elementu frame nebo iframe, ale
předtím, než jsou vytvořeny jakékoli elementy DOM nebo analyzovány skripty.
ondrag
Vyvolá se při přetažení elementu.
ondragend
Vyvolá se po uvolnění při přetažení.
ondragenter
Vyvolá se, když gesto přetažení vstupuje do ohraničení elementu.
ondragleave
Vyvolá se, když gesto přetažení opouští ohraničení elementu.
ondragover
Vyvolává se neustále po dobu, kdy se gesto přetažení nachází uvnitř ohraničení elementu.
ondragstart
Vyvolá se po zahájení gesta přetažení.
ondrop
Vyvolá se, když je gesto přetažení uvolněno na elementu.
onerror
Vyvolá se, pokud během načítání elementu dojde k chybě.
oninput
Vyvolá se po zadání textu do elementu formuláře.
onpaste
Vyvolá se po vložení položky do elementu.
onscroll
Vyvolá se, pokud je posouván element s možností posuvu.
onsearch
Vyvolá se při kopírování elementu. (Jsou dokumenty Apple správné?)
onselectstart
Vyvolá se po zahájení výběru.
Atribut contentEditable jazyka HTML
Atribut contentEditable můžete přidat ke kterémukoli elementu HTML, chcete-li uživatelům povolit úpravy jeho
obsahu. Například následující kód HTML nastavuje celý dokument jako upravitelný s výjimkou prvního elementu p:
<html>
<head/>
<body contentEditable="true">
<h1>de Finibus Bonorum et Malorum</h1>
<p contentEditable="false">Sed ut perspiciatis unde omnis iste natus error.</p>
<p>At vero eos et accusamus et iusto odio dignissimos ducimus qui blanditiis.</p>
</body>
</html>
Poznámka: Nastavíte-li vlastnost document.designMode na hodnotu on, všechny elementy v dokumentu budou
upravitelné bez ohledu na nastavení atributu contentEditable pro jednotlivé elementy. Avšak nastavením vlastnosti
designMode na hodnotu off nezakážete úpravy elementů, pro které má vlastnost contentEditable hodnotu true.
Další informace naleznete v části „Vlastnost Document.designMode“ na stránce 200.
Rozšíření pro jazyk CSS
Modul WebKit podporuje několik rozšířených vlastností CSS. V následující tabulce jsou uvedeny vlastnosti, pro které
je zajištěna podpora. V modulu WebKit jsou k dispozici nestandardní vlastnosti, ty ale nejsou plně podporovány v
prostředí AIR, buď proto, že jsou v modulu WebKit dosud ve vývoji, nebo protože se jedná o pokusné funkce, které
mohou být v budoucnosti odebrány.
Prostředí HTML
Název vlastnosti CSS
Hodnoty
Popis
-webkit-border-horizontal-spacing
Nezáporná délková jednotka
Určuje vodorovnou komponentu okraje u
ohraničení.
-webkit-border-vertical-spacing
Nezáporná délková jednotka
Určuje svislou komponentu okraje u
ohraničení.
-webkit-line-break
after-white-space, normální
Určuje pravidlo zalomení řádku pro čínský,
japonský a korejský text (CJK).
-webkit-margin-bottom-collapse
sbalit, zrušit, oddělit
Určuje způsob sbalení spodního okraje
tabulky.
-webkit-margin-collapse
Určuje způsob sbalení horního a spodního
okraje buňky v tabulce.
-webkit-margin-start
Libovolná délková jednotka.
Šířka počátečního okraje. U textu psaného
zleva doprava tato vlastnost potlačí levý okraj.
U textu psaného zprava doleva tato vlastnost
potlačí pravý okraj.
-webkit-margin-top-collapse
Určuje způsob sbalení horního okraje buňky v
tabulce.
-webkit-nbsp-mode
normální, mezera
Určuje chování pevných mezer v uzavřeném
obsahu.
-webkit-padding-start
Libovolná délková jednotka
Určuje šířku počátečního odsazení. U textu
psaného zleva doprava tato vlastnost potlačí
hodnotu levého odsazení. U textu psaného
zprava doleva tato vlastnost potlačí hodnotu
pravého odsazení.
-webkit-rtl-ordering
logická, vizuální
Potlačí výchozí zpracování smíšených textů
psaných zleva doprava a zprava doleva.
-webkit-text-fill-color
Jakákoli pojmenovaná nebo číselná hodnota
barvy
Určuje barvu výplně textu.
-webkit-text-security
kruh, kotouč, žádný, čtverec
Určuje náhradní tvar, který se použije v poli
pro zadání hesla.
-webkit-user-drag
•
automaticky – Výchozí chování
Potlačí chování při automatickém přetažení.
•
element – Celý element je přetažen
•
žádný – Element nelze přetáhnout
-webkit-user-modify
pouze čtení, čtení a zápis, pouze čtení a zápis
prostého textu
Určuje, zda může být obsah elementu
upravován.
-webkit-user-select
•
automaticky – Výchozí chování
Určuje, zda může uživatel vybrat obsah
elementu.
•
žádný – Element nelze vybrat
•
text – V elementu může být vybrán pouze
text
Další informace naleznete v příručce společnosti Apple k jazyku CSS v prohlížeči Safari
(http://developer.apple.com/documentation/AppleApplications/Reference/SafariCSSRef/).
207
Kapitola 21: Programování v jazycích
HTML a JavaScript
Některá témata programování jsou jedinečná pro vývoj aplikací Adobe® AIR™ pomocí jazyků HTML a JavaScript.
Následující informace jsou důležité bez ohledu na to, zda programujete aplikaci AIR založenou na HTML nebo
aplikaci AIR založenou na SWF, která spouští HTML a JavaScript pomocí třídy HTMLLoader (nebo komponenty
mx:HTML Flex™).
Popis třídy HTMLLoader
Třída HTMLLoader aplikace Adobe AIR definuje objekty zobrazení, které mohou v aplikaci AIR zobrazit obsah
HTML. Aplikace založené na SWF mohou přidat ovladač HTMLLoader do existujícího okna nebo vytvořit okno
HTML, které bude automaticky obsahovat objekt HTMLLoader, pomocí metody
HTMLLoader.createRootWindow(). K objektu HTMLLoader lze získat přístup prostřednictvím vlastnosti jazyka
JavaScript window.htmlLoader z načtené stránky HTML.
Načtení obsahu HTML z URL
Následující kód načte URL do objektu HTMLLoader a nastaví objekt jako podřízený objektu Sprite:
var container:Sprite;
var html:HTMLLoader = new HTMLLoader;
html.width = 400;
html.height = 600;
var urlReq:URLRequest = new URLRequest("http://www.adobe.com/");
html.load(urlReq);
container.addChild(html);
Vlastnosti width a height objektu HTMLLoader jsou standardně nastaveny na hodnotu 0. Tyto rozměry je vhodné
nastavit při přidávání objektu HTMLLoader na plochu. Objekt HTMLLoader odešle při načítání stránky několik
událostí. Pomocí těchto událostí lze určit, kdy lze s načtenou stránkou bezpečně interaktivně pracovat. Tyto události
jsou popsány v sekci „Zpracování událostí týkajících se HTML“ na stránce 225.
Text HTML lze rovněž vykreslit pomocí třídy TextField, ale její možnosti jsou omezené. Třída TextField aplikace
Adobe® Flash® Player podporuje podmnožinu značek HTML, její možnosti jsou však omezené z důvodu omezení
velikosti. (Třída HTMLLoader obsažená v aplikaci Adobe AIR není v aplikaci Flash Player k dispozici.)
Načtení obsahu HTML z řetězce
Metoda loadString() objektu HTMLLoader načte řetězec obsahu HTML do objektu HTMLLoader:
var htmlStr:String = "<html><body>Hello <b>world</b>.</body></html>";
html.loadString(htmlStr);
Obsah načtený pomocí metody loadString() se vloží do karantény zabezpečení aplikace a tím jí zajistí plný přístup
k rozhraní API aplikace AIR.
Programování v jazycích HTML a JavaScript
Důležitá pravidla zabezpečení při použití HTML v aplikacích AIR
Soubory instalované s aplikací AIR mají přístup k rozhraním API aplikace AIR. Obsah z jiných zdrojů tento přístup z
důvodu zabezpečení nemá. Kvůli tomuto omezení nemůže například obsah ze vzdálené domény (např.
http://example.com) číst obsah adresáře plochy uživatele (v lepším případě).
Vzhledem k tomu, že se v zabezpečení vyskytují mezery, kterých lze využít voláním funkce eval() (a souvisejících
rozhraní API), obsah instalovaný s aplikací má použití těchto funkcí standardně zakázáno. Některé architektury Ajax
však používají volání funkce eval() a souvisejících rozhraní API.
Má-li být obsah dobře zformován, aby fungoval v aplikaci AIR, je třeba vzít v úvahu pravidla pro omezení vyplývající
ze zabezpečení týkající se obsahu z jiných zdrojů. Obsah z jiných zdrojů se umístí do samostatných klasifikací
zabezpečení zvaných karantény (viz sekce „Karantény zabezpečení“ na stránce 26). Obsah instalovaný s aplikací se
standardně instaluje do karantény, která se nazývá aplikační karanténa, a to mu zajistí přístup k rozhraním API
aplikace AIR. Aplikační karanténa je obvykle nejbezpečnější karanténa, pro niž jsou zavedena omezení zamezující
provedení nedůvěryhodného kódu.
Běhový modul umožňuje načtení obsahu instalovaného s aplikací do jiné karantény, než je aplikační karanténa. Obsah
v neaplikačních karanténách pracuje v prostředí zabezpečení podobném běžnému webovému prohlížeči. Kód v
neaplikačních karanténách například může použít metodu eval() a další související metody (ale současně nemá
povolen přístup k rozhraním API aplikace AIR). Běhový modul zahrnuje postupy pro zajištění bezpečné komunikace
obsahu v různých karanténách (aniž by například byla rozhraní API aplikace AIR vystavena neaplikačnímu obsahu).
Podrobnosti naleznete v sekci „Vytváření křížových skriptů pro obsah v různých karanténách zabezpečení“ na
stránce 221.
Jestliže voláte kód, který má z bezpečnostních důvodů zakázáno používat karanténu, odešle běhový modul chybu
jazyka JavaScript: „Narušení bezpečnosti běhu aplikace Adobe AIR pro kód JavaScript v karanténě zabezpečení
aplikace“.
Aby k této chybě nedocházelo, dodržujte postupy psaní kódu popsané v následující sekci „Zamezení vzniku chyb
jazyka JavaScript souvisejících se zabezpečením“ na stránce 208.
Další informace naleznete v sekci „Zabezpečení HTML“ na stránce 29.
Zamezení vzniku chyb jazyka JavaScript souvisejících se
zabezpečením
Jestliže voláte kód, který má kvůli těmto omezením vyplývajícím ze zabezpečení zakázáno používat karanténu, odešle
běhový modul chybu jazyka JavaScript: „Narušení bezpečnosti běhu aplikace Adobe AIR pro kód JavaScript v
karanténě zabezpečení aplikace“. Aby k této chybě nedocházelo, dodržujte následující postupy psaní kódu.
Příčiny chyb jazyka JavaScript souvisejících se zabezpečením
Provádění kódu v aplikační karanténě nesmí provádět většinu operací zahrnujících vyhodnocení a provádění řetězců,
jakmile se spustí událost load dokumentu a ukončí se zpracování některých událostí load. Při pokusu o použití
následujících příkazů jazyka JavaScript, které vyhodnocují a provádějí potenciálně nezabezpečené řetězce, vzniknou
chyby jazyka JavaScript:
• funkce eval()
• setTimeout() a setInterval()
• Konstruktor funkce
Kromě toho dojde k selhání následujících typů příkazů jazyka JavaScript, aniž by byla vygenerována chyba
nebezpečného kódu JavaScript:
• javascript: URL
• Zpětná volání událostí přiřazená pomocí atributů onevent v příkazech innerHTML a outerHTML
• Načtení souborů JavaScript z místa mimo instalační adresář aplikace
• document.write() a document.writeln()
• Synchronní požadavky XMLHttpRequests před událostí load nebo během zpracování události load
• Dynamicky vytvořené elementy skriptu
Poznámka: V některých omezených případech je povoleno vyhodnocení řetězců. Další informace naleznete v sekci
„Omezení kódu pro obsah v různých karanténách zabezpečení“ na stránce 31.
Aplikace Adobe uchovává seznam architektur Ajax, o nichž je známo, že podporují karanténu zabezpečení
aplikace, na adrese http://www.adobe.com/go/airappsandboxframeworks_cz.
V následujících sekcích je popsáno, jakým způsobem je zapotřebí přepsat skripty, aby nedocházelo k těmto chybám
nebezpečného kódu JavaScript a k tichému selhání u kódu spuštěného v aplikační karanténě.
Mapování aplikačního obsahu do jiné karantény
Ve většině případů lze aplikaci přepsat nebo změnit její strukturu, aby nedocházelo k chybám jazyka JavaScript
souvisejícím se zabezpečením. Když však přepsání nebo změna struktury aplikace nepřipadá v úvahu, lze načíst
aplikační obsah do jiné karantény pomocí metody popsané v sekci „Načtení aplikačního obsahu do neaplikační
karantény“ na stránce 222. Jestliže tento obsah potřebuje také přístup k rozhraním API aplikace AIR, lze vytvořit most
karantény, jak je popsáno v sekci „Vytvoření rozhraní mostu karantény“ na stránce 222.
funkce eval()
V aplikační karanténě je možné použít funkci eval() pouze před událostí load stránky nebo během zpracování
události load. Jakmile bude stránka načtena, volání funkce eval() již nebude moci kód provést. Avšak v následujících
případech je možné kód přepsat a tím se vyhnout použití funkce eval().
Přiřazení vlastností k objektu
Místo analýzy řetězce za účelem vytvoření mechanismu přístupu k vlastnosti:
eval("obj." + propName + " = " + val);
zajistěte přístup k vlastnostem pomocí závorkové notace:
obj[propName] = val;
Vytvoření funkce s proměnnými dostupnými v kontextu
Nahraďte příkazy jako je tento:
function compile(var1, var2){
eval("var fn = function(){ this."+var1+"(var2) }");
return fn;
}
následujícím kódem:
function compile(var1, var2){
var self = this;
return function(){ self[var1](var2) };
}
Vytvoření objektu za použití názvu třídy jako parametru řetězce
Zvažte hypotetickou třídu JavaScript definovanou následujícím kódem:
var CustomClass =
{
Utils:
{
Parser: function(){ alert('constructor') }
},
Data:
{
}
};
var constructorClassName = "CustomClass.Utils.Parser";
Nejjednodušší by bylo vytvořit instanci objektu pomocí funkce eval():
var myObj;
eval('myObj=new ' + constructorClassName +'()')
Volání funkce eval() se však lze vyhnout provedením analýzy jednotlivých komponent názvu třídy a vytvořením
nového objektu pomocí závorkové notace:
function getter(str)
{
var obj = window;
var names = str.split('.');
for(var i=0;i<names.length;i++){
if(typeof obj[names[i]]=='undefined'){
var undefstring = names[0];
for(var j=1;j<=i;j++)
undefstring+="."+names[j];
throw new Error(undefstring+" is undefined");
}
obj = obj[names[i]];
}
return obj;
}
Vytvořte instanci pomocí následujícího kódu:
try{
var Parser = getter(constructorClassName);
var a = new Parser();
}catch(e){
alert(e);
}
setTimeout() a setInterval()
Nahraďte řetězec předaný jako funkce zpracování odkazem na funkci nebo objektem. Například nahraďte příkaz jako
je tento:
setTimeout("alert('Timeout')", 10);
setTimeout(alert('Timeout'), 10);
Nebo když funkce vyžaduje, aby volající nastavil objekt this, nahraďte příkaz jako je tento:
this.appTimer = setInterval("obj.customFunction();", 100);
var _self = this;
this.appTimer = setInterval(function(){obj.customFunction.apply(_self);}, 100);
Konstruktor funkce
Volání funkce new Function(param, body) lze nahradit deklarací vložené funkce nebo použít ještě před
zpracováním události load stránky.
javascript: URL
Kód definovaný v odkazu pomocí schématu URL javascript: se v karanténě aplikace ignoruje. Není vygenerována
žádná chyba nebezpečného kódu JavaScript. Pomocí schémat URL javascript: lze nahradit odkazy jako je tento:
<a href="javascript:code()">Click Me</a>
<a href="#" onclick="code()">Click Me</a>
Zpětná volání událostí přiřazená pomocí atributů onevent v příkazech
innerHTML a outerHTML
Při použití příkazu innerHTML nebo outerHTML k přidání elementů do objektového modelu dokumentu (DOM)
budou všechna zpětná volání událostí přiřazená uvnitř příkazu, např. onclick nebo onmouseover, ignorována.
Nebude vygenerována žádná chyba zabezpečení. Místo toho lze novým elementům přiřadit atribut id a nastavit
funkce zpětného volání zpracování událostí pomocí metody addEventListener().
Například existuje-li v dokumentu cílový element jako:
<div id="container"></div>
Nahraďte příkazy jako je tento:
document.getElementById('container').innerHTML =
'<a href="#" onclick="code()">Click Me.</a>';
document.getElementById('container').innerHTML = '<a href="#" id="smith">Click Me.</a>';
document.getElementById('smith').addEventListener("click", function() { code(); });
Načtení souborů JavaScript z místa mimo instalační adresář aplikace
Načtení souborů skriptů z místa mimo aplikační karanténu není povoleno. Nebude vygenerována žádná chyba
zabezpečení. Všechny soubory skriptů spuštěné v aplikační karanténě musí být instalovány v adresáři aplikace. Aby
bylo možné použít na stránce externí skripty, je třeba stránku mapovat do jiné karantény. Viz sekce „Načtení
aplikačního obsahu do neaplikační karantény“ na stránce 222.
document.write() a document.writeln()
Po zpracování události load stránky se volání metody document.write() nebo document.writeln() ignorují.
Nebude vygenerována žádná chyba zabezpečení. Případně je možné načíst nový soubor nebo nahradit tělo dokumentu
pomocí technik zpracování DOM.
Synchronní požadavky XMLHttpRequests před událostí load nebo během
zpracování události load
Synchronní požadavky XMLHttpRequests spuštěné před událostí load stránky nebo během zpracování události load
stránky nevrátí žádný obsah. Asynchronní požadavky XMLHttpRequests lze spustit, nevrátí se však dříve, než skončí
událost load. Po zpracování události load se již synchronní požadavky XMLHttpRequests chovají normálně.
Dynamicky vytvořené elementy skriptu
Dynamicky vytvořené elementy skriptu, například při vytvoření pomocí příkazu innerHTML nebo metody
document.createElement(), jsou ignorovány.
Přístup ke třídám API aplikace AIR z jazyka JavaScript
Kromě standardních a rozšířených elementů architektury Webkit má kód HTML a JavaScript přístup také k
hostitelským třídám, které poskytuje běhový modul. Tyto třídy umožňují přístup k pokročilým funkcím, které jsou k
dispozici v aplikaci AIR, k nimž patří:
• Přístup k systému souborů
• Použití lokálních databází SQL
• Řízení nabídek aplikace a okna
• Přístup k socketům pro práci v síti
• Použití vlastních tříd a objektů
• Možnosti zvuku
Rozhraní API souboru AIR například zahrnuje třídu File obsaženou v balíčku flash.filesystem. V jazyce JavaScript
lze vytvořit objekt File následujícím způsobem:
var myFile = new window.runtime.flash.filesystem.File();
Objekt runtime je speciální objekt jazyka JavaScript, který je k dispozici pro obsah HTML spuštěný v aplikační
karanténě aplikace AIR. Umožňuje přístup ke třídám runtime z jazyka JavaScript. Vlastnost flash objektu
runtime poskytuje přístup k balíčku flash. Vlastnost flash.filesystem objektu runtime zase poskytuje přístup
k balíčku flash.filesystem (a tento balíček zahrnuje třídu File). Balíčky představují způsob uspořádání tříd použitých
v jazyce ActionScript.
Poznámka: Vlastnost runtime se nepřidává automaticky k objektům oken stránek načtených do elementu frame
nebo iframe. Dokud je však podřízený dokument v aplikační karanténě, má přístup k vlastnosti runtime
nadřazeného dokumentu.
Vhledem k tomu, že struktura balíčku tříd runtime by vyžadovala, aby vývojáři zadávali dlouhé řetězce kódu
JavaScript za účelem získání přístupu k jednotlivým třídám (jako v příkazu
window.runtime.flash.desktop.NativeApplication), obsahuje sada SDK aplikace AIR soubor
AIRAliases.js, který umožňuje mnohem snazší přístup k třídám runtime (například jednoduchým zadáním
air.NativeApplication).
Třídy API aplikace AIR jsou projednávány v celé této příručce. Ostatní třídy API aplikace Flash Player, které mohou
být pro vývojáře HTML důležité, jsou popsány v Referenční příručce jazyka Adobe AIR pro vývojáře HTML.
ActionScript je jazyk používaný v obsahu SWF (Flash Player). Syntaxe jazyků JavaScript a ActionScript je však
podobná. (Oba jsou založeny na verzích jazyka ECMAScript.) Všechny vestavěné třídy jsou k dispozici v obou
jazycích, JavaScript (obsah HTML) i ActionScript (obsah SWF).
Poznámka: Kód JavaScript nemůže používat třídy Dictionary, XML a XMLList, které jsou k dispozici v jazyce
ActionScript.
Poznámka: Další informace naleznete v sekcích Třídy, balíčky a jmenné prostory jazyka ActionScript 3.0 a Základy
jazyka ActionScript pro vývojáře jazyka JavaScript.
Použití souboru AIRAliases.js
Třídy runtime jsou uspořádány do struktury balíčku, jako zde:
•
window.runtime.flash.desktop.NativeApplication
•
window.runtime.flash.desktop.ClipboardManager
•
window.runtime.flash.filesystem.FileStream
•
window.runtime.flash.data.SQLDatabase
Sada SDK aplikace AIR obsahuje soubor AIRAliases.js, který poskytuje definice „alias“ umožňující přístup ke
třídám runtime bez psaní složitých příkazů. K výše uvedeným třídám lze například získat přístup jednoduchým
zadáním:
•
air.NativeApplication
•
air.Clipboard
•
air.FileStream
•
air.SQLDatabase
Tento seznam je jen malou podmnožinou tříd v souboru AIRAliases.js. Kompletní seznam tříd a funkcí na úrovni
balíčku naleznete v Referenční příručce jazyka Adobe AIR pro vývojáře HTML.
Kromě běžně používaných tříd runtime obsahuje soubor AIRAliases.js také alias pro běžně používané funkce na
úrovni balíčku: window.runtime.trace(), window.runtime.flash.net.navigateToURL() a
window.runtime.flash.net.sendToURL(), jež mají alias air.trace(), air.navigateToURL() a
air.sendToURL().
Chcete-li použít soubor AIRAliases.js, začleňte do stránky HTML následující odkaz script:
<script src="AIRAliases.js"></script>
Podle potřeby upravte cestu v odkazu src.
Důležité: Není-li uvedeno jinak, vzorový kód JavaScript v této dokumentaci předpokládá, že byl do stránky HTML
začleněn soubor AIRAliases.js.
Popis URL v aplikaci AIR
V obsahu HTML spuštěném v aplikaci AIR lze použít kterékoliv z následujících schémat URL při definování atributů
src pro tagy img, frame, iframe a script, v atributu href tagu link či kdekoliv jinde, kde lze poskytnout URL.
Schéma URL
Popis
Příklad
file
Cesta vztahující se ke kořenu systému souborů.
app
Cesta vztahující se ke kořenovému adresáři instalované
aplikace.
app:/images
app-storage
Cesta vztahující se k odkládacímu adresáři aplikace. Aplikace
AIR definuje pro každou instalovanou aplikaci jedinečný
odkládací adresář aplikace, který je užitečný při ukládání dat
specifických pro danou aplikaci.
http
Standardní požadavek HTTP.
http://www.adobe.com
https
Standardní požadavek HTTPS.
https://secure.example.com
Další informace týkající se použití schémat URL v aplikaci AIR naleznete v sekci „Používání schémat URL AIR v
adresách URL“ na stránce 272.
Řada rozhraní API aplikace AIR, včetně tříd File, Loader, URLStream a Sound, používá objekt URLRequest místo
řetězce obsahujícího URL. Samotný objekt URLRequest se inicializuje řetězcem, který může používat kterékoliv ze
stejných schémat URL. Následující příkaz například vytvoří objekt URLRequest, který lze použít v požadavku na
domovskou stránku společnosti Adobe:
var urlReq = new air.URLRequest("http://www.adobe.com/");
Informace o objektech URLRequest naleznete v sekci „Požadavky URL a práce v síti“ na stránce 271.
Zpřístupňování objektů ActionScript pro JavaScript
JavaScript na stránce HTML načtené pomocí objektu HTMLLoader může volat třídy, objekty a funkce definované v
kontextu provádění jazyka ActionScript pomocí vlastností window.runtime, window.htmlLoader a
window.nativeWindow stránky HTML. Objekty a funkce jazyka ActionScript lze rovněž zpřístupnit pro jazyk
JavaScript vytvořením odkazů na ně v kontextu provádění jazyka JavaScript.
Jednoduchý příklad přístupu k objektům JavaScript z jazyka ActionScript
Následující příklad ilustruje, jakým způsobem lze do globálního objektu window stránky HTML přidat vlastnosti
odkazující na objekty ActionScript:
var foo:String = "Hello from container SWF."
function helloFromJS(message:String):void {
trace("JavaScript says:", message);
}
var urlReq:URLRequest = new URLRequest("test.html");
html.addEventListener(Event.COMPLETE, loaded);
html.load(urlReq);
function loaded(e:Event):void{
html.window.foo = foo;
html.window.helloFromJS = helloFromJS;
}
Obsah HTML (v souboru s názvem test.html) načtený do objektu HTMLLoader v předchozím příkladu má přístup k
vlastnosti foo a k metodě helloFromJS() definované v nadřazeném souboru SWF:
<html>
<script>
function alertFoo() {
alert(foo);
}
</script>
<body>
<button onClick="alertFoo()">
What is foo?
</button>
<p><button onClick="helloFromJS('Hi.')">
Call helloFromJS() function.
</button></p>
</body>
</html>
Při přistupování ke kontextu jazyka JavaScript načítaného dokumentu lze pomocí události htmlDOMInitialize
vytvářet objekty v sekvenci tvorby stránky dostatečně brzy, aby k nim měly přístup všechny skripty definované na
stránce. Jestliže budete čekat až na událost complete, budou mít k přidaným objektům přístup jen ty skripty na
stránce, které se spustí až po události load stránky.
Zpřístupňování definic tříd pro JavaScript
Pokud chcete, aby třídy ActionScript vlastní aplikace byly přístupné pro jazyk JavaScript, můžete načtený obsah
HTML přiřadit k aplikační doméně obsahující definice tříd. Aplikační doménu kontextu provádění jazyka JavaScript
lze nastavit pomocí vlastnosti runtimeApplicationDomain objektu HTMLLoader. Chcete-li aplikační doménu
například nastavit na primární aplikační doménu, nastavte vlastnost runtimeApplicationDomain na
ApplicationDomain.currentDomain, jak je znázorněno v následujícím kódu:
html.runtimeApplicationDomain = ApplicationDomain.currentDomain;
Po nastavení vlastnosti runtimeApplicationDomain bude kontext jazyka JavaScript sdílet definice tříd s přiřazenou
doménou. Jestliže chcete v jazyce JavaScript vytvořit instanci vlastní třídy, vytvořte odkaz na definici třídy pomocí
vlastnosti window.runtime a použijte operátor new:
var customClassObject = new window.runtime.CustomClass();
Obsah HTML musí pocházet z kompatibilní domény zabezpečení. Bude-li obsah HTML z jiné domény zabezpečení,
než je přiřazená aplikační doména, stránka místo ní použije výchozí aplikační doménu. Například při načtení vzdálené
stránky z Internetu nelze přiřadit ApplicationDomain.currentDomain jako aplikační doménu stránky.
Odstranění posluchačů událostí
Když přidáte posluchače událostí JavaScript do objektů mimo aktuální stránku, včetně objektů runtime, objektů v
načteném obsahu SWF nebo i objektů JavaScript spuštěných v jiných stránkách, je vhodné po zrušení zavedení stránky
tyto posluchače událostí vždy odstranit. V opačném případě bude posluchač událostí odesílat událost do funkce
zpracování, která již neexistuje. Pokud k tomu dojde, zobrazí se následující chybová zpráva: „Aplikace se pokusila
vytvořit odkaz na objekt JavaScript na stránce HTML, která již neexistuje“. Po odstranění nepotřebných posluchačů
událostí může aplikace AIR rovněž znovu získat s tím související paměť. Další informace naleznete v sekci „Odstranění
posluchačů událostí ve stránkách HTML, které navigují“ na stránce 229.
Přístup k objektovému modelu dokumentu HTML a
objektům JavaScript z jazyka ActionScript
Jakmile objekt HTMLLoader odešle událost complete, lze přistupovat ke všem objektům v objektovém modelu
dokumentu (DOM) HTML pro danou stránku. K přístupným objektům patří elementy zobrazení (např. objekty div
a p ve stránce), jakož i proměnné a funkce jazyka JavaScript. Událost complete odpovídá události load stránky jazyka
JavaScript. Dokud nebude odeslána událost complete, nemusí být elementy DOM, proměnné a funkce analyzovány
či vytvořeny. Pokud je to možné, počkejte na událost complete a teprve potom přistupujte k DOM HTML.
Zvažte například následující stránku HTML:
<html>
<script>
foo = 333;
function test() {
return "OK.";
}
</script>
<body>
<p id="p1">Hi.</p>
</body>
</html>
Tato jednoduchá stránka HTML definuje proměnnou jazyka JavaScript s názvem foo a funkci jazyka JavaScript s
názvem test(). Obě jsou vlastnostmi globálního objektu window této stránky. Kromě toho objekt window.document
zahrnuje element s názvem P (s ID p1), k němuž lze získat přístup pomocí metody getElementById(). Po načtení
stránky (jakmile objekt HTMLLoader odešle událost complete) lze ke každému z těchto objektů přistoupit z jazyka
ActionScript, jak znázorňuje následující kód ActionScript:
html.width = 300;
html.height = 300;
html.addEventListener(Event.COMPLETE, completeHandler);
var xhtml:XML =
<html>
<script>
foo = 333;
function test() {
return "OK.";
}
</script>
<body>
<p id="p1">Hi.</p>
</body>
</html>;
html.loadString(xhtml.toString());
function completeHandler(e:Event):void {
trace(html.window.foo); // 333
trace(html.window.document.getElementById("p1").innerHTML); // Hi.
trace(html.window.test()); // OK.
}
Chcete-li získat přístup k obsahu elementu HTML, použijte vlastnost innerHTML. Předchozí kód například používá
příkaz html.window.document.getElementById("p1").innerHTML k získání obsahu elementu HTML s názvem p1.
Z jazyka ActionScript je rovněž možné nastavit vlastnosti stránky HTML. Následující příklad například nastavuje
obsah elementu p1 a hodnotu proměnné jazyka JavaScript foo na stránce pomocí odkazu na objekt HTMLLoader,
který ji obsahuje:
html.window.document.getElementById("p1").innerHTML = "Goodbye";
html.window.foo = 66;
Vložení obsahu SWF do HTML
Obsah SWF lze v aplikaci AIR vložit do obsahu HTML stejným způsobem jako v prohlížeči. K vložení obsahu SWF
použijte tag object, tag embed nebo oba dva.
Poznámka: Při vývoji webu se obvykle používají oba tagy object i embed k zobrazení obsahu SWF na stránce HTML.
V aplikaci AIR nemá tato metoda žádný význam. V obsahu, který má být zobrazen v aplikaci AIR, lze použít samotný
tag object standardní pro W3C. Současně je možné dále používat tagy object a embed společně, pokud je to zapotřebí,
pro obsah HTML, který se má rovněž zobrazovat v prohlížeči.
Následující příklad ilustruje zobrazení souboru SWF v obsahu HTML pomocí tagu object HTML. Soubor SWF se
načte z adresáře aplikace, lze však použít libovolné schéma URL podporované aplikací AIR. (Místo, odkud se načte
soubor SWF, určí karanténu zabezpečení, do níž aplikace AIR vloží obsah.)
<object type="application/x-shockwave-flash" width="100%" height="100%">
<param name="movie" value="app:/SWFFile.swf"></param>
</object>
Obsah je rovněž možné načíst dynamicky pomocí skriptu. Následující příklad vytvoří uzel object k zobrazení
souboru SWF určeného v parametru urlString. Uzel se přidá jako podřízený element stránky s ID určeným
parametrem elementID:
<script>
function showSWF(urlString, elementID){
var displayContainer = document.getElementById(elementID);
displayContainer.appendChild(createSWFObject(urlString,650,650));
}
function createSWFObject(urlString, width, height){
var SWFObject = document.createElement("object");
SWFObject.setAttribute("type","application/x-shockwave-flash");
SWFObject.setAttribute("width","100%");
SWFObject.setAttribute("height","100%");
var movieParam = document.createElement("param");
movieParam.setAttribute("name","movie");
movieParam.setAttribute("value",urlString);
SWFObject.appendChild(movieParam);
return SWFObject;
}
</script>
Použití knihoven jazyka ActionScript na stránce HTML
Aplikace AIR rozšiřuje element script HTML, aby stránka mohla importovat třídy ActionScript do zkompilovaného
souboru SWF. Chcete-li například importovat knihovnu s názvem myClasses.swf umístěnou v podadresáři lib
kořenové složky aplikace, vložte do souboru HTML následující tag script:
<script src="lib/myClasses.swf" type="application/x-shockwave-flash"></script>
Důležité: Atribut type musí být type="application/x-shockwave-flash", aby byla knihovna správně načtena.
Při balení souboru AIR je rovněž potřeba zahrnout adresář lib a soubor myClasses.swf.
K importovaným třídám získáte přístup pomocí vlastnosti runtime objektu Window jazyka JavaScript:
var libraryObject = new window.runtime.LibraryClass();
Jsou-li třídy v souboru SWF uspořádány do balíčků, je třeba zahrnout také název balíčku. Kdyby například byla
definice LibraryClass umístěna v balíčku s názvem utilities, bylo by zapotřebí vytvořit instanci této třídy pomocí
následujícího příkazu:
var libraryObject = new window.runtime.utilities.LibraryClass();
Poznámka: Ke kompilaci knihovny ActionScript SWF, jež má být součástí stránky HTML v aplikaci AIR, použijte
kompilátor acompc. Utilita acompc je součástí sady Flex 3 SDK a je popsána v dokumentaci Flex 3 SDK.
Přístup k DOM HTML a objektům JavaScript z importovaného souboru
ActionScript
Jestliže chcete k objektům na stránce HTML přistupovat z jazyka ActionScript v souboru SWF importovaného do
stránky pomocí tagu <script>, předejte odkaz na objekt JavaScript, např. window nebo document, do funkce
definované v kódu ActionScript. Pomocí odkazu ve funkci získáte přístup k objektu JavaScript (nebo k jiným objektům
dostupným prostřednictvím předaného odkazu).
Zvažte například následující stránku HTML:
<html>
<script src="ASLibrary.swf" type="application/x-shockwave-flash"></script>
<script>
num = 254;
function getStatus() {
return "OK.";
}
function runASFunction(window){
var obj = new runtime.ASClass();
obj.accessDOM(window);
}
</script>
<body onload="runASFunction">
<p id="p1">Body text.</p>
</body>
</html>
Tato jednoduchá stránka HTML má proměnnou jazyka JavaScript s názvem num a funkci jazyka JavaScript s názvem
getStatus(). Obě jsou vlastnostmi objektu window této stránky. Kromě toho objekt window.document zahrnuje
element s názvem P (s ID p1).
Stránka načte soubor ActionScript „ASLibrary.swf“ obsahující třídu ASClass. Třída ASClass definuje funkci s názvem
accessDOM(), která jednoduše sleduje hodnoty těchto objektů JavaScript. Metoda accessDOM() bere objekt Window
jazyka JavaScript jako argument. Pomocí tohoto odkazu Window má přístup k ostatním objektům na stránce, včetně
proměnných, funkcí a elementů DOM, jak ilustruje následující definice:
public class ASClass{
public function accessDOM(window:*):void {
trace(window.num); // 254
trace(window.document.getElementById("p1").innerHTML); // Body text..
trace(window.getStatus()); // OK.
}
}
Z importované třídy ActionScript lze získat i nastavovat vlastnosti stránky HTML. Následující funkce například
nastaví obsah elementu p1 na stránce a nastaví hodnotu proměnné foo jazyka JavaScript na stránce:
public function modifyDOM(window:*):void {
window.document.getElementById("p1").innerHTML = "Bye";
window.foo = 66;
Převádění objektů Date a RegExp
Oba jazyky JavaScript i ActionScript definují třídy Date a RegExp, ale objekty těchto typů se nepřevádějí automaticky
mezi oběma kontexty provádění. Objekty Date a RegExp je nezbytné převést na ekvivalentní typ, než je bude možné
použít k nastavení vlastností nebo parametrů funkcí v alternativním kontextu provádění.
Například následující kód ActionScript převádí objekt Date jazyka JavaScript s názvem jsDate na objekt Date jazyka
ActionScript:
var asDate:Date = new Date(jsDate.getMilliseconds());
Následující kód ActionScript převádí objekt RegExp jazyka JavaScript s názvem jsRegExp na objekt RegExp jazyka
ActionScript:
var flags:String = "";
if (jsRegExp.dotAll) flags += "s";
if (jsRegExp.extended) flags += "x";
if (jsRegExp.global) flags += "g";
if (jsRegExp.ignoreCase) flags += "i";
if (jsRegExp.multiline) flags += "m";
var asRegExp:RegExp = new RegExp(jsRegExp.source, flags);
Práce se seznamem stylů HTML z jazyka ActionScript
Jakmile objekt HTMLLoader odešle událost complete, lze kontrolovat a zpracovávat styly CSS na stránce.
Zvažte například následující jednoduchý dokument HTML:
<html>
<style>
.style1A { font-family:Arial; font-size:12px }
.style1B { font-family:Arial; font-size:24px }
</style>
<style>
.style2 { font-family:Arial; font-size:12px }
</style>
<body>
<p class="style1A">
Style 1A
</p>
<p class="style1B">
Style 1B
</p>
<p class="style2">
Style 2
</p>
</body>
</html>
Potom co objekt HTMLLoader načte tento obsah, můžete pracovat se styly CSS na stránce pomocí pole cssRules pole
window.document.styleSheets, jak je znázorněno zde:
var html:HTMLLoader = new HTMLLoader( );
html.load(urlReq);
var styleSheet0:Object = html.window.document.styleSheets[0];
styleSheet0.cssRules[0].style.fontSize = "32px";
styleSheet0.cssRules[1].style.color = "#FF0000";
var styleSheet1:Object = html.window.document.styleSheets[1];
styleSheet1.cssRules[0].style.color = "blue";
styleSheet1.cssRules[0].style.font-family = "Monaco";
}
Tento kód upraví styly CSS tak, aby výsledný dokument HTML vypadal takto:
Mějte na paměti, že kód může přidat styly na stránku až poté, co objekt HTMLLoader odešle událost complete.
Vytváření křížových skriptů pro obsah v různých
karanténách zabezpečení
Model zabezpečení za běhu izoluje kód pocházející z různých zdrojů. Vytvořením křížových skriptů pro obsah v
různých karanténách zabezpečení lze obsahu v jedné karanténě umožnit přístup k vybraným vlastnostem a metodám
v jiné karanténě.
Karantény zabezpečení aplikace AIR a kód JavaScript
Aplikace AIR prosazuje zásadu stejného původu, která brání kódu v jedné doméně v interakci s obsahem v jiné
doméně. Všechny soubory jsou umístěny do karantény v závislosti na jejich původu. Obsah v aplikační karanténě
obvykle nemůže porušit princip stejného původu a vytvořit křížové skripty pro obsah načtený z místa mimo instalační
adresář aplikace. Aplikace AIR však poskytuje několik metod umožňujících vytvoření křížových skriptů pro
neaplikační obsah.
Jedna z těchto metod mapuje aplikační obsah do jiné karantény zabezpečení pomocí elementů frame nebo iframe.
Stránky načtené z oblasti karantény aplikace se chovají, jako by byly načteny ze vzdálené domény. Například při
mapování aplikačního obsahu do domény example.com může tento obsah vytvořit křížové skripty se stránkami
načtenými z domény example.com.
Vzhledem k tomu, že tato metoda umístí aplikační obsah do jiné karantény, nebudou se již na kód uvnitř tohoto
obsahu vztahovat omezení týkající se provádění kódu ve vyhodnocených řetězcích. Pomocí této metody mapování
karantény lze zmírnit tato omezení i v případě, že není zapotřebí vytvářet křížové skripty pro vzdálený obsah.
Mapování obsahu tímto způsobem může být užitečné zejména při práci s jedním z mnoha rámců jazyka JavaScript
nebo s existujícím kódem, který se spoléhá na vyhodnocení řetězců. Je však vhodné zvážit riziko, že při spuštění kódu
mimo aplikační karanténu by mohlo dojít k vložení a provedení nedůvěryhodného kódu, a zajistit zvláštní ochranu.
Aplikační obsah mapovaný do jiné karantény zároveň ztratí přístup k rozhraním API aplikace AIR, takže metodu
mapování karantény nelze použít ke zpřístupnění funkčnosti aplikace AIR pro kód prováděný mimo aplikační
karanténu.
Další metoda vytváření křížových skriptů umožňuje vytvoření rozhraní zvaného most karantény mezi obsahem v
neaplikační karanténě a jeho nadřazeným dokumentem v aplikační karanténě. Pomocí tohoto mostu získá podřízený
obsah přístup k vlastnostem a metodám definovaným nadřazeným obsahem, nebo nadřazený obsah získá přístup k
vlastnostem a metodám definovaným podřízeným obsahem, případně obojí.
A konečně lze také z aplikační karantény, a případně i z jiných karantén, provést požadavek XMLHttpRequests napříč
doménami.
Další informace naleznete v sekcích „Elementy HTML frame a iframe“ na stránce 202, „Zabezpečení HTML“ na
stránce 29 a „Objekt XMLHttpRequest“ na stránce 196.
Načtení aplikačního obsahu do neaplikační karantény
Chcete-li aplikačnímu obsahu umožnit bezpečné vytváření křížových skriptů pro obsah načtený z místa mimo
instalační adresář aplikace, můžete pomocí elementů frame nebo iframe načíst aplikační obsah do stejné karantény
zabezpečení jako externí obsah. Jestliže není zapotřebí vytvářet křížové skripty pro vzdálený obsah, ale přesto chcete
načíst stránku aplikace mimo aplikační karanténu, můžete použít stejnou metodu a jako původní doménu zadat
http://localhost/ či jinou neškodnou hodnotu.
Aplikace AIR přidává k elementu frame nové atributy sandboxRoot a documentRoot, pomocí nichž lze určit, zda se
má aplikační soubor načtený do elementu frame mapovat do neaplikační domény. Soubory, které použijí cestu pod
adresou URL sandboxRoot, se místo toho načtou z adresáře documentRoot. Z bezpečnostních důvodů se aplikační
obsah načtený tímto způsobem zpracovává, jako by byl ve skutečnosti načten z adresy URL sandboxRoot.
Vlastnost sandboxRoot definuje, která adresa URL se má použít pro určení karantény a domény, do níž má být
umístěn obsah elementu frame. Je třeba použít schéma URL file:, http: nebo https:. Pokud určíte relativní URL,
zůstane obsah v aplikační karanténě.
Vlastnost documentRoot určuje, ze kterého adresáře se má načíst obsah elementu frame. Je třeba použít schéma URL
file:, app: nebo app-storage:.
Následující příklad mapuje obsah instalovaný v podadresáři sandbox aplikace pro spuštění ve vzdálené karanténě a
doméně www.example.com:
<iframe
src="http://www.example.com/local/ui.html"
sandboxRoot="http://www.example.com/local/"
documentRoot="app:/sandbox/">
</iframe>
Stránka ui.html by mohla načíst soubor javascript z lokální složky sandbox pomocí následujícího tagu script:
<script src="http://www.example.com/local/ui.js"></script>
Rovněž by mohla načíst obsah z adresáře na vzdáleném serveru pomocí tagu script, jako je například tento:
<script src="http://www.example.com/remote/remote.js"></script>
Adresa URL sandboxRoot zamaskuje jakýkoliv obsah na stejné adrese URL na vzdáleném serveru. V předchozím
příkladu by nebylo možné získat přístup ke vzdálenému obsahu na adrese www.example.com/local/ (ani v žádném
z jejích podadresářů), neboť aplikace AIR přemapuje požadavek na lokální adresář aplikace. Požadavky se přemapují
bez ohledu na to, zda jsou odvozeny z navigace stránky, z požadavku XMLHttpRequest nebo z jiného způsobu načtení
obsahu.
Vytvoření rozhraní mostu karantény
Most karantény lze použít, když obsah v aplikační karanténě musí mít přístup k vlastnostem či metodám definovaným
obsahem v neaplikační karanténě nebo když neaplikační obsah musí mít přístup k vlastnostem či metodám
definovaným obsahem v aplikační karanténě. K vytvoření mostu použijte vlastnosti childSandboxBridge a
parentSandboxBridge objektu window libovolného podřízeného dokumentu.
Vytvoření podřízeného mostu karantény
Pomocí vlastnosti childSandboxBridge může podřízený dokument zpřístupnit rozhraní pro obsah v nadřazeném
dokumentu. Jestliže chcete rozhraní zpřístupnit, nastavte vlastnost childSandbox na funkci nebo objekt v
podřízeném dokumentu. Potom budete mít k objektu nebo funkci přístup z obsahu v nadřazeném dokumentu.
Následující příklad ilustruje, jakým způsobem může skript spuštěný v podřízeném dokumentu zpřístupnit objekt
obsahující funkci a vlastnost pro nadřazený dokument:
var interface = {};
interface.calculatePrice = function(){
return ".45 cents";
}
interface.storeID = "abc"
window.childSandboxBridge = interface;
Kdyby byl tento podřízený obsah načten do elementu iframe, který by měl přiřazeno ID „podřízený element“, bylo by
možné přistoupit k rozhraní z nadřazeného obsahu čtením vlastnosti childSandboxBridge elementu frame:
var childInterface = document.getElementById("child").contentWindow.childSandboxBridge;
air.trace(childInterface.calculatePrice()); //traces ".45 cents"
air.trace(childInterface.storeID)); //traces "abc"
Vytvoření nadřazeného mostu karantény
Pomocí vlastnosti parentSandboxBridge může nadřazený dokument zpřístupnit rozhraní pro obsah v podřízeném
dokumentu. Má-li být rozhraní zpřístupněno, nadřazený dokument nastaví vlastnost parentSandbox podřízeného
dokumentu na funkci nebo objekt definovaný v nadřazeném dokumentu. Potom budete mít k objektu nebo funkci
přístup z obsahu v podřízeném dokumentu. Následující příklad ilustruje, jakým způsobem může skript spuštěný v
nadřazeném elementu frame zpřístupnit objekt obsahující funkci pro podřízený dokument:
var interface = {};
interface.save = function(text){
var saveFile = air.File("app-storage:/save.txt");
//write text to file
}
document.getElementById("child").contentWindow.parentSandboxBridge = interface;
Pomocí tohoto rozhraní by podřízený element frame mohl uložit text do souboru s názvem save.txt, ale neměl by
žádný jiný přístup k systému souborů. Podřízený obsah by mohl vyvolat funkci save následujícím způsobem:
var textToSave = "A string.";
window.parentSandboxBridge.save(textToSave);
Aplikační obsah by měl ostatním karanténám zpřístupňovat co nejužší rozhraní. Neaplikační obsah by měl být
považován za přirozeně nedůvěryhodný, neboť může být vystaven náhodnému či zlovolnému vložení kódu. Je
nezbytné zavést vhodnou ochranu, která zamezí zneužití rozhraní, jež se zpřístupňuje pomocí nadřazeného mostu
karantény.
Přístup k nadřazenému mostu karantény během načítání stránky
Aby měl skript v podřízeném dokumentu přístup k nadřazenému mostu karantény, musí být most vytvořen ještě před
spuštěním skriptu. Objekty window, frame a iframe odešlou událost dominitialize, když se vytvoří nový DOM
stránky, ale před tím, než se začnou analyzovat skripty nebo přidávat elementy DOM. Pomocí události
dominitialize lze vytvořit most v sekvenci tvorby stránky dostatečně brzy, aby k němu měly přístup všechny skripty
v podřízeném dokumentu.
Následující příklad ilustruje postup při vytváření nadřazeného mostu karantény v odezvě na událost dominitialize
vyvolanou z podřízeného elementu frame:
<html>
<head>
<script>
var bridgeInterface = {};
bridgeInterface.testProperty = "Bridge engaged";
function engageBridge(){
document.getElementById("sandbox").contentWindow.parentSandboxBridge = bridgeInterface;
}
</script>
</head>
<body>
<iframe id="sandbox"
ondominitialize="engageBridge()"/>
</body>
</html>
Následující dokument child.html ilustruje, jakým způsobem může podřízený obsah získat přístup k nadřazenému
mostu karantény:
<html>
<head>
<script>
document.write(window.parentSandboxBridge.testProperty);
</script>
</head>
<body></body>
</html>
Chcete-li událost dominitialize poslouchat raději u podřízeného objektu window než u objektu frame, je třeba
přidat posluchače do nového podřízeného objektu window vytvořeného pomocí funkce window.open():
var childWindow = window.open();
childWindow.addEventListener("dominitialize", engageBridge());
childWindow.document.location = "http://www.example.com/air/child.html";
V takovém případě není možné mapovat aplikační obsah do neaplikační karantény. Tato metoda je užitečná jen v
případě, že se načítá child.html z místa mimo adresář aplikace. Aplikační obsah v objektu window lze stále mapovat
do neaplikační karantény, ale nejprve je nutné načíst přechodnou stránku, která sama používá objekty frame k načtení
podřízeného dokumentu a k jeho mapování do požadované karantény.
Pokud vytvoříte okno pomocí funkce createRootWindow() třídy HTMLLoader, nebude nové okno podřízeným
objektem dokumentu, z něhož byla funkce createRootWindow() zavolána. Proto nelze vytvořit most karantény z
volajícího okna do neaplikačního obsahu načteného v tomto novém okně. Místo toho je zapotřebí načíst do tohoto
nového okna přechodnou stránku, která sama používá objekty frame k načtení podřízeného dokumentu. Potom lze
vytvořit most z nadřízeného dokumentu nového okna do podřízeného dokumentu načteného v objektu frame.
225
Kapitola 22: Zpracování událostí týkajících
se HTML
Systém zpracování událostí umožňuje programátorům pohodlným způsobem reagovat na vstup od uživatele a
systémové události. Model událostí Adobe® AIR™ je nejen pohodlný, ale také vyhovuje normám. Model událostí s
architekturou zpracování událostí založenou na specifikaci událostí objektového modelu dokumentu (DOM) 3.
úrovně, odpovídající průmyslovým normám, poskytuje výkonný a přesto intuitivní nástroj zpracování událostí pro
programátory.
Události HTMLLoader
Objekt HTMLLoader odesílá následující události ActionScript™:
Událost
Popis
htmlDOMInitialize
Odeslaná při vytvoření dokumentu HTML, ale ještě před analýzou veškerých skriptů a před přidáním
uzlů DOM na stránku.
complete
Odeslána po vytvoření DOM HTML v odpovědi na operaci načtení, ihned po události onload na
stránce HTML.
htmlBoundsChanged
Odeslána při změně jedné nebo obou vlastností contentWidth a contentHeight.
locationChange
Odeslána při změně vlastnosti umístění třídy HTMLLoader.
scroll
Odeslána vždy, když modul HTML změní pozici rolování. Události rolování mohou být způsobeny
navigací k odkazům kotev (odkazy #) na stránce nebo voláním metody window.scrollTo(). Také
zadání textu do textového vstupu nebo textové oblasti může způsobit událost rolování.
uncaughtScriptException
Odeslána, když se vyskytne výjimka JavaScript v objektu HTMLLoader a když tato výjimka není
zachycena v kódu JavaScript.
U události JavaScript můžete registrovat také funkci ActionScript (např. onClick). Podrobnosti viz „Zpracování
událostí DOM pomocí jazyka ActionScript“ na stránce 225.
Zpracování událostí DOM pomocí jazyka ActionScript
Můžete registrovat funkce ActionScript a použít je k reagování na kód JavaScript. Zvažte například následující obsah
HTML:
<html>
<body>
<a href="#" id="testLink">Click me.</a>
</html>
Můžete registrovat funkci ActionScript jako manipulační program pro libovolnou událost na stránce. Například
následující kód přidá funkci clickHandler() jako posluchač pro událost onclick na elementu testLink na stránce
HTML:
Zpracování událostí týkajících se HTML
var html:HTMLLoader = new HTMLLoader( );
html.load(urlReq);
html.window.document.getElementById("testLink").onclick = clickHandler;
}
function clickHandler():void {
trace("You clicked it!");
}
Pomocí metody addEventListener() můžete tyto události registrovat. Metodu completeHandler() v
předcházejícím příkladu byste například mohli nahradit následujícím kódem:
var testLink:Object = html.window.document.getElementById("testLink");
testLink.addEventListener("click", clickHandler);
}
Když se posluchač odkazuje na určitý element DOM, je dobré s odesláním události complete před přidáním
posluchačů události počkat na nadřazený objekt HTMLLoader. Stránky HTML často načítají více souborů a DOM
HTML není plně vestavěný, dokud nejsou načteny a analyzovány všechny soubory. Objekt HTMLLoader odešle
událost complete, jakmile jsou vytvořeny všechny elementy.
Reagování na nezachycené výjimky JavaScript
Posuďte následující dokument HTML:
<html>
<head>
<script>
function throwError() {
var x = 400 * melbaToast;
}
</script>
</head>
<body>
<a href="#" onclick="throwError()">Click me.</a>
</html>
Obsahuje funkci JavaScript, throwError(), která se odkazuje na neznámou proměnnou, melbaToast:
Jakmile operace JavaScript narazí na neplatnou operaci, která není zachycená v kódu JavaScript se strukturou
try/catch, objekt HTMLLoader obsahující tuto stránku odešle událost HTMLUncaughtScriptExceptionEvent.
Můžete registrovat manipulační program pro tuto událost, jako v následujícím kódu:
html.load(urlReq);
html.width = container.width;
html.height = container.height;
container.addChild(html);
html.addEventListener(HTMLUncaughtScriptExceptionEvent.UNCAUGHT_SCRIPT_EXCEPTION,
htmlErrorHandler);
function htmlErrorHandler(event:HTMLUncaughtJavaScriptExceptionEvent):void
{
trace("exceptionValue:", event.exceptionValue)
for (var i:int = 0; i < event.stackTrace.length; i++)
{
trace("sourceURL:", event.stackTrace[i].sourceURL);
trace("line:", event.stackTrace[i].line);
trace("function:", event.stackTrace[i].functionName);
}
}
V jazyku JavaScript můžete stejnou událost zpracovat pomocí vlastnosti window.htmlLoader:
<html>
<head>
<script>
function throwError() {
}
function htmlErrorHandler(event) {
var message = "exceptionValue:" + event.exceptionValue + "\n";
for (var i = 0; i < event.stackTrace.length; i++){
message += "sourceURL:" + event.stackTrace[i].sourceURL +"\n";
message += "line:" + event.stackTrace[i].line +"\n";
message += "function:" + event.stackTrace[i].functionName + "\n";
}
alert(message);
}
window.htmlLoader.addEventListener("uncaughtScriptException", htmlErrorHandler);
</script>
</head>
<body>
<a href="#" onclick="throwError()">Click me.</a>
</html>
Manipulační program události htmlErrorHandler() zruší výchozí chování události (což je odeslání chybové zprávy
JavaScript do výstupu sledování aplikace AIR) a vygeneruje svou vlastní zprávu pro výstup. Vygeneruje hodnotu
exceptionValue objektu HTMLUncaughtScriptExceptionEvent. Výstupem budou vlastnosti jednotlivých objektů v
poli stackTrace:
exceptionValue: ReferenceError: Can't find variable: melbaToast
sourceURL: app:/test.html
line: 5
function: throwError
sourceURL: app:/test.html
line: 10
function: onclick
Zpracování událostí chodu programu pomocí jazyka
JavaScript
Třídy chodu programu podporují přidávání manipulačních programů událostí pomocí metody
addEventListener(). Chcete-li přidat funkci manipulačního programu pro určitou událost, vyvolejte metodu
addEventListener() objektu, který událost odesílá, přičemž poskytnete typ události a funkci zpracování. Například
chcete-li poslouchat událost closing odeslanou, když uživatel klepne na zavírací tlačítko okna na titulkovém pásu,
použijte následující příkaz:
window.nativeWindow.addEventListener(air.NativeWindow.CLOSING, handleWindowClosing);
Vytváření funkcí manipulačního programu události
Následující kód vytvoří jednoduchý soubor HTML, který zobrazuje informace o pozici hlavního okna. Funkce
manipulačního programu moveHandler() poslouchá událost přesunutí (definovanou třídou
NativeWindowBoundsEvent) hlavního okna.
<html>
<script src="AIRAliases.js" />
<script>
function init() {
writeValues();
window.nativeWindow.addEventListener(air.NativeWindowBoundsEvent.MOVE,
moveHandler);
}
function writeValues() {
document.getElementById("xText").value = window.nativeWindow.x;
document.getElementById("yText").value = window.nativeWindow.y;
}
function moveHandler(event) {
air.trace(event.type); // move
writeValues();
}
</script>
<body onload="init()" />
<table>
<tr>
<td>Window X:</td>
<td><textarea id="xText"></textarea></td>
</tr>
<tr>
<td>Window Y:</td>
<td><textarea id="yText"></textarea></td>
</tr>
</table>
</body>
</html>
Když uživatel přesune okno, elementy textové oblasti zobrazí aktualizované souřadnice X a Y polohy okna.
Všimněte si, že objekt události je předaný jako argument metodymoveHandler(). Parametr události umožňuje, aby
vaše funkce manipulačního programu zkontrolovala objekt události. V tomto příkladu je použita vlastnost type
objektu události k oznámení, že daná událost je událost move.
Odstraňování posluchačů událostí
Metodu removeEventListener() můžete použít k odstranění posluchače událostí, který již nepotřebujete. Je dobré
odstranit všechny posluchače, které se již nebudou používat. Vyžadované parametry zahrnují parametry eventName
a listener, které jsou stejné jako vyžadované parametry pro metodu addEventListener().
Odstranění posluchačů událostí ve stránkách HTML, které navigují
Když obsah HTML naviguje nebo když je vyřazen, protože okno, které jej obsahuje, je zavřené, posluchače událostí,
které se odkazují na objekty na nenačtených stránkách, nebudou odstraněny automaticky. Když nějaký objekt odešle
událost do manipulačního programu, který již byl odstraněn z paměti, zobrazí se následující chybová zpráva:
„Aplikace se pokusila o odkaz na objekt JavaScript ve stránce HTML, který již není zavedený v paměti“.
Chcete-li se této chybě vyhnout, odstraňte posluchače událostí JavaScript ve stránce HTML, než se ztratí. V případě
navigace stránky (s objektem HTMLLoader) odstraňte posluchač události během události unload objektu window.
Například následující kód JavaScript odstraní posluchač události pro událost uncaughtScriptException:
window.onunload = cleanup;
window.htmlLoader.addEventListener('uncaughtScriptException', uncaughtScriptException);
function cleanup()
{
window.htmlLoader.removeEventListener('uncaughtScriptException',
uncaughtScriptExceptionHandler);
}
Chcete-li zabránit výskytu chyb při zavírání oken obsahujících obsah HTML, vyvolejte funkci vyčištění v odpovědi na
událost closing objektu NativeWindow (window.nativeWindow). Například následující kód JavaScript odstraní
posluchač události pro událost uncaughtScriptException:
window.nativeWindow.addEventListener(air.Event.CLOSING, cleanup);
function cleanup()
{
window.htmlLoader.removeEventListener('uncaughtScriptException',
uncaughtScriptExceptionHandler);
}
Výskytu této chyby můžete také zabránit odstraněním posluchače události ihned po jeho spuštění. Například
následující kód JavaScript vytvoří okno HTML vyvoláním metody createRootWindow() třídy HTMLLoader a přidá
posluchač události pro událost complete. Při vyvolání manipulačního programu události complete dojde k
odstranění jeho vlastního posluchače události pomocí funkce removeEventListener():
var html = runtime.flash.html.HTMLLoader.createRootWindow(true);
html.addEventListener('complete', htmlCompleteListener);
function htmlCompleteListener()
{
html.removeEventListener(complete, arguments.callee)
// handler code..
}
html.load(new runtime.flash.net.URLRequest("second.html"));
Odstranění nepotřebných posluchačů událostí také umožní, aby systémový program na čištění uvolněné paměti získal
zpět veškerou paměť přiřazenou těmto posluchačům.
Kontrola existujících posluchačů událostí
Metoda hasEventListener() umožňuje prověřit existenci posluchače události na určitém objektu.
231
Kapitola 23: Skriptování kontejneru
HTML
Třída HTMLLoader slouží jako kontejner pro obsah HTML v Adobe® AIR™. Tato třída poskytuje mnoho vlastností a
metod zděděných ze třídy Sprite pro ovládání chování a vzhledu objektu na seznamu zobrazení ActionScript™ 3.0. Dále
tato třída definuje vlastnosti a metody pro takové úlohy, jako je například načítání a interakce s obsahem HTML a
správa historie.
Třída HTMLHost definuje množinu výchozích chování pro HTMLLoader. Při vytvoření objektu HTMLLoader není
poskytnuta žádná implementace HTMLHost. Proto když HTML spustí jedno z implicitních chování, například změnu
umístění okna nebo titul okna, nic se nestane. Třídu HTMLHost můžete rozšířit a definovat tak chování požadovaná
pro vaši aplikaci.
Výchozí implementace HTMLHost je poskytnuta pro okna HTML vytvořená AIR. Výchozí implementaci HTMLHost
můžete přiřadit jinému objektu HTMLLoader nastavením vlastnosti htmlHost objektu pomocí nového objektu
HTMLHost vytvořeného pomocí parametru defaultBehavior nastaveného na true.
Vlastnosti zobrazení objektů HTMLLoader
Objekt HTMLLoader dědí vlastnosti třídy přehrávače Adobe® Flash® Player Sprite. Můžete například změnit velikost,
přesunout, skrýt a změnit barvu pozadí. Nebo můžete použít pokročilé efekty, například filtry, masky, změnu měřítka
a rotaci. Při používání efektů vezměte v úvahu důsledky pro čitelnost. Obsah SWF a PDF načtený do stránky HTML
nelze zobrazit, když jsou některé efekty použity.
Okna HTML obsahují objekt HTMLLoader, který vykresluje obsah HTML. Tento objekt je vymezen v oblasti okna,
takže změna rozměrů, polohy, rotace nebo faktory změny měřítka nevytvoří vždy požadované výsledky.
Základní vlastnosti zobrazení
Základní vlastnosti zobrazení HTMLLoader vám umožňují umístit ovládání do nadřazeného objektu zobrazení, pro
nastavení velikosti a zobrazení nebo skrytí ovládání. Tyto vlastnosti byste neměli změnit pro objekt HTMLLoader
okna HTML.
Mezi základní vlastnosti patří:
Vlastnost
Poznámky
x, y
Umístěte objekt do jeho nadřazeného kontejneru.
width, height
Změní rozměry oblasti zobrazení.
visible
Ovládá viditelnost objektu a jakýkoliv obsah, který obsahuje.
Mimo okno HTML jsou vlastnosti width a height objektu HTMLLoader implicitně nastaveny na 0. Před tím, než lze
načtený obsah HTML spatřit, musíte nastavit šířku a výšku. Obsah HTML je nakreslen na velikosti HTMLLoader,
rozvržen podle vlastností HTML a CSS v obsahu. Změna velikosti objektu HTMLLoader změní tok obsahu.
Skriptování kontejneru HTML
Při načítání obsahu do nového objektu HTMLLoader (kde je widthstále nastavena na 0), může být lákavé
nastavitwidth a height zobrazení HTMLLoader pomocí vlastností contentWidth a contentHeight. Tato technika
je funkční pro stránky, které mají při rozvržení podle pravidel hustoty HTML a CSS rozumnou minimální šířku.
Nicméně některé stránky se bez rozumné šířky poskytnuté objektem HTMLLoader rozloží do dlouhého a úzkého
rozvržení.
Poznámka: Při změně šířky a výšky objektu HTMLLoader se hodnoty měřítka x a y narozdíl od většiny ostatních typů
objektů zobrazení nezmění.
Průhlednost obsahu HTMLLoader
Vlastnost paintsDefaultBackground objektu HTMLLoader, implicitně nastavená na true, určuje, zda objekt
HTMLLoader vykreslí neprůhledné pozadí. Je-li paintsDefaultBackground nastavena na hodnotu false, je pozadí
bez barvy. Kontejner objektu zobrazení nebo jiné objekty zobrazení pod objektem HTMLLoader jsou viditelné za
vystupujícími prvky obsahu HTML.
Jestliže prvek těla nebo jakýkoliv jiný prvek dokumentu HTML určuje barvu pozadí (například pomocí
style=„background-color:gray"), je pozadí dané části HTML neprůhledné a je vykresleno určenou barvou
pozadí. Jestliže nastavíte vlastnost opaqueBackground objektu HTMLLoader a paintsDefaultBackground je
false, bude barva nastavená pro opaqueBackground viditelná.
Poznámka: Můžete použít průhlednou grafiku ve formátu PNG a poskytnout tak pozadí s prolnutím alfa pro element v
dokumentu HTML. Nastavení stylu neprůhlednosti elementu HTML není podporováno.
Změna měřítka obsahu HTMLLoader
Neměňte měřítko objektu HTMLLoader za faktor měřítka 1.0. Text v obsahu HTMLLoader je vykreslen při
specifickém rozlišení a zobrazí se seskupeně, jestliže se zvětší měřítko objektu HTMLLoader. Pro zabránění změně
měřítka objektu HTMLLoader i jeho obsahu při změně velikosti okna nastavte vlastnost scaleMode plochy na
StageScaleMode.NO_SCALE.
Zohlednění při načítání obsahu SWF nebo PDF na stránce HTML
Obsah SWF a PDF načtený do objektu HTMLLoader zmizí za následujících podmínek:
• Jestliže změníte velikost měřítka objektu HTMLLoader na faktor jiný než 1,0.
• Jestliže nastavíte vlastnost alfa objektu HTMLLoader na hodnotu jinou než 1,0.
• Jestliže otáčíte obsahem objektu HTMLLoader.
Obsah se znovu objeví, jestliže odstraníte chybné nastavení vlastnosti a odstraníte aktivní filtry.
Poznámka: Runtime nemůže zobrazit obsah SWF ani PDF v průhledných oknech.
Více informací o načítaní tohoto typu médií v objektu HTMLLoader naleznete v tématech Načítání obsahu SWF na
stránce HTML a „Přidávání obsahu PDF“ na stránce 245.
Další vlastnosti zobrazení
Třída HTMLLoader dědí několik metod, které lze použít pro zvláštní efekty. Obecně mají tyto efekty omezení, jsou-li
použity se zobrazením HTMLLoader, ale mohou být užitečné pro přechody nebo jiné dočasné efekty. Jestliže
například zobrazíte dialogové okno pro získání vstupu uživatele, můžete rozostřit zobrazení hlavního okna, dokud
uživatel dialogové okno nezavře. Podobně můžete nechat zobrazení zmizet při zavírání okna.
Mezi další vlastnosti zobrazení patří:
Vlastnost
Omezení
alfa
Může snížit čitelnost obsahu HTML
filtry
V okně HTML jsou vnější efekty oříznuty okrajem okna.
grafika
Tvary nakreslené pomocí příkazů grafiky se zobrazí pod obsahem HTML, včetně výchozího pozadí.
Vlastnost paintsDefaultBackground musí být nepravda, aby byly nakreslené tvary viditelné.
opaqueBackground
Nezmění barvu výchozího pozadí. Vlastnost paintsDefaultBackground musí být nepravda, aby byla
barevná vrstva viditelná.
nato ení
Rohy obdélníkové oblasti HTMLLoader lze oříznout okrajem okna. Obsah SWF a PDF načtený v obsahu
HTML není zobrazen.
scaleX, scaleY
Vykreslené zobrazení se může jevit seskupeně, pokud jsou faktory měřítka větší než 1. Obsah SWF a PDF
načtený v obsahu HTML není zobrazen.
transform
Může snížit čitelnost obsahu HTML Zobrazení HTML lze oříznout okrajem okna. Obsah SWF a PDF načtený
do obsahu HTML není zobrazen, jestliže transformace zahrnuje rotaci, změnu měřítka nebo zkosení.
Následující příklad ukazuje způsob nastavení pole filters pro rozostření celého zobrazení HTML:
var urlReq:URLRequest = new URLRequest("http://www.adobe.com/");
html.load(urlReq);
html.width = 800;
html.height = 600;
var blur:BlurFilter = new BlurFilter(8);
var filters:Array = [blur];
html.filters = filters;
Rolování obsahu HTML
Třída HTMLLoader zahrnuje následující vlastnosti, které vám umožňují ovládat rolování obsahu HTML:
Vlastnost
Popis
contentHeight
Výška obsahu HTML v obr. bodech.
contentWidth
Šířka obsahu HTML v obr. bodech.
scrollH
Poloha horizontálního posunutí obsahu HTML v objektu HTMLLoader.
scrollV
Poloha vertikálního posunutí obsahu HTML v objektu HTMLLoader.
Následující kód nastaví vlastnost scrollVtak, že je obsah HTML rolován až na konec stránky:
html.addEventListener(Event.HTML_BOUNDS_CHANGE, scrollHTML);
const SIZE:Number = 600;
html.width = SIZE;
html.height = SIZE;
var urlReq:URLRequest = new URLRequest("http://www.adobe.com");
html.load(urlReq);
this.addChild(html);
function scrollHTML(event:Event):void
{
html.scrollV = html.contentHeight - SIZE;
}
HTMLLoader neobsahuje vodorovné a svislé lišty pro rolování. V jazyce ActionScript můžete implementovat lišty
rolování. Můžete také použít metodu HTMLLoader.createRootWindow() pro vytvoření okna, které obsahuje objekt
HTMLLoader s lištami rolování (viz „Vytváření oken s rolováním obsahu HTML“ na stránce 243).
Přístup k seznamu historie HTML
Při načítání nových stran do objektu HTMLLoader spravuje runtime pro daný objekt seznam historie. Seznam historie
odpovídá objektu window.history na stránce HTML. Třída HTMLLoader obsahuje následující vlastnosti a metody,
které vám umožní pracovat se seznamem historie HTML:
Člen třídy
Popis
historyLength
Celková délka seznamu historie včetně položek vpřed a zpět.
historyPosition
Aktuální pozice na seznamu historie. Položky historie před touto pozicí představují navigaci „zpět“ a položky za
touto pozici představují navigaci „dopředu“.
historyAt()
Vrátí objekt URLRequest odpovídající záznamu historie v určené pozici v seznamu historie.
historyBack()
Je-li to možné, naviguje zpět seznamem historie.
historyForward()
Je-li to možné, naviguje dopředu seznamem historie.
historyGo()
Naviguje určitý počet kroků v historii prohlížeče. Je-li kladné, naviguje vpřed, je-li záporné, naviguje zpět.
Navigace na nulu znovu načte stránku. Určení pozice za koncem naviguje na konec seznamu.
Položky v seznamu historie jsou uloženy jako objekty typu HistoryListItem. Třída HistoryListItem má následující
vlastnosti:
Vlastnost
Popis
isPost
Nastavena na true, jestliže stránka HTML obsahuje data POST.
originalUrl
Původní URL stránky HTML před případným přesměrováním.
title
Název stránky HTML.
url
URL stránky HTML.
Nastavení agenta uživatele použitého při načítání
obsahu HTML
Třída HTMLLoader má vlastnost userAgent, která vám umožňuje nastavit řetězec agenta uživatele použitý třídou
HTMLLoader. Vlastnost userAgent objektu HTMLLoader nastavte před voláním metody load(). Jestliže nastavíte
tuto vlastnost na instanci HTMLLoader, vlastnost userAgent URLRequest předaná metodě load() se nepoužije.
Nastavením vlastnosti URLRequestDefaults.userAgent můžete nastavit výchozí řetězec agenta-uživatele, který
budou používat všechny objekty HTMLLoader v doméně aplikace. Statické vlastnosti URLRequestDefaults se použijí
jako výchozí pro všechny objekty URLRequest, nejen pro objekty URLRequests použité s metodou load() objektů
HTMLLoader. Nastavení vlastnosti userAgent HTMLLoader potlačí výchozí nastavení
URLRequestDefaults.userAgent.
Jestliže buď pro vlastnost userAgent objektu HTMLLoader nebo pro vlastnost URLRequestDefaults.userAgent
nenastavíte hodnotu agenta uživatele, bude použita výchozí hodnota agenta uživatele AIR. Výchozí hodnota se mění
v závislosti na operačním systému v době běhu (například Mac OS nebo Windows), na jazyku v době běhu a na verzi
v době běhu, jako v následujících dvou příkladech:
•
„Mozilla/5.0 (Macintosh; U; PPC Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko)
AdobeAIR/1.0"
•
„Mozilla/5.0 (Windows; U; en) AppleWebKit/420+ (KHTML, like Gecko) AdobeAIR/1.0"
Nastavení kódování znaků, které bude použito pro
obsah HTML.
Stránka HTML může určit kódování znaků, které používá, zahrnutím tagu meta. Viz následující příklad:
meta http-equiv="content-type" content="text/html" charset="ISO-8859-1";
Potlačte nastavení stránky a nastavením vlastnosti textEncodingOverride objektu HTMLLoader zajistěte, že je
použito specifické kódování znaků:
html.textEncodingOverride = "ISO-8859-1";
Určete kódování znaku pro obsah HTMLLoader, které bude použito, pokud stránka HTML neurčuje nastavení
pomocí vlastnosti textEncodingFallback objektu HTMLLoader:
html.textEncodingFallback = "ISO-8859-1";
Vlastnost textEncodingOverride potlačí nastavení stránky HTML. A vlastnost textEncodingOverride a
nastavení na stránce HTML potlačí vlastnost textEncodingFallback.
Před načtením obsahu HTML nastavte vlastnost textEncodingOverride nebo textEncodingFallback.
Definování uživatelských rozhraní podobných
prohlížeči pro obsah HTML.
Jazyk JavaScript poskytuje několik rozhranní API pro ovládání okna zobrazujícího obsah HTML. V aplikaci AIR jsou
tato API potlačena implementací vlastní třídy HTMLHost.
O rozšiřování třídy HTMLHost
Jestliže vaše aplikace například představuje více objektů HTMLLoader v rozhraní opatřeném tabulátorem, můžete si
přát změnit tituly načtenými stránkami HTML pro změnu štítku záložky, nikoliv titulu hlavního okna. Podobně může
váš kód odpovídat na volání window.moveTo() změnou polohy objektu HTMLLoader v jeho nadřazeném zobrazení
přesunutím okna, které obsahuje objekt HTMLLoader, a to tím, že neprovede nic, nebo něco zcela jiného.
Třída AIR HTMLHost ovládá následující vlastnosti a metody jazyka JavaScript:
•
window.status
•
window.document.title
•
window.location
•
window.blur()
•
window.close()
•
window.focus()
•
window.moveBy()
•
window.moveTo()
•
window.open()
•
window.resizeBy()
•
window.resizeTo()
Když vytvoříte objekt HTMLLoader pomocí new HTMLLoader(), nejsou uvedené vlastnosti nebo metody jazyka
JavaScript aktivovány. Třída HTMLHost poskytuje výchozí, prohlížeči podobnou implementaci těchto rozhraní
jazyka JavaScript. Třídu HTMLHost můžete také rozšířit a upravit tak její chování. Pro vytvoření objektu HTMLHost
podporujícího výchozí chování nastavte parametr defaultBehaviors v konstruktoru HTMLHost na true:
var defaultHost:HTMLHost = new HTMLHost(true);
Když vytvoříte okno HTML v aplikaci AIR s metodou třídy HTMLLoader createRootWindow(), je instance
HTMLHost podporující výchozí chování přiřazena automaticky. Chování hostitelského objektu můžete změnit
přiřazením odlišné implementace HTMLHost k vlastnosti htmlHost třídy HTMLLoader, nebo můžete přiřadit
hodnotu null a úplně tak tyto funkce vypnout.
Poznámka: AIR přiřadí výchozí objekt HTMLHost k úvodnímu oknu vytvořenému pro aplikaci AIR vycházející z HTML
a k libovolným oknům vytvořeným výchozí implementací metody jazyka JavaScript window.open().
Příklad: rozšiřování třídy HTMLHost
Následující příklad ukazuje, jak uživatelsky upravit způsob, jakým objekt HTMLLoader ovlivní uživatelské rozhraní,
rozšířením třídy HTMLHost:
1 Vytvořte soubor Flash pro AIR. Nastavte jeho dokumentovou třídu na CustomHostExample a poté daný soubor
uložte jako CustomHostExample.fla.
2 Vytvořte soubor jazyka ActionScript pojmenovaný CustomHost.as obsahující třídu, která rozšiřuje třídu
HTMLHost (podtřídu). Tato třída potlačí určité metody nové třídy pro zpracování změn v nastavení souvisejícím
s uživatelským rozhraním. Například následující třída, CustomHost, definuje chování pro volání window.open()
a provede změnu na window.document.title. Volání metodywindow.open() otevře stránku HTML v novém
okně a provede změnuwindow.document.title (včetně nastavení elementu <title> stránky HTML) pro změnu
titulu okna.
package
{
import
import
import
import
import
import
import
import
import
import
flash.display.StageScaleMode;
flash.display.NativeWindowInitOptions;
flash.events.Event;
flash.events.NativeWindowBoundsEvent;
flash.geom.Rectangle;
flash.html.HTMLLoader;
flash.html.HTMLHost;
flash.html.HTMLWindowCreateOptions;
public class CustomHost extends HTMLHost
{
public var statusField:TextField;
public function CustomHost(defaultBehaviors:Boolean=true)
{
super(defaultBehaviors);
}
override public function windowClose():void
{
htmlLoader.stage.nativeWindow.close();
}
override public function createWindow(
windowCreateOptions:HTMLWindowCreateOptions ):HTMLLoader
{
var initOptions:NativeWindowInitOptions = new NativeWindowInitOptions();
var bounds:Rectangle = new Rectangle(windowCreateOptions.x,
windowCreateOptions.y,
windowCreateOptions.width,
windowCreateOptions.height);
var htmlControl:HTMLLoader = HTMLLoader.createRootWindow(true, initOptions,
windowCreateOptions.scrollBarsVisible, bounds);
htmlControl.htmlHost = new HTMLHostImplementation();
if(windowCreateOptions.fullscreen){
htmlControl.stage.displayState =
StageDisplayState.FULL_SCREEN_INTERACTIVE;
}
return htmlControl;
}
override public function updateLocation(locationURL:String):void
{
trace(locationURL);
}
override public function set windowRect(value:Rectangle):void
{
htmlLoader.stage.nativeWindow.bounds = value;
}
override public function updateStatus(status:String):void
{
statusField.text = status;
trace(status);
}
override public function updateTitle(title:String):void
{
htmlLoader.stage.nativeWindow.title = title + "- Example Application";
}
override public function windowBlur():void
{
htmlLoader.alpha = 0.5;
}
override public function windowFocus():void
{
htmlLoader.alpha = 1;
}
}
}
3 Vytvořte jiný soubor jazyka ActionScript pojmenovaný CustomHostExample.as pro získání dokumentové třídy
aplikace. Tato třída vytvoří objekt HTMLLoader a nastaví jeho hostitelskou vlastnost na instanci třídy CustomHost
definovanou v předešlém kroku:
package
{
import
import
import
import
flash.html.HTMLLoader;
public class CustomHostExample extends Sprite
{
function CustomHostExample():void
{
html.width = 550;
html.height = 380;
var host:CustomHost = new CustomHost();
html.htmlHost = host;
var urlReq:URLRequest = new URLRequest("Test.html");
html.load(urlReq);
addChild(html);
var statusTxt:TextField = new TextField();
statusTxt.y = 380;
statusTxt.height = 20;
statusTxt.width = 550;
statusTxt.background = true;
statusTxt.backgroundColor = 0xEEEEEEEE;
addChild(statusTxt);
host.statusField = statusTxt;
}
}
}
Pro testování zde popsaného kódu zahrňte soubor HTML s následujícím obsahem do adresáře aplikace:
<html>
<head>
<title>Test</title>
<script>
function openWindow()
{
document.title = "Test"
window.open('Test.html');
}
</script>
</head>
<body bgColor="#EEEEEE">
<a href="#" onclick="window.open('Test.html')">window.open('Test.html')</a>
<br/><a href="#" onclick="window.document.location='http://www.adobe.com'">
window.document.location = 'http://www.adobe.com'</a>
<br/><a href="#" onclick="window.moveBy(6, 12)">moveBy(6, 12)</a>
<br/><a href="#" onclick="window.close()">window.close()</a>
<br/><a href="#" onclick="window.blur()">window.blur()</a>
<br/><a href="#" onclick="window.focus()">window.focus()</a>
<br/><a href="#" onclick="window.status = new Date().toString()">window.status=new
Date().toString()</a>
</body>
</html>
Zpracovávání změn vlastnosti window.location
Potlačí metodu locationChange() pro zpracovávání změn URL stránky HTML. Metoda locationChange() je
volána, když jazyk JavaScript na stránce změní hodnotu window.location. Následující příklad jednoduše načte
požadovanou URL:
override public function updateLocation(locationURL:String):void
{
htmlLoader.load(new URLRequest(locationURL));
}
Poznámka: Vlastnost htmlLoader objektu HTMLHost můžete použít pro odkázání na aktuální objekt HTMLLoader.
Zpracovávání volání jazyka JavaScript window.moveBy(), window.moveTo(),
window.resizeTo(), window.resizeBy()
Potlačí metodu set windowRect() pro zpracovávání změn v ohraničení obsahu HTML. Metoda set windowRect()
je volána, když jazyk JavaScript na stránce volá window.moveBy(), window.moveTo(), window.resizeTo()
nebowindow.resizeBy(). Následující příklad jednoduše načte ohraničení okna plochy:
override public function set windowRect(value:Rectangle):void
{
htmlLoader.stage.nativeWindow.bounds = value;
}
Zpracovávání volání jazyka JavaScript window.open()
Potlačí metodu createWindow() pro zpracovávání volání jazyka JavaScript window.open(). Implementace metody
createWindow() jsou odpovědné za vytvoření a vrácení nového objektu HTMLLoader. Obvykle byste HTMLLoader
zobrazili v novém okně, ale vytvoření okna není vyžadováno.
Následující příklad ukazuje způsob implementace funkce createWindow() pomocí
HTMLLoader.createRootWindow() pro vytvoření okna i objektu HTMLLoader. Objekt NativeWindow můžete také
vytvořit samostatně a přidat HTMLLoader na plochu okna.
override public function createWindow(windowCreateOptions:HTMLWindowCreateOptions):HTMLLoader{
var bounds:Rectangle = new Rectangle(windowCreateOptions.x, windowCreateOptions.y,
windowCreateOptions.width, windowCreateOptions.height);
var htmlControl:HTMLLoader = HTMLLoader.createRootWindow(true, initOptions,
windowCreateOptions.scrollBarsVisible, bounds);
htmlControl.htmlHost = new HTMLHostImplementation();
if(windowCreateOptions.fullscreen){
htmlControl.stage.displayState = StageDisplayState.FULL_SCREEN_INTERACTIVE;
}
return htmlControl;
}
Poznámka: Tento příklad přiřadí vlastní implementaci HTMLHost jakýmkoliv novým oknům vytvořeným pomocí
window.open(). Můžete také použít různé implementace nebo nastavit vlastnost htmlHost na nulu pro nová okna.
Objekt předaný jako parametr metodě createWindow() je objekt HTMLWindowCreateOptions. Třída
HTMLWindowCreateOptions zahrnuje vlastnosti, které hlásí hodnoty nastavené v řetězci parametru features ve
voláníwindow.open():
Vlastnost HTMLWindowCreateOptions
Odpovídající nastavení v řetězci vlastností ve volání jazyka
JavaScript window.open()
fullscreen
fullscreen
height
height
locationBarVisible
location
menuBarVisible
menubar
resizeable
resizable
scrollBarsVisible
scrollbars
statusBarVisible
status
toolBarVisible
toolbar
width
width
x
left nebo screenX
y
top nebo screenY
Třída HTMLLoader neimplementuje všechny funkce, které lze určit v řetězci funkce. Vaše aplikace musí v případě
potřeby poskytovat posuvníky, pruhy umístění, pruhy nabídek, stavové řádky a panely nástrojů.
Další argumenty pro metodu jazyka JavaScript window.open() jsou zpracovány systémem. Implementace
createWindow() by neměla načíst obsah v objektu HTMLLoader nebo nastavit titul okna.
Zpracovávání volání jazyka JavaScript window.close()
Potlačí windowClose() pro zpracování volání jazyka JavaScript metody window.close(). Následující příklad zavře
v případě volání metody window.close() okno pracovní plochy:
{
htmlLoader.stage.nativeWindow.close();
}
Volání jazyka JavaScript window.close() nemusí zavřít obsahové okno. Můžete například odstranit HTMLLoader
ze seznamu zobrazení a tím ponecháte okno (které může mít jiný obsah) otevřené, viz následující kód:
{
htmlLoader.parent.removeChild(htmlLoader);
}
Zpracovávání změn vlastnosti window.status
Potlačí metodu updateStatus() pro zpracování změn jazyka JavaScript hodnoty window.status. Následující
příklad sleduje hodnotu statutu:
override public function updateStatus(status:String):void
{
trace(status);
}
Požadovaný statut je předán jako řetězec metodě updateStatus().
Objekt HTMLLoader neposkytuje stavový řádek.
Zpracovávání změn vlastnosti window.document.title
potlačí metodu updateTitle() pro zpracování změn jazyka JavaScript hodnoty window.document.title.
Následující příklad změní titul okna a k přidá k titulu řetězec „ukázka“.
override public function updateTitle(title:String):void
{
htmlLoader.stage.nativeWindow.title = title + " - Sample";
}
Jestliže je na stránce HTML nastavena vlastnost document.title, je požadovaný titul předán jako řetězec metodě
updateTitle().
Změny document.title nemusí změnit titul okna obsahujícího objekt HTMLLoader. Mohli byste například změnit
další prvek rozhraní, například textové pole.
Zpracovávání volání jazyka JavaScript k window.blur() a window.focus()
Potlačí metody windowBlur() a windowFocus() pro zpracovávání volání jazyka JavaScript k window.blur() a
window.focus(), viz následující příklad:
override public function windowBlur():void
{
}
override public function windowFocus():void
{
NativeApplication.nativeApplication.activate(htmlLoader.stage.nativeWindow);
}
Poznámka: AIR neposkytuje rozhraní API pro deaktivaci okna nebo aplikace.
Vytváření oken s rolováním obsahu HTML
Třída HTMLLoader obsahuje statickou metodu HTMLLoader.createRootWindow(), která vám umožňuje otevřít
nové okno (reprezentované objektem NativeWindow), které obsahuje objekt HTMLLoader a definuje některé
nastavení uživatelského rozhraní pro dané okno. Tato metoda přebírá čtyři parametry, které vám umožňují definovat
uživatelské rozhraní:
Parametr
Popis
visible
Booleovská hodnota, která určuje, zda je okno zpočátku viditelné (true) nebo nikoliv (false).
windowInitOptions
Objekt NativeWindowInitOptions. Třída NativeWindowInitOptions definuje volby inicializace pro objekt
NativeWindow, včetně následujících: zda lze okno minimalizovat, maximalizovat nebo změnit jeho velikost, zda
má okno systémový chróm nebo uživatelský chróm, zda je okno průhledné nebo nikoliv (pro okna, která
nepoužívají systémový chróm) a typ okna.
scrollBarsVisible
Zda jsou k dispozici posuvníky(true) nebo nikoliv (false).
bounds
Objekt Rectangle definující polohu a velikost nového okna.
Například následující kód používá metodu HTMLLoader.createRootWindow() pro vytvoření okna s obsahem
HTMLLoader, který používá posuvníky:
var bounds:Rectangle = new Rectangle(10, 10, 600, 400);
var html2:HTMLLoader = HTMLLoader.createRootWindow(true, initOptions, true, bounds);
var urlReq2:URLRequest = new URLRequest("http://www.example.com");
html2.load(urlReq2);
html2.stage.nativeWindow.activate();
Poznámka: Okna vytvořená voláním createRootWindow() přímo v jazyce JavaScript zůstávají nezávislá na úvodním
okně HTML. Například vlastnosti okna jazyka JavaScript opener a parent mají hodnotu null. Jestliže nicméně voláte
createRootWindow() nepřímo potlačením metody HTMLHost createWindow() pro volání createRootWindow(),
poté vlastnosti opener a parent odkazují na úvodní okno HTML.
Vytváření podtříd třídy HTMLLoader
Můžete vytvořit podtřídu třídy HTMLLoader pro vytvoření nových chování. Můžete například vytvořit podtřídu,
která definuje výchozí posluchače události pro události HTMLLoader (například události odeslané při vykreslení
HTML nebo když uživatel klepne na odkaz).
Následující příklad rozšíří třídu HTMLHost pro zajištění chování normal v případě volání metody jazyka JavaScript
window.open(). Příklad poté definuje podtřídu HTMLLoader, která používá vlastní třídu implementace HTMLHost:
package
{
import flash.html.HTMLLoader;
public class MyHTMLHost extends HTMLHost
{
public function MyHTMLHost()
{
super(false);
}
override public function createWindow(opts:HTMLWindowCreateOptions):void
{
var bounds:Rectangle = new Rectangle(opts.x, opts.y, opts.width, opts.height);
var html:HTMLLoader = HTMLLoader.createRootWindow(true,
initOptions,
opts.scrollBarsVisible,
bounds);
html.stage.nativeWindow.orderToFront();
return html
}
}
Níže je definována podtřída třídy HTMLLoader, která přiřadí objekt MyHTMLHost jeho vlastnosti htmlHost:
package
{
import flash.html.HTMLLoader;
import MyHTMLHost;
import HTMLLoader;
public class MyHTML extends HTMLLoader
{
public function MyHTML()
{
super();
htmlHost = new MyHTMLHost();
}
}
}
Podrobnosti o třídě HTMLHost a metoděHTMLLoader.createRootWindow() použité v tomto příkladě naleznete v
tématu „Definování uživatelských rozhraní podobných prohlížeči pro obsah HTML.“ na stránce 236.
245
Kapitola 24: Přidávání obsahu PDF
Aplikace běžící v prostředí Adobe® AIR™ dokáží vykreslit nejen obsah SWF a HTML, ale také obsah PDF. Aplikace AIR
vykreslují obsah PDF pomocí třídy HTMLLoader, modulu WebKit a zásuvného modulu prohlížeče Adobe® Reader®.
V aplikaci AIR může být obsah PDF roztažen na celou výšku a šířku vaší aplikace nebo může být zobrazen jako část
rozhraní. Zásuvný modul prohlížeče Adobe Reader ovládá zobrazení souborů PDF v aplikaci AIR, takže úpravy
rozhraní panelu nástrojů (např. nástrojů nastavení pozice, ukotvení a viditelnosti) zůstávají u postupného zobrazování
souborů PDF v aplikacích AIR i prohlížeči.
Důležité: Pro vykreslení obsahu PDF v aplikaci AIR musí mít uživatel instalovanou aplikaci Adobe Reader nebo Adobe®
Acrobat® verze 8.1 nebo vyšší.
Zjišťování schopností PDF
Nemá-li uživatel instalovanou aplikaci Adobe Reader nebo Adobe Acrobat ve verzi 8.1 nebo vyšší, obsah PDF se v
aplikaci AIR nezobrazí. Chcete-li zjistit, jestli uživatel může vykreslit obsah PDF, nejprve zkontrolujte vlastnost
HTMLLoader.pdfCapability. Tato vlastnost je nastavena na jednu z následujících konstant třídy:
Konstanta
Popis
HTMLPDFCapability.STATUS_OK
Byla zjištěna postačující verze (8.1 nebo vyšší) aplikace Adobe Reader
a obsah PDF může být načten do objektu HTMLLoader.
HTMLPDFCapability.ERROR_INSTALLED_READER_NOT_FOUND
Nebyla zjištěna žádná verze aplikace Adobe Reader. Objekt
HTMLLoader nemůže zobrazit obsah PDF.
HTMLPDFCapability.ERROR_INSTALLED_READER_TOO_OLD
Byla zjištěna aplikace Adobe Reader, ale její verze je příliš stará.
Objekt HTMLControl nemůže zobrazit obsah PDF.
HTMLPDFCapability.ERROR_PREFERRED_READER_TOO_OLD
Byla zjištěna dostatečná verze (8.1 nebo pozdější) aplikace Adobe
Reader, ale verze aplikace Adobe Reader nastavená na zpracování
obsahu PDF je starší než Reader 8.1. Objekt HTMLControl nemůže
zobrazit obsah PDF.
Poznámka: Windows: pokud v uživatelském systému běží aplikace Acrobat nebo Adobe Reader verze 7.x nebo pozdější,
bude tato verze použita, i když je instalována pozdější verze, která podporuje načtení načteného PDF. Má-li v tomto
případě vlastnost pdfCampability hodnotu HTMLPDFCapability.STATUS_OK, když se aplikace AIR pokouší načíst
obsah PDF, starší verze aplikace Acrobat nebo Reader zobrazí upozornění (a v aplikaci AIR nebude vrácena žádná
výjimka). Může-li u vašich koncových uživatelů nastat takováto situace, zvažte, zda jim nedoporučíte zavřít aplikaci
Acrobat před spuštěním vaší aplikace. Možná budete potřebovat zobrazit tyto pokyny, jestliže se obsah PDF nenačte
během přijatelného časového rámce.
Následující kód zjistí, zda uživatel může zobrazit obsah PDF v aplikaci AIR a pokud ne, bude sledovat chybový kód
odpovídající chybovému objektu HTMLPDFCapability.
Přidávání obsahu PDF
if(HTMLLoader.pdfCapability == HTMLPDFCapability.STATUS_OK)
{
trace("PDF content can be displayed");
}
else
{
trace("PDF cannot be displayed. Error code:", HTMLLoader.pdfCapability);
}
Načítání obsahu PDF
PDF můžete do aplikace AIR přidat vytvořením instance HTMLLoader, nastavením jejích rozměrů a načtením cesty PDF.
V následujícím příkladu je načten soubor PDF z externího webu. Nahraďte URLRequest za cestu k dostupnému
externímu PDF.
var request:URLRequest = new URLRequest("http://www.example.com/test.pdf");
pdf = new HTMLLoader();
pdf.height = 800;
pdf.width = 600;
pdf.load(request);
container.addChild(pdf);
Můžete také načíst obsah z URL souboru a schémat URL pro konkrétní aplikaci AIR, např. app a app-storage.
Například následující kód načte soubor test.pdf do podadresáře PDF adresáře aplikace:
app:/js_api_reference.pdf
Další informace o schématech URL AIR viz „Používání schémat URL AIR v adresách URL“ na stránce 272.
Skriptování obsahu PDF
Pomocí kódu JavaScript můžete ovládat obsah PDF stejně jako v případě webové stránky v prohlížeči.
Rozšíření jazyka JavaScript na Acrobat poskytují mimo jiné následující funkce:
• Ovládání navigace v obsahu stránky a jeho zvětšení
• Zpracování formulářů v rámci dokumentu
• Ovládání multimediálních událostí
Veškeré podrobnosti o rozšířeních jazyka JavaScript pro Adobe Acrobat jsou uvedena v příručce k Adobe Acrobat
Developer Connection na adrese http://www.adobe.com/devnet/acrobat/javascript.html.
Základy komunikace HTML-PDF
Kód JavaScript ve stránce HTML může posílat zprávy kódu JavaScript v obsahu PDF vyvoláním metody
postMessage() objektu DOM zastupujícího obsah PDF. Posuďte například následující vložený obsah PDF:
<object id="PDFObj" data="test.pdf" type="application/pdf" width="100%" height="100%"/>
Následující kód JavaScript v obsahujícím obsahu HTML posílá zprávu kódu JavaScript v souboru PDF:
pdfObject = document.getElementById("PDFObj");
pdfObject.postMessage(["testMsg", "hello"]);
Soubor PDF může obsahovat kód JavaScript pro přijmutí této zprávy. Kód JavaScript můžete přidávat k obsahu PDF
v některých kontextech, včetně kontextu na úrovni dokumentu, složky, stránky, pole a dávky. Zde je probrán pouze
kontext na úrovni dokumentu, který definuje skripty, které se vyhodnocují při otevření dokumentu PDF.
Soubor PDF může přidat vlastnost messageHandler k objektu hostContainer. Vlastnost messageHandler je
objektem, který definuje funkce manipulačního programu pro reagování na zprávy. Například následující kód
definuje funkci pro zpracování zpráv přijatých souborem PDF z hostitelského kontejneru (jímž je obsah HTML
obsahující vložený soubor PDF):
this.hostContainer.messageHandler = {onMessage: myOnMessage};
function myOnMessage(aMessage)
{
if(aMessage[0] == "testMsg")
{
app.alert("Test message: " + aMessage[1]);
}
else
{
app.alert("Error");
}
}
Kód JavaScript ve stránce HTML může vyvolat metodu postMessage() objektu PDF obsaženého ve stránce. Při
vyvolání této metody se odešle zpráva („Ahoj od HTML") do kódu JavaScript na úrovni dokumentu v souboru PDF:
<html>
<head>
<title>PDF Test</title>
<script>
function init()
{
pdfObject = document.getElementById("PDFObj");
try {
pdfObject.postMessage(["alert", "Hello from HTML"]);
}
catch (e)
{
alert( "Error: \n name = " + e.name + "\n message = " + e.message );
}
}
</script>
</head>
<body onload='init()'>
<object
id="PDFObj"
data="test.pdf"
type="application/pdf"
width="100%" height="100%"/>
</body>
</html>
Další pokročilé příklady a informace o přidávání kódu JavaScript do souboru PDF pomocí aplikace Acrobat 8 viz
Vytváření křížových skriptů obsahu PDF v aplikaci Adobe AIR.
Skriptování obsahu PDF z kódu ActionScript
Kód ActionScript (v obsahu SWF) nedokáže komunikovat přímo s obsahem JavaScript v obsahu PDF. Kód
ActionScript však může komunikovat s kódem JavaScript ve stránce HTML načtené v objektu HTMLLoader, který
načítá obsah PDF, a tento kód JavaScript může komunikovat s kódem JavaScript v načteném souboru PDF. Další
informace viz „Programování v jazycích HTML a JavaScript“ na stránce 207.
Známá omezení obsahu PDF v aplikaci AIR
Obsah PDF v aplikaci Adobe AIR má následující omezení:
• Obsah PDF se nezobrazuje v okně (objekt NativeWindow), které je průhledné (kde je vlastnost transparent
nastavena na hodnotu true).
• Pořadí zobrazení souboru PDF funguje jinak než jiné objekty zobrazení v aplikaci AIR. I když je podle pořadí
zobrazení HTML obsah PDF správně ořezán, v pořadí zobrazení aplikace AIR bude vždy posazen před obsahem.
• Obsah PDF se nezobrazuje v okně v režimu přes celou obrazovku (když je vlastnost displayState vymezené
plochy nastavena na hodnotu StageDisplayState.FULL_SCREEN nebo
StageDisplayState.FULL_SCREEN_INTERACTIVE).
• Vizuální vlastnosti objektu HTMLLoader, který obsahuje soubor PDF, nelze změnit. Změna vlastností filters,
alpha, rotation nebo scaling objektu HTMLLoader vykreslí soubor PDF jako neviditelný, dokud nejsou tyto
vlastnosti znovu nastaveny. To platí i v případě, změníte-li tyto vlastnosti kontejnerů objektu zobrazení, který
obsahuje objekt HTMLLoader.
• Vlastnost scaleMode objektu Stage objektu NativeWindow obsahujícího obsah PDF musí být nastavena na
StageScaleMode.NO_SCALE.
• Klepnutím na odkazy vedoucí k obsahu v rámci souboru PDF se aktualizuje pozice rolování obsahu PDF.
Klepnutím na odkazy vedoucí k obsahu mimo soubor PDF se přesměruje objekt HTMLLoader, který obsahuje PDF
(i když je cíl odkazu nové okno).
• PDF komentující pracovní postupy nefunguje v aplikaci AIR 1.0.
249
Kapitola 25: Použití správy digitálních
práv
Server Adobe® Flash® Media Rights Management Server (FMRMS) zajišťuje vydavatelům médií schopnost šířit obsah,
zejména soubory FLV a MP4, a získat zpět výrobní náklady prostřednictvím přímé (zaplacené uživateli) nebo nepřímé
(zaplacené reklamou) úhrady od zákazníků. Vydavatelé šíří média jako zašifrované soubory FLV, které lze stahovat a
přehrávat pomocí přehrávače Adobe® Media Player™ nebo libovolné aplikace AIR, jež využívá rozhraní API pro správu
digitálních práv (DRM).
Se serverem FMRMS mohou poskytovatelé obsahu používat licence založené na identitě k ochraně obsahu pomocí
uživatelských oprávnění. Řekněme například, že uživatel chce shlédnout televizní program, ale nechce sledovat s ním
spojené reklamy. Aby se sledování reklam vyhnul, zaregistruje se a zaplatí vydavateli obsahu určitou odměnu. Pak
může pomocí svých autorizačních oprávnění získat přístup k programu a přehrát si ho bez reklam. Další uživatel může
chtít sledovat obsah v režimu offline, zatímco cestuje bez přístupu k Internetu. Po zaregistrování a zaplacení vydavateli
obsahu za tuto nadstandardní službu mu autorizační oprávnění umožní přístup k programu, který si může stáhnout z
webového místa vydavatele. Uživatel pak může shlédnout daný obsah v režimu offline v povoleném období. Obsah je
rovněž chráněn pomocí uživatelských oprávnění a nelze ho sdílet s jinými uživateli.
Když se uživatel pokusí přehrát soubor s šifrováním DRM, aplikace se spojí se serverem FMRMS, který se zase spojí se
systémem vydavatele obsahu prostřednictvím jeho servisního rozhraní (SPI) za účelem autorizace uživatele a získání
licence, tedy povolení, které určuje, zda má uživatel povolen přístup k obsahu, a pokud ano, tak na jak dlouho. Toto
povolení rovněž určuje, zda má uživatel k obsahu přístup v režimu offline, a pokud ano, na jak dlouho. Uživatelská
oprávnění jsou tedy nezbytná pro určení přístupu k zašifrovanému obsahu.
Licence založené na identitě rovněž podporují anonymní přístup. Anonymní přístup může například použít
poskytovatel k šíření obsahu podporovaného reklamou nebo k zajištění volného přístupu k aktuálnímu obsahu po
určitý počet dní. Archivní materiál lze považovat za nadstandardní obsah, který je nezbytné zaplatit a který vyžaduje
uživatelská oprávnění. Poskytovatel obsahu může rovněž určit a vymezit typ a verzi přehrávače potřebného k
přehrávání daného obsahu.
V této sekci je popsáno, jak lze v aplikaci AIR umožnit přehrávání obsahu chráněného šifrováním pomocí správy
digitálních práv. Není nutné vědět, jak se šifruje obsah pomocí DRM, ale předpokládá se, že máte přístup k obsahu s
šifrováním DRM a komunikujete se serverem FMRMS, aby bylo možné uživatele autorizovat a získat povolení.
Obecné informace o serveru FMRMS, včetně vytváření pravidel, naleznete v dokumentaci přiložené k FMRMS.
Informace týkající se přehrávače Adobe Media Player naleznete v nápovědě, která je k dispozici v přehrávači Adobe
Media Player.
Další informace o správě digitálních práv online
Více informací týkajících se správy digitálních práv naleznete v následujících zdrojích:
• DRMAuthenticateEvent
• DRMErrorEvent
• DRMStatusEvent
Použití správy digitálních práv
• NetStream
• Adobe AIR Developer Connection pro Flash (hledat „digital rights management“ nebo „drm“)
Popis toku operací při zpracování zašifrovaných
souborů FLV
Existují čtyři typy událostí: StatusEvent. DRMAuthenticateEvent, DRMErrorEvent a DRMStatusEvent, jež mohou být
odeslány při pokusu aplikace AIR o přehrávání souboru s šifrováním DRM. Pokud mají být tyto soubory
podporovány, aplikace by měla přidat posluchače událostí pro zpracování událostí DRM.
V následující části je popsán tok operací při načítání a přehrávání obsahu chráněného šifrováním DRM v aplikaci AIR:
1 Aplikace se pomocí objektu NetStream pokusí přehrát soubor FLV nebo MP4. Je-li jeho obsah zašifrovaný, odešle
se událost events.StatusEvent s kódem DRM.encryptedFLV, který značí, že soubor FLV je zašifrovaný.
Poznámka: Pokud aplikace nechce soubor s šifrováním DRM přehrávat, může poslouchat událost Status, která se
odešle, když aplikace narazí na zašifrovaný obsah, potom uživateli oznámit, že soubor není podporován, a ukončit
spojení.
2 Jestliže se jedná o soubor s anonymním šifrováním, což znamená, že jeho obsah mohou prohlížet všichni uživatelé,
aniž by bylo nutné zadávat autorizační oprávnění, přejde aplikace AIR k poslednímu kroku v tomto toku operací.
Pokud však soubor vyžaduje licenci založenou na identitě, což znamená, že je vyžadováno uživatelské oprávnění,
objekt NetStream vygeneruje objekt události DRMAuthenticateEvent. Uživatel musí nejprve poskytnout své
autorizační oprávnění a teprve potom bude možné zahájit přehrávání.
3 Aplikace AIR musí zajistit mechanismus pro sběr potřebných autorizačních oprávnění. Pomocí vlastností
usernamePrompt, passwordPrompt a urlPrompt třídy DRMAuthenticationEvent, jež poskytuje server obsahu,
lze koncovému uživateli sdělit informace o požadovaných datech. Tyto vlastnosti lze použít při tvorbě
uživatelského rozhraní pro načítání potřebných uživatelských oprávnění. Například řetězec hodnoty
usernamePrompt může udávat, že uživatelské jméno musí být ve formě e-mailové adresy.
Poznámka: Aplikace AIR neposkytuje výchozí uživatelské rozhraní pro sběr autorizačních oprávnění. Napsat
uživatelské rozhraní a zpracovat události DRMAuthenticateEvent je úkolem vývojář aplikace. Pokud aplikace
nezajistí posluchače událostí pro objekty DRMAuthenticateEvent, zůstane objekt s šifrováním DRM ve stavu „čekání
na oprávnění“ a obsah tudíž nebude k dispozici.
4 Jakmile aplikace obdrží uživatelská oprávnění, předá je pomocí metody setDRMAuthenticationCredentials()
do objektu NetStream. To dá objektu NetStream pokyn, že má při nejbližší možné příležitosti zkusit uživatele
autorizovat. Aplikace AIR pak předá oprávnění serveru FMRMS kvůli autorizaci. Byl-li uživatel autorizován,
aplikace přejde k následujícímu kroku.
V případě neúspěšné autorizace se odešle nová událost DRMAuthenticateEvent a aplikace se vrátí k 3. kroku. Tento
proces se opakuje donekonečna. Aplikace by měla zajistit mechanismus pro zpracování a omezení opakovaných
pokusů o autorizaci. Mohla by uživateli například umožnit zrušení pokusu, který může ukončit spojení s objektem
NetStream.
5 Po autorizaci uživatele nebo v případě použití anonymního šifrování pak podsystém DRM načte povolení. Toto
povolení slouží ke kontrole, zda je uživatel oprávněn prohlížet obsah. Informace v povolení může platit pro
autorizované i anonymní uživatele. Autorizovaní i anonymní uživatelé například mohou mít přístup k obsahu po
stanovenou dobu, než vyprší platnost obsahu, nebo nemusí mít k obsahu přístup kvůli tomu, že poskytovatel
obsahu nepodporuje verzi zobrazovací aplikace.
Jestliže nenastala chyba a uživatel byl oprávněn k prohlížení obsahu, odešle se objekt události DRMStatusEvent a
aplikace AIR zahájí přehrávání. Objekt DRMStatusEvent uchovává informace z příslušného povolení, které určují
pravidla a práva uživatele. Například uchovává informace o tom, zda lze obsah zpřístupnit v režimu offline nebo kdy
skončí platnost povolení a obsah již nebude možné prohlížet. Pomocí těchto dat může aplikace informovat uživatele
o stavu jeho pravidel. Aplikace může například na stavovém řádku zobrazovat zbývající počet dní, kdy může uživatel
obsah prohlížet.
Pokud má uživatel povolen přístup v režimu offline, povolení se uloží do vyrovnávací paměti a zašifrovaný obsah se
stáhne do počítače uživatele a bude přístupný po dobu definovanou v době platnosti offline. Vlastnost „detail“ v
události obsahuje údaj „DRM.voucherObtained“. Aplikace rozhodne, kam má být obsah lokálně uložen, aby byl
přístupný offline.
Každá chyba týkající se DRM vede k tomu, že aplikace odešle objekt události DRMErrorEvent. Aplikace AIR zpracuje
neúspěšnou autorizaci DRM opětným spuštěním objektu události DRMAuthenticationEvent. Všechny ostatní
události chyb musí aplikace zpracovat explicitně. To platí i pro případy, když uživatel zadá platná oprávnění, ale
povolení, které zašifrovaný obsah chrání, omezí přístup k obsahu. Autorizovaný uživatel například nemusí mít zatím
přístup k obsahu, neboť práva dosud nebyla zaplacena. To může nastat také v případě, kdy dva uživatelé, oba členové
registrovaní u stejného vydavatele médií, budou chtít sdílet obsah, za který zaplatil jen jeden z nich. Aplikace by měla
uživatele informovat o vzniku chyby, například omezení přístupu k obsahu, a také nabídnout alternativní řešení,
například pokyny, jak se zaregistrovat a zaplatit za prohlížení obsahu.
Změny ve třídě NetStream
Třída NetStream poskytuje jednosměrné streamované připojení mezi aplikací Flash Player nebo aplikací AIR a
serverem Flash Media Server nebo místním systémem souborů. (Třída NetStream rovněž podporuje postupné
stahování.) Objekt NetStream je kanálem v objektu NetConnection. Jako součást aplikace AIR třída NetStream
zahrnuje čtyři nové události týkající se DRM:
Událost
Popis
drmAuthenticate
Tato událost je definována ve třídě DRMAuthenticateEvent a odešle se při pokusu objektu NetStream o
přehrávání obsahu zašifrovaného pomocí správy digitálních práv (DRM), který před přehráváním vyžaduje
uživatelské oprávnění k autorizaci.
K vlastnostem této události patří header, usernamePrompt, passwordPrompt a urlPrompt, které lze použít k
získání a nastavení oprávnění uživatele. K této události dochází opakovaně, dokud objekt NetStream přijímá
platná uživatelská oprávnění.
Událost
Popis
drmError
Je definována ve třídě DRMErrorEvent a odešle se, když se objekt NetStream při pokusu o přehrávání souboru
zašifrovaného pomocí správy digitálních práv (DRM) setká s chybou související s DRM. Objekt události chyby
DRM se například odešle při neúspěšné autorizaci uživatele. Může to být proto, že si uživatel nezaplatit práva
k prohlížení obsahu nebo že poskytovatel obsahu nepodporuje zobrazovací aplikaci.
drmStatus
Je definována ve třídě DRMStatusEvent a odešle se, když se obsah zašifrovaný pomocí správy digitálních práv
(DRM) začne přehrávat (když je uživatel autorizován a oprávněn přehrávat obsah). Objekt DRMStatusEvent
obsahuje informace související s povolením, například zda lze obsah zpřístupnit offline nebo kdy skončí
platnost povolení a obsah již nebude možné prohlížet.
status
Je definována ve třídě events.StatusEvent a odešle se pouze v případě, že se aplikace pokusí přehrát obsah
zašifrovaný pomocí správy digitálních práv (DRM), vyvoláním metody NetStream.play(). Hodnota vlastnosti
stavového kódu je „DRM.encryptedFLV“.
Třída NetStream zahrnuje následující metody specifické pro DRM:
Metoda
Popis
resetDRMVouchers()
Vymaže z místní vyrovnávací paměti všechna data povolení správy digitálních práv (DRM) pro
aktuální obsah. Aplikace musí povolení znovu stáhnout, aby měl uživatel přístup k zašifrovanému
obsahu.
Následující kód například odstraní povolení pro objekt NetStream:
NetStream.resetDRMVouchers();
air.NetStream.resetDRMVouchers();
Předává do objektu NetStream sadu autorizačních oprávnění, tj. uživatelské jméno, heslo a typ
autorizace, k autorizaci. Platné typy autorizace jsou „drm" a „proxy". U typu autorizace „drm"
se poskytnutá oprávnění ověřují se serverem FMRMS. U typu autorizace „proxy" se oprávnění
ověřují s proxy serverem a musí odpovídat oprávněním, jež požaduje proxy server. Možnost
„proxy“ například umožňuje aplikaci provést ověření se serverem proxy, když podnik takový krok
vyžaduje předtím, než může uživatel přistupovat na Internet. Pokud není použita anonymní
autorizace, po ověření serverem proxy se musí uživatel autorizovat u serveru FMRMS a získat tak
povolení k přehrávání obsahu. Metodu setDRMAuthenticationcredentials() lze použít
podruhé s možností „drm" a ověřením u serveru FMRMS.
V následujícím kódu je pro autorizaci uživatele nastaveno uživatelské jméno („administrator“), heslo („password“) a
typ autorizace „drm“. Metoda setDRMAuthenticationCredentials() musí zajistit oprávnění, která budou odpovídat
oprávněním, jež zná a přijímá poskytovatel obsahu (stejná uživatelská oprávnění, která zajistila povolení prohlížet
obsah). Tento příklad nezahrnuje kód pro přehrávání videa a zajištění úspěšného připojení ke streamu videa.
var connection:NetConnection = new NetConnection();
connection.connect(null);
var videoStream:NetStream = new NetStream(connection);
videoStream.addEventListener(DRMAuthenticateEvent.DRM_AUTHENTICATE,
drmAuthenticateEventHandler)
private function drmAuthenticateEventHandler(event:DRMAuthenticateEvent):void
{
videoStream.setDRMAuthenticationCredentials("administrator", "password", "drm");
}
var connection:NetConnection = new air.NetConnection();
var videoStream= new air.NetStream();
videoStream.addEventListener(air.DRMAuthenticateEvent.DRM_AUTHENTICATE,
function drmAuthenticateEventHandler(event)
{
}
Použití třídy DRMStatusEvent
Objekt NetStream odesílá objekt DRMStatusEvent, když se obsah chráněný pomocí správy digitálních práv (DRM)
začne úspěšně přehrávat (když je ověřeno povolení a když je uživatel autorizován a oprávněn přehrávat obsah. Událost
DRMStatusEvent se rovněž odesílá pro anonymní uživatele, pokud mají povolen přístup. Kontrolou povolení se zjistí,
zda anonymní uživatelé, u nichž není vyžadována autorizace, mají povolen přístup k přehrávání obsahu. Anonymním
uživatelům může být zamítnut přístup z několika důvodů. Anonymní uživatelé například nemusí mít k obsahu
přístup, protože uplynula jeho platnost.
Objekt DRMStatusEvent obsahuje informace související s povolením, například zda lze obsah zpřístupnit offline nebo
kdy skončí platnost povolení a obsah již nebude možné prohlížet. Aplikace může pomocí těchto dat sdělit stav pravidel
a práv uživatele.
Vlastnosti třídy DRMStatusEvent
Třída DRMStatusEvent zahrnuje následující vlastnosti:
Vlastnost
Popis
detail
Řetězec vysvětlující kontext události stavu. Ve verzi DRM 1.0 je jedinou platnou hodnotou
DRM.voucherObtained.
isAnonymous
Označuje, zda je obsah chráněný šifrováním DRM dostupný bez toho, aby uživatel musel zadat své
přihlašovací údaje (true), či nikoliv (false). Hodnota „false“ znamená, že uživatel musí zadat uživatelské jméno
a heslo, jež se bude shodovat s tím, které zná a očekává poskytovatel obsahu.
isAvailableOffline
Značí, zda lze obsah chráněný šifrováním DRM zpřístupnit offline (true) či nikoliv (false). Má-li být digitálně
chráněný obsah zpřístupněn offline, musí být jeho povolení uloženo do vyrovnávací paměti lokálního
počítače uživatele.
Vlastnost
Popis
offlineLeasePeriod
Zbývající počet dní, po který může být obsah sledovaný v režimu offline.
policies
Vlastní objekt, který může obsahovat vlastní vlastnosti DRM.
voucherEndDate
Konečné datum, kdy uplyne platnost povolení a obsah již nebude možné prohlížet.
Vytváření zpracování události DRMStatusEvent
V následujícím příklad se vytvoří zpracování události, jež vygeneruje informace o stavu obsahu DRM pro objekt
NetStream, který událost spustil. Přidejte tohoto posluchače událostí k objektu NetStream, který míří k obsahu s
šifrováním DRM.
private function drmStatusEventHandler(event:DRMStatusEvent):void
{
trace(event.toString());
}
function drmStatusEventHandler(event:DRMStatusEvent):void
{
}
Použití třídy DRMAuthenticateEvent
Objekt DRMAuthenticateEvent se odešle při pokusu objektu NetStream o přehrávání obsahu zašifrovaného pomocí
správy digitálních práv (DRM), který před přehráváním vyžaduje uživatelské oprávnění k autorizaci.
Zpracování události DRMAuthenticateEvent je odpovědné za získávání potřebných oprávnění (jméno uživatele, heslo
a typ) a předávání těchto hodnot do metody NetStream.setDRMAuthenticationCredentials() k ověření. Každá
aplikace AIR musí poskytnout jistý mechanismu k získání osobních přihlašovacích údajů uživatele. Aplikace může
například uživateli poskytnout jednoduché rozhraní k zadání uživatelského jména a hesla a volitelně i typové hodnoty.
Aplikace AIR by rovněž měla zajistit mechanismus pro zpracování a omezení opakovaných pokusů o autorizaci.
Vlastnosti třídy DRMAuthenticateEvent
Třída DRMAuthenticateEvent zahrnuje následující vlastnosti:
Vlastnost
Popis
authenticationType
Značí, zda jsou poskytnutá oprávnění určena k ověření se serverem FMRMS („drm“) nebo s proxy serverem
(„proxy“). Možnost „proxy“ například umožňuje aplikaci provést ověření se serverem proxy, když podnik
takový krok vyžaduje předtím, než může uživatel přistupovat na Internet. Pokud není použita anonymní
autorizace, po ověření serverem proxy se musí uživatel autorizovat u serveru FMRMS a získat tak povolení k
přehrávání obsahu. Metodu setDRMAuthenticationcredentials() lze použít podruhé s možností „drm“ a
ověřením u serveru FMRMS.
header
Záhlaví souboru se zašifrovaným obsahem, poskytnuté serverem. Obsahuje informace o kontextu
zašifrovaného obsahu.
netstream
Objekt NetStream, který inicializoval tuto událost.
Vlastnost
Popis
passwordPrompt
Výzva k zadání hesla uživatele, poskytnutá serverem. Řetězec může zahrnovat pokyn pro typ vyžadovaného
hesla.
urlPrompt
Výzva pro řetězec adresy URL, poskytnutá serverem. Řetězec může poskytnout umístění, kam se odešle
uživatelské jméno a heslo.
usernamePrompt
Výzva k zadání uživatelského jména, poskytnutá serverem. Řetězec může zahrnovat pokyn pro typ
vyžadovaného uživatelského jména. Poskytovatel obsahu může například jako uživatelské jméno vyžadovat
emailovou adresu.
Vytváření zpracování události DRMAuthenticateEvent
V následujícím příklad se vytvoří zpracování události, jež předá naprogramovaná autorizační oprávnění do objektu
NetStream, který událost spustil. (Tento příklad nezahrnuje kód pro přehrávání videa a zajištění úspěšného připojení
ke streamu videa.)
var connection:NetConnection = new NetConnection();
var videoStream:NetStream = new NetStream(connection);
videoStream.addEventListener(DRMAuthenticateEvent.DRM_AUTHENTICATE,
private function drmAuthenticateEventHandler(event:DRMAuthenticateEvent):void
{
}
var connection:NetConnection = new air.NetConnection();
var videoStream= new air.NetStream();
videoStream.addEventListener(air.DRMAuthenticateEvent.DRM_AUTHENTICATE,
function drmAuthenticateEventHandler(event)
{
}
Vytvoření rozhraní pro načítání uživatelských oprávnění
V případech, kdy obsah DRM vyžaduje autorizaci uživatele, aplikace AIR obvykle potřebuje načíst autorizační
oprávnění uživatele prostřednictvím uživatelského rozhraní.
Použití třídy DRMErrorEvent
Aplikace AIR odešle objekt DRMErrorEvent, když se objekt NetStream při pokusu o přehrávání souboru
zašifrovaného pomocí správy digitálních práv (DRM) setká s chybou související s DRM. V případě neplatných
oprávnění uživatele bude objekt DRMAuthenticateEvent zpracovávat chybu opakovaným odesíláním, dokud uživatel
nezadá platné přihlašovací údaje nebo dokud aplikace AIR neodmítne další pokusy. Aplikace by měla poslouchat
všechny další události chyb DRM a tak zjišťovat, identifikovat a zpracovávat chyby související s DRM.
Přestože uživatel zadá platná oprávnění, nemusí mu být v závislosti na podmínkách povolení DRM dovoleno prohlížet
zašifrovaný obsah. Například když se uživatel pokusí prohlížet obsah v neautorizované aplikaci, tedy v aplikaci, jež
není ověřena vydavatelem zašifrovaného obsahu. V takovém případě bude odeslán objekt DRMErrorEvent. Události
chyb se rovněž může spustit, pokud je obsah poškozený nebo pokud verze aplikace neodpovídá údajům obsaženým v
povolení. Aplikace musí zajistit vhodný mechanismus pro zpracování chyb.
Vlastnosti třídy DRMErrorEvent
Třída DRMErrorEvent zahrnuje následující vlastnost:
subErrorID
Udává ID drobné chyby s dalšími informacemi o problému, který ji způsobil.
V následující tabulce jsou uvedeny chyby hlášené objektem DRMErrorEvent:
Kód závažné
chyby
Kód drobné chyby
Podrobnosti chyby
1001
0
Ověření uživatele se nezdařilo.
1002
0
Flash Media Rights Management Server (FMRMS)
nepodporuje protokol SSL (Secure Sockets
Layer).
1003
0
Platnost obsahu uplynula a obsah již není možné
prohlížet.
1004
0
Chyba ověření uživatele. Může nastat například v
případě, že si uživatel obsah nekoupil a nemá
tedy práva k jeho prohlížení.
1005
0
1006
0
Vyžaduje se aktualizace klienta, tzn. server Flash
Media Rights Management Server (FMRMS)
vyžaduje nový stroj správy digitálních práv
(DRM).
1007
0
Obecná interní chyba
1008
Podrobný kód chyby
dešifrování
Nesprávný licenční klíč.
1009
0
Obsah FLV je poškozený.
1010
0
1011
0
Server URL
publisherID:applicationID
Popis
Nelze se připojit k serveru.
ID zobrazovací aplikace neodpovídá platnému ID
podporovanému vydavatelem obsahu.
Verze aplikace neodpovídá verzi specifikované
pravidly.
Kód závažné
chyby
Kód drobné chyby
Podrobnosti chyby
1012
0
Ověření povolení přiřazeného k zašifrovanému
obsahu se nezdařilo; existuje možnost, že obsah
je poškozen.
1013
0
Povolení přiřazené k zašifrovanému obsahu
nebylo možné uložit.
1014
0
Ověření integrity záhlaví souboru FLV se
nezdařilo; existuje možnost, že obsah je
poškozen.
Kód závažné
chyby
ID drobné chyby
3300
Kód chyby serveru
Adobe Policy Server
Aplikace zjistila neplatné povolení přiřazené k
obsahu.
3301
0
Ověření uživatele se nezdařilo.
3302
0
Protokol SSL (Secure Sockets Layer) není
serverem správy oprávnění Flash Media Rights
Management Server (FMRMS) podporován.
3303
0
Platnost obsahu uplynula a obsah již není možné
prohlížet.
3304
0
Chyba ověření uživatele. K tomu může dojít i v
případě, že je uživatel ověřen, například pokud si
uživatel nezakoupil oprávnění k zobrazení
obsahu.
3305
0
3306
0
Vyžaduje se aktualizace klienta; server Flash
Media Rights Management Server (FMRMS)
vyžaduje nový stroj správy digitálních práv
klienta.
3307
0
Obecná interní porucha správy digitálních práv.
3308
Podrobný kód chyby
dešifrování
Nesprávný licenční klíč.
3309
0
Obsah videa Flash je poškozený.
3310
0
publisherID:applicationID
ID zobrazovací aplikace neodpovídá platnému ID
podporovanému vydavatelem obsahu. Jinými
slovy, zobrazovací aplikace není podporována
vydavatelem obsahu.
3311
0
min=x:max=y
Verze aplikace neodpovídá údajům obsaženým v
povolení.
3312
0
Podrobnosti chyby
Server URL
Popis
Popis
Nelze se připojit k serveru.
Ověření povolení přiřazeného k zašifrovanému
obsahu se nezdařilo; existuje možnost, že obsah
je poškozen.
Kód závažné
chyby
ID drobné chyby
Podrobnosti chyby
3313
0
Povolení přiřazené k zašifrovanému obsahu
nebylo možné uložit do aplikace Microsafe.
3314
0
Ověření integrity záhlaví souboru FLV se
nezdařilo; existuje možnost, že obsah je
poškozen.
3315
Popis
Vzdálené přehrávání obsahu chráněného DRM
není povoleno.
Vytváření zpracování události DRMErrorEvent
V následujícím příklad se vytvoří zpracování události pro objekt NetStream, který událost spustil. To se vyvolá, když
objekt NetStream narazí při pokusu o přehrávání obsahu s šifrováním DRM na chybu. Obvykle, když aplikace narazí
na chybu, provede libovolný počet úloh pro vyčištění, informuje uživatele o chybě a nabídne možnosti pro vyřešení
daného problému.
private function drmErrorEventHandler(event:DRMErrorEvent):void
{
}
function drmErrorEventHandler(event)
{
air.trace(event.toString());
}
259
Kapitola 26: Možnosti spuštění a ukončení
aplikací
V této sekci jsou vysvětleny možnosti a pokyny pro spuštění nainstalované aplikace Adobe® AIR™, jakož i možnosti a
pokyny pro ukončení spuštěné aplikace.
Vyvolání aplikací
Aplikace AIR se vyvolá, když uživatel (nebo operační systém):
• vyvolá aplikaci z tvůrce prostředí;
• použije aplikaci jako příkaz v interpretu příkazového řádku;
• otevře typ souboru, pro který je aplikace výchozí aplikací pro otevření;
• (Mac OS X) klepne na ikonu aplikace na hlavním panelu ukotvení (bez ohledu na to, zda je aplikace v danou chvíli
spuštěna či nikoliv);
• spustí aplikaci z instalátoru (buď na konci nového instalačního procesu, nebo poklepáním na soubor AIR u již
nainstalované aplikace);
• zahájí aktualizaci aplikace AIR, když nainstalovaná verze signalizuje, že sama zpracovává aktualizace aplikace
(začleněním deklarace <customUpdateUI>true</customUpdateUI> do souboru deskriptoru aplikace);
• navštíví webovou stránku hostující identifikátor Flash nebo aplikaci, která vyvolá metodu com.adobe.air.AIR
launchApplication() určující identifikační informace pro aplikaci AIR. (Deskriptor aplikace musí rovněž
zahrnovat deklaraci <allowBrowserInvocation>true</allowBrowserInvocation>, aby vyvolání prohlížeče
bylo úspěšné.) Viz sekce „Spuštění nainstalované aplikace AIR z prohlížeče“ na stránce 283.
Při každém vyvolání aplikace AIR odešle aplikace AIR objekt InvokeEvent typu invoke prostřednictvím jediné
instance objektu NativeApplication. Aby aplikace měla čas se inicializovat a zaregistrovat posluchače událostí, umístí
se události invoke do fronty místo toho, aby byly vyřazeny. Po zaregistrování posluchače jsou všechny události ve
frontě doručeny.
Poznámka: Jestliže je aplikace vyvolána pomocí funkce vyvolání z prohlížeče, odešle objekt NativeApplication událost
invoke jen v případě, že aplikace dosud není spuštěna. Viz sekce „Spuštění nainstalované aplikace AIR z prohlížeče“ na
stránce 283.
Chcete-li přijmout události invoke, vyvolejte metodu addEventListener() objektu NativeApplication
(NativeApplication.nativeApplication). Když posluchač událostí zaregistruje událost invoke, obdrží také
všechny události invoke, které nastaly před registrací. Události invoke umístěné ve frontě se odesílají po jedné v
krátkém intervalu poté, co se vrátí vyvolání funkce addEventListener(). Pokud v průběhu tohoto procesu nastane
nová událost invoke, může být odeslána dříve než jedna či více událostí ve frontě. Díky tomuto řazení událostí do
fronty lze zpracovat všechny události invoke, k nimž došlo před provedením inicializačního kódu. Mějte na paměti,
že pokud přidáte posluchače událostí později během provádění (po inicializaci aplikace), přesto obdrží všechny
události invoke, které nastaly od spuštění aplikace.
Spouští se jen jedna instance aplikace AIR. Jestliže bude již spuštěná aplikace znovu vyvolána, aplikace AIR odešle
novou událost invoke do spuštěné instance. Úkolem aplikace AIR je reagovat na událost invoke a provést
odpovídající akci (např. otevřít nové okno s dokumentem).
Možnosti spuštění a ukončení aplikací
Objekt InvokeEvent obsahuje všechny argumenty předané do aplikace, jakož i adresář, z něhož byla aplikace
vyvolána. Byla-li aplikace vyvolána kvůli přiřazení k typu souboru, bude do argumentů příkazového řádku zahrnuta
úplná cesta k tomuto souboru. Stejně tak pokud byla aplikace vyvolána z důvodu aktualizace aplikace, bude poskytnuta
úplná cesta k aktualizačnímu souboru aplikace AIR.
Aplikace může události invoke zpracovávat zaregistrováním posluchače pomocí objektu NativeApplication:
NativeApplication.nativeApplication.addEventListener(InvokeEvent.INVOKE, onInvokeEvent);
air.NativeApplication.nativeApplication.addEventListener(air.InvokeEvent.INVOKE,
onInvokeEvent);
A definováním posluchače událostí:
var arguments:Array;
var currentDir:File;
public function onInvokeEvent(invocation:InvokeEvent):void {
arguments = invocation.arguments;
currentDir = invocation.currentDirectory;
}
Zachycení argumentů příkazového řádku
Argumenty příkazového řádku spojené s vyvoláním aplikace AIR jsou doručeny v události invoke odeslané objektem
NativeApplication. Vlastnost InvokeEvent.arguments obsahuje pole argumentů předávaných operačním systémem
při vyvolání aplikace AIR. Jestliže argumenty obsahují relativní cesty k souborům, obvykle je možné cesty rozlišit
pomocí vlastnosti currentDirectory.
S argumenty předanými do programu aplikace AIR se zachází jako s řetězci oddělenými prázdnými místy (mezerami),
pokud nejsou uzavřeny v uvozovkách.
Argumenty
Array
tick tock
{tick,tock}
tick "tick tock"
{tick,tick tock}
"tick" “tock”
{tick,tock}
\"tick\" \"tock\"
{"tick","tock"}
Vlastnost InvokeEvent.currentDirectory obsahuje objekt File představující adresář, z něhož byla spuštěna
aplikace.
Při vyvolání aplikace následkem otevření typu souboru zaregistrovaného aplikací bude do argumentů příkazového
řádku zahrnuta nativní cesta k souboru ve formě řetězce. (Úkolem aplikace je soubor otevřít nebo s ním provést
zamýšlenou operaci.) Stejně tak když je aplikace naprogramována tak, aby se sama aktualizovala (místo toho, aby se
spoléhala na standardní uživatelské rozhraní pro aktualizaci aplikace AIR), a uživatel poklepe na soubor AIR
obsahující aplikaci s odpovídajícím ID aplikace, bude zahrnuta nativní cesta k souboru AIR.
K souboru lze získat přístup pomocí metody resolve() objektu File currentDirectory:
if((invokeEvent.currentDirectory != null)&&(invokeEvent.arguments.length > 0)){
dir = invokeEvent.currentDirectory;
fileToOpen = dir.resolvePath(invokeEvent.arguments[0]);
}
Rovněž je vhodné ověřit, že argument je skutečně cestou k souboru.
Příklad: Záznam událostí vyvolání
Následující příklad znázorňuje způsob registrace posluchačů a zpracování události invoke. V tomto příkladu se
zaznamenají všechny přijaté události vyvolání a zobrazí se aktuální adresář a argumenty příkazového řádku.
Poznámka: Chcete-li vytvořit následující příklad pomocí aplikace Adobe® Flash® CS3, vytvořte nejprve soubor Flash
(Adobe AIR). V panelu nastavení jazyka ActionScript 3.0 (Soubor > Nastavení publikování... > tlačítko Nastavení)
zadejte do pole třídy Document název InvokeEventLogExample. Uložete soubor FLA s názvem
InvokeEventLogExample.fla. Potom ve stejné složce vytvořte soubor ActionScript. Zadejte do souboru ActionScript
následující kód a soubor uložte s názvem InvokeEventLogExample.as.
package
{
import
import
import
import
flash.events.InvokeEvent;
public class InvokeEventLogExample extends Sprite
{
public var log:TextField;
public function InvokeEventLogExample()
{
log = new TextField();
log.x = 15;
log.y = 15;
log.width = 520;
log.height = 370;
log.background = true;
addChild(log);
NativeApplication.nativeApplication.addEventListener(InvokeEvent.INVOKE, onInvoke);
}
public function onInvoke(invokeEvent:InvokeEvent):void
{
var now:String = new Date().toTimeString();
logEvent("Invoke event received: " + now);
if (invokeEvent.currentDirectory != null)
{
logEvent("Current directory=" + invokeEvent.currentDirectory.nativePath);
}
else
{
logEvent("--no directory information available--");
}
if (invokeEvent.arguments.length > 0)
{
logEvent("Arguments: " + invokeEvent.arguments.toString());
}
else
{
logEvent("--no arguments--");
}
}
public function logEvent(entry:String):void
{
log.appendText(entry + "\n");
trace(entry);
}
}
}
Spuštění při přihlášení
Aplikaci AIR lze nastavit na automatické spuštění při přihlášení aktuálního uživatele nastavením možnosti
NativeApplication.nativeApplication.startAtLogin=true. Po provedení tohoto nastavení se aplikace
automaticky spustí pokaždé, když se uživatel přihlásí. Spouštění při startu bude probíhat, dokud nebude nastavení
změněno na hodnotu false, dokud uživatel ručně nezmění nastavení prostřednictvím operačního systému nebo
dokud aplikace nebude odinstalována. Spuštění při přihlášení je nastavení prováděné za běhu.
Poznámka: Aplikace se nespusí při startu počítačového systému. Spustí se po přihlášení uživatele. Toto nastavení platí
pouze pro aktuálního uživatele. Kromě toho musí být aplikace nainstalovaná, aby bylo možné úspěšně nastavit vlastnost
startAtLogin na hodnotu true. Pokud bude tato vlastnost nastavena bez toho, aby byla aplikace nainstalovaná
(například při spuštění pomocí ADL), bude vrácena chyba.
Vyvolání z prohlížeče
Pomocí funkce vyvolání z prohlížeče může webové místo spustit instalovanou aplikaci AIR, jež má být spuštěna z
prohlížeče. Spuštění z prohlížeče je povoleno jen tehdy, když soubor deskriptoru aplikace nastaví možnost
allowBrowserInvocation na hodnotu true:
Další informace o souboru deskriptoru aplikace naleznete v části „Nastavení vlastností aplikace AIR“ na stránce 42 .
Při vyvolání aplikace prostřednictvím prohlížeče bude objektem NativeApplication aplikace vyvolán objekt
BrowserInvokeEvent.
Chcete-li přijmout události BrowserInvokeEvent, vyvolejte metodu addEventListener() objektu NativeApplication
(NativeApplication.nativeApplication) v aplikaci AIR. Když posluchač událostí zaregistruje událost
BrowserInvokeEvent, obdrží také všechny události BrowserInvokeEvent, které nastaly před registrací. Tyto události
jsou odeslány poté, co je vráceno vyvolání metody addEventListener(), avšak nikoliv nutně před dalšími událostmi
BrowserInvokeEvent, které by mohly být přijaty po registraci. To umožňuje zpracovat události BrowserInvokeEvent,
které nastaly před provedením inicializačního kódu (například při původním vyvolání aplikace z prohlížeče). Mějte na
paměti, že pokud přidáte posluchače událostí později během provádění (po inicializaci aplikace), přesto obdrží
všechny události BrowserInvokeEvent, které nastaly od spuštění aplikace.
Objekt BrowserInvokeEvent zahrnuje následující vlastnosti:
Vlastnost
Popis
arguments
Pole argumentů (řetězců) pro předání aplikaci.
isHTTPS
Zda obsah v prohlížeči používá schéma URL https (true) či nikoliv (false).
isUserEvent
Zda vyvolání prohlížeče vedlo k uživatelské události (například klepnutí myší). V aplikaci AIR 1.0 je tato
vlastnost vždy nastavena na hodnotu true; AIR vyžaduje, aby uživatel aktivoval vyvolání funkce vyvolání z
prohlížeče.
sandboxType
Typ karantény pro obsah v prohlížeči. Platné hodnoty jsou definovány stejně jako hodnoty, které lze použít ve
vlastnosti Security.sandboxType, a mohou být následující:
•
Security.APPLICATION – obsah je v aplikační karanténě zabezpečení.
•
Security.LOCAL_TRUSTED – obsah je v místní důvěryhodné karanténě zabezpečení.
•
Security.LOCAL_WITH_FILE – obsah je v místní důvěryhodné karanténě zabezpečení se souborovým
systémem.
securityDomain
•
Security.LOCAL_WITH_NETWORK – obsah je v místní důvěryhodné karanténě zabezpečení se sítí.
•
Security.REMOTE – obsah je ve vzdálené doméně.
Doména zabezpečení pro obsah v prohlížeči, například www.adobe.com nebo www.example.org. Tato
vlastnost se nastavuje pouze pro obsah ve vzdálené karanténě zabezpečení (pro obsah ze síťové domény). Pro
obsah v místní nebo aplikační karanténě zabezpečení se nenastavuje.
Při použití funkce vyvolání z prohlížeče je vhodné dobře zvážit možné dopady na zabezpečení. Když webové místo
spustí aplikaci AIR, může odesílat data prostřednictvím vlastnosti arguments objektu BrowserInvokeEvent. Buďte
opatrní při použití těchto dat při citlivých operacích, například jako soubor nebo kód načítající rozhraní API. Míra
rizika závisí na tom, co aplikace s daty provádí. Pokud očekáváte, že aplikaci vyvolá jen určité webové místo, měla by
aplikace zkontrolovat vlastnost securityDomain objektu BrowserInvokeEvent. Rovněž lze požadovat, aby webové
místo vyvolávající aplikaci používalo protokoly HTTP, což je možné ověřit při kontrole vlastnosti isHTTPS objektu
BrowserInvokeEvent.
Aplikace by měla ověřit data, která se do ní předávají. Jestliže aplikace například očekává, že do ní budou předány
adresy URL k určité doméně, měla by ověřit, že skutečně směřují k dané doméně. Tím lze zabránit tomu, aby se
aplikace nechala oklamat útočníkem a poslala mu citlivá data.
Žádná aplikace by neměla používat argumenty BrowserInvokeEvent, které by mohly směřovat k místním zdrojům.
Aplikace by například neměla vytvářet objekty File na základě cesty předané z prohlížeče. Pokud mají být z prohlížeče
předávány vzdálené cesty, měla by aplikace zajistit, aby tyto cesty nepoužívaly protokol file:// místo vzdáleného
protokolu.
Podrobnosti týkající se spouštění aplikace z prohlížeče naleznete v sekci „Spuštění nainstalované aplikace AIR z
Ukončení aplikace
Nejrychlejší způsob ukončení aplikace je vyvolat metodu NativeApplication.nativeApplication.exit(), což
funguje dobře, když aplikace nemusí ukládat žádná data ani čistit žádné zdroje. Po vyvolání metody exit() se zavřou
všechna okna a potom se ukončí aplikace. Aby však mohla okna či jiné komponenty v aplikaci proces ukončení
přerušit, například kvůli uložení důležitých dat, je vhodné odeslat před vyvoláním metody exit() náležitá
upozornění.
Dále je pro zajištění správného ukončení aplikace vhodné zvážit poskytnutí jediné cesty pro provádění, bez ohledu na
to, jakým způsobem bude proces vypnutí zahájen. Uživatel (nebo operační systém) může spustit ukončení aplikace
následujícími způsoby:
• Zavřením posledního okna aplikace, když je možnost NativeApplication.nativeApplication.autoExit
nastavena na hodnotu true.
• Zvolením příkazu ukončení aplikace z operačního systému, například když uživatel vybere příkaz ukončení
aplikace z výchozí nabídky. K tomu dochází u systému Mac OS; systém Windows neposkytuje příkaz ukončení
aplikace prostřednictvím systémových prvků.
• Vypnutím počítače.
Když se příkaz ukočení provede jedním z těchto způsobů prostřednictvím operačního systému, objekt
NativeApplication vyvolá událost exiting. Pokud nebude událost exiting zrušena žádným posluchačem, zavřou se
všechna otevřená okna. Každé okno odešle událost closing a potom událost close. Jestliže některé okno událost
closing zruší, proces vypínání se zastaví.
V případě, že v dané aplikaci záleží na pořadí zavírání oken, poslouchejte událost exiting z objektu NativeApplication
a sami zavřete okna ve správném pořadí. To může nastat například u okna dokumentu s paletami nástrojů. Mohlo by
to být nepraktické (nebo i horší), pokud by systém zavřel palety, ale uživatel by se rozhodl příkaz ukončení zrušit, aby
mohl uložit nějaká data. V systému Windows nastane událost exiting jedině po zavření posledního okna (když je
vlastnost autoExit objektu NativeApplication nastavena na hodnotu true).
Chcete-li zachovat jednotné chování na všech platformách bez ohledu na to, zda bude proces ukončení vyvolán
pomocí systémových prvků operačního systému, příkazů nabídky nebo logiky aplikace, dodržujte následující
doporučené postupy pro ukončení aplikace:
1 Vždy odešlete událost exiting pomocí objektu NativeApplication před vyvoláním metody exit() v kódu aplikace
a zkontrolujte, že žádná jiná komponenta aplikace tuto událost nezruší.
public function applicationExit():void {
var exitingEvent:Event = new Event(Event.EXITING, false, true);
NativeApplication.nativeApplication.dispatchEvent(exitingEvent);
if (!exitingEvent.isDefaultPrevented()) {
NativeApplication.nativeApplication.exit();
}
}
2 Poslouchejte událost exiting aplikace z objektu NativeApplication.nativeApplication a ve zpracování
zavřete všechna okna (tak, že nejprve odešlete událost closing). Po zavření všech oken proveďte potřebné úlohy
pro vyčištění, například uložení dat aplikace nebo odstranění dočasných souborů. Při čištění používejte jen
synchronní metody, aby skončily ještě před zavřením aplikace.
Jestliže nezáleží na pořadí zavírání oken, můžete vytvořit smyčku přes pole
NativeApplication.nativeApplication.openedWindows a postupně jednotlivá okna zavřít. V případě, že na
pořadí záleží, zajistěte metodu pro zavření oken ve správném pořadí.
private function onExiting(exitingEvent:Event):void {
var winClosingEvent:Event;
for each (var win:NativeWindow in NativeApplication.nativeApplication.openedWindows) {
winClosingEvent = new Event(Event.CLOSING,false,true);
win.dispatchEvent(winClosingEvent);
if (!winClosingEvent.isDefaultPrevented()) {
win.close();
} else {
exitingEvent.preventDefault();
}
}
if (!exitingEvent.isDefaultPrevented()) {
//perform cleanup
}
}
3 Okna by měla vždy provádět vlastní operace čištění posloucháním vlastních událostí closing.
4 Použijte v aplikaci jen jeden posluchač události exiting, neboť zpracování vyvolané dříve by nepoznalo, zda
pozdější zpracování událost exiting nezruší (a není moudré spoléhat jen na pořadí provádění).
Viz také
„Nastavení vlastností aplikace AIR“ na stránce 42
„Představení vlastního uživatelského rozhraní pro aktualizaci aplikace“ na stránce 292
266
Kapitola 27: Čtení nastavení aplikace
Za běhu můžete získat vlastnosti souboru deskriptoru aplikace i ID vydavatele aplikace. Tyto hodnoty jsou nastaveny
ve vlastnostech applicationDescriptor a publisherID objektu NativeApplication.
Čtení souboru deskriptoru aplikace
Soubor deskriptoru aplikace aktuálně spuštěné aplikace můžete číst jako objekt XML, a to získáním vlastnosti
applicationDescriptor objektu NativeApplication. Viz následující příklad:
var appXml:XML = NativeApplication.nativeApplication.applicationDescriptor;
K datům desktriptoru aplikace můžete získat přístup jako k objektu XML (E4X), viz následující příklad:
var appXml:XML = NativeApplication.nativeApplication.applicationDescriptor;
var ns:Namespace = appXml.namespace();
var appId = appXml.ns::id[0];
var appVersion = appXml.ns::version[0];
var appName = appXml.ns::filename[0];
air.trace("appId:", appId);
air.trace("version:", appVersion);
air.trace("filename:", appName);
var xmlString = air.NativeApplication.nativeApplication.applicationDescriptor;
Více informací naleznete v tématu „Struktura souboru deskriptoru aplikace“ na stránce 42.
Získávání identifikátorů aplikace a vydavatele
ID aplikace a vydavatele společně jedinečným způsobem identifikují aplikaci AIR. ID aplikace určíte v elementu <id>
deskriptoru aplikace. ID vydavatele je odvozeno od certifikátu použitého k podpisu balíku instalace AIR.
ID aplikace lze číst z vlastnosti objektu NativeApplication id, viz následující kód:
trace(NativeApplication.nativeApplication.applicationID);
ID vydavatele lze číst z vlastnosti objektu NativeApplication publisherID:
trace(NativeApplication.nativeApplication.publisherID);
Poznámka: Když aplikace AIR běží s programem ADL, nemá ID vydavatele, pokud není ID přiřazeno přechodně pomocí
příznaku -pubID na příkazovém řádku ADL.
ID vydavatele pro nainstalovanou aplikaci lze nalézt v souboru META-INF/AIR/publisherid v instalačním adresáři
aplikace.
Více informací naleznete v tématu „O identifikátorech vydavatele AIR“ na stránce 286.
267
Kapitola 28: Práce s runtime a
informacemi operačního systému
Tato část se věnuje způsobům, kterými může aplikace AIR spravovat asociace souboru operačního systému, zjišťovat
aktivitu uživatele a získávat informace o době běhu Adobe® AIR™.
Správa asociací souboru
Asociace mezi vaší aplikací a typem souboru musí být deklarovány v deskriptoru aplikace. Během procesu instalace
přiřadí instalátor aplikace AIR tuto aplikaci jako výchozí aplikaci otevření pro každý z deklarovaných typů souborů,
pokud již není výchozí jiná aplikace. Proces instalace aplikace AIR nepotlačí stávající asociaci typu souboru. Pro
přebrání asociace z jiné aplikace volejte v době běhu metodu NativeApplication.setAsDefaultApplication().
Při spuštění aplikace je dobrým postupem ověřit, zda jsou očekávané asociace souborů na svém místě. Důvodem je to,
že instalátor aplikace AIR nepotlačí stávající asociace souboru, a že asociace souboru v systému uživatele se mohou
kdykoliv změnit. Když má jiná aplikace aktuální asociaci souboru, je také dobrým postupem dotázat se uživatele před
přebráním stávající asociace.
Následující metody třídy NativeApplication umožňují aplikaci zpracovávání asociací souborů. Každá z metod přebírá
příponu souboru jako parametr:
Metoda
Popis
isSetAsDefaultApplication()
Vrátí hodnotu „true“, jestliže je aplikace AIR aktuálně asociována s určeným typem souboru.
setAsDefaultApplication()
Vytvoří asociaci mezi aplikací AIR a akcí otevření daného typu souboru.
removeAsDefaultApplication()
Odstraní asociaci mezi aplikací AIR a typem souboru.
getDefaultApplication()
Nahlásí cestu aplikace, která je aktuálně asociována s typem souboru.
Prostředí AIR může zpracovávat pouze asociace pro typy souborů původně deklarované v deskriptoru aplikace.
Nemůžete získat informace o asociacích nedeklarovaného typu souboru, pokud uživatel ručně vytvořil asociaci mezi
typem souboru a vaší aplikací. Volání jakékoliv metody pro zpracování asociací souboru s příponou typu souboru
nedeklarovanou v deskriptoru aplikace způsobí, že aplikace vygeneruje výjimku v době běhu.
Informace o deklarování typů souborů v deskriptoru aplikace naleznete v tématu „Deklarace asociací typů souborů“
na stránce 49.
Získávání verze runtime a úrovně dočasné opravy.
Objekt NativeApplication má vlastnost runtimeVersion, která je verzí runtime, ve kterém aplikace běží (řetězec,
například„1.0.5"). Objekt NativeApplication má také vlastnost runtimePatchLevel, která je úrovní dočasné opravy
runtime (číslo, například 2960). Následující kód používá tyto vlastnosti:
trace(NativeApplication.nativeApplication.runtimeVersion);
trace(NativeApplication.nativeApplication.runtimePatchLevel);
Práce s runtime a informacemi operačního systému
Zjišťování možností AIR
Pro soubor přibalený v aplikaci Adobe AIR je vlastnost Security.sandboxType nastavena na hodnotu definovanou
konstantou Security.APPLICATION. Můžete načíst obsah (který může a nemusí obsahovat rozhraní API specifické
pro aplikaci AIR) na základě toho, zda je v karanténě zabezpečení aplikace Adobe AIR soubor, viz následující kód:
if (Security.sandboxType == Security.APPLICATION)
{
// Load SWF that contains AIR APIs
}
else
{
// Load SWF that does not contain AIR APIs
}
Všechny zdroje, které nejsou instalovány s aplikací AIR, jsou přiřazeny ke stejným karanténám zabezpečení, jako by
byly přiřazeny přehrávačem Adobe® Flash® Player ve webovém prohlížeči. Vzdálené zdroje jsou umístěny do karantén
na základě jejich zdrojových domén a lokální zdroje jsou umístěny do karantén „local-with-networking“, „local-withfilesystem“ nebo „local-trusted sandbox“.
Můžete zkontrolovat, zda je statická vlastnost Capabilities.playerType nastavena na „Desktop" a zjistit tak, zda
je obsah prováděn v době běhu (a není spuštěn v přehrávači Flash Player, který běží v prohlížeči).
Více informací naleznete v tématu „Zabezpečení aplikace AIR“ na stránce 23.
Sledování přítomnosti uživatele
Objekt NativeApplication odešle dvě události, které vám pomohou zjistit, kdy uživatel aktivně používá počítač. Neníli v intervalu určeném vlastností NativeApplication.idleThreshold zjištěna žádná aktivita myši nebo klávesnice,
NativeApplication odešle událost userIdle. Dojde-li ke vstupu klávesnice nebo myši, objekt NativeApplication
odešle událost userPresent. Interval idleThreshold je měřen ve vteřinách a má výchozí hodnotu 300 (5 minut). Z
vlastnosti NativeApplication.nativeApplication.lastUserInputsi můžete také zobrazit počet vteřin od
posledního vstupu uživatele.
Následující řádky kódu nastaví práh nečinnosti na 2 minuty a budou poslouchat pro událost userIdle i userPresent :
NativeApplication.nativeApplication.idleThreshold = 120;
NativeApplication.nativeApplication.addEventListener(Event.USER_IDLE, function(event:Event) {
trace("Idle");
});
NativeApplication.nativeApplication.addEventListener(Event.USER_PRESENT,
function(event:Event) {
trace("Present");
});
Poznámka: Pouze jediná událost userIdle je odeslána mezi libovolnými dvěmi událostmi userPresent.
269
Kapitola 29: Sledování připojení k síti
Adobe® AIR™ poskytuje prostředky ke zjišťování změn síťového připojení počítače, v němž je nainstalována aplikace
AIR. Tyto informace jsou užitečné, pokud určitá aplikace používá data získaná ze sítě. Aplikace může také kontrolovat
dostupnost síťové služby.
Zjišťování změn síťového připojení
Aplikace AIR může být spouštěna v prostředích s nejistým a proměnlivým síťovým připojením. Aby prostředí Adobe
AIR pomohlo aplikaci spravovat připojení k online prostředkům, odesílá událost změny sítě pokaždé, když připojení
začne být dostupné nebo nedostupné. Událost změny sítě je odeslána prostřednictvím objektu NativeApplication
aplikace. Na tuto událost reagujte přidáním posluchače:
NativeApplication.nativeApplication.addEventListener(Event.NETWORK_CHANGE, onNetworkChange);
A definujte funkci zpracování události:
function onNetworkChange(event:Event)
{
//Check resource availability
}
Událost Event.NETWORK_CHANGE neindikuje změnu v celé činnosti sítě, ale pouze skutečnost, že se změnilo síťové
připojení. Prostředí AIR neprovede žádný pokus o výklad významu změny sítě. Počítač připojený k síti může mít
mnoho skutečných a virtuálních připojení, takže ztráta připojení nemusí nutně znamenat ztrátu zdroje. Na druhou
stranu ani nová připojení nemusí zaručovat zlepšení dostupnosti zdrojů. V některých případech může nové připojení
dokonce blokovat přístup ke zdrojům, které byly dosud dostupné (například připojení k síti VPN).
Obecně platí, že jediný způsob, jak může aplikace zjistit, zda se může připojit ke vzdálenému zdroji, je pokus o
připojení. Za tímto účelem rámce v balíčku air.net, které sledují služby, poskytují aplikacím AIR prostředky založené
na událostech pro reakce na změny v síťovém připojení k určenému hostiteli.
Poznámka: Rámec pro sledování služeb zjišťuje, zda server odpoví na požadavek přijatelným způsobem. To nezaručuje
plné připojení. Škálovatelné webové služby často používají ukládání do paměti a zařízení k vyvažování zatížení pro
přesměrování provozu na cluster webových serverů. V takové situaci nabízejí poskytovatelé služeb pouze částečnou
diagnózu síťového připojení.
Základní informace o sledování služeb
Rámec pro sledování služeb je umístěn odděleně od rámce AIR v souboru servicemonitor.swc. Aby mohl soubor
servicemonitor.swc používat rámec, musí být zahrnut v procesu sestavení.
Důležité: Chcete-li používat tyto třídy v jazyce ActionScript, přetáhněte komponentu ServiceMonitorShim z panelu
Komponenty do panelu Knihovna a pak přidejte následující příkaz import do vašeho kódu jazyka ActionScript 3.0:
import air.net.*;
Sledování připojení k síti
Třída ServiceMonitor implementuje rámec pro sledování síťových služeb a poskytuje pro sledování služeb základní
funkce. Ve výchozím nastavení odesílá události týkající se síťového připojení instance třídy ServiceMonitor. Objekt
ServiceMonitor tyto události odesílá, když je vytvořena instance, a pokaždé, když Adobe AIR zjistí změnu sítě. Dále
můžete nastavit vlastnost pollInterval instance třídy ServiceMonitor pro kontrolu připojení v intervalech určených
v milisekundách bez ohledu na obecné události síťového připojení. Objekt ServiceMonitor připojení k síti
nekontroluje, dokud není vyvolána metoda start().
Třída URLMonitor, která je podtřídou třídy ServiceMonitor, zjišťuje změny v připojení pomocí protokolu HTTP pro
určený požadavek URLRequest.
Třída SocketMonitor, rovněž podtřída třídy ServiceMonitor, zjišťuje změny v připojení k určenému hostiteli na
určeném portu.
Zjišťování připojení pomocí protokolu HTTP
Třída URLMonitor určuje, zda je možné vytvořit požadavky HTTP na určenou adresu na portu 80 (obvyklý port pro
komunikaci pomocí protokolu HTTP). Následující kód používá instanci třídy URLMonitor ke zjišťování změn
připojení k webovému serveru Adobe:
import air.net.URLMonitor;
import flash.events.StatusEvent;
var monitor:URLMonitor;
monitor = new URLMonitor(new URLRequest('http://www.adobe.com'));
monitor.addEventListener(StatusEvent.STATUS, announceStatus);
monitor.start();
function announceStatus(e:StatusEvent):void {
trace("Status change. Current status: " + monitor.available);
}
Zjišťování soketového připojení
Aplikace AIR mohou také používat soketová připojení pro připojení vynuceného typu. Brány firewall a síťové
směrovače obvykle z bezpečnostních důvodů omezují komunikaci v síti na neautorizovaných portech. Proto musí
vývojáři brát v úvahu, že uživatelé pravděpodobně neumí vytvářet soketová připojení.
Podobně jako v příkladu s třídou URLMonitor používá následující kód instanci třídy SocketMonitor ke zjišťování
změn v soketovém připojení na portu 6667, který je obvyklý pro službu IRC:
import air.net.ServiceMonitor;
import flash.events.StatusEvent;
socketMonitor = new SocketMonitor('www.adobe.com',6667);
socketMonitor.addEventListener(StatusEvent.STATUS, socketStatusChange);
socketMonitor.start();
function announceStatus(e:StatusEvent):void {
trace("Status change. Current status: " + socketMonitor.available);
}
271
Kapitola 30: Požadavky URL a práce v síti
Nové funkce Adobe AIR týkající se zadávání požadavků URL nejsou dostupné pro obsah SWF běžící v prohlížeči. Tyto
funkce jsou dostupné pouze pro obsah v karanténě zabezpečení aplikace. V této části jsou popsány funkce třídy
URLRequest při běhu a je zde probráno síťové rozhraní API měnící obsah AIR.
Další informace o používání síťových a komunikačních schopností jazyka ActionScript™ 3.0 viz příručku
Programování v jazyku ActionScript 3.0, dodávanou s programy Adobe® Flash® CS3 a Adobe® Flex™ Builder™ 3.
Používání třídy URLRequest
Třída URLRequest umožňuje definovat více než jen řetězec URL. Aplikace AIR přidává k třídě URLRequest některé
nové vlastnosti, které jsou dostupné pouze pro obsah AIR běžící v karanténě zabezpečení aplikace. Obsah při běhu
může definovat URL pomocí nových schémat URL (kromě standardních schémat jako file a http).
Vlastnosti třídy URLRequest
Třída URLRequest zahrnuje následující vlastnosti, které jsou dostupné pro obsah pouze v karanténě zabezpečení
aplikace:
Vlastnost
Popis
followRedirects
Určuje, zda bude následováno přesměrování (true, výchozí hodnota) nebo ne (false). Toto je podporováno
pouze při běhu.
manageCookies
Určuje, zda by měl zásobník protokolu HTTP pro tento požadavek spravovat cookies (true, výchozí hodnota)
nebo ne (false). Toto je podporováno pouze při běhu.
authenticate
Určuje, zda by měl být pro tento požadavek zpracován požadavek na ověření (true) nebo ne (false). Toto je
podporováno pouze při běhu. Výchozí nastavení je ověřovat požadavky – to může způsobit zobrazení
dialogového okna ověření, jestliže server vyžaduje zobrazení oprávnění. Můžete také nastavit jméno uživatele
a heslo – viz „Nastavení výchozích hodnot třídy URLRequest“ na stránce 272.
cacheResponse
Určuje, zda by pro tento požadavek mělo být provedeno uložení dat úspěšné odezvy do vyrovnávací paměti.
Toto je podporováno pouze při běhu. Výchozí nastavení je uložit odpověď do vyrovnávací paměti (true).
useCache
Určuje, zda by měl být před zachycením dat objektem URLRequest brán ohled na místní vyrovnávací paměť.
Toto je podporováno pouze při běhu. Pro výchozí nastavení (true) lze použít verzi s místní vyrovnávací
pamětí, je-li k dispozici.
userAgent
Specifikuje řetězec uživatel-agent, který se má použít v požadavku HTTP.
Následující vlastnosti objektu URLRequest je možno nastavit pomocí obsahu v libovolné karanténě (nejen v karanténě
zabezpečení aplikace AIR):
Vlastnost
Popis
contentType
Typ obsahu MIME libovolných dat odeslaných s požadavkem URL.
data
Objekt obsahující data, která se mají přenášet s požadavkem URL.
digest
Bezpečný „digest“ ze souboru uloženého do vyrovnávací paměti ke sledování vyrovnávací paměti přehrávače
Adobe® Flash® Player.
Požadavky URL a práce v síti
Vlastnost
Popis
metoda
Ovládá metodu požadavku HTTP, např. operace GET nebo POST. (Obsah běžící v doméně zabezpečení
aplikace AIR může určovat jiné řetězce než „GET" nebo „POST" jako vlastnost method. Povoleno je libovolné
sloveso HTTP a výchozí metoda je „GET". Viz „Zabezpečení aplikace AIR“ na stránce 23 .)
requestHeaders
Pole hlaviček požadavků HTTP přidávaných do požadavku HTTP.
URL
Určuje adresu URL, na kterou se směřuje požadavek.
Poznámka: Třída HTMLLoader má příbuzné vlastnosti pro nastavení týkající se obsahu načteného objektem
HTMLLoader. Podrobnosti viz „Popis třídy HTMLLoader“ na stránce 207.
Nastavení výchozích hodnot třídy URLRequest
Třída URLRequestDefaults umožňuje definovat výchozí nastavení pro objekty URLRequest. Například následující
kód nastaví výchozí hodnoty pro vlastnosti manageCookies a useCache:
URLRequestDefaults.manageCookies = false;
URLRequestDefaults.useCache = false;
air.URLRequestDefaults.manageCookies = false;
air.URLRequestDefaults.useCache = false;
Třída URLRequestDefaults obsahuje metodu setLoginCredentialsForHost(), která umožňuje určit výchozí
jméno uživatele a heslo pro použití pro určitého hostitele. Hostitel, který je definován v parametru hostname této
metody, může být doména, např. „www.example.com", nebo doména a číslo portu, např. „www.example.com:80".
Všimněte si, že všechny domény „example.com", „www.example.com" a „sales.example.com" jsou považovány
za unikátní hostitele.
Tato oprávnění budou použita, pouze když si je server vyžádá. Jestliže byl uživatel již ověřen (např. pomocí
dialogového okna ověření), nelze ověřeného uživatele změnit vyvoláním metody setLoginCredentialsForHost().
Například následující kód nastaví výchozí jméno uživatele a heslo pro použití s doménou www.example.com:
URLRequestDefaults.setLoginCredentialsForHost("www.example.com", "Ada", "love1816$X");
air.URLRequestDefaults.setLoginCredentialsForHost("www.example.com", "Ada", "love1816$X");
Každá vlastnost nastavení třídy URLRequestDefaults platí pouze pro aplikační doménu obsahu nastavujícího danou
vlastnost. Avšak metoda setLoginCredentialsForHost() platí pro obsah ve všech aplikačních doménách v rámci
aplikace AIR. Tak se může aplikace přihlásit k hostiteli a mít veškerý obsah v rámci aplikace přihlášený pomocí
zadaných oprávnění.
Další informace viz třídu URLRequestDefaults v příručce Referenční příručka jazyka ActionScript 3.0 a jeho součástí
(http://www.adobe.com/go/learn_air_aslr_cz).
Používání schémat URL AIR v adresách URL
Standardní schémata URL, jako je následující, jsou dostupná při definování adres URL v libovolné karanténě
zabezpečení v aplikaci AIR:
http: a https:
Použijte je tak, jako byste je použili ve webovém prohlížeči.
file:
Slouží k určení cesty vzhledem ke kořenu systému souborů. Například:
Při definování URL pro obsah běžící v karanténě zabezpečení aplikace můžete použít i následující schémata:
app:
Slouží k určení cesty vzhledem ke kořenovému adresáři instalované aplikace (adresář, který obsahuje soubor
deskriptoru aplikace pro instalovanou aplikaci). Například následující cesta vede ke zdrojovému podadresáři adresáře
instalované aplikace:
app:/resources
Když zdrojový adresář aplikace běží v aplikaci ADL, je nastaven na adresář obsahující soubor deskriptoru aplikace.
app-storage:
Slouží k určení cesty vzhledem k ukládacímu adresáři aplikace. Pro každou instalovanou aplikaci definuje aplikace AIR
jedinečný ukládací adresář aplikace pro jednotlivé uživatele, což je užitečné místo pro ukládání dat náležejících k dané
aplikaci. Například následující cesta vede k souboru prefs.xml v podadresáři nastavení ukládacího adresáře aplikace.
Umístění ukládacího adresáře aplikace je založeno na jménu uživatele, Id aplikace a Id vydavatele:
• V systému Mac OS – V:
/Users/jméno uživatele/Library/Preferences/Id aplikace.publisherID/Local Store/
Například:
/Users/babbage/Library/Preferences/com.example.TestApp.02D88EEED35F84C264A183921344EEA353
A629FD.1/Local Store
• V systému Windows – V adresáři Dokumenty a nastavení, v:
jméno uživatele/Application Data/Id aplikace.publisherID/Local Store/
Například:
C:\Documents and Settings\babbage\Application
Data\com.example.TestApp.02D88EEED35F84C264A183921344EEA353A629FD.1\Local Store
URL (a vlastnost url) pro objekt File vytvořený pomocí vlastnosti File.applicationStorageDirectory používá
schéma URL app-storage, jako v následujícím případě:
var dir:File = File.applicationStorageDirectory;
dir = dir.resolvePath("preferences");
trace(dir.url); // app-storage:/preferences
var dir = air.File.applicationStorageDirectory;
dir = dir.resolvePath("prefs.xml");
air.trace(dir.url); // app-storage:/preferences
Používání schémat URL v aplikaci AIR
Můžete použít objekt URLRequest, který používá kterékoli z těchto schémat URL k definování požadavku URL pro
několik různých objektů, např. objekt FileStream nebo Sound. Můžete tato schémata použít také v obsahu HTML
běžícím v aplikaci AIR. Můžete je například použít v atributu src tagu img.
Můžete však použít pouze tato schémata URL náležející k aplikaci AIR (app: a app-storage:) v obsahu v karanténě
zabezpečení aplikace. Další informace viz „Zabezpečení aplikace AIR“ na stránce 23.
Zakázaná schémata URL
Některá rozhraní API umožňují spustit obsah ve webovém prohlížeči. Z důvodů zabezpečení jsou některá schémata
URL při použití těchto API v aplikaci AIR zakázána. Seznam zakázaných schémat závisí na karanténě zabezpečení
kódu používajícího API. Podrobnosti viz „Otevření URL ve výchozím systémovém webovém prohlížeči“ na
stránce 274.
Změny v třídě URLStream
Třída URLStream poskytuje přístup nízké úrovně ke stahování dat z URL. Při běhu obsahuje třída URLStream novou
událost: httpResponseStatus. Narozdíl od události httpStatus je událost httpResponseStatus doručena před
veškerými daty odpovědi. Událost httpResponseStatus (definovaná v třídě HTTPStatusEvent) zahrnuje vlastnost
responseURL, která je URL, ze které byla vrácena odpověď, a vlastnostresponseHeaders, která je pole objektů
URLRequestHeader představující záhlaví odpovědi, která danou odpověď vrátila.
Otevření URL ve výchozím systémovém webovém
prohlížeči
URL můžete otevřít ve výchozím systémovém webovém prohlížeči pomocí funkce navigateToURL(). V případě
objektu URLRequest, který předáváte jako parametr request této funkce, se používá pouze vlastnost url.
var url = "http://www.adobe.com";
var urlReq = new air.URLRequest(url);
air.navigateToURL(urlReq);
Při použití funkce navigateToURL() jsou povolena schémata URL na základě karantény zabezpečení kódu volajícího
funkci navigateToURL().
Některá rozhraní API umožňují spustit obsah ve webovém prohlížeči. Z důvodů zabezpečení jsou některá schémata
URL při použití těchto API v aplikaci AIR zakázána. Seznam zakázaných schémat závisí na karanténě zabezpečení
kódu používajícího API. (Podrobnosti o karanténách zabezpečení viz „Zabezpečení aplikace AIR“ na stránce 23.)
Karanténa aplikace
Povolena jsou následující schémata. Použijte je tak, jako byste je použili ve webovém prohlížeči.
•
http:
•
https:
•
file:
•
mailto: – aplikace AIR přesměruje tyto požadavky na registrovanou systémovou poštovní aplikaci
•
app:
•
app-storage:
Všechna ostatní schémata URL jsou zakázána.
Vzdálená karanténa
•
http:
•
https:
•
Místní karanténa se souborem
•
file:
•
Místní karanténa se sítí
•
http:
• https:
•
Místní důvěryhodná karanténa
•
file:
•
http:
• https:
•
276
Kapitola 31: Distribuce, Instalace a
Spuštění aplikací AIR
Aplikace AIR jsou distribuovány jako jediný instalační soubor AIR, který obsahuje kód aplikace a všechny datové
zdroje. Tento soubor můžete distribuovat za použití jakýchkoliv obvyklých prostředků, například stažením, odesláním
e-mailem, nebo pomocí fyzických médií, například CD-ROM. Uživatelé mohou aplikaci nainstalovat poklepáním na
soubor AIR. Můžete použít funkci hladká instalace, která umožňuje uživatelům nainstalovat aplikaci AIR (a dle
potřeby Adobe® AIR™) klepnutím na jediný odkaz na webové stránce.
Před tím, než lze instalační soubor AIR distribuovat, musí být zabalen a označen certifikátem podpisu kódu a osobním
klíčem. Digitální podepsání instalačního souboru zajistí, že vaše aplikace nebude od podpisu upravena. Pokud byl dále
digitální certifikát vydán důvěryhodnou certifikační autoritou, například Verisign nebo Thawte, mohou vaši uživatelé
potvrdit vaši totožnost jako vydavatele a autora podpisu. Soubor AIR je podepsán, když je aplikace zabalena pomocí
programu AIR Developer Tool (ADT).
Více informací o způsobu zabalení aplikace do souboru AIR pomocí aktualizace AIR pro nástroj Flash naleznete v
tématu „Vytváření souborů aplikace AIR a instalátoru“ na stránce 15.
Více informací o způsobu zabalení aplikace do souboru AIR pomocí Adobe® AIR™ SDK naleznete v tématu „Zabalení
instalačního souboru AIR pomocí programu AIR Developer Tool (ADT)“ na stránce 307.
Instalace a spuštění aplikace AIR z pracovní plochy
Soubor AIR můžete jednoduše odeslat příjemci. Soubor AIR můžete například odeslat jako přílohu e-mailu nebo jako
odkaz na webové stránce.
Jakmile si uživatel stáhne aplikaci AIR, řídí se pro instalaci těmito pokyny:
1 Poklepejte na soubor AIR.
Program Adobe AIR musí již být na počítači nainstalován.
2 V okně instalace ponechte zvolené výchozí nastavení a klepněte na tlačítko Pokračovat.
V OS Windows provede AIR automaticky následující:
• Nainstaluje aplikaci do adresáře Program Files
• Vytvoří pro aplikaci odkaz na pracovní ploše
• Vytvoří odkaz v aplikaci Start
• Přidá záznam pro aplikaci do ovládacího panelu Přidat / Odebrat programy
V OS Mac je aplikace implicitně přidána do adresáře Aplikace.
Jestliže je aplikace již nainstalovaná, umožní instalátor uživateli vybrat si mezi spuštěním stávající verze aplikace
nebo aktualizací na verzi ve staženém souboru AIR. Instalátor určí aplikaci pomocí ID aplikace a ID vydavatele v
souboru AIR.
3 Po dokončení instalace klepněte na možnost Dokončit.
V OS Mac potřebuje uživatel pro instalaci aktualizované verze aplikace odpovídající systémová oprávnění pro instalaci
do adresáře aplikace. V OS Windows potřebuje uživatel oprávnění správce.
Distribuce, Instalace a Spuštění aplikací AIR
Aplikace může také nainstalovat novou verzi skrze jazyk ActionScript nebo JavaSript. Více informací naleznete v
tématu „Aktualizace aplikací AIR“ na stránce 291.
Jakmile je aplikace AIR nainstalována, uživatel jednoduše poklepe na ikonu aplikace pro její spuštění, jako v případě
jakékoliv jiné aplikace pracovní plochy.
• V OS Windows poklepejte na ikonu aplikace (která je buď nainstalovaná na pracovní ploše nebo ve složce) nebo
vyberte aplikaci z nabídky Start.
• V OS Mac poklepejte na aplikaci ve složce, do které byla nainstalovaná. Výchozím instalačním adresářem je adresář
/Aplikace.
Funkce AIR hladká instalace umožňuje uživateli nainstalovat aplikaci AIR klepnutím na odkaz na webové stránce.
Funkce AIR iniciace prohlížečeumožňuje uživateli spustit nainstalovanou aplikaci AIR klepnutím na odkaz na webové
stránce. Tyto funkce jsou popsány v následující části.
Instalace a spuštění aplikací AIR z webové stránky
Funkce hladké instalace vám umožňuje vložit SWF soubor do webové stránky, která umožňuje uživateli instalovat
aplikaci AIR z prohlížeče. Jestliže runtime není instalováno, instaluje funkce hladké instalace runtime. Funkce hladké
instalace umožňuje uživateli instalovat aplikaci AIR bez uložení souborů AIR do počítače. Součástí sady AIR SDK je
soubor badge.swf, který vám umožňuje snadno použít funkci hladké instalace. Podrobnosti naleznete v tématu
„Použití souboru badge.swf k nainstalování aplikace AIR“ na stránce 278.
O uživatelském nastavení souboru badge.swf hladké instalace
Vedle použití souboru badge.swf poskytnutého se sadou SDK můžete vytvořit svůj vlastní soubor, který použijete na
stránce prohlížeče. Váš vlastní soubor SWF může vzájemně reagovat s runtime následujícími způsoby:
• Může nainstalovat aplikaci AIR. Viz „Instalace aplikace AIR z prohlížeče“ na stránce 282.
• Může provést kontrolu a zjistit, jestli je nainstalovaná určitá aplikace AIR. Viz „Kontrola z webové stránky, zda je
aplikace AIR nainstalována.“ na stránce 282.
• Může zkontrolovat, zda je runtime nainstalováno. Viz „Kontrola, zda je runtime nainstalováno“ na stránce 281.
• Může spustit nainstalovanou aplikaci AIR v systému uživatele. Viz „Spuštění nainstalované aplikace AIR z
Tyto možnosti jsou poskytnuty voláním rozhraní API v souboru SWF hostovaném na adobe.com: air.swf. Tato část
popisuje způsob použití a uživatelského nastavení souboru badge.swf a způsob volání rozhraní API air.swf z vašeho
vlastního souboru SWF.
Dále může soubor SWF spuštěný v prohlížeči komunikovat se spuštěnou aplikací AIR pomocí třídy LocalConnection.
Více informací naleznete v tématu Komunikace mezi aplikacemi.
Důležité: Funkce popsané v této části (a rozhraní API v souboru air.swf) vyžadují, aby měl koncový uživatel ve webovém
prohlížeči nainstalovanou aktualizaci 3 přehrávače Adobe® Flash® Player 9. Můžete zapsat kód tak, abyste zkontrolovali
nainstalovanou verzi přehrávače Flash Player a poskytnuli uživateli alternativní rozhraní, jestliže není požadovaná
verze přehrávače Flash Player nainstalovaná. Jestliže je například nainstalována starší verze přehrávače Flash Player,
můžete poskytnout obsah na verzi souboru AIR ke stažení (namísto použití rozhraní API souboru air.swf k nainstalování
aplikace).
Použití souboru badge.swf k nainstalování aplikace AIR
Součástí sady AIR SDK je soubor badge.swf, který vám umožňuje snadno použít funkci hladké instalace. Soubor
badge.swf může nainstalovat runtime a aplikaci AIR z odkazu na webové stránce. Soubor badge.swf a jeho zdrojový
kód jsou vám k distribuci poskytnuty na vaší webové stránce.
Pokyny v této části nabízejí informace o nastavení parametrů souboru badge.swf poskytnutém společností Adobe.
Máte také k dispozici zdrojový kód pro soubor badge.swf file, který si můžete libovolně nastavit.
Vložení souboru badge.swf do webové stránky
1 Vyhledejte následující soubory umístěné v adresáři samples/badge AIR SDK a přidejte je do svého prohlížeče.
• badge.swf
• default_badge.html
• AC_RunActiveContent.js
2 Otevřete stránku default_badge.html v textovém editoru.
3 Na stránce default_badge.html ve funkci jazyka JavaScript AC_FL_RunContent() upravte definice parametru
FlashVars pro následující:
Parametr
Popis
appname
Název aplikace zobrazený souborem SWF, jestliže runtime není nainstalováno.
appurl
(Vyžadovaný). URL souboru AIR, který má být stažen. Musíte použít absolutní, nikoliv relativní, URL.
airversion
(Vyžadovaný). Pro verzi 1.0 runtime jej nastavte na 1.0.
imageurl
URL obrazu (volitelné), která se zobrazí v symbolu.
buttoncolor
Barva tlačítka stahování (určená jako hexadecimální hodnota, například FFCC00).
messagecolor
Barva textové zprávy zobrazené pod tlačítkem, jestliže runtime není nainstalováno (určena jako
hexadecimální hodnota, například FFCC00).
4 Minimální velikost souboru badge.swf je 217 obrazových bodů na šířku a 180 obrazových bodů na výšku. Upravte
hodnoty parametrů width a height funkce AC_FL_RunContent()tak, aby vám vyhovovaly.
5 Přejmenujte soubor default_badge.html a upravte jeho kód (nebo jej zahrňte do jiné HTML stránky) tak, aby vám
vyhovoval.
Soubor badge.swf můžete také upravit a znovu kompilovat. Podrobnosti naleznete v tématu „Úprava souboru
badge.swf“ na stránce 279.
Instalace aplikace AIR z odkazu hladké instalace na webové stránce.
Jakmile jste na stránku přidali odkaz hladké instalace, může uživatel instalovat aplikaci AIR klepnutím na odkaz v
souboru SWF.
1 Navigujte na stránku HTML ve webovém prohlížeči, který má nainstalovaný přehrávač Flash Player (verze 9
aktualizace 3 nebo novější).
2 Na webové stránce klepněte na odkaz na soubor badge.swf.
• Jestliže jste runtime nainstalovali, přejděte k následujícímu kroku.
• Jestliže jste runtime nenainstalovali, zobrazí se dialogové okno, kde budete dotázáni, zda si přejete runtime
nainstalovat nebo nikoliv. Instalujte runtime (viz „Instalace prostředí Adobe AIR“ na stránce 1) a pokračujte k
následujícímu kroku.
3 V okně instalace ponechte zvolené výchozí nastavení a klepněte na tlačítko Pokračovat.
V počítači s OS Windows provede AIR automaticky následující:
• Instaluje aplikaci do umístění c:\Program Files\
• Vytvoří pro aplikaci odkaz na pracovní ploše
• Vytvoří odkaz v nabídce Start
• Přidá záznam pro aplikaci do ovládacího panelu Přidat/Odebrat programy
V operačním systému Mac OS přidá instalátor aplikaci do adresáře Aplikace (například do adresáře /Aplikace v
operačním sytému Mac OS).
4 Vyberte požadované možnosti a klepněte na tlačítko Instalovat.
5 Po dokončení instalace klepněte na možnost Dokončit.
Úprava souboru badge.swf
Sada SDK AIR poskytuje zdrojové soubory pro soubor badge.swf. Tyto soubory jsou zahrnuty ve složce src sady SDK:
Zdrojové soubory
Popis
badge.fla
Zdrojový soubor Flash CS3 nebo CS4 použitý pro kompilaci souboru badge.swf. Soubor badge.fla kompiluje
do souboru SWF 9 (který lze načíst v přehrávači Flash Player).
AIRBadge.as
Třída ActionScript 3.0, která definuje základní třídu použitou v souboru basdge.fla.
Aplikaci Flash CS3 nebo CS4 lze použít k novému navržení vizuálního rozhraní souboru badge.fla.
Funkce konstruktoru AIRBadge() definovaná ve třídě AIRBadge načte soubor air.swf hostovaný na
http://airdownload.adobe.com/air/browserapi/air.swf. Soubor air.swf obsahuje kód pro používání funkce hladké
instalace.
Metoda onInit()(ve třídě AIRBadge) je volána, když je soubor air.swf úspěšně načten:
private function onInit(e:Event):void {
_air = e.target.content;
switch (_air.getStatus()) {
case "installed" :
root.statusMessage.text = "";
break;
case "available" :
if (_appName && _appName.length > 0) {
root.statusMessage.htmlText = "<p align='center'><font color='#"
+ _messageColor + "'>In order to run " + _appName +
", this installer will also set up Adobe® AIR™.</font></p>";
} else {
+ _messageColor + "'>In order to run this application, "
+ "this installer will also set up Adobe® AIR™.</font></p>";
}
break;
case "unavailable" :
+ _messageColor
+ "'>Adobe® AIR™ is not available for your system.</font></p>";
root.buttonBg_mc.enabled = false;
break;
}
}
Kód nastaví globální proměnnou _air na hlavní třídu načteného souboru air.swf. Tato třída obsahuje následující
veřejné metody, ke kterým soubor badge.swf získává přístup pro volání funkce hladké instalace:
Metoda
Popis
getStatus()
Určuje, zda je runtime na počítači nainstalováno (nebo může být nainstalováno). Podrobnosti naleznete v
tématu „Kontrola, zda je runtime nainstalováno“ na stránce 281.
installApplication() Nainstaluje určenou aplikaci na počítač uživatele. Podrobnosti naleznete v tématu „Instalace aplikace AIR z
•
url—Řetězec definující URL. Musíte použít absolutní, nikoliv relativní, cestu URL.
•
runtimeVersion—Řetězec určující verzi runtime (například „1.0.M6") vyžadovanou aplikací k instalaci.
•
arguments— Argumenty, které budou předané aplikaci, když je po instalaci spuštěna. Aplikace je spuštěna
po instalaci, jestliže element allowBrowserInvocation je nastaven na true v souboru deskriptoru
aplikace. (Více informací o souboru deskriptoru aplikace naleznete v tématu„Nastavení vlastností aplikace
AIR“ na stránce 42.) Jestliže je aplikace spuštěna jako výsledek hladké instalace z prohlížeče (když si uživatel
zvolí spuštění aplikace po instalaci), objekt aplikace NativeApplication odešle objekt BrowserInvokeEvent
pouze pokud jsou předány argumenty. Vezměte na vědomí důsledky pro zabezpečení dat, která předáte
aplikaci. Podrobnosti naleznete v tématu „Spuštění nainstalované aplikace AIR z prohlížeče“ na stránce 283.
Nastavení pro url a runtimeVersion jsou předána do souboru SWF prostřednictvím nastavení FlashVars na HTML
stránce kontejneru.
Jestliže se aplikace po instalaci spustí automaticky, může nainstalovaná aplikace díky komunikaci LocalConnection po
iniciaci kontaktovat soubor badge.swf. Podrobnosti naleznete v tématu Komunikace mezi aplikacemi.
Můžete také volat metodu getApplicationVersion() souboru air.swf a zkontrolovat, jestli je aplikace
nainstalována. Tuto metodu můžete volat buď před procesem instalace aplikace nebo po zahájení instalace.
Podrobnosti naleznete v tématu „Kontrola z webové stránky, zda je aplikace AIR nainstalována.“ na stránce 282.
Načtení souboru air.swf
Můžete vytvořit svůj vlastní soubor SWF, který používá rozhraní API v souboru air.swf, pro interakci s runtime a
aplikacemi AIR z webové stránky v prohlížeči. Soubor air.swf je hostován na
http://airdownload.adobe.com/air/browserapi/air.swf. Pro odkazování rozhraní API souboru air.swf z vašeho
souboru SWF načtěte soubor air.swf do stejné domény aplikace jako svůj soubor SWF. Následující kód ukazuje příklad
načtení souboru air.swf do domény aplikace načítaného souboru SWF:
var airSWF:Object; // This is the reference to the main class of air.swf
var airSWFLoader:Loader = new Loader(); // Used to load the SWF
var loaderContext:LoaderContext = new LoaderContext();
// Used to set the application domain
loaderContext.applicationDomain = ApplicationDomain.currentDomain;
airSWFLoader.contentLoaderInfo.addEventListener(Event.INIT, onInit);
airSWFLoader.load(new URLRequest("http://airdownload.adobe.com/air/browserapi/air.swf"),
loaderContext);
function onInit(e:Event):void
{
airSWF = e.target.content;
}
Jakmile je soubor air.swf načten (když objekt contentLoaderInfo objektu Loader odešle událost init), můžete volat
libovolné z rozhraní API souboru air.swf. Tato rozhraní API jsou popsána v následujících částech:
• „Kontrola, zda je runtime nainstalováno“ na stránce 281
• „Kontrola z webové stránky, zda je aplikace AIR nainstalována.“ na stránce 282
• „Instalace aplikace AIR z prohlížeče“ na stránce 282
• „Spuštění nainstalované aplikace AIR z prohlížeče“ na stránce 283
Poznámka: Soubor badge.swf dodaný se sadou SDK AIR automaticky načte soubor air.swf. Viz „Použití souboru
badge.swf k nainstalování aplikace AIR“ na stránce 278. Pokyny v této části se vztahují k vytváření vlastního souboru
SWF, který načte soubor air.swf.
Kontrola, zda je runtime nainstalováno
Soubor SWF může zkontrolovat, zda je runtime nainstalováno voláním metody getStatus() v souboru air.swf
načteném z http://airdownload.adobe.com/air/browserapi/air.swf. Podrobnosti naleznete v tématu „Načtení souboru
air.swf“ na stránce 281.
Jakmile je soubor air.swf načten, může soubor SWF volat metodu souboru air.swf getStatus(), viz. následující:
var status:String = airSWF.getStatus();
Metoda getStatus() vrátí jednu z následujících hodnot řetězce, na základě statutu runtime na počítači:
Hodnota řetězce
Popis
"available"
Runtime lze nainstalovat na tomto počítači, ale aktuálně nainstalováno není.
"unavailable"
Runtime nemůže být na tomto počítači nainstalováno.
"installed"
Runtime je na tomto počítači nainstalováno.
Metoda getStatus() vygeneruje chybu, jestliže požadovaná verze přehrávače Flash Player (verze 9 aktualizace 3)
není v prohlížeči nainstalovaná.
Kontrola z webové stránky, zda je aplikace AIR nainstalována.
Soubor SWF může zkontrolovat, zda je aplikace AIR (s odpovídajícím ID aplikace a ID vydavatele) nainstalovaná
voláním metody getApplicationVersion() v souboru air.swf načteném z
http://airdownload.adobe.com/air/browserapi/air.swf. Podrobnosti naleznete v tématu „Načtení souboru air.swf“ na
stránce 281.
Jakmile je soubor air.swf načten, může soubor SWF volat metodu souboru air.swf getApplicationVersion(), viz.
následující:
var appID:String = "com.example.air.myTestApplication";
var pubID:String = "02D88EEED35F84C264A183921344EEA353A629FD.1";
airSWF.getApplicationVersion(appID, pubID, versionDetectCallback);
function versionDetectCallback(version:String):void
{
if (version == null)
{
trace("Not installed.");
// Take appropriate actions. For instance, present the user with
// an option to install the application.
}
else
{
trace("Version", version, "installed.");
// Take appropriate actions. For instance, enable the
// user interface to launch the application.
}
}
Metoda getApplicationVersion() má následující parametry:
Parametry
Popis
appID
ID aplikace pro danou aplikaci. Podrobnosti naleznete v tématu „Definice základních informací aplikace“ na
stránce 43.
pubID
ID vydavatele pro danou aplikaci. Podrobnosti naleznete v tématu „O identifikátorech vydavatele AIR“ na
stránce 286.
callback
Funkce zpětného volání, která slouží jako funkce zpracování. Metoda getApplicationVersion() operuje
asynchronně a po zjištění nainstalované verze (nebo nepřítomnosti nainstalované verze), je tato metoda
zpětného volání iniciována. Definice metody zpětného volání musí zahrnovat jeden parametr, řetězec, který
je nastaven na řetězec verze nainstalované aplikace. Jestliže není aplikace nainstalovaná, bude funkci předána
nulová hodnota, viz následující ukázka kódu.
Metoda getApplicationVersion() vygeneruje chybu, jestliže požadovaná verze přehrávače Flash Player (verze 9
aktualizace 3) není v prohlížeči nainstalovaná.
Instalace aplikace AIR z prohlížeče
Soubor SWF může nainstalovat aplikaci AIR voláním metody installApplication() v souboru air.swf načteném z
http://airdownload.adobe.com/air/browserapi/air.swf. Podrobnosti naleznete v tématu „Načtení souboru
Jakmile je soubor air.swf načten, může soubor SWF volat metodu souboru air.swf installApplication(), viz.
následující:
var url:String = "http://www.example.com/myApplication.air";
var runtimeVersion:String = "1.0";
var arguments:Array = ["launchFromBrowser"]; // Optional
airSWF.installApplication(url, runtimeVersion, arguments);
Metoda installApplication() nainstaluje určenou aplikaci na počítač uživatele. Tato metoda má následující
parametry:
Parametr
Popis
url
Řetězec definující URL souboru AIR k instalaci. Musíte použít absolutní, nikoliv relativní, cestu URL.
runtimeVersion
Řetězec určující verzi runtime (například „1.0“) vyžadovanou aplikací k instalaci.
arguments
Pole argumentů, které budou předány aplikaci, když je po instalaci spuštěna. Aplikace je spuštěna po instalaci,
jestliže element allowBrowserInvocation je nastaven na true v souboru deskriptoru aplikace. (Více
informací o souboru deskriptoru aplikace naleznete v tématu„Nastavení vlastností aplikace AIR“ na
stránce 42.) Jestliže je aplikace spuštěna jako výsledek hladké instalace z prohlížeče (když si uživatel zvolí
spuštění aplikace po instalaci), objekt aplikace NativeApplication odešle objekt BrowserInvokeEvent pouze
pokud byly předány argumenty. Podrobnosti naleznete v tématu „Spuštění nainstalované aplikace AIR z
Metoda installApplication() může operovat pouze je-li volána v objektu pro zpracování události pro událost
uživatele, například klepnutí myší.
Metoda installApplication() vygeneruje chybu, jestliže požadovaná verze přehrávače Flash Player (verze 9
Pro instalaci aktualizované verze aplikace v OS Mac musí mít uživatel příslušná oprávnění pro nainstalování do
adresáře aplikace (a oprávnění správce, jestliže aplikace aktualizuje runtime). V OS Windows potřebuje uživatel
oprávnění správce.
Můžete také volat metodu getApplicationVersion() souboru air.swf a zkontrolovat, zda je aplikace již
nainstalována. Tuto metodu můžete volat buď před zahájením procesu instalace aplikace nebo po zahájení instalace.
Podrobnosti naleznete v tématu „Kontrola z webové stránky, zda je aplikace AIR nainstalována.“ na stránce 282.
Jakmile aplikace běží, může komunikovat s obsahem SWF v prohlížeči pomocí třídy LocalConnection. Podrobnosti
naleznete v tématu Komunikace mezi aplikacemi.
Spuštění nainstalované aplikace AIR z prohlížeče
Pro použití funkce vyvolání prohlížeče (povolení, aby byla spuštěna z prohlížeče) musí soubor deskriptoru aplikace
cílové aplikace zahrnovat následující nastavení:
Více informací o souboru deskriptoru aplikace naleznete v tématu„Nastavení vlastností aplikace AIR“ na stránce 42.
Soubor SWF v prohlížeči může spustit aplikaci AIR voláním metody launchApplication() v souboru air.swf
načteném z http://airdownload.adobe.com/air/browserapi/air.swf. Podrobnosti naleznete v tématu „Načtení souboru
Jakmile je soubor air.swf načten, může soubor SWF volat metodu souboru air.swf launchApplication(), viz.
následující kód:
var appID:String = "com.example.air.myTestApplication";
var pubID:String = "02D88EEED35F84C264A183921344EEA353A629FD.1";
var arguments:Array = ["launchFromBrowser"]; // Optional
airSWF.launchApplication(appID, pubID, arguments);
Metoda launchApplication() je definovaná na nejvyšší úrovni souboru air.swf (který je načten v doméně aplikace
souboru SWF uživatelského rozhraní). Volání této metody způsobí, že aplikace AIR spustí určenou aplikaci (je-li
instalována a je-li povolena inicializace prohlížeče prostřednictvím nastavení allowBrowserInvocation v souboru
deskriptoru aplikace). Tato metoda má následující parametry:
Parametr
Popis
appID
ID aplikace pro aplikaci, která má být spuštěna. Podrobnosti naleznete v tématu „Definice základních informací
pubID
ID vydavatele pro aplikaci, která má být spuštěna. Podrobnosti naleznete v tématu „O identifikátorech
vydavatele AIR“ na stránce 286.
arguments
Pole argumentů, které budou předány aplikaci. Objekt NativeApplication aplikace odešle událost
BrowserInvokeEvent, která má vlastnost argumentů nastavenou na toto pole.
Metoda launchApplication() může operovat pouze je-li volána v objektu pro zpracování události pro událost
uživatele, například klepnutí myší.
Metoda launchApplication() vygeneruje chybu, jestliže požadovaná verze přehrávače Flash Player (verze 9
Jestliže je element allowBrowserInvocation nastaven v souboru deskriptoru aplikace na false, volání metody
launchApplication() nepřinese žádné výsledky.
Před poskytnutím uživateli rozhraní pro spuštění aplikace si můžete přát volat metodu getApplicationVersion() v
souboru air.swf. Podrobnosti naleznete v tématu „Kontrola z webové stránky, zda je aplikace AIR nainstalována.“ na
stránce 282.
Je-li aplikace iniciována prostřednictvím funkce iniciace prohlížeče, objekt aplikace NativeApplication odešle objekt
BrowserInvokeEvent. Podrobnosti naleznete v tématu „Vyvolání z prohlížeče“ na stránce 262.
Jestliže používáte funkci iniciace prohlížeče, ujistěte se, že zohledníte implikace zabezpečení popsané v tématu
„Vyvolání z prohlížeče“ na stránce 262.
Jakmile aplikace běží, může komunikovat s obsahem SWF v prohlížeči pomocí třídy LocalConnection. Podrobnosti
naleznete v tématu Komunikace mezi aplikacemi.
Nasazení firmy
IT správci mohou nainstalovat runtime Adobe AIR a aplikace AIR tiše pomocí standardních nástrojů nasazení plochy.
IT správci mohou provést následující:
• Tiše nainstalovat runtime Adobe AIR pomocí nástrojů, například Microsoft SMS, IBM Tivoli, nebo jakýchkoliv
nástrojů nasazení, které umožňují tiché instalace používající počáteční zavádění.
• Tiše nainstalovat aplikaci AIR pomocí stejných nástrojů použitých k nasazení runtime
Více informací naleznete v tématu Příručky správce Adobe AIR
(http://www.adobe.com/go/learn_air_admin_guide_cz).
Digitální podepisování souboru AIR
Digitální podpis vašich instalačních souborů AIR s certifikátem vydaným uznávanou certifikační autoritou (CA)
poskytuje vašim uživatelům významnou záruku, že aplikace, kterou instalují, nebyla náhodně nebo úmyslně upravena
a identifikuje vás jako autora podpisu (vydavatele). AIR zobrazí název vydavatele během instalace, pokud byla aplikace
AIR podepsána s certifikátem, který je důvěryhodný, nebo který provede propojení na důvěryhodný certifikát v počítači
instalace. V opačném případě je název vydavatele zobrazen jako „Neznámý“.
Důležité: Podvodné entity by mohly falsifikovat soubor AIR s vaší totožností, jestliže nějakým způsobem získají váš
soubor úložiště klíčů podpisu nebo zjistí váš osobní klíč.
Informace o certifikátech podpisu kódu
Záruky zabezpečení, omezení a právní závazky týkající se použití certifikátů podpisu kódu jsou uvedeny v Prohlášení
o postupech certifikátu (Certificate Practice Statements - CPS) a v ujednáních odběratele zveřejněných vydávající
certifikační autoritou. Více informací o ujednáních pro dvě z největších certifikačních autorit naleznete na níže
uvedených odkazech:
Verisign CPS (http://www.verisign.com/repository/CPS/)
Ujednání odběratele autority Verisign (https://www.verisign.com/repository/subscriber/SUBAGR.html)
Thawte CPS (http://www.thawte.com/cps/index.html)
Dohoda o podepisování kódu vývojáře autority Thawte (http://www.thawte.com/ssl-digital-certificates/free-guideswhitepapers/pdf/develcertsign.pdf)
O podepisování kódu AIR
Když je soubor AIR podepsán, je digitální podpis zahrnut v instalačním souboru. Podpis zahrnuje souhrn balíku, který
je použit pro ověření, že soubor AIR nebyl od podepsání upraven a zahrnuje informace o certifikátu podpisu, který je
použit pro ověření totožnosti vydavatele.
AIR používá infrastrukturu veřejného klíče (PKI) podporovanou pomocí certifikátu operačního systému uloženého
pro určení důvěryhodnosti certifikátu. Pro ověření informace vydavatele musí počítač, na kterém je aplikace AIR
nainstalována, buď přímo důvěřovat certifikátu použitému pro podepsání aplikace AIR, nebo musí důvěřovat řetězci
certifikátů propojujícímu certifikát s důvěryhodnou certifikační autoritou.
Jestliže je soubor AIR podepsán s certifikátem, který neprovede propojení k jednomu z důvěryhodných kořenových
certifikátů (a toto běžně zahrnuje všechny certifikáty s vlastním podpisem), nelze informace vydavatele ověřit. Zatímco
AIR může určit, že balík AIR nebyl od jeho podepsání změněn, neexistuje způsob pro zjištění, kdo daný soubor vlastně
vytvořil a podepsal.
Poznámka: Uživatel si může zvolit důvěřovat certifikátu s vlastním podpisem a libovolná aplikace AIR podepsaná s
certifikátem poté zobrazí hodnotu pole společného názvu v daném certifikátu jako název vydavatele. AIR neposkytuje
uživatelům žádné prostředky k označení certifikátu jako důvěryhodného. Certifikát (neobsahující osobní klíč) musí být
poskytnut uživateli samostatně a uživatel musí použít jeden z mechanismů poskytnutých operačním systémem nebo
příslušný nástroj pro import certifikátu do příslušného umístění v systémovém úložišti certifikátu.
O identifikátorech vydavatele AIR
Jako součást procesu vytváření souboru AIR vygeneruje program AIR Developer Tool (ADT) ID vydavatele. Jedná se
o identifikátor, který je jedinečný pro identifikátor použitý pro vytvoření souboru AIR. Jestliže znovu použijete stejný
certifikát pro více aplikací AIR, budou mít tyto aplikace stejné ID vydavatele. ID vydavatele je použito k identifikaci
aplikace AIR v komunikaci LocalConnection (Viz Komunikace mezi aplikacemi). ID vydavatele nainstalované
aplikace můžete určit načtením vlastnosti NativeApplication.nativeApplication.publisherID.
Následující pole jsou použita pro vypočtení ID vydavatele: Name, CommonName, Surname, GivenName, Initials,
GenerationQualifier, DNQualifier, CountryName, localityName, StateOrProvinceName, OrganizationName,
OrganizationalUnitName, Title, Email, SerialNumber, DomainComponent, Pseudonym, BusinessCategory,
StreetAddress, PostalCode, PostalAddress, DateOfBirth, PlaceOfBirth, Gender, CountryOfCitizenship,
CountryOfResidence a NameAtBirth. Jestliže obnovíte certifikát vydaný certifikační autoritou nebo obnovíte certifikát
s vlastním podpisem, musí tato pole být stejná, aby také ID vydavatele zůstalo stejné. Mimo to musí být stejný také
kořenový certifikát CA a veřejný klíč certifikátu s vlastním podpisem.
O formátech certifikátu
Podpisové nástroje AIR přijímají jakékoliv úložiště klíčů přístupné pomocí funkce Java Cryptography Architecture
(JCA). Mezi ně patří úložiště klíčů vycházející ze souborů, například soubory s formátem PKCS12 (které obvykle
používají koncovku souboru .pfx nebo .p12), soubory jazyka Java .keystore, úložiště klíčů hardware PKCS11 a systémová
úložiště klíčů. Formáty úložiště klíčů, ke kterým může program ADT získat přístup, závisí na verzi a konfiguraci runtime
jazyka Java použitého ke spuštění programu ADT. Přístup k některým typům úložišť klíčů, například k známkám
hardware PKCS11, může vyžadovat instalaci a konfiguraci dalších ovladačů software a modulů JCA.
K podepsání souborů AIR můžete použít stávající certifikát podpisu kódu třídy 3 poskytující vysoké zajištění nebo
můžete obdržet nový certifikát. Lze použít například libovolný z následujících typů certifikátu od autorit Verisign nebo
Thawte:
• Verisign:
• Microsoft Authenticode Digital ID
• Sun Java Signing Digital ID
• Thawte:
• AIR Developer Certificate
• Apple Developer Certificate
• JavaSoft Developer Certificate
• Microsoft Authenticode Certificate
Poznámka: Certifikát musí být označen pro podpis kódu. Obvykle nemůžete použít certifikát SSL k podepsání souborů AIR.
Časové známky
Když podepíšete soubor AIR, nástroj balení pošle serveru dotaz ohledně autority časové známky pro získání nezávisle
ověřitelného data a času podpisu. Získaná časová známka je vložena do souboru AIR. Pokud je certifikát podpisu
platný v době podpisu, lze soubor AIR nainstalovat, i po vypršení certifikátu. Pokud ale není obdržena žádná časová
známka, soubor AIR již nelze nainstalovat, pokud certifikát vyprší nebo je zrušen.
Nástroje balení AIR implicitně získají časovou známku. Pokud ale chcete povolit zabalení aplikace, když je služba
časových známek nedostupná, můžete získávání časových známek vypnout. Společnost Adobe doporučuje, aby
všechny veřejně distribuované soubory AIR obsahovaly časovou známku.
Výchozí autorita časových známek používaná nástroji balení AIR je Geotrust.
Získání certifikátu
Pro získání certifikátu navštivte webové stránky certifikační autority a projděte procesem zprostředkování dané
společnosti. Nástroje použité k vytvoření souboru úložiště klíčů potřebného nástroji AIR závisí na typu zakoupeného
certifikátu, způsobu uložení certifikátu na počítači příjemce a někdy také na prohlížeči použitém k získání certifikátu.
Pro získání a export například certifikátu Microsoft Authenticode vyžadují autority Verisign nebo Thawte použití
aplikace Microsoft Internet Explorer. Certifikát lze poté exportovat jako soubor .pfx přímo z uživatelského rozhraní
Internet Explorer.
Certifikát s vlastním podpisem můžete vygenerovat pomocí programu Air Development Tool (ADT) používaného k
balení instalačních souborů AIR. Lze také použít některé nástroje třetích stran.
Pokyny pro vygenerování certifikátu s vlastním podpisem i pokyny pro podepsání souboru AIR naleznete v tématu
„Zabalení instalačního souboru AIR pomocí programu AIR Developer Tool (ADT)“ na stránce 307. Soubory AIR
můžete také exportovat a podepsat pomocí aplikací Flex Builder, Dreamweaver a aktualizace AIR pro nástroj Flash.
Následující příklad popisuje způsob získání certifikátu vývojáře AIR od certifikační autority Thawte a přípravu tohoto
certifikátu pro jeho použití s programem ADT. Tento příklad ukazuje pouze jeden z mnoha způsobů získání a přípravy
certifikátu podpisu kódu, který můžete použít.
Příklad: Získání certifikátu vývojáře AIR od autority Thawte
Pro zakoupení certifikátu vývojáře AIR server autority Thawte vyžaduje použití prohlížeče Mozilla Firefox. Osobní
klíč pro certifikát je uložen v úložišti klíčů prohlížeče. Ujistěte se, zda je úložiště klíčů Firefox zajištěno pomocí
hlavního hesla, a že je samotný počítač fyzicky zabezpečen. (Jakmile je proces zprostředkování dokončen, můžete
certifikát a osobní klíč z úložiště klíčů prohlížeče exportovat a odstranit.)
Jako součást procesu přihlášení certifikátu je vygenerována dvojice osobního a veřejného klíče. Osobní klíč je
automaticky uložen v úložišti klíčů aplikace Firefox. Pro vyžádání i načtení certifikátu ze serveru autority Thawte
musíte použít stejný počítač a stejný prohlížeč.
1 Navštivte server autority Thawte a přejděte na Stránka produktů pro certifikáty podpisu kódu.
2 Ze seznamu certifikátů podpisu kódu vyberte Adobe AIR Developer Certificate.
3 Absolvujte proces přihlášení zahrnující dva kroky. Je třeba poskytnout informace o organizaci a vaše kontaktní
údaje. Thawte poté provede proces ověření identity a může požádat o dodatečné informace. Po dokončení ověření
vám autorita Thawte odešle e-mail s pokyny, jak načíst certifikát.
Poznámka: Poznámka: Dodatečné informace o typu vyžadované dokumentace lze nalézt zde:
https://www.thawte.com/ssl-digital-certificates/free-guides-whitepapers/pdf/enroll_codesign_cz.pdf.
4 Načtěte vydaný certifikát ze serveru Thawte. Certifikát je automaticky uložen do úložiště klíčů aplikace Firefox.
5 Exportujte soubor úložiště klíčů obsahující osobní klíč a certifikát z úložiště klíčů Firefox pomocí následujících
kroků:
Poznámka: Při exportu osobního klíče a certifikátu z aplikace Firefox je export proveden ve formátu .p12 (pfx), který
může být použit programy ADT, Flex, Flash a Dreamweaver.
a Otevřete dialogové okno aplikace Firefox Správce certifikátu:
b V OS Windows: otevřete Nástroje -> Možnosti -> Rozšířené -> Certifikáty -> Správa certifikátů
c V OS Mac: otevřete Firefox -> Preference -> Rozšířené -> Vaše certifikáty -> Zobrazit certifikáty
d Ze seznamu certifikátů vyberte Adobe AIR Code Signing Certificate a klepněte na tlačítko Záloha.
e Zadejte název souboru a umístění, kam chcete soubor úložiště klíčů exportovat. Poté klepněte na možnost
Uložit.
f
Jestliže používáte hlavní heslo Firefox, budete požádání o zadání svého hesla pro zařízení k zabezpečení
software, abyste mohli soubor exportovat. (Toto heslo je použito pouze aplikací Firefox.)
g V dialogovém okně Výběr hesla pro zálohování certifikátu vytvořte heslo pro soubor úložiště klíčů.
Důležité: Toto heslo chrání soubor úložiště klíčů a je vyžadováno, je-li soubor použit pro podpis aplikací AIR. Měli
byste zvolit bezpečné heslo.
h Klepněte na tlačítko OK. Měli byste obdržet zprávu o úspěšném provedení zálohy hesla. Soubor úložiště klíčů
obsahující osobní klíč a certifikát je uložen s příponou .p12 (ve formátu PKCS12)
6 Exportovaný soubor úložiště klíčů použijte s programy ADT, Flex Builder, Flash nebo Dreamweaver. Heslo
vytvořené pro tento soubor je vyžadováno při každém podpisu aplikace AIR.
Důležité: Osobní klíč a certifikát jsou stále uloženy v úložišti klíčů aplikace Firefox. To vám nejen umožňuje exportovat
další kopii souboru certifikátu, ale jedná se také o další bod přístupu, který musí být chráněn, aby bylo zajištěno
zabezpečení vašeho certifikátu a osobního klíče.
Změna certifikátů
Za některých okolností můžete potřebovat změnit certifikát, který používáte pro podpis aplikace AIR. Mezi takové
okolnosti patří:
• Aktualizace z certifikátu s vlastním podpisem na certifikát vydaný certifikační autoritou.
• Změna z certifikátu s vlastním podpisem, který za chvíli vyprší, na jiný
• Změna z jednoho komerčního certifikátu na jiný, například při změně identity vaší společnosti.
Vzhledem k tomu, že je certifikát podpisu jedním z prvků, které určují identitu aplikace AIR, nelze jednoduše podepsat
aktualizaci vaší aplikace s odlišným certifikátem. Aby aplikace AIR rozpoznala soubor AIR jako aktualizaci, musíte
podepsat původní i jakýkoliv aktualizovaný soubor AIR pomocí stejného certifikátu. V opačném případě nainstaluje
AIR nový soubor AIR jako samostatnou aplikaci namísto aktualizace stávající aplikace.
Stejně jako v případě AIR 1.1 můžete změnit certifikát podpisu aplikace pomocí podpisu přesunu. Podpis přesunu je
druhým podpisem použitým na soubor AIR aktualizace. Podpis přesunu používá původní certifikát, který udává, že
autor podpisu je původní vydavatel aplikace.
Důležité: Certifikát musí být změněn před tím, než původní certifikát vyprší nebo je zrušen. Jestliže před vypršením svého
certifikátu nevytvoříte aktualizaci podepsanou podpisem přesunu, budou uživatelé muset před instalací aktualizací
nainstalovat své stávající verze vaší aplikace. Komerčně vydané certifikáty mohou být obvykle pro zamezení vypršení
obnoveny. Certifikáty s vlastním podpisem obnovit nelze.
Chcete-li změnit certifikáty:
1 Vytvořte aktualizaci své aplikace
2 Zabalte a podepište aktualizovaný soubor AIR pomocí certifikátu nový
3 Znovu podepište soubor AIR pomocí certifikátu původní (pomocí příkazu programu ADT -migrate)
Postup použití podpisu přesunu je popsán v tématu „Podepsání souboru AIR pro změnu certifikátu aplikace“ na
stránce 313.
Po instalaci aktualizovaného souboru AIR se identita aplikace změní. Tato změna identity má následující důsledky:
• ID vydavatele aplikace se změní, aby odpovídalo novému certifikátu.
• Nová verze aplikace nemůže získat přístup k datům ve stávajícím kódovaném lokálním úložišti.
• Umístění adresáře ukládání aplikace se změní. Data ve starém umístění nejsou zkopírována do nového adresáře.
(Nicméně nová aplikace může najít původní adresář na základě starého ID vydavatele).
• Aplikace již nemůže otevřít místní připojení pomocí starého ID vydavatele.
• Jestliže uživatel znovu nainstaluje soubor AIR před provedením přesunu, AIR jej nainstaluje jako samostatnou
aplikaci pomocí původního ID vydavatele.
Vaše aplikace je odpovědná za přesun jakýchkoliv dat mezi původní a novou verzí aplikace. Pro přesun dat v
kódovaném lokálním úložišti (encrypted local store - ELS) musíte exportovat data před provedením změny certifikátu.
Nová verze vaší aplikace nemůže načíst ELS staré verze. (Často je jednodušší data pouze znovu vytvořit namísto jejich
přesunu.)
Podpis přesunu byste měli i nadále použít na co nejvíce následujících aktualizací. V opačném případě budou muset
uživatelé, kteří ještě neprovedli aktualizaci z původní aplikace, buď nainstalovat přechodnou verzi přesunu nebo
odinstalovat svou aktuální verzi před tím, než mohou nainstalovat nejnovější aktualizaci. Původní certifikát může také
samozřejmě vypršet a vy už nebudete moct použít podpis přesunu. (Nicméně dokud nevypnete získávání časových
známek, soubory AIR dříve podepsané podpisem přesunu zůstanou platné. Podpis přesunu je opatřen časovou
známkou a umožňuje AIR přijmout podpis i po vypršení certifikátu.)
Soubor AIR s podpisem přesunu je v jiných ohledech běžným souborem AIR. Jestliže je aplikace v systému
nainstalována bez původní verze, AIR nainstaluje novou verzi obvyklým způsobem.
Poznámka: Obvykle není třeba přesunout certifikát při obnovení komerčně vydaného certifikátu. Obnovený certifikát si
zachová stejnou identitu vydavatele jako certifikát původní, pokud nebyl změněn rozlišující název. Kompletní seznam
atributů certifikátu, které jsou použity k určení rozlišujícího názvu, naleznete v tématu „O identifikátorech vydavatele
AIR“ na stránce 286.
Terminologie
Tato část poskytuje slovníček některých klíčových pojmů, kterým byste měli rozumět při rozhodování o způsobu
podepsání své aplikace pro veřejnou distribuci.
Pojem
Popis
Certifikační autorita (CA)
Objekt v síti infrastruktury veřejných klíčů, který slouží jako důvěryhodná třetí strana a certifikuje
totožnost vlastníka veřejného klíče. CA obvykle vydává digitální certifikáty podepsané jejím
vlastním osobním klíčem a označuje tak, že ověřila totožnost držitele certifikátu.
Prohlášení o postupech certifikátu
(Certificate Practice Statement - CPS)
Stanovuje postupy a zásady certifikační autority při vydávání a ověřování certifikátů. CPS je
součástí smlouvy mezi CA a jejími odběrateli a souvisejícími stranami. Udává také postupy pro
ověření totožnosti a úroveň zaručení nabízenou certifikátem, který autorita poskytuje.
Seznam zrušených certifikátů
(Certificate Revocation List - CRL)
Seznam vydaných certifikátů, které byly zrušeny a nelze již na ně spoléhat. AIR zkontroluje CRL při
podpisu aplikace AIR a dále při instalaci aplikace, jestliže není přítomna žádná časová známka.
Řetězec certifikátu
Řetězec certifikátu je sekvence certifikátů, kde je každý certifikát v řetězci podepsán dalším
certifikátem.
Digitální certifikát
Digitální dokument obsahující informace o totožnosti majitele, veřejném klíči majitele a totožnosti
certifikátu jako takového. Certifikát vydaný certifikační autoritou je podepsán certifikátem
patřícím vydávající CA.
Digitální podpis
Kódovaná zpráva nebo souhrn, který lze dekódovat pouze pomocí veřejného klíče, poloviny
dvojice veřejného a osobního klíče. V infrastruktuře veřejného klíče obsahuje digitální podpis
jeden nebo více digitálních certifikátů, které lze dosledovat k certifikační autoritě. Digitální podpis
lze použít k ověření, zda zpráva (nebo soubor počítače) nebyla od podpisu pozměněna (v rámci
omezení zajištění poskytovaného použitým kryptografickým algoritmem) a, za předpokladu, že
důvěřujete vydávající certifikační autoritě, k ověření totožnosti autora podpisu.
Pojem
Popis
Úložiště klíčů
Databáze obsahující digitální certifikáty a v některých případech související osobní klíče.
Java Cryptography Architecture (JCA)
Rozšířitelná architektura pro správu a získání přístupu k úložištím klíčům. Více informací naleznete
v Referenční příručka Java Cryptography Architecture.
PKCS #11
Standard rozhraní kryptografické známky od RSA Laboratories. Úložiště klíčů založené na známce
hardware.
PKCS #12
Standard syntaxe pro výměnu osobních informací od RSA Laboratories. Úložiště klíčů vycházející
ze souboru obvykle obsahující osobní klíč a jeho asociovaný digitální certifikát.
Osobní klíč
Osobní polovina z dvoudílného asymetrického kryptografického systému veřejného a osobního
klíče. Osobní klíč je nutné uchovat v tajnosti a nikdy jej nepřenášet sítí. Digitálně podepsané zprávy
jsou kódovány pomocí osobního klíče autorem podpisu.
Veřejný klíč
Veřejná polovina z dvoudílného asymetrického kryptografického systému veřejného a osobního
klíče. Veřejný klíč je volně dostupný a používá se k dekódování zpráv kódovaných pomocí
osobního klíče.
Infrastruktura veřejného klíče (Public
Key Infrastructure - PKI)
Systém důvěry, kde certifikační autority ověřují totožnost majitelů veřejných klíčů. Klienti sítě se
spoléhají na digitální certifikáty vydané důvěryhodnou CA pro ověření totožnosti autora podpisu
digitální zprávy (nebo souboru).
Časová známka
Digitálně podepsaný údaj obsahující datum a čas, kdy došlo k události. ADT může do balíku AIR
zahrnout časovou známku z časového serveru podléhajícího RFC 3161. Je-li časová známka k
dispozici, použije ji AIR pro stanovení platnosti certifikátu v době podpisu. To umožňuje instalaci
aplikace AIR po vypršení jejího certifikátu podpisu.
Autorita časové známky
Autorita, která vydává časové známky. Pro to, aby byla časová známka programem AIR
rozpoznána, musí se shodovat s normou RFC 3161 a podpis časové známky musí provést zřetězení
k důvěryhodnému kořenovému certifikátu v počítači instalace.
291
Kapitola 32: Aktualizace aplikací AIR
Uživatelé mohou instalovat nebo aktualizovat aplikaci AIR poklepáním na soubor AIR na svém počítači nebo z
prohlížeče (pomocí funkce hladké instalace) a o správu instalace se postará instalátor Adobe® AIR™, který upozorní
uživatele, zda se chystá aktualizovat již existující aplikaci. (Viz „Distribuce, Instalace a Spuštění aplikací AIR“ na
stránce 276.)
Pomocí třídy Updater se však může instalovaná aplikace aktualizovat na novou verzi i sama. (Instalovaná aplikace umí
zjistit, zda je dostupná nová verze ke stažení a instalaci.) Třída Updater zahrnuje metodu update(), která umožňuje
vyhledat soubor AIR na počítači uživatele a aktualizovat jej na příslušnou verzi.
ID aplikace i ID vydavatele aktualizačního souboru AIR se musí shodovat s aplikací, která má být aktualizována. ID
vydavatele je odvozeno od podpisového certifikátu, což znamená, že aktualizace i aplikace, která má být aktualizována,
musí být podepsány stejným certifikátem.
Od verze AIR 1.1 můžete migrovat aplikaci, chcete-li použít nový podpisový certifikát kódu. Migrování aplikace pro
použití nového podpisu zahrnuje podepsání aktualizačního souboru AIR novým i původním certifikátem. Migrace
certifikátu je nevratný proces. Po migraci budou jako aktualizace stávající instalace rozpoznány pouze soubory AIR
podepsané novým certifikátem (nebo oběma certifikáty).
Pomocí migrace certifikátu můžete změnit certifikát s vlastním podpisem na komerční podpisový certifikát kódu nebo
z jednoho certifikátu s vlastním podpisem nebo komerčního certifikátu na jiný. Jestliže neprovedete migraci
certifikátu, stávající uživatelé budou muset před instalací nové verze vaší aplikace nejprve odinstalovat aktuální verzi.
Další informace viz „Změna certifikátů“ na stránce 288.
O aktualizaci aplikací
Třída Updater (v balíčku flash.desktop) zahrnuje jednu metodu, update(), kterou můžete použít k aktualizaci
aktuálně běžící aplikace s odlišnou verzí. Má-li například uživatel verzi souboru AIR („Sample_App_v2.air“)
umístěnou na ploše, aplikaci aktualizuje následující kód:
var updater:Updater = new Updater();
var airFile:File = File.desktopDirectory.resolvePath("Sample_App_v2.air");
var version:String = "2.01";
updater.update(airFile, version);
Před použitím třídy Updater musí uživatel nebo aplikace stáhnout do počítače aktualizovanou verzi souboru AIR.
Další informace viz „Stažení souboru AIR do počítače uživatele“ na stránce 293.
Výsledky volání metody
Když aplikace při běhu vyvolá metodu update(), chod programu ukončí aplikaci a poté se pokusí instalovat novou
verzi ze souboru AIR. Chod programu zkontroluje, zda se ID aplikace a ID vydavatele určená v souboru AIR shodují
s ID aplikace a ID vydavatele pro volání metody update() dané aplikace. (Informace o ID aplikace a ID vydavatele viz
„Nastavení vlastností aplikace AIR“ na stránce 42.) Také zkontroluje, zda se řetězec verze shoduje s řetězcem version
předaným metodě update(). Je-li instalace úspěšně dokončena, otevře chod programu novou verzi aplikace. Jinak
(pokud nebyla instalace dokončena) se znovu otevře stávající verze aplikace – ta, která byla na počítači před instalací.
V systému Mac OS musí mít uživatel pro instalaci aktualizované verze aplikace odpovídající systémová práva k
instalaci adresáře aplikace. V systému Windows musí mít uživatel práva správce.
Pokud aktualizovaná verze aplikace požaduje aktualizovanou verzi modulu runtime, tato nová verze se nainstaluje.
Pro aktualizaci chodu programu musí mít uživatel na daném počítači práva správce.
Při testování aplikace pomocí ADL bude mít volání metody update() za následek výjimku běhu programu.
O řetězci verze
Řetězec, který je zadán jako parametr version metody update() se musí shodovat s řetězcem v atributu version
hlavního elementu application souboru deskriptoru aplikace pro soubor AIR, který má být instalován. Zadání
parametru version je vyžadováno z důvodů zabezpečení. Požadováním, aby aplikace ověřovala číslo verze v souboru
AIR, se zamezí, aby nebyla neúmyslně instalována starší verze, která by mohla obsahovat oslabení bezpečnosti, které
již bylo v aktuálně instalované aplikaci opraveno. Aplikace by měla také porovnat řetězec verze v souboru AIR s
řetězcem verze v instalované aplikaci, aby se zabránilo útokům nižší kategorie.
Řetězec verze může mít libovolný formát. Může mít například podobu „2.01“ nebo „version 2“. Formát tohoto řetězce
je ponechán na rozhodnutí vývojáře aplikace. Chod programu neověřuje platnost řetězce verze, to by měl provést kód
aplikace před aktualizací aplikace.
Stahuje-li aplikace AIR soubor AIR přes web, je dobré mít nějaký mechanismus, pomocí kterého může webová služba
ohlásit aplikaci Adobe AIR právě stahované verze. Aplikace pak může tento řetězec použít jako parametr version
metody update(). Je-li soubor AIR získán nějakým jiným způsobem, při kterém je verze souboru AIR neznámá,
aplikace AIR může soubor AIR prověřit, aby určila informace o verzi. (Soubor AIR je komprimovaným archívem ZIP
a soubor deskriptoru aplikace je druhým záznamem v archívu.)
Podrobnosti o souboru deskriptoru aplikace naleznete v části „Nastavení vlastností aplikace AIR“ na stránce 42 .
Představení vlastního uživatelského rozhraní pro
aktualizaci aplikace
AIR zahrnuje výchozí rozhraní pro aktualizaci:
Toto rozhraní je použito vždy, když uživatel poprvé instaluje na svém počítači nějakou verzi aplikace. Můžete však
definovat své vlastní rozhraní pro použití pro následné instance. Uděláte to tak, že určíte element customUpdateUI v
souboru deskriptoru aplikace pro aktuálně instalovanou aplikaci:
Jakmile je aplikace instalována a uživatel otevře soubor AIR s ID aplikace a ID vydavatele, které se shodují s
instalovanou aplikací, chod programu otevře aplikaci a ne výchozí instalátor aplikace AIR. Další informace viz
„Poskytnutí zákaznického uživatelského rozhraní pro aktualizace aplikace“ na stránce 48.
Aplikace může rozhodnout, když je vyvolána (když objekt NativeApplication.nativeApplication odešle událost
invoke), zda provede aktualizaci aplikace (pomocí třídy Updater). Jestliže se rozhodne pro aktualizaci, může uživateli
předložit své vlastní instalační rozhraní (které se liší od standardního spuštěného rozhraní).
Stažení souboru AIR do počítače uživatele
Chcete-li použít třídu Updater, uživatel nebo aplikace musí nejprve uložit soubor AIR místně na počítač uživatele.
Například následující kód přečte soubor AIR z URL (http://example.com/air/updates/Sample_App_v2.air) a uloží
soubor AIR do ukládacího adresáře aplikace:
var urlString:String = "http://example.com/air/updates/Sample_App_v2.air";
var urlReq:URLRequest = new URLRequest(urlString);
var urlStream:URLStream = new URLStream();
var fileData:ByteArray = new ByteArray();
urlStream.addEventListener(Event.COMPLETE, loaded);
urlStream.load(urlReq);
function loaded(event:Event):void {
urlStream.readBytes(fileData, 0, urlStream.bytesAvailable);
writeAirFile();
}
function writeAirFile():void {
var file:File = File.applicationStorageDirectory.resolvePath("My App v2.air");
fileStream.writeBytes(fileData, 0, fileData.length);
fileStream.close();
trace("The AIR file is written.");
}
Další informace viz „Pracovní kroky při čtení a zápisu souborů“ na stránce 112.
Zjištění, zda je aplikace spuštěná poprvé
Jakmile jste aktualizovali aplikaci, možná budete chtít poskytnout uživateli zprávu „začínáme“ nebo „vítejte“. Po
spuštění aplikace zkontroluje, jestli je spuštěná poprvé, aby mohla určit, zda zobrazit zprávu.
Jeden způsob, jak to udělat, je po inicializaci aplikace uložit soubor do ukládacího adresáře aplikace. Aplikace by při
každém svém spuštění měla zkontrolovat existenci tohoto souboru. Pokud daný soubor neexistuje, znamená to, že
aplikace je u aktuálního uživatele spuštěná poprvé. Pokud soubor existuje, aplikace již byla minimálně jednou
spuštěná. Jestliže soubor existuje a obsahuje starší číslo verze, než je aktuální číslo verze, pak víte, že uživatel má novou
verzi spuštěnou poprvé.
Jestliže vaše aplikace ukládá data místně (např. do ukládacího adresáře aplikace), možná budete chtít při prvním
spuštění prověřit veškerá dříve uložená data (z předcházejících verzí).
295
Kapitola 33: Lokalizace aplikací AIR
Aplikace Adobe® AIR™ 1.1 zahrnuje podporu pro několik jazyků.
Úvod do lokalizace
Lokalizace je proces zahrnutí datových zdrojů pro podporu několika lokálních verzí. Lokální verze je kombinací jazyka
a kódu země. Například en_US označuje angličtinu jako jazyk používaný v USA, fr_FR pak francouzštinu používanou
ve Francii. Pro lokalizování aplikace v těchto lokálních verzích budete muset poskytnout dvě sady datových zdrojů:
jednu pro verzi en_US a druhou pro fr_FR.
Lokální verze mohou sdílet jazyky. Například en_US a en_GB (Velká Británie) jsou odlišné lokální verze. V tomto
případě obě lokální verze používají anglický jazyk, ale kód země označuje jiné místo a proto může být možné použití
jiných datových zdrojů. Například aplikace v lokální verzi en_US může hláskovat slovo „color“, zatímco totéž bude ve
verzi en_GB ve formě „colour“. Jednotky měny mohou být dolary nebo libry, v závislosti na lokální verzi a formát dat
a času může být také odlišný.
Můžete také poskytnout datové zdroje pro jazyk bez specifikování kódu země. Například můžete poskytnout datové
zdroje pro angličtinu a další datové zdroje pro lokální verzi en_US, specifickou pro americkou angličtinu.
AIR SDK poskytuje lokalizační strukturu HTML Localization Framework (obsažený v souboru AIRLocalizer.js). Tato
struktura zahrnuje rozhraní API, které pomáhá při práci s různými lokálními verzemi. Podrobnosti viz „Lokalizace
obsahu HTML“ na stránce 296.
Lokalizace neznamená pouze překlad řetězců použitých v aplikaci. Zahrnuje také kterýkoliv typ datových zdrojů,
například audio soubory, obrázky a videa.
Lokalizace názvu aplikace a popisu v instalačním
programu aplikace
Můžete specifikovat několik jazyků pro prvky name a description v popisovacím souboru aplikace. Například
následující určuje název aplikace ve třech jazycích (angličtina, francouzština, němčina):
<name>
<text xml:lang="en">Sample 1.0</text>
<text xml:lang="fr">Échantillon 1.0</text>
<text xml:lang="de">Stichprobe 1.0</text>
</name>
Atribut xml:lang pro každý textový element určuje jazykový kód; definice těchto kódů naleznete v dokumentu
RFC4646 RFC4646 (http://www.ietf.org/rfc/rfc4646.txt).
Název prvku definuje název aplikace, který zobrazuje instalační program aplikace AIR. Instalační program aplikace
AIR používá lokalizovanou hodnotu, která nejlépe odpovídá jazykům rozhraní definovaným nastavením operačního
souboru.
Podobně můžete specifikovat několik jazykových verzí prvku description v souboru popisovače aplikace. Tento
prvek definuje text popisovače, který zobrazuje instalační program aplikace AIR.
Lokalizace aplikací AIR
Tato nastavení platí pouze pro jazyk dostupný v instalačním programu aplikace AIR. Nedefinují lokální verze
dostupné pro spuštění instalované aplikace. Aplikace AIR může poskytnout uživatelské rozhraní podporující několik
jazyků, včetně těch, které jsou dostupné pro instalační program aplikace AIR.
Další informace viz „Definování vlastností v souboru deskriptoru aplikace“ na stránce 43.
Výběr lokální verze
Pro stanovení, která lokální verze je používána aplikací, můžete použít jednu z následujících metod:
• Výzva pro uživatele - můžete spustit aplikaci v některé výchozí lokální verzi a pak se uživatele dotázat, zda chce
zvolit jinou verzi.
•
Capabilities.languages - vlastnost Capabilities.languages uvádí seznam pole jazyků dostupných pro
upřednostňovaný jazyk uživatele, nastavený prostřednictvím operačního systému. Tyto řetězce obsahují jazykové
tagy (případně také skript a informace o oblasti); jejich definici naleznete v dokumentu RFC4646
(http://www.ietf.org/rfc/rfc4646.txt). Řetězce používají jako oddělovací znak pomlčky (například „en-US" nebo
„ja-JP"). První záznam ve vráceném poli bude mít stejnou identifikaci primárního jazyka jako vlastnost language.
Pokud je například vlastnost languages[0] nastavena na hodnotu „en-US", pak je vlastnost language nastavena
na hodnotu „en".Pokud je však vlastnost language nastavena na „xu" (specifikace neznámého jazyka), první prvek
v poli languages bude odlišný.
•
Capabilities.language - vlastnost Capabilities.language poskytuje uživatelskému rozhraní kód jazyka
operačního systému.. Tato vlastnost je však omezena na 20 známých jazyků. U anglických systémů vrátí tato
vlastnost pouze jazykový kód a nikoliv kód země. Z těchto důvodu je lepší použít první prvek v poli
Capabilities.languages.
Lokalizace obsahu Flash
Aplikace Flash CS3 a CS4 obsahují v komponentách jazyka ActionScript 3.0 třídu Locale. Třída Locale umožňuje
ovládat způsob zobrazování vícejazyčného textu souboru SWF. Panel Flash Strings umožňuje používat v dynamických
textových polích místo přesných hodnot identifikátory řetězců. To umožní vytvořit soubor SWF, který zobrazí text
zavedený ze souboru XML pro konkrétní jazyk. Informace o používání třídy Locale viz také Flash Referenční příručka
jazyka ActionScript 3.0 a jeho součástí.
Lokalizace obsahu HTML
Balík AIR 1.1 SDK obsahuje lokalizační strukturu HTML. Soubor skriptu JavaScript AIRLocalizer.js tuto strukturu
definuje. Adresář struktury balíku AIR SDK obsahuje soubor AIRLocalizer.js. Tento soubor zahrnuje třídu
air.Localizer, která poskytuje funkci pro pomoc při vytváření aplikací podporujících lokalizované verze.
Nahrávání kódu lokalizační struktury AIR HTML
Chcete-li používat lokalizační strukturu, nakopírujte soubor AIRLocalizer.js do svého projektu. Pak ji zahrňte do
hlavního souboru HTML aplikace, pomocí značky skriptu:
<script src="AIRLocalizer.js" type="text/javascript" charset="utf-8"></script>
Následující skript JavaScript může volat objekt air.Localizer.localizer:
<script>
var localizer = air.Localizer.localizer;
</script>
Objekt air.Localizer.localizer je jediný objekt, který definuje metody a vlastnosti pro použití a správu
lokalizovaných zdrojů. Třída Localizer zahrnuje následující metody:
Metoda
Popis
getFile()
Získává text specifikovaného zdrojového svazku pro specifikovanou lokální verzi. Viz „Získání zdrojů pro
specifickou lokální verzi“ na stránce 302.
getLocaleChain()
Vrací jazyky v řetězci lokální verze. Viz „Definování řetězce locale“ na stránce 301.
getString()
Získává řetězec definovaný pro zdroj. Viz „Získání zdrojů pro specifickou lokální verzi“ na stránce 302.
setBundlesDirectory(
)
Nastavuje umístění adresáře svazků. Viz „Uzpůsobení nastavení lokalizátoru AIR HTML“ na stránce 300.
setLocalAttributePre
fix()
Nastavuje prefix použitý lokalizačními atributy použitými v prvcích HTML DOM. Viz „Uzpůsobení nastavení
lokalizátoru AIR HTML“ na stránce 300
setLocaleChain()
Nastavuje pořadí jazyků v řetězci lokální verze. Viz „Definování řetězce locale“ na stránce 301.
sortLanguagesByPrefe
rence()
Třídí lokální verze v řetězci lokální verze na základě pořadí lokálních verzí v nastavení operačního systému. Viz
„Definování řetězce locale“ na stránce 301.
update()
Aktualizuje HTML DOM (nebo prvek DOM) s lokalizovanými řetězci ze stávajícího řetězce lokální verze. Diskuse
o řetězcích lokální verze viz také „Správa řetězců lokální verze“ na stránce 298. Informace o metodě update()
naleznete v kapitole „Aktualizace prvků DOM pro použití ve stávající lokální verzi“ na stránce 299.
Třída Localizer zahrnuje následující statické vlastnosti:
Vlastnost
Popis
localizer
Vrací odkaz na jediný objekt Localizer pro aplikaci.
ultimateFallbackLocale
Lokální verze použitá, když aplikace nepodporuje žádné uživatelské předvolby.
Viz „Definování řetězce locale“ na stránce 301.
Definování zdrojových svazků
Lokalizační struktura HTML načte lokalizované verze řetězců ze souborů localization. Lokalizační soubor je sbírkou
klíčových hodnot, sériově uspořádaných v textovém souboru. Lokalizační soubor je někdy popisován jako svazek.
Vytvořte podadresáře v adresáři aplikačního projektu, pojmenovaný locale. (Můžete také použít jiný název, viz
„Uzpůsobení nastavení lokalizátoru AIR HTML“ na stránce 300.) Tento adresář bude zahrnovat lokalizační soubory.
Tento adresář se nazývá adresářem svazků.
Pro každou lokální verzi podporovanou vaší aplikací vytvořte podadresář v adresáři svazků. Pojmenujte každý
podadresář tak, aby odpovídal kódu lokální verze. Například pojmenujte adresář francouzštiny „fr“ a angličtiny „en“.
Můžete použít znak podtržítka (_) pro definování lokální verze, která má jazyk a kód země. Například pojmenujte
adresář americké angličtiny „en_us“. (Alternativně můžete použít pomlčku namísto podtržítka, „en-us“. Lokalizační
struktura HTML podporuje obojí.)
Můžete přidat jakýkoliv počet zdrojových souborů do podadresáře lokální verze. Obecně vytvoříte lokalizační soubor
pro každý jazyk (a umístíte jej do adresáře daného jazyka). Lokalizační struktura HTML zahrnuje metodu getFile(),
která umožňuje načtení obsahu souboru (viz „Získání zdrojů pro specifickou lokální verzi“ na stránce 302.
Soubory, které mají příponu souboru .properties, jsou definovány jako lokalizační soubory vlastností. Můžete je
používat pro definování párů klíčové hodnoty pro lokální verzi. Soubor vlastnosti definuje jednu hodnotu řetězce pro
každý řádek. Například následující definice popisuje hodnotu řetězce „Hello in English." pro klíč pojmenovaný
greeting:
greeting=Hello in English.
Soubor vlastnosti obsahující následující text definuje šest párů klíčových hodnot:
title=Sample Application
greeting=Hello in English.
exitMessage=Thank you for using the application.
color1=Red
color2=Green
color3=Blue
Tento příklad ukazuje anglickou verzi souboru vlastností, která je uložena v adresáři en.
Francouzská verze tohoto souboru je umístěna v adresáři fr.
title=Programme d'échantillon
greeting=Bonjour en français.
exitMessage=Merci pour l'usage du programme.
color1=Rouge
color2=Vert
color3=Bleu
Můžete definovat několik zdrojových souborů pro různé typy informací. Například soubor legal.properties může
obsahovat základní text právních informací (například o autorských právech). Můžete použít znovu tento zdroj v
několika aplikacích. Podobně můžete definovat samostatné soubory, které definují lokalizovaný obsah pro různé části
uživatelského rozhraní.
Pokud chcete podporovat několik jazyků, použijte pro tyto soubory kódování UTF-8.
Správa řetězců lokální verze
Když aplikace načte soubor AIRLocalizer.js, prověří lokální verze definované ve vaší aplikaci. Tyto lokální verze
odpovídají podadresářům v adresáři svazků (viz také „Definování zdrojových svazků“ na stránce 297). Tento seznam
dostupných lokálních verzí je znám jako řetězec locale. Soubor AIRLocalizer.js automaticky roztřídí řetězec locale,
založený na upřednostňovaném pořadí definovaném nastavením operačního systému. (Vlastnost
Capabilities.languages uvádí seznam jazyků uživatelského rozhraní operačního systému v upřednostňovaném
pořadí.)
Pokud tedy aplikace definuje zdroje pro lokální verze „en“, „en_US“ a „en_UK“, struktura AIR HTML Localizer
roztřídí řetězec locale odpovídajícím způsobem. Když se aplikace spustí v systému, který hlásí „en“ jako primární
lokální verzi, řetězec locale je roztříděn jako [„en", „en_US", „en_UK"]. V tomto případě aplikace vyhledá zdroje
nejprve ve svazku „en“, pak ve svazku „en_US“.
Pokud však systém nahlásí primární lokální verzi „en-US“, pak třídění bude vypadat takto: [„en_US", „en",
„en_UK"]. V tomto případě aplikace vyhledá zdroje nejprve ve svazku „en_US“, pak ve svazku „en“.
Standardně aplikace definuje první lokální verzi v řetězci locale, jako výchozí lokální verzi pro použití. Můžete
uživatele požádat, aby zvolil lokální verzi při prvním spuštění aplikace. Poté můžete vybrat uložení volby do souboru
předvoleb a použít tuto lokální verzi při následujícím spuštění aplikace.
Aplikace může použít zdrojové řetězce v kterékoliv lokální verzi v řetězci locale. Pokud specifická lokální verze
nedefinuje řetězec zdroje, aplikace použije následující shodný řetězec zdroje pro ostatní lokální verze definované v
řetězci locale.
Řetězec locale můžete přizpůsobit zavoláním metody setLocaleChain() objektu Localizer. Viz „Definování řetězce
locale“ na stránce 301.
Aktualizace prvků DOM lokalizovaným obsahem
Prvek v aplikaci může odkazovat na klíčovou hodnotu v souboru vlastností lokalizace. Například prvek title v
následujícím příkladu specifikuje atribut local_innerHTML. Lokalizační struktura používá tento atribut k vyhledání
lokalizované hodnoty. Standardně struktura vyhledá názvy atributů, které začínají „local_". Struktura aktualizuje
atributy, které mají názvy odpovídající textu za „local_". V tomto případě struktura nastavuje atribut innerHTML
prvku title. Atribut innerHTML používá hodnotu definovanou v klíči mainWindowTitle v souboru výchozích
vlastností (default.properties):
<title local_innerHTML="default.mainWindowTitle"/>
Pokud stávající lokální verze nedefinuje žádnou shodnou hodnotu, pak lokalizační struktura vyhledá zbytek řetězce
locale. Používá následující lokální verzi v řetězci locale, pro kterou je hodnota definována.
V následujícím příkladu text (innerHTML attribute) prvku p používá hodnotu klíče greeting definovaného v souboru
výchozích vlastností:
<p local_innerHTML="default.greeting" />
V následujícím příkladu hodnota atributu (a zobrazený text) prvku input využívá hodnotu klíče btnBlue
definovanou v souboru výchozího nastavení:
<input type="button" local_value="default.btnBlue" />
Pro aktualizování HTML DOM s cílem použít řetězce definované ve stávajícím řetězci locale, zavolejte metodu
update() objektu Localizer. Zavoláním metody update() dojde k tomu, že objekt Localizer analyzuje DOM a použije
manipulační postupy tam, kde naleznete lokalizační atributy („local_..."):
air.Localizer.localizer.update();
Můžete definovat hodnoty pro atribut (například „innerHTML“) a odpovídající lokalizační atribut (například
„local_innerHTML“). V tomto případě lokalizační struktura pouze přepíše hodnotu atributu, pokud naleznete
odpovídající hodnotu v lokalizačním řetězci. Například následující prvek definuje atributy value a local_value:
<input type="text" value="Blue" local_value="default.btnBlue"/>
Můžete také aktualizovat pouze specifický prvek DOM. Viz následující kapitola, „Aktualizace prvků DOM pro použití
ve stávající lokální verzi“ na stránce 299.
Standardně lokalizátor AIR HTML používá „local_" jako prefix pro atributy definující nastavení lokalizace prvku.
Atribut local_innerHTML například standardně definuje název svazku a zdroje použitého pro hodnotu innerHTML
prvku. Atribut local_value například standardně definuje název svazku a zdroje použitého pro hodnotu value
prvku. Můžete nakonfigurovat Localizer tak, aby používal prefix atributu pro jiný, než „local_". Viz „Uzpůsobení
nastavení lokalizátoru AIR HTML“ na stránce 300.
Aktualizace prvků DOM pro použití ve stávající lokální verzi
Když objekt Localizer aktualizuje HTML DOM, způsobí, že označené prvky použijí hodnoty atributů na základě
řetězců definovaných ve stávajícím řetězci locale. Chcete-li, aby lokalizátor HTML aktualizoval HTML DOM,
zavolejte metodu update() objektu Localizer:
Chcete-li, aby lokalizátor aktualizoval pouze specifikovaný prvek DOM, přidejte jej jako parametr metodě update().
Metoda update() má pouze jeden parametr, parentNode, který je volitelný. Při specifikování parametr parentNode
stanoví lokalizování prvku DOM. Zavolání metody update() a stanovení parametru parentNode nastaví
lokalizované hodnoty pro všechny podřízené prvky, které specifikují lokalizační atributy.
Například můžete zvážit následující prvek div:
<div id="colorsDiv">
<h1 local_innerHTML="default.lblColors" ></h1>
<p><input type="button" local_value="default.btnBlue" /></p>
<p><input type="button" local_value="default.btnRed" /></p>
<p><input type="button" local_value="default.btnGreen" /></p>
</div>
Pro aktualizování tohoto prvku použijte lokalizované řetězce definované ve stávajícím řetězci locale použijte
následující kód JavaScript:
var divElement = window.document.getElementById("colorsDiv");
air.Localizer.localizer.update(divElement);
Pokud hodnota není v řetězci locale nalezena, lokalizační struktura nastaví hodnotu atribut na hodnotu atributu
„local_". Například v předchozím příkladu předpokládáme, že lokalizační struktura nemůže nalézt hodnotu klíče
lblColors (ve kterémkoliv souboru default.properties v řetězci locale). V tomto případě je použito
„default.lblColors" jako hodnota innerHTML. Použití této hodnoty signalizuje (vývojáři) chybějící zdroje.
Metoda update() odesílá událost resourceNotFound, pokud nemůže nalézt zdroj v řetězci locale. Konstanta
air.Localizer.RESOURCE_NOT_FOUND definuje řetězec „resourceNotFound". Událost má tři vlastnosti:
bundleName, resourceName a locale. Vlastnost bundleName je názvem svazku, ve kterém není zdroj nalezen.
Vlastnost resourceName je názvem svazku, ve kterém není zdroj nalezen. Vlastnost locale je názvem lokální verze,
ve které není zdroj nalezen.
Metoda update() odesílá událost bundleNotFound, když nemůže nalézt specifikovaný svazek. Konstanta
air.Localizer.BUNDLE_NOT_FOUND definuje řetězec „bundleNotFound". Událost má dvě vlastnosti: bundleName a
locale. Vlastnost bundleName je názvem svazku, ve kterém není zdroj nalezen. Vlastnost locale je názvem lokální
verze, ve které není zdroj nalezen.
Metoda update() pracuje asynchronně (a odesílá události resourceNotFound a bundleNotFound asynchronně).
Následující kód stanoví posluchače událostí pro události resourceNotFound a bundleNotFound:
air.Localizer.localizer.addEventListener(air.Localizer.RESOURCE_NOT_FOUND, rnfHandler);
air.Localizer.localizer.addEventListener(air.Localizer.BUNDLE_NOT_FOUND, rnfHandler);
function rnfHandler(event)
{
alert(event.bundleName + ": " + event.resourceName + ":." + event.locale);
}
function bnfHandler(event)
{
alert(event.bundleName + ":." + event.locale);
}
Uzpůsobení nastavení lokalizátoru AIR HTML
Metoda setBundlesDirectory() objektu Localizer umožňuje uzpůsobit cestu adresáře svazku. Metoda
setLocalAttributePrefix() objektu Localizer umožňuje přizpůsobit cestu adresáře svazku a hodnotu atributu
používanou objektem Localizer.
Výchozí adresář svazku je definován jako podadresář lokální verze adresáře aplikace. Můžete stanovit jiný adresář a to
zavoláním metody setBundlesDirectory() objektu Localizer. Tato metoda používá jeden parametr, path, který je
cestou do požadovaného adresáře, jako řetězec. Hodnota parametru path může být kterákoliv z následujících:
• Řetězec definující cestu relativní k adresáři aplikace, například „locales"
• Řetězec definující platnou adresu URL, která použije schémata URL app, app-storage nebo file, například
„app://languages" (nepoužívejte schéma URL http)
• Objekt File
Informace o adresách URL a cestách adresářů naleznete v kapitole „Cesty objektu File“ na stránce 99.
Například následující kód nastavuje adresář svazků na podadresář jazyka v adresáři ukládání dat aplikace (nikoliv v
adresáři samotné aplikace):
air.Localizer.localizer.setBundlesDirectory("languages");
Předejte platnou cestu jako parametr path. Jinak metoda odešle výjimku BundlePathNotFoundError. Tato chyba má
parametr „BundlePathNotFoundError" jako svou vlastnosti name, a vlastnost message specifikuje neplatnou cestu.
Standardně lokalizátor AIR HTML používá „local_" jako prefix pro atributy definující nastavení lokalizace prvku.
Například atribut local_innerHTML definuje název svazku a zdroje použitý pro hodnotu innerHTML následujícího
prvku input:
<p local_innerHTML="default.greeting" />
Metoda setLocalAttributePrefix() objektu Localizer umožňuje použít prefix atributu jiný, než „local_". Tato
statická metoda bere jeden parametr, což je řetězec, který chcete použít jako prefix atributu. Například následující kód
nastavuje lokalizační strukturu tak, že použije jako prefix atributu „loc_“:
air.Localizer.localizer.setLocalAttributePrefix("loc_");
Můžete přizpůsobit prefix atributu, který používá lokalizační struktura. Prefix můžete uzpůsobit, pokud výchozí
hodnota („local_") bude v konfliktu s názvem jiného atributu použitého kódem. Při volání této metody
nezapomeňte použít platné znaky pro atributy HTML. (Například hodnota nemůže obsahovat prázdný znak.)
Informace o použití lokalizačních atributů v prvcích HTML, viz „Aktualizace prvků DOM lokalizovaným obsahem“
na stránce 299.
Nastavení adresáře svazků a prefixu atributu se mezi jednotlivými relacemi aplikace neuchovává. Pokud použijete
vlastní nastavení adresáře svazků a prefixu atributu, nezapomeňte nastavení provést pokaždé, když se aplikace
aktivuje.
Definování řetězce locale
Standardně, když načtete kód AIRLocalizer.js, nastaví se řetězec locale. Lokální verze dostupné v adresáři svazků a
nastavení jazyka operačního systému definují tento řetězec locale. (Podrobnosti viz „Správa řetězců lokální verze“ na
stránce 298.)
Řetězec locale můžete změnit zavoláním statické metody setLocaleChain() objektu Localizer. Například může být
požadováno zavolání této metody v případě, že uživatel indikuje předvolbu pro specifický jazyk. Metoda
setLocaleChain() bere jeden parametr, chain, který je polem lokálních verzí, například
[„fr_FR",„fr",„fr_CA"]. Pořadí lokálních verzí v poli nastavuje pořadí, ve kterém struktura vyhledává zdroje (v
následujících operacích). Pokud zdroj není nalezen pro první lokální verzi v řetězci, pokračuje v hledání v jiném zdroji
lokální verze. Pokud chybí argument chain, není polem nebo se jedná o prázdný řetězec, funkce selže a odešle výjimku
IllegalArgumentsError.
Statická metoda getLocaleChain() objektu Localizer vrací objekt Array s uvedením seznamu lokálních verzí ve
stávajícím řetězci locale.
Následující kód načte stávající řetězec locale a přidá dvě lokální verze French do hlavičky řetězce:
var currentChain = air.Localizer.localizer.getLocaleChain();
newLocales = ["fr_FR", "fr"];
air.Localizer.localizer.setLocaleChain(newLocales.concat(currentChain));
Metoda setLocaleChain() odesílá událost „change", když aktualizuje řetězec locale. Konstanta
air.Localizer.LOCALE_CHANGE definuje řetězec „change". Událost má jednu vlastnost, localeChain, pole kódů
lokálních verzí v novém řetězci locale. Následující kód stanoví posluchače událostí pro tuto událost.
var currentChain = air.Localizer.localizer.getLocaleChain();
newLocales = ["fr_FR", "fr"];
localizer.addEventListener(air.Localizer.LOCALE_CHANGE, changeHandler);
air.Localizer.localizer.setLocaleChain(newLocales.concat(currentChain));
function changeHandler(event)
{
alert(event.localeChain);
}
Statická vlastnost air.Localizer.ultimateFallbackLocale představuje lokální verzi použitou, když aplikace
nepodporuje žádné uživatelské předvolby. Výchozí hodnota je „en". Můžete nastavit jinou lokální verzi, jak je
uvedeno v následujícím kódu:
air.Localizer.ultimateFallbackLocale = "fr";
Získání zdrojů pro specifickou lokální verzi
Metoda getString() objektu Localizer vrací řetězec definovaný pro zdroj ve specifické lokální verzi. Když voláte
metodu, není nutné specifikovat hodnotu locale. V tomto případě metoda hledá v celém řetězci lokální verze a vrací
řetězec do první lokální verze, která poskytuje stanovený název zdroje. Metoda má následující parametry:
Parametr
Popis
bundleName
Svazek, který obsahuje zdroj. Toto je název souboru vlastností bez přípony
.properties. (Například, pokud je tento parametr nastaven jako „alerts", kód
Localizer hledá v lokalizačních souborech pojmenovaných alerts.properties.
resourceName
Název zdroje.
templateArgs
Volitelné. Pole řetězců, které nahrazují očíslované značky v náhradních řetězcích.
Například zvažte zavolání funkce, kde má parametr templateArgs hodnotu
[„Raúl", „4"] a odpovídající zdrojový řetězec je „Ahoj, {0}. Máte {1}
novou zprávu.". V tomto případě funkce vrací hodnotu „Ahoj, Raúl. Máte
4 nové zprávy.". Toto nastavení ignorujete předáním hodnoty null.
locale
Volitelné. Kód lokální verze (například „en", „en_us" nebo „fr"), který se má
použít. Pokud je lokální verze k dispozici a není nalezena žádná odpovídající
hodnota, metoda nepokračujte v hledání hodnot v jiných lokální verzích v řetězci
locale. Pokud není specifikována žádná lokální verze, funkce navrací řetězec v
první lokální verzi, která poskytuje hodnotu pro daný název řetězce.
Lokalizační struktura může aktualizovat označené atributy HTML DOM. Můžete však používat lokalizované řetězce
jinými způsoby. Například můžete použít řetězec v jiných dynamicky generovaných kódech HTML nebo jako
hodnotu parametrů ve volání funkce. Například následující kód volá funkci alert() s řetězcem definovaným ve
zdroji error114 ve výchozím souborů vlastností lokální verze fr_FR:
alert(air.Localizer.localizer.getString("default", "error114", null, "fr_FR"));
Metoda getString() odesílá událost resourceNotFound, když nemůže nalézt zdroj ve specifikovaném svazku.
Konstanta air.Localizer.RESOURCE_NOT_FOUND definuje řetězec „resourceNotFound". Událost má tři vlastnosti:
bundleName, resourceName a locale. Vlastnost bundleName je názvem svazku, ve kterém není zdroj nalezen.
Vlastnost resourceName je názvem svazku, ve kterém není zdroj nalezen. Vlastnost locale je názvem lokální verze,
ve které není zdroj nalezen.
Metoda getString() odesílá událost bundleNotFound, když nemůže nalézt specifikovaný svazek. Konstanta
air.Localizer.BUNDLE_NOT_FOUND definuje řetězec „bundleNotFound". Událost má dvě vlastnosti: bundleName a
locale. Vlastnost bundleName je názvem svazku, ve kterém není zdroj nalezen. Vlastnost locale je názvem lokální
verze, ve které není zdroj nalezen.
Metoda getString() pracuje asynchronně (a odesílá události resourceNotFound a resourceNotFound
asynchronně). Následující kód stanoví posluchače událostí pro události resourceNotFound a bundleNotFound:
air.Localizerlocalizer.addEventListener(air.Localizer.RESOURCE_NOT_FOUND, rnfHandler);
air.Localizerlocalizer.addEventListener(air.Localizer.BUNDLE_NOT_FOUND, bnfHandler);
var str = air.Localizer.localizer.getString("default", "error114", null, "fr_FR");
function rnfHandler(event)
{
alert(event.bundleName + ": " + event.resourceName + ":." + event.locale);
}
function bnfHandler(event)
{
alert(event.bundleName + ":." + event.locale);
}
Metoda getFile() objektu Localizer navrací obsah jako svazek, řetězec, pro danou lokální verzi. Soubor svazku je
načten jako soubor UTF-8. Metoda obsahuje následující parametry:
Parametr
Popis
resourceFileName
Název zdrojového souboru (například „about.html").
templateArgs
Volitelné. Pole řetězců, které nahrazují očíslované značky v náhradních řetězcích.
Například zvažte zavolání funkce, kde má parametr templateArgs hodnotu
[„Raúl", „4"] a odpovídající zdrojový soubor obsahuje dvě řádky:
<html>
<body>Hello, {0}. You have {1} new messages.</body>
</html>
V tomto případě funkce vrací řetězec se dvěma řádky:
<html>
<body>Hello, Raúl. You have 4 new messages. </body>
</html>
locale
Kód lokální verze, například „en_GB", který se má použít. Pokud je lokální verze
k dispozici a není nalezen žádný odpovídající soubor, metoda nepokračujte v
hledání v jiných lokálních verzích v řetězci locale. Pokud není specifikován žádný
kód lokální verze, funkce vrací text v první lokální verzi v řetězci locale, který má
soubor odpovídající resourceFileName.
Například následující kód volá metodu document.write() pomocí obsahu souboru about.html lokální verze fr:
var aboutWin = window.open();
var aboutHtml = localizer.getFile("about.html", null, "fr");
aboutWin.document.close();
aboutWin.document.write(aboutHtml);
Metoda getFile() odesílá událost fileNotFound, pokud nemůže nalézt zdroj v řetězci locale. Konstanta
air.Localizer.FILE_NOT_FOUND definuje řetězec „resourceNotFound". Metoda getFile() pracuje asynchronně
(a odesílá událost fileNotFound asynchronně). Událost má dvě vlastnosti: fileName a locale. Vlastnost fileName
je názvem nenalezeného souboru. Vlastnost locale je názvem lokální verze, ve které není zdroj nalezen. Následující
kód stanoví posluchače událostí pro tuto událost.
air.Localizer.localizer.addEventListener(air.Localizer.FILE_NOT_FOUND, fnfHandler);
air.Localizer.localizer.getFile("missing.html", null, "fr");
function fnfHandler(event)
{
alert(event.fileName + ": " + event.locale);
}
Lokalizace data, času a měny
Způsob, kterým aplikace prezentuje datum, čas a měny se pro každou lokální verzi velmi liší. Například standardní
USA pro vyjádření data je měsíc/den/rok, zatímco evropský standard pro vyjádření je den/měsíc/rok.
Můžete zapsat kód pro formátování data, času a měny. Například následující kód převádí objekt Date do formátu
měsíc/den/rok nebo den/měsíc/úrok. Pokud proměnná locale (představující lokální verzi) bude nastavena na
hodnotu „en_US", funkce navrátí formát měsíc/den/rok. Příklad převádí objekt Date do formátu den/měsíc/rok pro
všechny ostatní lokální verze.
function convertDate(date)
{
if (locale == "en_US")
{
return (date.getMonth() + 1) + "/" + date.getDate() + "/" + date.getFullYear();
}
else
{
return date.getDate() + "/" + (date.getMonth() + 1) + "/" + date.getFullYear();
}
}
305
Kapitola 34: Vytváření aplikace AIR
pomocí nástrojů příkazového řádku
Nástroje příkazového řádku Adobe® AIR™ vám umožňují testovat a balit aplikace Adobe AIR. Tyto nástroje můžete
také použít v procesu automatického vývoje. Nástroje příkazového řádku AIR jsou obsaženy v sadě SDK AIR AIR SDK
(http://www.adobe.com/go/learn_air_download_AIRSDK_cz).
Použití programu AIR Debug Launcher (ADL)
Nástroj AIR Debug Launcher (ADL) použijte během vyvíjení pro spuštění aplikací vycházejících z SWF i HTML.
Pomocí ADL můžete spustit aplikaci bez předchozího zabalení a instalace. ADL implicitně používá runtime obsažený
v sadě SDK, což znamená, že pro použití ADL nemusíte runtime instalovat samostatně.
ADL vytiskne příkazy trace a chyby v době běhu do standardního výstupu, ale nepodporuje body rozdělení nebo jiné
funkce ladění. Jestliže vyvíjíte aplikaci vycházející z formátu SWF, použijte pro složité úkoly ladění nástroj Flash
Debugger (nebo aplikaci Flash CS4 nebo CS3).
Spuštění aplikace pomocí ADL
Použijte následující syntaxi:
adl [-runtime runtime-directory] [-pubid publisher-id] [-nodebug] application.xml [rootdirectory] [-- arguments]
-runtime runtime-directory Určuje adresář obsahující runtime, které má být použito. Jestliže není určeno, použije se
adresář runtime ve stejné sadě SDK jako v případě programu ADL. Jestliže ADL přesunete mimo složku sady SDK,
musíte poté určit adresář runtime. V OS Windows určete adresář obsahující adresář Adobe AIR . V OS X Mac určete
adresář obsahující Adobe AIR.framework.
-pubid publisher-id Přiřadí určenou hodnotu jako ID vydavatele aplikace AIR pro toto spuštění. Určení přechodného
ID vydavatele pro testování funkcí aplikace AIR, například komunikaci přes lokální připojení, které používá ID
vydavatele. To vám umožní jedinečně identifikovat aplikaci. Finální ID vydavatele je určeno digitálním certifikátem
použitým pro podepsání instalačního souboru AIR.
-nodebug Vypne podporu ladění. Je-li použit, proces aplikace se nemůže připojit k nástroji ladění Flash a dialogy pro
zpracovávání výjimek jsou potlačeny. Příkazy trace se stále tisknou do okna konzoly. Vypnutím ladění poběží vaše
aplikace o trochu rychleji a také podrobněji emuluje režim spuštění nainstalované aplikace.
application.xml Soubor deskriptoru aplikace. Viz téma „Nastavení vlastností aplikace AIR“ na stránce 42.
root-directory Určuje kořenový adresář aplikace, které má být spuštěna. Není-li určeno, použije se adresář obsahující
soubor deskriptoru aplikace.
-- arguments Jakékoliv řetězce znaků, které se zobrazí za „--“ jsou předány aplikaci jako argumenty příkazového
řádku.
Poznámka: Když spustíte aplikaci AIR, která již běží, nespustí se nová instance dané aplikace. Namísto toho se k běžící
instanci odešle událost invoke.
Vytváření aplikace AIR pomocí nástrojů příkazového řádku
Tisk příkazů trace
Pro tisk příkazů trace do konzoly použité ke spuštění ADL přidejte příkazy trace k vašemu kódu pomocí funkce
trace():
trace("debug message");
air.trace("debug message");
Příklady ADL
Spuštění aplikace v aktuálním adresáři:
adl myApp-app.xml
Spuštění aplikace v podadresáři aktuálního adresáře:
adl source/myApp-app.xml release
Spusťte aplikaci a předejte dva argumenty příkazového řádku, „tick“ a „tock“:
adl myApp-app.xml -- tick tock
Spuštění aplikace pomocí specifického runtime:
adl -runtime /AIRSDK/runtime myApp-app.xml
Připojení k programu Flash Debugger (FDB)
Pro ladění aplikace AIR vycházející ze SWF pomocí programu Flash Debugger spusťte relaci FDB a poté spusťte verzi
ladění vaší aplikace. Verze ladění souboru SWF se automaticky připojí k poslouchající relaci FDB.
1 Spusťte FDB. Program FDB naleznete v adresáři bin své složky Flex SDK.
Konzola zobrazí výzvu FDB: <fdb>
2 Spusťte příkaz Run: <fdb>run [Enter]
3 V odlišném příkazu nebo konzole skořepiny spusťte verzi ladění své aplikace:
adl myApp-debug.xml
4 Pomocí příkazů programu FDB nastavte dle potřeby body rozdělení.
5 Zadejte: continue [Enter]
kódy ukončení a chyb ADL
Následující tabulka popisuje kódy ukončení vytištěné ADL:
Kódy
ukončení
Popis
0
Úspěšné spuštění. ADL se ukončí po ukončení aplikace AIR.
1
Úspěšná iniciace již běžící aplikace AIR. ADL se okamžitě ukončí.
2
Chyba použití. Argumenty dodané ADL nejsou správné.
3
Runtime se nepodařilo nalézt.
4
Runtime se nepodařilo spustit. K tomu často dojde z důvodu, že verze úrovně záplaty určené v aplikaci
neodpovídá verzi nebo úrovni záplaty runtime.
5
Došlo k neznámé chybě.
Kódy
ukončení
Popis
6
Soubor deskriptoru aplikace se nepodařilo nalézt.
7
Obsah deskriptoru aplikace není platný. Tato chyba obvykle určuje, že XML není dobře vytvořen.
8
Hlavní obsahový soubor aplikace (určený v elementu <content> souboru deskriptoru aplikace) se
nepodařilo nalézt.
9
Hlavní obsahový soubor aplikace není platným SWF nebo HTML souborem.
Zabalení instalačního souboru AIR pomocí programu
AIR Developer Tool (ADT)
Instalační soubor AIR pro aplikace AIR vycházející z SWF i HTML můžete vytvořit pomocí nástroje AIR Developer
Tool (ADT). (Jestliže k vytvoření své aplikace používáte Adobe Flash CS3, můžete pro vývoj balíku AIR také použít
příkaz Vytvořit soubor AIR v nabídce Příkazy. Více informací naleznete v tématu „Aktualizace Adobe AIR pro
program Flash CS3 Professional“ na stránce 13. Pokud používáte aplikaci Flash CS4, vyberte položky Soubor >
Nastavení AIR. Další informace viz část Publikování pro prostředí Adobe AIR v dokumentu Používání programu
Flash.)
ADT je programem jazyka Java, který můžete spustit z příkazového řádku nebo z nástroje pro vyvíjení, například Ant.
Sady SDK AIR a Flex obsahují skripty příkazového řádku, které pro vás spustí program Java.
Zabalení instalačního souboru AIR
Každá aplikace AIR musí mít minimálně soubor deskriptoru aplikace a hlavní soubor SWF nebo HTML. Jakékoliv
datové zdroje jiných nainstalovaných aplikací musí být také zabaleny do souboru AIR.
Všechny soubory instalátoru AIR musí být podepsány pomocí digitálního certifikátu. Instalátor AIR používá podpis
k ověření, zda váš soubor aplikace nebyl od podepsání pozměněn. Můžete použít certifikát podpisu kódu z certifikační
autority, například VeriSign nebo Thawte, nebo certifikát s vlastním podpisem. Certifikát vydaný důvěryhodnou
autoritou poskytuje uživateli vaší aplikace určité záruky vaší totožnosti jako vydavatele. Certifikát s vlastním podpisem
nelze použít k ověření vaší autority jako autora podpisu. Tato nevýhoda také zeslabuje záruku, že balík nebyl
pozměněn, protože legitimní instalační soubor mohl být před dodáním uživateli nahrazen falzifikátem).
Soubor AIR můžete zabalit a podepsat v jediném kroku pomocí příkazu ADT -package. Pomocí příkazu preparemůžete také vytvořit dočasný nepodepsaný balík a tento přechodný balík můžete podepsat pomocí příkazu sign v samostatném kroku.
Při podepisování balíku instalace připojit ADT automaticky autoritu časové známky pro ověření času. Informace
časové známky je obsažena v souboru AIR. Soubor AIR, který obsahuje ověřenou časovou známku, lze nainstalovat
kdykoliv v budoucnosti. Jestliže se ADT nemůže připojit k serveru časové známky, je zabalení zrušeno. Volbu časové
známky můžete potlačit, ale bez časové známky nelze aplikaci AIR po vypršení certifikátu použitého k podepsání
instalačního souboru nainstalovat.
Jestliže vytváříte balík k aktualizaci stávající aplikace AIR, musí být podepsán se stejným certifikátem jako je původní
aplikace nebo s certifikátem, který má stejnou totožnost. Pro získání stejné totožnosti musí mít dva certifikáty stejný
rozlišovací název (všechna pole s informacemi se shodují) a stejný řetězec certifikátu a kořenový certifikát. Proto
můžete použít uznávaný certifikát od certifikační autority, pokud nezměníte žádnou z určujících informací.
Jako v případě AIR 1.1 můžete migrovat aplikaci pro použití nového certifikátu pomocí příkazu -migrate. Přesunutí
certifikátu vyžaduje podepsání souboru AIR pomocí nového i starého certifikátu. Přesun certifikátu vám umožňuje
provést změnu z certifikátu s vlastním podpisem na komerční certifikát podpisu kódu nebo z jednoho certifikátu s
vlastním podpisem či komerčního certifikátu na jiný. Při přesunu certifikátu nemusí vaši stávající uživatelé
odinstalovat svou stávající aplikaci před instalováním nové verze. Podpisy přesunutí jsou implicitně opatřeny časovou
známkou.
Poznámka: Nastavení v souboru deskriptoru aplikace určuje identitu aplikace AIR a její výchozí cestu instalace. Viz
„Struktura souboru deskriptoru aplikace“ na stránce 42.
Balík a podpis souboru AIR v jednom kroku
❖ Použijte příkaz -package s následující syntaxí (na jediném příkazovém řádku):
adt -package SIGNING_OPTIONSair_fileapp_xml [file_or_dir | -C dirfile_or_dir | -e file dir
...] ...
SIGNING_OPTIONS Možnosti podpisu určují úložiště klíčů obsahující osobní klíč a certifikát použitý k
podepsání souboru AIR. Pro podepsání aplikace AIR pomocí certifikátu s vlastním podpisem vygenerovaného
programem ADT můžete použít následující možnosti:
-storetype pkcs12 -keystore certificate.p12
V tomto příkladu je certificate.p12 názvem souboru úložiště klíčů. (program ADT vás požádá o heslo, protože není
zadáno na příkazovém řádku.) Možnosti podpisu jsou kompletně popsány v tématu „Možnosti podpisu
příkazového řádku programu ADT“ na stránce 310.
air_file Název souboru AIR, který je vytvořen.
app_xml Cesta k souboru deskriptoru aplikace. Cestu lze určit relativně k aktuálnímu adresáři nebo jako absolutní
cestu. (Soubor deskriptoru aplikace je v souboru AIR přejmenován na „application.xml“.)
file_or_dir Soubory a slovníky, které budou zabaleny v souboru AIR. Lze určit jakýkoliv počet souborů a slovníků,
oddělených prázdným prostorem. Jestliže uvedete adresář, budou všechny soubory a podadresáře, s výjimkou
skrytých souborů, přidány do balíku. (Pokud je určen soubor deskriptoru aplikace, přímo nebo pomocí zástupného
znaku či doplnění aplikace, je ignorován a není podruhé přidán do balíku.) Určené soubory a slovníky musí být
umístěny v aktuálním adresáři nebo jednom z jeho podadresářích. Pomocí volby -C změňte aktuální adresář.
Důležité: Zástupné znaky nelze použít v argumentech file_or_dir po volbě –C. (Skořepiny příkazu rozšiřují
zástupné znaky před předání argumentů do programu ADT a tento program vyhledá soubory ve špatném umístění.)
Pro nahrazení stávajícího adresáře můžete nicméně použít znak tečky „.“. Například „-C assets .“ zkopíruje vše v
adresáři datového zdroje, včetně všech dílčích adresářů, až ke kořenové úrovni balíku aplikace.
-C dir Změní pracovní adresář na hodnotu dir před zpracováním dalších souborů a adresářů přidaných do balíku
aplikace. Soubory nebo adresáře jsou přidány ke kořenům balíku aplikace. Volbu –C lze použít tolikrát, kolikrát si
přejete, pro zahrnutí souborů s více bodů do systému souborů. Je-li pro dirurčena relativní cesta, je cesta vždy
získána z původního pracovního adresáře.
Když program ADT zpracovává soubory a adresáře obsažené v balení, uloží se relativní cesta mezi aktuálním
adresářem a cílovými soubory. Tyto cesty jsou při instalaci balíku rozšířeny do struktury adresáře aplikace. Proto
určením -C release/bin lib/feature.swf umístíte soubor release/bin/lib/feature.swf do podadresáře
lib kořenové složky aplikace.
-e file dir Umístí určený soubor do určeného adresáře balíku.
Poznámka: Element <content> souboru deskriptoru aplikace musí určit finální umístění hlavního souboru aplikace
ve stromové struktuře adresáře balíku aplikace.
Příklady programu ADT
Soubory aplikace specifické pro balík v aktuálním adresáři:
adt –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.swf components.swc
Všechny soubory a podadresáře balíku v aktuálním pracovním adresáři:
adt –package -storetype pkcs12 -keystore ../cert.p12 myApp.air myApp.xml .
Poznámka: Soubor úložiště klíčů obsahuje osobní klíč použití k podepsání vaší aplikace. Certifikát podpisu nikdy
nevkládejte do balíku AIR! Jestliže v příkazu programu ADT použijete zástupné znaky, uložte soubor úložiště klíčů do
odlišného umístění, aby nebyl zahrnut do balíku. V tomto příkladu je soubor úložiště klíčů, cert.p12, umístěn do
nadřazeného adresáře.
Zabalení pouze hlavních souborů a obrazů podadresáře:
adt –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml myApp.swf images
Zabalení souboru application.xml a hlavního souboru SWF umístěného v pracovním adresáři(release/bin):
adt –package -storetype pkcs12 -keystore cert.p12 myApp.air release/bin/myApp.xml –C
release/bin myApp.swf
Zabalení datových zdrojů z více než jednoho místa v systému vývoje souborů. V tomto příkladu jsou datové zdroje
aplikace před zabalením umístěny v následujících složkách:
/devRoot
/myApp
/release
/bin
myApp.xml
myApp.swf
/artwork
/myApp
/images
image-1.png
...
image-n.png
/libraries
/release
/libs
lib-1.swf
...
lib-n.swf
AIRAliases.js
Spuštění následujícího příkazu ADT z adresáře /devRoot/myApp:
adt –package -storetype pkcs12 -keystore cert.p12 myApp.air release/bin/myApp.xml
–C release/bin myApp.swf
–C ../artwork/myApp images
–C ../libraries/release libs
Má za následek následující strukturu balíku:
/myAppRoot
/META-INF
/AIR
application.xml
hash
myApp.swf
mimetype
/images
image-1.png
...
image-n.png
/libs
lib-1.swf
...
lib-n.swf
AIRAliases.js
Spuštění ADT jako programu jazyka Java (bez nastavení cesty třídy):
java –jar {AIRSDK}/lib/ADT.jar –package -storetype pkcs12 -keystore cert.p12 myApp.air
myApp.xml myApp.swf
Spuštění ADT jako programu jazyka Java (cesta třídy Java je nastavena tak, aby obsahovala balík ADT.jar):
java com.adobe.air.ADT –package -storetype pkcs12 -keystore cert.p12 myApp.air myApp.xml
myApp.swf
Možnosti podpisu příkazového řádku programu ADT
Program ADT používá funkci Java Cryptography Architecture (JCA) k získání přístupu k osobním klíčům a
certifikátům pro podpis aplikací AIR. Možnosti podpisu určují úložiště klíčů a osobní klíče a certifikáty v daném
úložišti klíčů.
Úložiště klíčů musí obsahovat osobní klíč i asociovaný řetězec certifikátu. Řetězec certifikátu se používá k zavedení ID
vydavatele pro danou aplikaci. Jestliže certifikát podpisu provede propojení k důvěryhodnému certifikátu v počítači,
běžný název certifikátu se zobrazí jako název vydavatele v dialogovém okně instalace AIR.
Program ADT vyžaduje, aby certifikát odpovídal normě x509v3 (RFC3280) a obsahoval příponu rozšířeného použití
klíče (Extended Key Usage) s řádnou hodnotou pro podepsání kódu. Omezení v rámci certifikátu jsou respektována a
mohou vyloučit použití některých certifikátů pro podepsání aplikací AIR.
Poznámka: Je-li to vhodné, používá program ADT nastavení proxy prostředí runtime jazyka Java pro připojení ke
zdrojům aplikace Internet ke kontrole seznamu zrušených certifikátů a získání časových známek. Jestliže používáte
program ADT a při připojování ke zdrojům na internetu dojde k obtížím a vaše síť vyžaduje specifické nastavení proxy,
bude třeba nakonfigurovat nastavení proxy JRE.
Určení možnosti podpisu AIR
❖ K určení možností podpisu programu ADT pro příkazy -package a -prepare použijte následující syntaxi:
[-alias aliasName] [-storetype type] [-keystore path] [-storepass password1] [-keypass
password2] [-providerName className] [-tsa url]
-alias aliasName —Alias klíče v úložišti klíčů. Určení alias není nutné, jestliže úložiště klíčů obsahuje pouze jediný
certifikát. Není-li určen žádný alias, použije program ADT první klíč v úložišti klíčů.
Ne všechny aplikace pro správu úložiště klíčů umožňují přiřazení alias certifikátům. Například při používání
úložiště klíčů OS Windows použijte jako alias rozlišující název certifikátu. Můžete použít utilitu Java Keytool pro
zobrazení dostupných certifikátů, takže budete moct určit alias. Například spuštění příkazu:
keytool -list -storetype Windows-MY
vytvoří pro certifikát výstup podobný následující ukázce:
CN=TestingCert,OU=QE,O=Adobe,C=US, PrivateKeyEntry,
Certificate fingerprint (MD5): 73:D5:21:E9:8A:28:0A:AB:FD:1D:11:EA:BB:A7:55:88
Pro odkázání tohoto certifikátu na příkazovém řádku ADT nastavte alias na:
CN=TestingCert,OU=QE,O=Adobe,C=US
V OS Mac X je alias certifikátu v řetězci klíčů název zobrazený v aplikaci přístupu k řetězci klíčů.
-storetype type —Typ úložiště klíčů určený implementací úložiště. Výchozí implementace úložiště klíčů zahrnutá
ve většině instalací jazyka Java podporuje typy JKS a PKCS12. Java 5.0 obsahuje podporu pro typ PKCS11 pro získání
přístupu k úložištím klíčů na známkách hardware a typ Keychain pro získání přístupu k řetězci klíčů OS Mac X.
Java 6.0 obsahuje podporu pro typ MSCAPI (pro OS Windows). Jestliže byly nainstalovány a nakonfigurovány jiní
poskytovatelé JCA, mohou být k dispozici další typy úložišť klíčů. Jestliže nebyly určeny žádné typy úložiště klíčů,
použije se výchozí typ pro výchozího poskytovatele JCA.
Typ uložení
Formát úložiště klíčů
Minimální verze Java
JKS
Soubor úložiště klíčů Java
(.keystore)
1.2
PKCS12
soubor PKCS12 (.p12 nebo
.pfx)
1.4
PKCS11
Známka hardware
1.5
Úložiště řetězce
klíčů
Úložiště řetězce klíčů pro
OS Mac X
1.5
Windows-MY
nebo WindowsROOT
MSCAPI
1.6
-keystore path —Cesta k souboru úložiště klíčů pro typy uložení vycházející ze souborů.
-storepass password1 —Heslo vyžadované pro přístup k úložišti klíčů. Není-li určeno, program ADT požádá o
zadání hesla.
-keypass password2 —Heslo vyžadované pro přístup k osobnímu klíči, který je použit pro podepsání aplikace AIR.
Není-li určeno, program ADT požádá o zadání hesla.
-providerName className —Poskytovatel JCA pro určený typ úložiště klíčů. Není-li určen, použije program ADT
výchozího poskytovatele pro daný typ úložiště klíčů.
-tsa url —Určuje URL serveru časové známky vyhovujícímu normě RFC3161-pro udělení časové známky
digitálnímu podpisu. Není-li určena žádná URL, použije se výchozí server časové známky poskytnutý autoritou
Geotrust. Když je podpis aplikace AIR opatřen časovou známkou, aplikace může být stále instalována i po vypršení
certifikátu podpisu, protože časová známka ověří, že certifikát byl v době podpisu platný.
Jestliže se program ADT nemůže připojit k serveru časové známky, je podepisování zrušeno a nebude vytvořen
žádný balík. Pro vypnutí získávání časové známky určete -tsa none. Nicméně aplikace AIR zabalená bez časové
známky nemůže být nainstalována po vypršení certifikátu podpisu.
Poznámka: Možnosti podpisu jsou podobné ekvivalentním možnostem utility Java Keytool. Utilitu Keytool můžete
použít k prozkoumání a správě úložišť klíčů v systému Windows. Utilitu zabezpečení Apple® lze za tímto účelem také
použít v OS Mac X.
Příklady možností podepsání
Podepsání se souborem .p12:
-storetype pkcs12 -keystore cert.p12
Podepsání s výchozím úložištěm klíčů Java:
-alias AIRcert -storetype jks
Podepsání se specifickým úložištěm klíčů Java:
-alias AIRcert -storetype jks -keystore certStore.keystore
Podepsání s řetězcem klíčů OS Mac X:
-alias AIRcert -storetype KeychainStore -providerName Apple
Podepsání s úložištěm klíčů OS Windows:
-alias cn=AIRCert -storeype Windows-MY
Podepsání známkou hardware (rady pro konfiguraci Java k použití známky a správnou hodnotu providerName
naleznete v pokynech výrobce známky):
-alias AIRCert -storetype pkcs11 -providerName tokenProviderName
Podepsání bez vložení časové známky:
-storetype pkcs12 -keystore cert.p12 -tsa none
Vytvoření nepodepsaného přechodného souboru AIR pomocí programu ADT
K vytvoření nepodepsaného přechodného souboru AIR použijte příkaz -prepare. Přechodný soubor AIR musí být
podepsán použitím příkazu programu ADT -sign pro vytvoření platného instalačního souboru AIR.
Příkaz -prepare přebírá stejné příznaky a parametry jako příkaz -package(s výjimkou možností podpisu). Jediným
rozdílem je to, že výstupní soubor není podepsaný. Přechodný soubor je vygenerován s příponou názvu souboru: airi.
Pro podpis přechodného souboru AIR použijte příkaz programu ADT -sign. (Viz Podpis přechodného souboru AIR
pomocí programu ADT.)
Příklad ADT
adt –prepare unsignedMyApp.airi myApp.xml myApp.swf components.swc
Podpis přechodného souboru AIR pomocí programu ADT
Pro podpis přechodného souboru AIR pomocí programu ADT použijte příkaz -sign. Příkaz podpisu je funkční pouze
u přechodných souborů AIR (přípona airi). Soubor AIR nelze podepsat podruhé.
Pro podpis přechodného souboru AIR použijte příkaz programu ADT -prepare. (Viz „Vytvoření nepodepsaného
přechodného souboru AIR pomocí programu ADT“ na stránce 312.)
Podpis souboru AIRI
❖ Použijte příkaz ADT -sign s následující syntaxí:
adt -sign SIGNING_OPTIONSairi_fileair_file
SIGNING_OPTIONS Možnosti podpisu určují osobní klíč a certifikát použitý k podepsání souboru AIR. Tyto
možnosti podpisu jsou popsány v tématu „Možnosti podpisu příkazového řádku programu ADT“ na stránce 310.
airi_file Cesta k nepodepsanému přechodnému souboru AIR, který musí být podepsán.
air_file Název souboru AIR, který má být vytvořen.
Příklad ADT
adt –sign -storetype pkcs12 -keystore cert.p12 unsignedMyApp.airi myApp.air
Více informací naleznete v tématu „Digitální podepisování souboru AIR“ na stránce 285.
Podepsání souboru AIR pro změnu certifikátu aplikace
K aktualizaci stávající aplikace AIR pro použití nového certifikátu podpisu použijte příkaz programu ADT -migrate.
Přesun certifikátu může být užitečný v následujících situacích:
• Aktualizace z certifikátu s vlastním podpisem na certifikát vydaný certifikační autoritou
• Změna z certifikátu s vlastním podpisem, který brzy vyprší, na nový certifikát s vlastním podpisem.
• Změna z jednoho komerčního certifikátu na jiný, například při změně identity vaší společnosti.
Pro použití podpisu přesunu musí být původní certifikát stále platný. Jakmile certifikát vyprší, nelze podpis přesunu
použit. Uživatelé vaší aplikace budou muset odinstalovat stávající verzi před tím, než budou moct nainstalovat
aktualizovanou verzi. Všimněte si, že podpis přesunu je implicitně označen časovou známkou, takže aktualizace AIR
podepsané s podpisem přesunu zůstanou platné i po vypršení certifikátu.
Poznámka: Obvykle není třeba přesunout certifikát při obnovení komerčně vydaného certifikátu. Obnovený certifikát si
zachová stejnou identitu vydavatele jako certifikát původní, pokud nebyl změněn rozlišující název. Kompletní seznam
atributů certifikátu, které jsou použity k určení rozlišujícího názvu, naleznete v tématu „O identifikátorech vydavatele
AIR“ na stránce 286.
Chcete-li přesunout aplikaci pro použití nového certifikátu:
1 Vytvořte aktualizaci své aplikace
2 Zabalte a podepište aktualizovaný soubor AIR pomocí certifikátu nový
3 Znovu podepište soubor AIR certifikátem původní pomocí příkazu -migrate
Soubor AIR podepsaný pomocí příkazu -migrate lze použít k nainstalování nové verze aplikace i k aktualizaci
předcházejících verzí, včetně verzí podepsaných starým certifikátem.
Přesun aplikace AIR pro použití nového certifikátu
❖ Použijte příkaz ADT -migrate s následující syntaxí:
adt -migrate SIGNING_OPTIONSair_file_inair_file_out
SIGNING_OPTIONS Možnosti podpisu určují osobní klíč a certifikát použitý k podepsání souboru AIR. Tyto
možnosti musí určovat původní certifikát podpisu a jsou popsány v tématu „Možnosti podpisu příkazového řádku
programu ADT“ na stránce 310.
air_file_in Soubor AIR pro aktualizaci podepsaný novým certifikátem.
air_file_out Soubor AIR, který má být vytvořen.
Příklad ADT
adt –migrate -storetype pkcs12 -keystore cert.p12 myApp.air myApp.air
Více informací naleznete v tématu „Digitální podepisování souboru AIR“ na stránce 285.
Poznámka: Příklad -migrate byl přidán k programu ADT ve verzi AIR 1.1.
Vytvoření certifikátu s vlastním podpisem pomocí
programu ADT
Certifikáty s vlastním podpisem vám umožňují vytvořit platný instalační soubor AIR, ale vašim uživatelům poskytují
pouze omezené záruky bezpečnosti, protože věrohodnost certifikátů s vlastním podpisem nelze ověřit. Při instalaci
souboru AIR s vlastním podpisem je informace o vydavateli zobrazena uživateli jako Neznámé. Certifikát
vygenerovaný programem ADT je platný po dobu pěti let.
Jestliže vytvoříte aktualizaci pro aplikaci AIR, která byla podepsána vámi vytvořeným certifikátem, musíte stejný
certifikát použít k podepsání původních i aktualizovaných souborů AIR. Certifikáty vytvořené programem ADT jsou
vždy jedinečné, i při použití stejných parametrů. Jestliže si proto přejete vámi podepsané aktualizace pomocí
certifikátu vygenerovaného programem ADT, zachovejte původní certifikát v bezpečném umístění. Dále nebude
možné aktualizovaný soubor AIR vytvořit po vypršení původního certifikátu vygenerovaného programem ADT.
(Nové aplikace můžete publikovat s odlišným certifikátem, ale nikoliv však nové verze stejné aplikace.)
Důležité: Z důvodů omezení certifikátů s vlastním podpisem Adobe důrazně doporučuje používat pro podepisování
veřejně dostupných aplikací AIR komerční certifikáty od známé certifikační autority, například VeriSign nebo Thawte.
Certifikát a přiřazený osobní klíč vygenerovaný programem ADT jsou uloženy v souboru úložiště klíčů typu PKCS12.
Určené heslo je nastaveno na samotném klíči, nikoliv na úložišti.
Vygenerování digitálního certifikátu ID pro soubory AIR s vlastním podpisem.
❖ Použijte příkaz programu ADT -certificate (na jediném příkazovém řádku):
adt -certificate -cn name [-ou org_unit][-o org_name][-c country] key_typepfx_filepassword
-cn name Řetězec přiřazený jako běžné jméno nového certifikátu.
-ou org_unit Řetězec přiřazený jako organizační jednotka vydávající certifikát. (Volitelné.)
-o org_nameŘetězec přiřazený jako organizace vydávající certifikát. (Volitelné.)
-c countryKód země ISO-3166 obsahující dvě písmena. Certifikát není vygenerován, je-li zadán neplatný kód.
(Volitelné.)
key_typeTyp klíče, který bude pro certifikát použit. Buď „1024-RSA“ nebo „2048-RSA“.
pfx_file Cesta pro soubor certifikátu, který bude vygenerován.
password Heslo pro nový certifikát. Heslo je vyžadováno při podepisování souborů AIR tímto certifikátem.
Příklady vygenerování certifikátu
adt -certificate -cn SelfSign -ou QE -o "Example, Co" -c US 2048-RSA newcert.p12 39#wnetx3tl
adt -certificate -cn ADigitalID 1024-RSA SigningCert.p12 39#wnetx3tl
Pro použití těchto certifikátů k podepsání souborů AIR použijte následující možnosti podpisu s příkazy programu
ADT -package nebo -prepare:
-storetype pkcs12 -keystore newcert.p12 -keypass 39#wnetx3tl
-storetype pkcs12 -keystore SigningCert.p12 -keypass 39#wnetx3tl
Použití nástroje Apache Ant s nástroji sady SDK
Toto téma obsahuje příklady použití vývojového nástroje Apache Ant k testování a balení aplikací AIR.
Poznámka: Tyto informace nejsou určeny jako kompletní přehled nástroje Apache Ant. Dokumentaci nástroje Ant
naleznete na těchto odkazech: http://Ant.Apache.org.
Používání nástroje Ant pro jednoduché projekty
Tento příklad ukazuje vývoj aplikace AIR pomocí nástroje Ant a nástrojů příkazového řádku AIR. Jednoduchá
struktura projektu je použita u všech souborů uložených v jediném adresáři.
Pro usnadnění opětovného použití vývojového skriptu používají tyto příklady několik definovaných vlastností. Jedna
množina vlastností definuje nainstalovaná umístění nástrojů příkazového řádku:
<property name="SDK_HOME" value="C:/Flex3SDK"/>
<property name="ADL" value="${SDK_HOME}/bin/adl.exe"/>
<property name="ADT.JAR" value="${SDK_HOME}/lib/adt.jar"/>
Druhá množina vlastností je specifická pro každý projekt. Tyto vlastnosti předpokládají konvenci názvů, kde jsou
deskriptor aplikace a soubory AIR pojmenovány na základě kořenového zdrojového souboru. Jiné konvence jsou
snadno podporované.
<property
<property
<property
<property
<property
<property
name="APP_NAME" value="ExampleApplication"/>
name="APP_ROOT" value="."/>
name="APP_DESCRIPTOR" value="${APP_ROOT}/${APP_NAME}-app.xml"/>
name="AIR_NAME" value="${APP_NAME}.air"/>
name="STORETYPE" value="pkcs12"/>
name="KEYSTORE" value="ExampleCert.p12"/>
Iniciace programu ADL pro testování aplikace
Pro spuštění aplikace pomocí programu ADL použijte úlohu exec:
<target name="test" depends="compile">
<target name="test">
<exec executable="${ADL}">
<arg value="${APP_DESCRIPTOR}"/>
</exec>
</target>
Iniciace programu ADT k zabalení aplikace
K zabalení aplikace použijte úlohu jazyka Java pro spuštění nástroje adt.jar:
<target name="package">
<java jar="${ADT.JAR}" fork="true" failonerror="true">
<arg value="-package"/>
<arg value="-storetype"/>
<arg value="${STORETYPE}"/>
<arg value="-keystore"/>
<arg value="${KEYSTORE}"/>
<arg value="${AIR_NAME}"/>
<arg value="${APP_NAME}.swf"/>
<arg value="*.png"/>
</java>
</target>
Jestliže má vaše aplikace více souborů k zabalení, můžete přidat další prvky <arg>.
Použití nástroje Ant pro složitější projekty
Struktura adresáře typické aplikace je složitější než jediný adresář. Následující příklad ukazuje vývojový soubor
použitý ke kompilaci, testování a zabalení aplikace AIR, který má praktičtější projektovou strukturu adresářů.
Tento ukázkový projekt ukládá zdrojové soubory aplikace a jiné datové zdroje jako soubory ikon do adresáře src.
Vývojový skript vytvoří následující pracovní adresáře:
build Uchovává verze uvedení (bez ladění) kompilovaných souborů SWF.
debug Uchovává nezabalené laděné verze aplikace, včetně libovolných kompilovaných souborů SWF a souborů
datových zdrojů. Utilita ADL spustí aplikaci z tohoto adresáře.
release Uchovává finální balík AIR
Nástroje AIR vyžadují použití některých dodatečných možností, pokud pracujete se soubory mimo aktuální pracovní
adresář:
Testování Druhý argument předaný programu ADL určuje kořenový adresář aplikace AIR. Pro určení kořenového
adresáře aplikace je k úloze testování přidán následující řádek:
<arg value="${debug}"/>
Balení Balení souborů z podadresářů, které by neměly být součástí finální struktury balíku, vyžaduje použití příkazu
-C pro změnu pracovního adresáře ADT. Když použijete příkaz -C, budou soubory a adresáře v novém pracovním
adresáři zkopírovány na kořenovou úroveň souboru balíku AIR. Proto -C build file.png zkopíruje file.png do
kořene adresáře aplikace. Podobně -C assets icons zkopíruje složku ikon na kořenovou úroveň a zkopíruje také
všechny soubory a adresáře uvnitř této složky. Například následující sekvence řádků v úloze balení přidá adresář s
ikonami přímo na kořenovou úroveň souboru balíku aplikace:
<arg value="-C"/>
<arg value="${assets}"/>
<arg value="icons"/>
Poznámka: Jestliže potřebujete přesunout mnohou zdrojů a datových zdrojů do odlišných souvisejících umístění, je
obvykle jednodušší seřadit je do přechodného adresáře pomocí úloh nástroje Ant, než vytvořit složitý seznam argumentů
pro program ADT. Jakmile jsou vaše zdroje zorganizovány, můžete k jejich zabalení použít jednoduchý seznam
argumentů programu ADT.
<project>

<property name="SDK_HOME" value="C:/Flex3SDK"/>
<property name="ADL" value="${SDK_HOME}/bin/adl.exe"/>
<property name="ADT.JAR" value="${SDK_HOME}/lib/adt.jar"/>

<property name="PROJ_ROOT_DIR" value="."/>
<property name="APP_NAME" value="ExampleApplication"/>
<property name="APP_ROOT_DIR" value="."/>
<property name="APP_ROOT_FILE" value="${APP_NAME}.swf"/>
<property name="APP_DESCRIPTOR" value="${PROJ_ROOT_DIR}/${APP_NAME}-app.xml"/>
<property name="AIR_NAME" value="${APP_NAME}.air"/>
<property name="release" location="${PROJ_ROOT_DIR}/release"/>
<property name="assets" location="${PROJ_ROOT_DIR}/src/assets"/>
<property name="STORETYPE" value="pkcs12"/>
<property name="KEYSTORE" value="ExampleCert.p12"/>
<target name="init" depends="clean">
<mkdir dir="${release}"/>
</target>
<target name="test">
<exec executable="${ADL}">
<arg value="${APP_ROOT_DIR}"/>
</exec>
</target>
<target name="package" depends="init">
<java jar="${ADT.JAR}" fork="true" failonerror="true">
<arg value="-package"/>
<arg value="-storetype"/>
<arg value="${STORETYPE}"/>
<arg value="-keystore"/>
<arg value="${KEYSTORE}"/>
<arg value="${release}/${AIR_NAME}"/>
<arg value="-C"/>
<arg value="${APP_ROOT_DIR}"/>
<arg value="${APP_ROOT_FILE}"/>
<arg value="-C"/>
<arg value="${assets}"/>
<arg value="icons"/>
</java>
</target>
<target name="clean" description="clean up">
<delete dir="${release}"/>
</target>
</project>
318
Rejstřík
Symboly
? znak (otazník), v nepojmenovaných
parametrech SQL 168
Čísla
1024-RSA 314
128bitové šifrování AES-CBC 190
2048-RSA 314
AIR Developer Tool (ADT)
možnosti podpisu 310
argumenty příkazového řádku,
zachycení 260
soubory AIRI 312
asociace typu souboru 267
vytvoření certifikátů s vlastním
podpisem 314
asociace typů souborů 49, 260
Ajax
podpora v karanténě zabezpečení
aplikace 32
zabezpečení 32
Á
AC_RuntimeActiveContent.js 278
aktivace oken 61, 67
Acrobat 194, 245
aktivita uživatele, zjišťování 268
Action Message Format (AMF) 125
aktivní okno 66
ActionScript
aktivované položky nabídky 82
aktivita (uživatele), zjišťování 268
asynchronní programování
databáze 161, 164, 181
systém souborů 98
XMLHttpRequests 212
atribut allowCrossDomainXHR (elementy
frame a iframe) 196, 202
atribut documentRoot (elementy frame a
iframe) 194, 202, 222
atribut documentRoot (prvky frame a
iframe) 30
objekty zobrazení 65
aktualizace aplikací AIR 48, 291
atribut minimumPatchLevel (soubor
deskriptoru aplikace) 43
vytváření křížových skriptů
JavaScript 214
AMF (Action Message Format) 148, 151
atribut ondominitialize 203
aplikace
atribut s upravitelným obsahem
(HTML) 133
Adobe Acrobat Developer Center 246
Adobe AIR
Viz aplikace AIR
Aplikace AIR
aktualizace 23
aktualizace 23, 48
instalace 1, 23
asociace typu souboru 267
nové funkce 50
asociace typů souborů 49
odinstalace 2
cesta instalace 44
úvod 7
ikony 48
atribut sandboxRoot (elementy frame a
iframe) 194, 197, 202, 222
atributy documentRoot (prvky frame a
iframe) 30
automatické spuštění (spuštění aplikace AIR
při přihlášení) 262
Adobe Media Player 249
informace o autorských právech 46
Adobe Reader 194, 245
instalace 23
adresář aplikace 100
verze 44, 268
adresář dokumenty 100
vyvolání prohlížeče 49
bitmapové obrazy, nastavení pro ikony 93
adresář home 100
zjištění instalace 282
bitmapy
Adresář Moje dokumenty (Windows) 100
aplikace AIR
B
binární data
Viz bytová pole
podpora kopírování a vkládání 137
adresář plochy 100
aktualizace 291
Adresář Program Files (OS Windows) 276
asociace typů souborů 260
adresář uložení dat aplikace 25, 100, 104
distribuce 276
poloha v nich 149
adresář volitel dialogová okna 102
instalace 276
pořadí bytů 150
adresáře 100, 107
nastavení 42, 43, 266
velikost 149
podpora tažení 123, 131
bytová pole
kopírování 108
odinstalování 26
odkazování 100
spouštění 259
odstraňování 109, 112
spuštění 276, 283
Č
časové známky 286
přesouvání 108
ukončení 259
certifikační autority (CA) 285
vypsání 108
verze 291
certifikáty
vytváření 108
vyvolání 259
autority (CA) 41
vyvolání aplikací 260
zavírání 259
formáty 286
AIR Debug Launcher (ADL)
kódy ukončení a chyb 306
aplikační karanténa 194, 195, 207, 208, 209,
212, 222
možnosti příkazového řádku programu
ADT 310
AppInstallDisabled (Nastavení registru
Windows) 26
podepisování kódu 41
podepisování souborů AIR 285
Rejstřík
přesunutí 288, 313
vytváření 162
řetězce 289
zabezpečení 168
vypršení 286
změna dat 177
změna 288, 313
databáze v paměti 162
Certifikáty Authenticode od společnosti
Microsoft 286
datové typy, databáze 181
Certifikáty pro vývojáře AIR 286
Digitální ID Microsoft Authenticode 286
Certifikáty pro vývojáře Apple 286
Digitální ID pro podpis Sun Java 286
Certifikáty pro vývojáře JavaSoft 286
digitální podpisy 285, 307, 310
certifikáty s vlastním podpisem 41, 285, 314
distribuce aplikací AIR 276
Certifikáty Thawte 285, 286
dočasné adresáře 108
Certifikáty Verisign 285, 286
dočasné soubory 112
cesty (soubor a adresář) 104
dokumentace aplikace Flash 9
cesty, relativní 104
dokumentace jazyka ActionScript 9
default_badge.html 278
dokumentace společnosti Adobe 9
Ch
Chod aplikace AIR
aktualizace 23
chod programu AIR
nové funkce 50
Clipboard (Schránka) 198
CSS
přístup ke stylům HTML z jazyka
ActionScript 220
rozšíření prostředí AIR 205
čtení souborů 112
Ď
databáze
asynchronní režim 161
chyby 178
identifikátory řádku 177
dokumentace, související 9
DOM HTML a nativní okna 55
DPAPI (přidružení šifrovaných dat k
uživatelům) 190
DRM 249
oprávnění 255
dynamické generování kódu 31
É
element allowBrowserInvocation (soubor
deskriptoru aplikace) 49, 259, 262
Element customUpdateUI (soubor
element customUpdateUI (soubor
deskriptoru aplikace) 48, 259
Element fileTypes (soubor deskriptoru
aplikace) 267
mazání dat 177
element fileTypes (soubor deskriptoru
aplikace) 49
načítání dat 169
element ID (soubor deskriptoru aplikace) 44
o 158
element ID (třída NativeApplication) 266
pole 159
element ikony (soubor deskriptoru
aplikace) 48
použití pro 158
primární klíče 176, 177
připojení 164
řádky 159
sloupce 159
soubory 158
struktura 159
synchronní režim 161
tabulky 159, 163
třídy použité s 159
typování dat 168, 181
v paměti 162
více, práce s 178
výkon 168
element initialWindow (soubor deskriptoru
aplikace) 47, 55
element installFolder (soubor deskriptoru
aplikace) 46
element maximalizace (soubor deskriptoru
aplikace) 48
element maxSize (soubor deskriptoru
aplikace) 48
element minimalizace (soubor deskriptoru
aplikace) 48
element názvu souboru (soubor deskriptoru
aplikace) 44
element obsahu (soubor deskriptoru
aplikace) 47
element popisu (soubor deskriptoru
aplikace) 45
element programMenuFolder (soubor
element průhlednosti (soubor deskriptoru
aplikace) 47
element šířky (soubor deskriptoru
aplikace) 47
element titulu (soubor deskriptoru
aplikace) 47
element verze (soubor deskriptoru
aplikace) 44
element viditelnosti (soubor deskriptoru
aplikace) 47
element výšky (soubor deskriptoru
aplikace) 47
element x (soubor deskriptoru aplikace) 47
element y (soubor deskriptoru aplikace) 47
element změny velikosti (soubor
elementy frame 194, 196, 202
elementy iframe 194, 196, 202
Endian.BIG_ENDIAN 150
Endian.LITTLE_ENDIAN 150
F
Flash Media Rights Management Server 249
Flash Player 50, 192, 195, 213
Flex
podpora přetažení 125
FMRMS (Flash Media Rights Management
Server) 249
formát GZIP 151
formát souborů ZIP 153
formát SVG (scalable vector graphics) 195
formáty dat, Schránka 143
funkce (JavaScript)
definice 32
konstruktor 211
literály 32
Funkce AC_FL_RunContent() (v
default_badge.html) 278
funkce eval() 28, 31, 196, 208, 209
funkce setInterval() 32, 201, 211
element minSize (soubor deskriptoru
aplikace) 48
funkce setTimeout() 32, 201, 211
element názvu (soubor deskriptoru
aplikace) 45
funkce vyvolání z prohlížeče 262
funkce vyvolání prohlížeče 49
Rejstřík
G
gesto tažení dovnitř 123, 127
informace o autorských právech aplikace
AIR 46
konstruktory Function (v jazyce
JavaScript) 196
gesto tažení ven 123, 125
instalace
kontextové nabídky 78, 84
H
hesla
instalace aplikací AIR 276
modul runtime prostředí AIR 1
nastavení pro zašifrovaný multimediální
obsah 249
hlavní obrazovka 75
HTML
HTML 85
kopírování a vkládání
HTML 139, 198
J
Java Cryptography Architecture (JCA) 310
klávesové zkratky 141
JavaScript
příkazy nabídky 141
odložené vykreslení 145
chybové události 225
režimy přenosu 144
DOM, přístup z jazyka ActionScript 216
chyby 208, 216, 226, 229
výchozí položky nabídky (Mac OS) 142
karantény 195
modul runtime prostředí AIR a 192
kopírování adresářů 108
kopírování a vkládání 139
PDF 246
kopírování souborů 110
načtení obsahu 207
podpora prostředí AIR 195
kořenové svazky 100
okna 61
koš (odstranění souboru) 112
podpora přetažení 123, 131
přístup k rozhraním API aplikace
AIR 212
překrytí obsahu SWF 63
programování 207
rolování 225
soubor AIRAliases.js 213
rozšíření prostředí AIR 202
události, zpracování 228
L
literály objektů (v jazyce JavaScript) 31
tisk 195
vytváření křížových skriptů
ActionScript 214
lokalizace 295
události 225
vložené objekty 194
zabezpečení 29, 194, 221
zásuvné moduly 194
zabezpečení 221
zamezení vzniku chyb zabezpečení 208
jmenný prostor XML (soubor deskriptoru
aplikace) 43
JSON 196
Í
ID aplikace 44
identifikátory vydavatele 266, 286
ikony
K
karanténa zabezpečení aplikace 26, 268
kurzor, účinky tažení 128, 132
lokální databáze
Viz databáze
lokální verze, výběr pro aplikaci 296
M
Mac OS
ikony proxy 59
panel nástrojů 59
animace 93
karanténa zabezpečení lokálnídůvěryhodná 26
manipulační program onload 31
aplikace 48
karanténa zabezpečení lokální-se-sítí 26
mazání adresářů 109
hlavní panel 67, 93
obrazy 93
karanténa zabezpečení lokální-se-systémem
souborů 26
metoda acceptDragDrop() (třída
NativeDragManager) 124, 128
odstranění 93
karantény 195, 221, 268
oznamovací oblast 93
karantény zabezpečení 26
metoda activate() (třída NativeWindow) 61,
66, 67
ukotvení 93, 94
klávesa Apple 81
metoda addChild() (třída Stage) 64
ikony doku 94
klávesa Ctrl 81
metoda addChildAt() (třída Stage) 64
podpora 93
klávesa Shift 81
Metoda attach() (třída SQLConnection) 178
poskakování 94
klávesové ekvivalenty příkazů nabídky 81
metoda bounce() (třída Icon) 94
klávesové zkratky
Metoda browseForDirectory() (třída
File) 102
ikony hlavního panelu 67
ikony hlavního panelu (Windows) 59
ikony hlavního panelu systému 79, 82
klávesové zkratky pro příkazy nabídky 81
ikony na hlavním panelu 93
knihy z nakladatelství Adobe Press 9
ikony oznamovací oblasti
kódy chyb
podpora 93
ikony proxy
Mac OS 59
ikony ukotvení
DRM 256
kódy ukončení (ADL) 306
kompilátor acompc 218
komprese deflate 151
minimalizace oken a ikony ukotvení 67
komprese ZLIB 151
nabídky 82
komprimování dat 151
maximalizace oken 48, 56, 68
Metoda browseForOpen() (třída File) 103
Metoda browseForSave() (třída File) 103
metoda clearData()
objekt ClipboardData 198
objekt DataTransfer 131, 199
metoda close()
třída NativeWindow 68
metoda close() (objekt Window) 55
metoda compress() (třída ByteArray) 151
Rejstřík
metoda copy() (třída
NativeApplication) 141
Metoda copyTo() (třída File) 110
metoda Loader.loadBytes() 39
metoda loadString() (třída
HTMLLoader) 207
Metoda createDirectory() (třída File) 108
metoda maximize() (třída
NativeWindow) 68
metoda createElement() (objekt
Document) 212
metoda minimize() (třída
NativeWindow) 68
metoda createRootWindow() (třída
HTMLLoader) 61, 63, 207
metoda moveTo()
Metoda createTempDirectory() (třída
File) 108, 112
Metoda moveTo() (třída File) 110
Metoda createTempFile() (třída File) 112
Metoda moveToTrash() (třída File) 112
Metoda deleteDirectory() (třída File) 109
Metoda moveToTrashAsync() (třída
File) 112
Metoda copyToAsync() (třída File) 110
Metoda deleteDirectoryAsync() (třída
File) 109
Metoda deleteFile() (třída File) 111
Metoda deleteFileAsync() (třída File) 111
metoda dispatchEvent() (třída
NativeWindow) 56
objekt Window 55
Metoda moveToAsync() (třída File) 110
Metoda
NativeApplication.setAsDefaultApplic
ation() 267
metoda open()
objekt Window 33, 61
metoda setAsDefaultApplication() (třída
metoda setData()
metoda Clipboard 145
objekt ClipboadData 198
objekt DataTransfer 131, 133, 199
metoda setDataHandler() (třída
Clipboard) 145
metoda setDragImage() (vlastnosti
dataTransfer události tažení
HTML) 131
metoda
(třída NetStream) 250, 252
metoda startMove() (třída
NativeWindow) 70
metoda startResize() (třída
NativeWindow) 70
metoda uncompress() (třída ByteArray) 151
Metoda update() (třída Updater) 291
metoda display() (třída NativeMenu) 88
objekt Window (Okno) 201
metoda doDrag() (třída
NativeDragManager) 124, 125, 128
třída SQLConnection 161
metoda open() (třída SQLConnection) 162
Metoda execute() (třída SQLStatement) 167,
169, 176
metoda write() (objekt Document) 212
metoda openAsync() (třída
SQLConnection) 161, 162, 164
metoda writeBytes() (třída ByteArray) 148
metoda exit()
metoda orderBehind() (třída
NativeWindow) 67
metoda writeInt() (třída ByteArray) 148
třída NativeApplication 264
metoda write() (objekt Document
(Dokument)) 200
metoda writeFloat() (třída ByteArray) 148
Metoda getApplicationVersion() (soubor
air.swf) 282
metoda orderInBackOf() (třída
NativeWindow) 67
metoda writeln() (objekt Document
(Dokument)) 200
metoda getData()
metoda orderInFrontOf() (třída
NativeWindow) 67
metoda writeln() (objekt Document) 212
metoda orderToBack() (třída
NativeWindow) 67
metoda writeUTFBytes() (třída
ByteArray) 148
metoda orderToFront() (třída
NativeWindow) 67
Microsoft Windows
metoda getData() (třída Clipboard) 124
Metoda postMessage() (objekt PDF) 247
metoda getData() (vlastnosti dataTransfer
události tažení HTML) 131
minimalizace oken 48, 56, 67, 68
metoda print() (objekt Window
(Okno)) 195
místní důvěryhodná karanténa 195
Metoda getDefaultApplication() (třída
metoda readBytes() (třída ByteArray) 148
místní karanténa z hlediska systému
souborů 195
Metoda getDirectoryListing() (třída
File) 108
metoda readFloat() (třída ByteArray) 148
mnemotechnické znaky
metoda readInt() (třída ByteArray) 148
objekt ClipboardData 198
objekt DataTransfer 133, 199
třída Clipboard 128
událost kopírování a vložení v HTML 139
Metoda getDirectoryListingAsync() (třída
File) 108
Metoda getResult() (třída
SQLStatement) 176
metoda readUTFBytes() (třída
ByteArray) 148
modul runtime prostředí AIR
Metoda relativize() (třída File) 104
metoda getStatus() (soubor air.swf) 281
metoda removeEventListener() 229
Metoda isSetAsDefaultApplication() (třída
Metoda listRootDirectories() (třída File) 100
metoda loadBytes() (třída Loader) 39
položky nabídky 81
modifikační klávesy, položky nabídky 81
Metoda removeAsDefaultApplication()
(třída NativeApplication) 267
Metoda installApplication() (soubor
air.swf) 282
ikony hlavního panelu 59
metoda readObject() (třída ByteArray) 148
metoda getScreensForRectangle() (třída
Screen) 75
metoda hasEventListener() 230
metoda writeObject() (třída ByteArray) 148
metoda resetDRMVouchers() (třída
NetStream) 252
Metoda resolvePath() (třída File) 100
metoda restore() (třída NativeWindow) 68
Metoda setAsDefaultApplication() (třída
instalace 1
odinstalace 2
monitory
Viz obrazovky
mosty karantén 30, 34, 194, 195, 209, 221,
222
Rejstřík
Ň
nabídka
aplikace 90
neznámý název vydavatele (v instalátoru
aplikace AIR) 285
objekty RegExp, převádění mezi jazyky
ActionScript a JavaScript 219
normální okna 57
objekty zobrazení (ActionScript) 65
obnovení oken 56, 68
struktura 80
Nabídka Start (Windows) 46
Ó
objekt Canvas (Plátno) 197, 204
nabídky 78
objekt DataTransfer
události 90
aplikace 82
vlastnost types 133
obrazovky 74
hlavní 75
okna, přesouvání mezi 75
výčet 75
ikona hlavního panelu systému 82
objekt DataTransfer (přetažení HTML) 199
ikony hlavního panelu systému 79
objekt DataTransfer (tažení HTML) 131,
132, 133
komunikace pomocí kódu JavaScript 246
Objekt Document
přidávání do aplikací AIR 245
klávesové ekvivalenty 81
kontextové nabídky 84
oddělovače 84
okno 82, 90
podnabídky 80, 83
položka ukotvení 82
položky 80
příkazy kopírování a vkládání 141
rozbalovací 82, 88
struktura 79
tok událostí 80, 88
třídy pro práci s nimi 79
typy 79
ukotvení 79
vlastní 79
výchozí systémové 79
vytváření 82
XML, definování nabídek 86
nabídky aplikace 78, 90
vytváření 82
nabídky okna 78, 90
metoda write() 32
metoda writeln() 32
objekt Document
metoda createElement() 212
obsah PDF
načítání 246
známá omezení 248
obsah SWF
překrytí přes HTML 63
v HTML 194
metoda write() 212
oddělovače, nabídka 84
metoda writeln() 212
oddělovací znak cesty (systém souborů) 102
vlastnost designMode 133
odinstalace
vlastnost stylesheets 220
objekt Document (Dokument)
metoda wirte() 200
metoda wirtelin() 200
vlastnost designMode 200
Objekt Window
modul runtime prostředí AIR 2
odinstalování
aplikace AIR 26
odkazy na objekty
vlastnost childSandboxBridge 30
odkládací adresář aplikace 214
vlastnost parentSandboxBridge 30
odložené vykreslení (kopírování a
vkládání) 145
vlastnost runtime 28, 33
objekt Window
odstranění souborů 111, 112
metoda close() 55
odstraňování adresářů 109, 112
metoda moveTo() 55
okna 54
metoda open() 33, 61
aktivace 61
vlastnost htmlLoader 62, 207
aktivní 66, 67
vlastnost nativeWindow 55, 62
chování 57
vlastnost opener 62
inicializace 59
Nastavení registru Windows 26
vlastnost parent 62
maximalizace 48, 56, 68
nativní nabídky
maximální velikost 61
minimalizace 48, 56, 67, 68
vytváření 82
nabídky ukotvení 79
Nastavení FlashVars (pro používání
badge.swf) 278
Viz nabídky
nativní okna
objekt Window (Okno)
Viz okna
metoda open 201
nepravoúhlá 58
Název sloupce OID (SQL) 177
metoda print() 195
normální okna 57
Název sloupce ROWID (SQL) 177
objekt htmlLoader 193
obnovení 56, 68
název vydavatele 285
objekt nativeWindow 193
poloha 47
neaktivní čas (uživatele) 268
vlastnost htmlLoader 201
pomocná okna 57
neaplikační karantény 135, 194, 195, 208,
209, 222
vlastnost nativeWindow 201
pořadí 67
pořadí zobrazení 67
neaplikační karantény zabezpečení 28
pozadí 58
nepojmenované parametry (v příkazech
SQL) 168
minimální velikost 61
Objekt XMLHttpRequest 33
přemísťování 56, 70
objekt XMLHttpRequest 196, 202, 212
přesouvání 75
objekty Date, převádění mezi jazyky
ActionScript a JavaScript 219
průhlednost 47, 58
Rejstřík
režim změny velikosti plochy 61
pole (databáze) 159
Příkaz SELECT (SQL) 169, 181
skrývání 66
Příkaz UPDATE (SQL) 177
správa 66
Pole NSHumanReadableCopyright(OS
Mac) 46
styl 57
poloha oken 47
systémové prvky 57
příkazy, nabídka
Viz položky nabídky
příkazy, SQL 166
systémové prvky operačního systému 57
checked 82
tok událostí 56
enabled 82
třídy pro práci s nimi 55
klávesové ekvivalenty 81
typy 57
klávesové zkratky 81
události 72
připojení k databázi 164
úvodní 55
mnemotechnické znaky 81
velikost 47, 61
stavy 82
přípony (soubor), asociace s aplikací AIR 49,
267
viditelnost 47
výběr 89
vlastní systémové prvky 57
vytváření 83
vlastnosti 47
položky nabídky, data
primární klávesy
primární klíče
databáze 176
přípony (soubor), přiřazení k aplikaci
AIR 260
procházení
přiřazení 82
výběr adresáře 102
vzhled 57
pomocná okna 57
výběr souboru 103
zavírání 56, 68, 264
pořadí bytů 150
zjednodušená okna 57
pořadí bytů big-endian 150
změna velikosti 48, 56, 70
pořadí bytů little-endian 150
zobrazení 66
pořadí oken 67
vytváření 59, 65, 207
okna pracovní plochy
Viz okna
okna zobrazená na celou obrazovku 73
oprávnění
pro obsah s šifrováním DRM 255
pořadí zobrazení, okna 67
povolení, použití pro obsah s šifrováním
DRM 249
požadavky
Program AIR Developer Tool (ADT)
zabalení souboru AIR 307
Prohlášení o postupech certifikátu
(CPS) 289
protokol asfunction 28
průhledná okna 47, 58
pruhy nabídek 80
prvky iframe 30
vykreslení PDF 245
pozice myši během tažení 129
Ř
řádky (databáze) 159, 176
překlad aplikací 295
Registrace typů souborů 267
oprávnění vyžadovaná pro aktualizaci
runtime AIR nebo aplikaci AIR 23
přemísťování oken 56, 70
relativní cesty (mezi soubory) 104
přesouvání adresářů 108
osobní klíče 310
přesouvání souborů 110
řetězec klíčů (přidružení šifrovaných dat k
uživatelům) 190
otazník (?) znaky, v nepojmenovaných
parametrech SQL 168
přesun podpisu 288, 313
oprávnění vyžadovaná pro aktualizaci
runtime AIR nebo aplikace AIR 276,
283
ověřování dat, vyvolání aplikace 263
pozadí oken 58
přetažení
do obsahu neaplikační karantény (v
HTML) 135
RIA (Rich Internet Applications) 7
_ROWID_ column name (SQL) 177
rozbalovací nabídky 78, 88
vytváření 82
P
panel nástrojů (Mac OS) 59
efekty kurzoru 128, 132
rozměry, okna 47
formáty přenosu 123
Runtime AIR
parametry, v příkazech SQL 167
gesta 123
PDF
HTML 129, 199
podpora 194, 245
klávesy modifikátoru 128
pevná vazba šifrovaných dat 190
podpora Flex 125
podepisování kódu 41, 285
příbuzné třídy 123
podepisování souborů AIR 307
události v HTML 130
podnabídky 80, 83
podpisy
přesunutí 288, 313
Podpora databáze SQLLite 157
Viz také databáze
pojmenované parametry (v příkazech
SQL) 167
výchozí chování v HTML 130
úrovně dočasné opravy 268
zjišťování 268, 281
runtime AIR
úrovně záplaty 43
Š
schéma adresy URL v jazyce JavaScript 202
přihlášení do systému, spuštění aplikace
AIR 262
schéma app adresy URL 195
přihlášení, spuštění aplikace AIR 262
Schéma URL app 246
Příkaz CREATE TABLE (SQL) 163
schéma URL app 37, 39, 62, 214, 222
Příkaz DELETE (SQL) 177
Schéma URL app-storage 246
Příkaz INSERT (SQL) 181
schéma URL app-storage 25, 37, 39
schéma URL aplikace 104
Rejstřík
schéma URL app-support 222
schéma URL file 214
přesouvání 110
schéma URL javascript 32, 211
zápis 112
schéma URL souboru 37, 104
Soubory AIR
Ť
tabulky (databáze) 159
vytváření 163
tagy script 196, 200, 212, 213, 218
schéma URL uložení dat aplikace 104
podepisování 285
technická podpora 9
Schémata URL 104
zabalení 307
text
Schopnosti
vlastnost language 296
vlastnost languages 296
Schránka
Soubory AIRI
vytváření pomocí programu AIR
Developer Tool (ADT) 312
soubory cookie 198
tisk 195
Třída
formáty dat 143, 144
Soubory Info.plist (OS Mac) 46
Soubory P12 286
třída ApplicationDomain 215
systémová 137
Soubory PFX 286
třída BrowserInvokeEvent 262
zabezpečení 138
soubory SWF
třída ByteArray
serializace objektů 125
načtení pomocí tagu script 218
SQLStatement 159, 165
konstruktor 148
spouštění aplikací AIR 259
metoda compress() 151
správa digitálních práv 249
metoda readBytes() 148
spuštění aplikací AIR 276, 283
metoda readFloat() 148
SQL
metoda readInt() 148
serializované objekty
Seznam zrušených certifikátů (CRL) 289
seznamy souborů
seznamy stylů, HTML
práce v jazyce ActionScript 220
šifrovaná data, ukládání a načítání 190
šifrování 249
název sloupce OID 177
metoda readObject() 148
název sloupce ROWID 177
metoda readUTFBytes() 148
nepojmenované parametry (v
příkazech) 168
metoda uncompress() 151
o 159
parametry v příkazech 167
metoda writeBytes() 148
metoda writeFloat() 148
metoda writeInt() 148
šifrování dat 190
pojmenované parametry (v
příkazech) 167
šifrování obsahu videa 249
příkaz CREATE TABLE 163
metoda writeUTFBytes() 148
skrývání oken 66
příkaz DELETE 177
vlastnost bytesAvailable 149
sloupce (databáze) 159
příkaz INSERT 181
vlastnost length 149
Sloupce AUTOINCREMENT (SQL) 177
příkaz SELECT 169, 181
vlastnost position 149
sloupce INTEGER PRIMARY KEY
(SQL) 177
příkaz UPDATE 177
snímky 30
soubor AIRAliases.js 193, 213
Soubor AIRLocalizer.js 296
soubor API 98
soubor deskriptoru aplikace 42
soubor desktriptoru aplikace
čtení 266
soubor ID vydavatele 266
soubor JavaScript
AIRAliases.js 193
soubor volitel dialogová okna 103
soubory
čtení 112
databáze 158
kopírování 110
odkazování 102
příkazy 165, 166
_ROWID_ column name 177
metoda writeObject() 148
Třída Capabilities
vlastnost playerType 268
třída Clipboard
sloupce AUTOINCREMENT 177
metoda getData() 124, 128
sloupce INTEGER PRIMARY KEY 177
metoda setData() 145
třídy použité s 159
metoda setDataHandler() 145
typování dat 168, 181
vlastnost generalClipboard 137
start (systém), spuštění aplikace AIR 262
Třída ClipboardFormats 143
synchronní programování
Třída ClipboardTransferModes 144
databáze 161, 164, 181
třída CompressionAlgorithm 151
systém souborů 98
Třída ContextMenu 81, 84
XMLHttpRequests 212
třída ContextMenuEvent
systém souborů
zabezpečení 37
vlastnost contextMenuOwner 84
vlastnost mouseTarget 84
systém souborů API 98
Třída ContextMenuItem 81
systémové prvky operačního systému 57
třída Dictionary 213
okna HTML 61
třída DRMAuthenticateEvent 250, 254
třída DRMErrorEvent 250
odstranění 111, 112
kódy chyb 256
vlastnost subErrorID 256
Rejstřík
třída DRMStatusEvent 250
metoda createRootWindow() 61, 63, 207
vlastnost supportsDockIcon 93
třída EncryptedLocalStore 190
metoda loadString() 207
vlastnost supportsMenu 90
Třída File 99
události 225
vlastnost supportsSystemTrayIcon 93
getRootDirectories() 99
vlastnost height 207
třída NativeBoundsEvent 72
metoda browseForDirectory() 102
vlastnost paintsDefaultBackground 58, 64
třída NativeDragEvent
metoda browseForOpen() 103
vlastnost pdfCapability 245
metoda browseForSave() 103
vlastnost
runtimeApplicationDomain 215
metoda copyTo() 110
metoda copyToAsync() 110
vlastnost width 207
vlastnost clipboard 128
vlastnost dropAction 127, 128
třída NativeDragManager
metoda acceptDragDrop() 124, 128
metoda createDirectory() 108
Třída HTMLPDFCapability 245
metoda createTempDirectory() 108, 112
Třída HTMLUncaughtScriptException 226
třída NativeMenu 80, 88
metoda createTempFile() 112
třída Icon
třída NativeMenuItem 80
metoda deleteDirectory() 109
metoda deleteDirectoryAsync() 109
metoda deleteFile() 111
metoda bounce() 94
třída icon
vlastnost bitmaps 93
metoda doDrag() 124, 125, 128
data vlastnost data 82
vlastnost keyEquivalent 81
vlastnost keyEquivalentModifiers 81
metoda deleteFileAsync() 111
Třída InvokeEvent 49
vlastnost label 142
metoda getDirectoryListingAsync() 108
třída InvokeEvent 260
vlastnost mnemonicIndex 81
metoda getRootDirectories() 99
vlastnost arguments 260
metoda moveTo() 110
vlastnost currentDirectory 260
vlastnost podnabídky 80
metoda moveToAsync() 110
třída Keyboard 81
konstruktor 61
metoda moveToTrash() 112
třída Loader 62
metoda activate 66
metoda moveToTrashAsync() 112
třída LoaderContext
metoda activate() 61, 67
metoda relativize() 104
metoda resolvePath() 99
vlastnost applicationStorageDirectory 99
vlastnost creationDate 110
vlastnost creator 110
vlastnost desktopDirectory 99
vlastnost documentsDirectory 99
vlastnost encoding 107
vlastnost exists 110
vlastnost isDirectory 110
vlastnost lineEnding 107
vlastnost
allowLoadBytesCodeExecution 39
vlastnost applicationDomain 34
vlastnost securityDomain 34
třída LoaderInfo
vlastnost childSandboxBridge 35
Třída LocalConnection 277, 284
Třída NativeApplication
metoda getDefaultApplication() 267
metoda isSetAsDefaultApplication() 267
metoda addEventListener() 72
metoda close() 68
metoda dispatchEvent() 56
metoda maximize() 68
metoda minimize() 68
metoda orderBehind() 67
metoda orderInBackOf() 67
metoda orderInFrontOf() 67
metoda orderToBack() 67
metoda orderToFront() 67
metoda restore() 68
vlastnost modificationDate 110
metoda
removeAsDefaultApplication() 267
vlastnost name 110
metoda setAsDefaultApplication() 49
metoda startResize() 70
vlastnost nativePath 99, 110
vlastnost applicationDescriptor 266
události 72
vlastnost parent 110
vlastnost ID 266
vlastnost alwaysInFront 67
vlastnost separátor 107
vlastnost idleThreshold 268
vlastnost stage 64
vlastnost size 110
vlastnost lastUserInput 268
vlastnost systemChrome 57
vlastnost spaceAvailable 106
vlastnost publisherID 266, 286
vlastnost systemMaxSize 61
vlastnost type 110
vlastnost runtimePatchLevel 267
vlastnost systemMinSize 61
vlastnost url 99, 110
vlastnost runtimeVersion 267
vlastnost transparent 57, 58
vlastnost userDirectory 99
metoda startMove() 70
vlastnost type 57
třída File 98
metoda addEventListener() 259
vlastnost visible 61, 66
třída FileMode 98
metoda copy() 141
vytváření instancí 65
třída FileStream 98
metoda exit() 264
třída NativeWindow class
Třída HTMLLoader 207
vlastnost activeWindow 66
třída HTMLLoader
JavaScript, přístup 193
vlastnost autoExit 264
třída NativeWindowDisplayStateEvent 72
JavaScript, přístup 193
vlastnost icon 93
třída NativeWindowInitOptions 60, 61
vlastnost startAtLogin 262
Rejstřík
třída NetStream
třída StageDisplayState 73
událost move 56, 72
metoda resetDRMVouchers() 252
třída StageScaleMode 61, 70
událost moving 72
metoda
setDRMAuthenticationCredentials() 2
50, 252
třída StatusEvent 250
událost nativeDragComplete 124, 127, 129
třída TextField
událost nativeDragDrop 124
třída Netstream
zašifrovaný obsah, přehrávání 250
Třída Responder 166, 176
třída Screen 74
metoda getScreenForRectangle() 75
vlastnost mainScreen 75
vlastnost screens 75
Třída Security
metoda allowDomain() 34, 38
vlastnost sandboxType 268
Třída souboru
odkazování na lokální databázi 162
Třída SQLCollationType 159
Třída SQLColumnNameStyle 159
Třída SQLConnection 159
metoda attach() 178
metoda open 162
metoda open() 161
metoda openAsync() 161, 162, 164
Třída SQLError 159, 166
Třída SQLErrorEvent 159, 166
Třída SQLEvent 159
Třída SQLIndexSchema 159
Třída SQLMode 159, 165
Třída SQLResult 159
Třída SQLSchemaResult 159
Třída SQLStatement
metoda execute() 176
metoda getResult() 176
metoda spuštění 167
objekt parametry 166
vlastnost parametrů 167
vlastnost sqlConnection 166
vlastnost textu 166, 167, 169, 177
Třída SQLTableSchema 159
Třída SQLTransactionLockType 159
Třída SQLTriggerSchema 159
Třída SQLUpdateEvent 159
Třída SQLViewSchema 159
třída Stage
metoda addChild() 64
metoda addChildAt() 64
vlastnost displayState 73
vlastnost nativeWindow 60, 66
vlastnost scaleMode 61, 70
událost nativeDragEnter 124, 127, 128, 129
načtený HTML 207
událost nativeDragExit 124, 129
značky img 28
událost nativeDragOver 124, 127, 128, 129
Třída Updater 291
událost nativeDragStart 124, 129
třída URLStream 196
událost nativeDragUpdate 124, 129
třída Window 54
událost posouvání 225
třída WindowedApplication 54
událost resize 56, 72
třída XMLList 213
událost resizing 72
typy MIME
událost schránky 199
kopírování a vkládání HTML 198
událost select 80, 89, 90
kopírování a vkládání v HTML 144
událost tažení 130
přetažení HTML 131
Událost uncaughtScriptExcpetion 225
událost upuštění 130
Ú
událost active 72
událost userIdle 268
událost browserInvoke 263
událost vyjmutí 139
událost browserInvokey 284
událost výsledku 166
událost chyby 166
události
Událost userPresent 268
událost close 72
HTML 225
událost closing 68, 72, 228, 264
manipulační programy 228
událost complete 216, 220
nabídka 80, 88
událost contextmenu 85
nativní okna 56
událost deactivate 72
posluchače 228
událost displaying 80, 90
událost displayStateChange 56, 72
události load 212
událost displayStateChanging 56, 72
události menuItemSelect 81
událost dokončení 225
události menuSelect 81
událost dominitialize 203
události unload (odstranění z paměti) 200
událost drag (přetažení) 199
ukázkové aplikace 2
událost dragend 130, 199
ukončení aplikací AIR 259
událost dragenter 130, 199
úložiště klíčů 310, 314
událost dragleave 130, 199
UntrustedAppInstallDisabled (Nastavení
registru Windows) 26
událost dragover 130, 199
událost dragstart 130, 199
událost drop (vložení) 199
událost enterFrame 64
událost exiting 264
událost htmlBoundsChanged 225
Událost htmlDOMInitialize 225
událost invoke 259
událost kopírování 139
událost load 208, 216
událost load (načtení) 194, 196
událost locationChange 225
událost mouseDown 70, 124
událost mouseMove 124
UpdateDisabled (Nastavení registru
Windows) 26
URL 214
načtení obsahu HTML 207
úrovně dočasné opravy
runtime AIR 268
úrovně záplaty, runtime AIR 43
útoky pomocí downgradované verze
aplikace a zabezpečení 40
Rejstřík
uživatelská jména
nastavení pro zašifrovaný multimediální
obsah 249
uživatelská pověření a zabezpečení 40
V
velikost oken 47
velikost, okna 61
verze, aplikace AIR 268
videa FLV, šifrování 249
viditelnost oken 47
vlastní systémové prvky 57
vlastní uživatelské rozhraní pro
aktualizaci 292
vlastnost activeWindow (třída
vlastnost air (soubor AIRAliases.js) 193, 213
vlastnost customItems (třída
ContextMenu) 84
Vlastnost nativePath (třída File) 100
vlastnost data
vlastnost nativeWindow
vlastnost designMode (objekt Document
(Dokument)) 200
vlastnost designMode (objekt
Document) 133
Vlastnost desktopDirectory (třída File) 100
vlastnost nativePath (třída File) 110
objekt Window (Okno) 193, 201
třída Stage 60, 66
vlastnost nativeWindow (objekt
Window) 55, 62
vlastnost opener (objekt Window) 62
vlastnost displayState (třída Stage) 73
vlastnost paintsDefaultBackground (třída
HTMLLoader) 58, 64
Vlastnost documentsDirectory (třída
File) 100
Vlastnost parametrů (třída
SQLStatement) 166, 167
vlastnost dropAction (třída
NativeDragEvent) 127, 128
vlastnost parent (objekt Window) 62
vlastnost dropEffect (objekt
DataTransfer) 131, 132, 199
vlastnost parentSandboxBridge
vlastnost effectAllowed (objekt
DataTransfer) 131, 132, 199
vlastnost parent (třída File) 110
(objekt Window (Okno)) 201
objekt Window 30
třída LoaderInfo 35
vlastnost allowLoadBytesCodeExecution
(třída LoaderContext) 39
Vlastnost encoding (třída File) 107
vlastnost alwaysInFront (třída
NativeWindow) 67
Vlastnost generalClipboard (třída
Clipboard) 137
vlastnost applicationDescriptor(třída
vlastnost height (třída HTMLLoader) 207
Vlastnost pdfCapability (třída
HTMLLoader) 245
Vlastnost hostContainer (PDF) 247
Vlastnost playerType
vlastnost htmlLoader (objekt Window
(Okno)) 193, 201
vlastnost podnabídky
vlastnost htmlLoader (objekt Window) 62,
207
třída InvokeEvent 260
vlastnost position (třída ByteArray) 149
vlastnost icon (třída NativeApplication) 93
Vlastnost applicationStorageDirectory
(třída File) 100
vlastnost arguments
vlastnost autoExit
vlastnost exists (třída File) 110
Vlastnost idleThreshold (třída
vlastnost parentSandboxBridge (objekt
Window) 222
třída Capabilities 268
vlastnost publisherID (třída
NativeApplication) 266, 286
vlastnost bitmaps (třída Icon) 93
vlastnost innerHTML 32, 200, 212
vlastnost runtime (objekt Window
(Okno)) 193, 200
vlastnost bytesAvailable (třída
ByteArray) 149
vlastnost isDirectory (třída File) 110
vlastnost runtime (objekt Window) 62, 212
vlastnost isHTTPS (třída
BrowserInvokeEvent) 263
vlastnost runtimeApplicationDomain (třída
HTMLLoader) 215
vlastnost keyEquivalent (třída
NativeMenuItem) 81
Vlastnost runtimePatchLevel (třída
vlastnost clientX (události tažení
HTML) 131
vlastnost keyEquivalentModifiers (třída
NativeMenuItem) 81
Vlastnost runtimeVersion (třída
vlastnost clientY (události tažení
HTML) 131
vlastnost label (třída NativeMenuItem) 142
vlastnost sandboxRoot
vlastnost childSandboxBridge
objekt Window 30
třída LoaderInfo 35
vlastnost clipboard (třída
NativeDragEvent) 128
vlastnost clipboardData (události
schránky) 199
Vlastnost lastInsertRowID (třída
SQLResult) 176
Vlastnost lastUserInput (třída
vlastnost length (třída ByteArray) 149
Vlastnost clipboardData property (události
kopírování a vkládání v HTML) 139
Vlastnost lineEnding (třída File) 107
vlastnost contextMenuOwner (třída
ContextMenuEvent) 84
Vlastnost messageHandler (PDF) 247
vlastnost creationDate (třída File) 110
vlastnost creator (třída File) 110
vlastnost currentDirectory (třída
InvokeEvent) 260
vlastnost currentDomain (třída
ApplicationDomain) 215
vlastnost mainScreen (třída Screen) 75
vlastnost mnemonicIndex
vlastnost modificationDate (třída File) 110
vlastnost mouseTarget (třída
ContextMenuEvent) 84
vlastnost name (třída File) 110
snímek 30
snímek iframe 30
vlastnost sandboxType
třída Security 268
vlastnost scaleMode
třída Stage 70
vlastnost screens (třída Screen) 75
vlastnost screenX (události tažení
HTML) 131
vlastnost screenY (události tažení
HTML) 131
vlastnost securityDomain (třída
BrowserInvokeEvent) 263
Rejstřík
Vlastnost separátor (třída File) 107
vytváření křížových skriptů 34, 214, 221
vlastnost size (třída File) 110
vyvolání aplikací AIR 259
adresář uložení dat aplikace 25
Vlastnost spaceAvailable (třída File) 106
vzdálené karantény 195
chyby jazyka JavaScript 208
Vlastnost sqlConnection (třída
SQLStatement) 166
vzdálené karantény zabezpečení 26
CSS 29
vzhled oken 57
databáze 168
vlastnost stage
vlastnost startAtLogin (třída
vlastnost styleSheets (objekt Document) 220
vlastnost subErrorID (třída
DRMErrorEvent) 256
vlastnost supportsDockIcon (třída
vlastnost supportsMenu (třída
vlastnost supportsSystemTrayIcon (třída
vlastnost systemChrome (třída
NativeWindow) 57
vlastnost systemMaxSize (třída
NativeWindow) 61
vlastnost systemMinSize (třída
NativeWindow) 61
Vlastnost textu (třída SQLStatement) 166,
167, 169, 177
zabezpečení
dynamické generování kódu 31
W
web podpory společnosti Adobe 9
funkce eval() 31
WebKit 192, 195, 205
HTML 29, 31, 192, 194, 208
vlastnost -webkit-border-horizontalspacing jazyka CSS 206
instalace (aplikace a chod programu) 23
vlastnost -webkit-border-vertical-spacing
jazyka CSS 206
karanténa zabezpečení aplikace 26
vlastnost -webkit-line-break jazyka CSS 206
vlastnost -webkit-margin-bottom-collapse
jazyka CSS 206
funkce vyvolání z prohlížeče 263
JavaScript 221
karantény 194, 195, 221, 268
karantény zabezpečení 26
křížové skriptování 34
vlastnost -webkit-margin-collapse jazyka
CSS 206
metoda Loader.loadBytes() 39
vlastnost -webkit-margin-start jazyka
CSS 206
mosty karantén 30, 222
vlastnost -webkit-margin-top-collapse
jazyka CSS 206
načítání obsahu 62
vlastnost -webkit-nbsp-mode jazyka
CSS 206
nejlepší postupy 39
mezidoménové vyrovnávací paměti 28
mosty karantény zabezpečení 34
neaplikační karantény zabezpečení 28
vlastnost -webkit-padding-start jazyka
CSS 206
objekty XMLHttpRequest 33
vlastnost -webkit-rtl-ordering jazyka
CSS 206
Schránka 138
vlastnost type (třída NativeWindow) 57
vlastnost -webkit-text-fill-color jazyka
CSS 206
snímky 29, 30
vlastnost types
vlastnost -webkit-text-security CSS 206
vlastnost transparent (třída
NativeWindow) 57, 58
vlastnost type (třída File) 110
událost kopírování a vložení v HTML 139
vlastnost -webkit-user-drag CSS 130, 206
událost tažení HTML 131
vlastnost types (objekt DataTransfer) 133
vlastnost -webkit-user-modify jazyka
CSS 206
vlastnost types (typy)
vlastnost -webkit-user-select CSS 130, 132
objekt DataTransfer 199
Vlastnost url
třída File 100
vlastnost url
třída File 110
Vlastnost url (třída File) 100
Vlastnost userDirectory (třída File) 100
vlastnost visible
třída NativeWindow 61, 66
vlastnost -webkit-user-drag CSS 132
vlastnost width (třída HTMLLoader) 207
vlastnosti outerHTML 200
vložené objekty (v HTML) 194
výčet obrazovek 75
vypsání adresářů 108
vysunovací okna 67
vytváření adresářů 108
vlastnost -webkit-user-select jazyka CSS 206
webové prohlížeče
instalace aplikací AIR z 282, 283
spuštění aplikace AIR z webového
prohlížeče 262
protokol asfunction 28
šifrování dat 190
snímky iframe 29, 30
struktury Ajax 32
systém souborů 37
textová pole 28
útoky pomocí downgradované verze
aplikace 40
uživatelská oprávnění pro instalaci 23
uživatelská pověření 40
window.open() 33
XMLHTTPRequest 203
značky img 28
zjištění, zda je aplikace AIR nainstalována
z 282
Zabezpečení jazyka JavaScript 31
zjišťování runtime AIR z 281
zabezpečení mezidoménové vyrovnávací
paměti 28
X
XML
definování nabídek 86
třída 213
xmlns (soubor deskriptoru aplikace) 43
zápis souborů 112
zásuvné moduly (v HTML) 194
zavírání aplikací 264
zavírání aplikací AIR 259
zavírání oken 56, 68, 264
zjednodušená okna 57
Ž
zabalení souborů AIR
program AIR Developer Tool (ADT) 307
změna velikosti oken 48, 56, 70
značky img (v obsahu objektu TextField) 28
Rejstřík
značky skriptu
vlastnosti src 32
znak @ (at) v názvech parametru příkazu
SQL 167
znak \
(dvojtečka) v názvech parametru příkazu
SQL 167
znak at (@), v názvech parametru příkazu
SQL 167
znak dvojtečka (\
) v názvech parametru příkazu SQL 167
zobrazení
Viz obrazovky
zobrazení oken 66
zpracování onclick 211
zpracování onmouseover 211
zvolené položky nabídky 82

Stáhnout PDF s nápovědou

Transkript

Podobné dokumenty

ASP.NET pre začiatočníkov

Objektově orientovaná tvorba softwaru

Zobrazit nápovědu v souboru

Zobrazit nápovědu v souboru

Krajská příloha k národní RIS 3 - ICUK Inovační centrum Ústeckého