转：AIR应用开发中文指南(BETA2)

Posted on 2008-05-20 11:53 analyzer 阅读(3484) 评论(0) 编辑收藏举报

本文转自常青的BLOG

目录

第一章. 开始Adobe AIR之旅
1.1 什么是Adobe AIR
1.2 安装AIR运行时及例程
1.3 设置开发环境
1.4 分发，安装和运行AIR应用程序
1.5 关于AIR的安全性
1.6 AIR文件结构
第二章. 设置Flex Builder
2.1 关于Flex Builder对于AIR的支持情况
2.2 从Flex Builder 2.0.1迁移到Flex Builder 3
第三章. 设置Flex SDK
3.1 在Windows下安装和配置Flex 3 SDK
3.2 删除mms.cfg设置
第四章. 用Flex Builder创建第一个Flex AIR程序
4.1 新建一个AIR工程
4.2 编写代码
4.3 测试写好的程序
4.4 打包并运行程序
第五章. 用Flex SDK创建第一个Flex AIR程序
5.1 创建应用程序描述文件
5.2 编写程序代码
5.3 编译程序代码
5.4 测试程序
5.5 打包程序
第六章. 用Flex Bilder开发AIR程序
6.1 创建AIR工程
6.2 调试AIR程序
6.3 打包程序
6.4 创建AIR库工程
第七章. 使用Flex AIR组件
7.1 关于Flex AIR组件
7.2 使用WindowedApplication组件
7.3 关于HTML组件
7.4 Window容器
第八章. 使用命令行工具创建AIR应用程序
8.1 使用amxmlc编译器编译程序代码
8.2 使用acompc编译器编译AIR组件和库
8.3 使用AIR调试器(ADL)调试程序
8.4 使用AIR开发工具(ADT)打包程序
8.5 在简单的工程项目中使用Ant
8.6 在复杂的工程项目中使用Ant
第九章. 设置应用程序属性
9.1 应用程序描述文件的结构
9.2 定义应用程序描述文件中的属性
9.3 Adobe AIR 新增功能
第十章. 窗体（Windows）和菜单
10.1 AIR窗体基础
10.2 创建窗体
10.3 控制窗体
10.4 监听窗体事件
10.5 使用全屏窗体模式
10.6 屏幕
10.7 AIR 菜单简介
10.8 创建本地菜单
第十一章.文件与数据
11.1 AIR 文件系统概要
11.2 使用File对象
11.3 获取文件系统信息
11.4 目录
11.5 文件
11.6 加密的本地存储
11.7 拖拽(Drag And Drop)
11.8 复制与粘贴
11.9 本地SQL数据库

第一章. 开始Adobe AIR之旅

什么是 Adobe AIR？

Adobe Integrated Runtime (AIR) 是一个跨操作系统的运行时，利用现有的Web开发技术（Flash，Flex，HTML，JavaScript，Ajax）来构建富Internet应用程序并部署为桌面应用程序。

AIR 支持现有的Web技术如Flash，Flex，HTML，JavaScript和AJAX，可以用你最熟练的技术来开发您所见过的最具用户体验的RIA程序，例如，一个AIR程序可以使用如下一种或多种组合技术构建：

Flash / Flex / ActionScript
HTML / JavaScript / CSS / Ajax
PDF 可嵌入任何应用程序中

作为结果，AIR 应用程序可以是：

基于Flash 或 Flex：应用程序根内容（理解为容器）为Flash/Flex (SWF)
基于Flash 或 Flex 的HTML 或 PDF。应用程序的根内容为基于Flash/Flex (SWF) 的HTML
(HTML, JS, CSS) 或 PDF

基于HTML，应用程序根内容为HTML, JS, CSS
基于HTML的Flash/Flex或PDF，应用程序根内容为基于HTML 的Flash/Flex (SWF) 或 PDF
用户使用AIR 应用程序的方式和传统桌面程序是一样的，当运行时环境安装好后，AIR 程序就可以其他桌面程序一样运行了。

=700) window.open('http://www.asshow.com/bbs/attachment/16_765_f175da5e7ec0e36.jpg');" src="http://www.asshow.com/bbs/attachment/16_765_f175da5e7ec0e36.jpg" onload="if(this.width>'700')this.width='700';if(this.height>'700')this.height='700';" border=0>

因为AIR 是应用程序运行时环境，因此她很小且对用户来说不可见。运行时环境提供了一套一致的跨操作系统平台和框架来开发和部署应用程序，因此你的程序不必到每个平台上进行测试，在一个平台上开发好就可以在其他平台上运行了，这有很多好处：

开发AIR应用程序不必做额外的跨平台工作，节省了时间，因为跨平台的工作AIR都帮我们做好了（只要其他平台能支持AIR）。

比起Web技术及其设计模式，AIR应用程序开发迅速，她允许将Web开发技术搬到桌面上来而不用另外去学习桌面程序开发技术或复杂的底层代码，这比起低级语言如C 和 C++更容易学习，且不用去处理每个操作系统复杂的底层APIs 。

安装运行时及例程

AIR允许在桌面上运行富Internet应用程序（富客户端）。首先，你需要在计算机上安装一个运行时环境，装好后，下载示例程序，试着运行下，看看在桌面上跑的AIR程序会是什么样子。

安装运行时环境

按照下面的说明下载和安装Windows 或 Mac OS X 版本的AIR,只需要装一次，您就可以在任何时候运行AIR程序了。

安装Windows版本

1. 从Adobe Labs站点下载安装文件(AIR1_win_beta1.exe) 。

2. 双击安装文件AIR1_win_beta1.exe 。

3. 根据提示完成安装。

4. 如果你修改了mms.cfg 文件，则在运行AIR程序之前删除它，在Windows操作系统中该文件放置在C:\winnt\system32\macromed\flash\mms.cfg。

安装Mac OS版本

1. 从Adobe Labs站点下载安装文件(AIR1_mac_beta1.dmg) 。

2. 双击安装文件AIR1_mac_beta1.dmg 。

3. 根据提示完成安装。

4. 如果安装时出现认证窗口，输入Mac OS 用户名和密码。

5. 如果你修改了mms.cfg 文件，则在运行AIR程序之前删除它，在Mac OS操作系统中该文件放置在/Library/Application Support/Macromedia/mms.cfg 。

安装和运行AIR示例程序

AIR beta1 包含了一些示例程序。

1. 从Adobe Labs站点下载AIR示例程序。

2. 双击AIR文件。

3. 在安装窗口中选择installation选项，点Continue 。

4. 安装完成后，打开程序。

5. 在Windows系统中，双击桌面上的程序图标。

6. 在Mac OS系统中，双击程序图标，它安装在用户目录的Applications子目录中(例如, Macintosh HD/Users/JoeUser/Applications/) 。

运行AIR应用程序

在你所使用的系统上正确安装AIR的运行环境后，安装你下载的AIR程序，就可以运行顺利了。本站“作品展示“专栏里有一些，新手可以去下载安装体验一下什么是AIR。

上面是运行AIR，下面说开发AIR的环境。

设置开发环境

在编写AIR程序之前，你还需要设置开发环境。在Flex Builder 3中可开发基于Flex和基于ActionScript的AIR程序，或者使用Flex 和AIR SDKs的命令行工具，如果开发基于HTML的AIR程序，必须要AIR SDK，它包含了打包程序所需要的工具。

分发，安装和运行AIR应用程序

AIR程序是非常易于安装的，无缝安装特性让用户安装最新的AIR运行时，安装AIR程序，装好后，就可以和普通桌面程序一样运行了。

一旦打包好了AIR程序，有几种途径进行分发：

1. 你可以直接通过电子邮件或Web页面来发送AIR安装包给终端用户。

2. 也可以在Web页面上加入一个无缝安装链接，无缝安装特性可在Web页面上提供一个链接让用户通过点击改链接来安装AIR程序。如果用户没有安装AIR运行时，则会提示用户安装运行时，无缝安装技术也可让用户不必下载AIR文件就可以安装AIR程序。

如果用户下载了AIR文件，只要双击文件即可启动AIR安装向导，如果用户点击了Web页面的无缝安装链接，则会弹出对话框提示用户是否立即安装AIR程序。

Windows系统中在默认设置下，安装AIR程序会：

1. 安装在Program Files 目录

2. 创建桌面快捷键

3. 创建开始菜单快捷键

4. 在添加/删除控制面板中添加程序操作项目

在Mac OS中，默认下AIR程序安装在用户目录中的Applications子目录下。

如果程序已经安装，则安装向导会提示用户是否打开程序或者更新程序，安装器是根据应用程序的ID（appID）来确定的。

关于AIR安全性

AIR环境提供和一般桌面程序类似的，能够访问操作系统资源的能力，AIR程序比起SWF或浏览器中HTML文件来约束更小些，因此可能会出现安全问题，所以正确理解AIR程序的安全模型非常重要。

安装向导安全警告

在AIR程序安装过程中，用户会看到一个安全提示，这是AIR程序开发者给出的提示信息以及允许程序访问的操作系统类型，这些信息让用户在安装程序时有个大致了解。

安全沙漏

在AIR beta版本中，在特定的安全沙漏中AIR程序可访问本地文件系统，在将来的AIR版本中，应用程序资源将有着不同的安全沙漏，这取决与AIR程序是如何被安装的。

对于SWF你可以设置安全沙漏类型属性（sandboxType属性）为只读，因为SWF可以包含在AIR程序里，该属性是Security.APPLICATION 的一个常量。

所有未和AIR程序一起安装的其他资源都被放入同一个安全沙漏中，远程资源根据源域放入沙漏中，本地资源被放入local-with-networking，local-with-filesystem，或local-trusted 。

AIR程序安全沙漏中的资源访问特权

AIR应用程序安全沙漏中的SWF可以通过脚本访问来自其他域中的SWF文件，但是默认下，外部的SWF要想访问AIR应用程序安全沙漏内的SWF则会受到约束。

AIR程序沙漏中的SWF 文件和HTML内容可读取任何域中的内容及其数据。

随AIR程序安装的SWF文件不必寻找cross-domain策略文件，要提升权限可调用Security.allowDomain() 方法。

AIR为AIR程序安全沙漏中的SWF文件和HTML内容提供了增强型的特权，其中包括读取和写入本地资源和文件。

健壮的应用程序开发最佳实践

当编写AIR程序时，你要知道虽然你使用了Web技术，但是却不受浏览器安全沙漏限制，也就是说AIR程序可能有意或无意中破坏本地系统，AIR真试图把这种风险降低到最小，但是类似此方面的漏洞仍然可能出现。

产生风险的最大可能就是在读取外部数据或内容时，因此你必须时刻注意使用中的数据是否来自于网络还是本地系统，下面的这些例子都有可能存在潜在的风险：

引入外部内容时

将导致脚本注入风险：

1. 如果一个TextField对象读取的内容中包含链接，则该链接可能会执行不可预料的结果。

2. 如果程序读取一个非信任的SWF，则该SWF可能会以非法特权执行。

3. 如果程序从外部程序中读取JSON 内容，则该内容可能会访问运行时特权。

影响程序行为的数据

这将会导致弱安全性。比如，如果一个程序使用来自网络上的数据去检测一个文件名或写入一个配置文件，因此需要检测这些数据是否安全以及是否来自信任的数据源。

现在的AIR还是beta版，如果你遇到了诸如配置和选项的弱安全问题，请告诉Adobe，目前Adobe现在处理这些安全问题，到时他们将会优先给你一份AIR 1.0的正式版本。

对于HTML内容的安全约束

HTML内容和其他AIR内容一样都放在同一个安全沙漏模型中操作，但是这里有些特殊的情况。如果内容都在程序安全沙漏内，则HTML控制对象中的HTML内容只能访问安全约束的runtime类（如JavaScript对象window.runtime）。对于基于HTML的程序来说，从应用程序资源目录中载入的数据（顶层Frame）总是可以访问runtime类，而从应用程序资源外部载入的数据无论是子框架还是(IFRAME)，还是通过页面定位读取的数据，其权限与原来的域保持一致，不能访问受AIR安全约束的runtime类，默认下非程序内容是不能访问跨脚本内容，如JavaScript window 属性，nativeWindow 和htmlControl不能在程序沙漏外工作。要想安全访问脚本，可以使用the flash.system.Door API 创建严密的通信网关在程序内容和非程序内容之间提供一个有限的接口。

AIR文件结构

除了所有文件及图片等资源文件之外，下面两个文件是必须的：

AIR files

用来打包AIR程序，主要作为安装文件。

应用程序描述文件

一个XML格式的文件，包括每个AIR程序（嵌入的AIR文件）定义的这种程序属性，例如应用程序名称，appID，以及主程序窗口特征。

当使用Flex Builder 和AIR Extensions时，在创建AIR项目时application.xml文件会被自动创建。如果你使用Flex 和AIR SDKs (包括开发基于HTML的应用程序)，你需要手动创建这个文件。另外当使用Flex Builder的AIR Extensions时，可通过导出应用程序为AIR文件，如果使用Flex 和AIR SDKs开发，这需要ADT 命令行工具生成AIR文件。

第二章. 设置Flex Builder

要用Flex开发Adobe® Integrated Runtime (AIR™) 应用程序，需要如下软件：

下载并安装Adobe Flex Builder 3，用它来创建，测试，调试，打包AIR应用程序。

下载Adobe Flex 3 SDK，用你熟悉的文本编辑器和命令行工具来开发Flex AIR 应用程序。

关于Flex Builder对于AIR的支持情况

Flex Builder对AIR的支持有如下方面：

一个新建AIR项目的向导

自动创建和管理application.xml文件

运行和调试AIR程序

自动导出AIR项目并打包为AIR安装文件

第三章. 设置Flex SDK

在Windows下安装和配置Flex 3 SDK

Adobe AIR 命令行工具需要安装Java，可以是JRE或JDK（1.4.2版本以上），JRE到这里下载 http://java.sun.com/j2se/1.4.2/download.ht...loads/index.jsp 。

注意：终端用户不需要Java环境。

Flex SDK 包含AIR API和命令行工具用于打包，编译和调试AIR应用程序。

1. 如果还没有，可到Adobe Labs上下载一份Flex 3 SDK。

2. 解压缩SDK到指定目录。

3, 定位到bin子目录。

编译器设置

Flex SDK中包含两个编译器，mxmlc 编译器编译MXML和ActionScript代码为SWF文件，compc编译器编译组件和库为SWC文件。两个编译器都可作为本地二进制程序或Java程序在命令行下运行。（本地二进制程序实际上是调用Java程序）如果要使用本地二进制程序，需要把Flex 3 SDK\bin目录加入环境变量path中。如果使用Java程序命令，需要把mxmlc.jar和compc.jar加入到环境变量中。

编译器配置文件

使用编译器时可以指定编译的一些可选参数，全局Flex SDK 配置文件包含一个默认值，你可以编辑这个文件定制自己的开发环境。air_config.xml这个全局配置文件在Flex 3 SDK的frameworks 目录中。

注意：如果使用amxmlc命令启动编译器时air_config.xml会代替flex_config.xml。

关于编译器的可选选项可参考(http://livedocs.macromedia.com/flex/2/docs/00001490.html)

调试器设置

AIR直接支持调试功能，因此不需要一个调试版本的运行时环境。要想管理命令行调试，需要使用调试版的Flash播放器，只需要设置下环境变量指定这些命令的所在目录即可。

调试版的Flash播放器已在Flex 3 SDK目录中。二进制命令fdb.exe在bin目录，Java版的在lib目录。AIR调试启动器adl.exe或ADL在bin目录

注意，你不能直接用FDB启动AIR程序，因为FDB会试图用Flash播放器运行程序，因此你必须让AIR程序连接FDB回话。

应用程序打包器设置

AIR开发工具(ADT)，用来把程序打包为AIR文件，要想运行ADT，必须安装Java环境。

SDK包含一个脚本来执行ADT。要运行ADT脚本需要把Flex SDK的bin目录加到系统path变量中。

删除mms.cfg设置

如果你事先修改了mms.cfg 文件(如Flash播放器的安全设置)，在测试AIR之前先删除它，在AIR的M2版本里，这个配置文件的一些设置会限制AIR的功能。

在Mac OS系统中，这个文件在/Library/Application Support/Macromedia/mms.cfg 。
在Microsoft Windows系统中，这个文件在如C:\winnt\system32\macromed\flash\mms.cfg 。

第四章. 用Flex Builder创建第一个Flex AIR程序

创建一个AIR工程

开始本章内容之前，记得先安装好Adobe AIR运行时以及设置好开发环境。

在Flex Builder里创建工程

1. 打开Flex Builder 3.

2. 选择菜单File | New | AIR Project (如果你使用Eclipse插件形式，选择菜单File | New | Other，打开Flex节点，选择AIR工程)。

3. 接受默认设置，点击Next。

4. 在下个对话框中(设置构建路径)，不用改变，点Next。

5. 指定下面的设置，然后点Finish：

ID

AIRHelloWorld

Name

Hello World

Description

A test AIR application

Copyright

2007

其中Description和Copyright域是可选的，但是其他的都是必填的。

设置应用程序窗口的透明性

1. 在Project Navigator视图中打开AIRHelloWorld-app.xml文件。

2. 在rootContent节点中，设置systemChrome和transparent 属性为：

systemChrome="standard" transparent="false"

保存修改，关闭AIRHelloWorld-app.xml文件。

编写程序代码

要编写这个"Hello World"程序代码，需要编辑此程序的MXML文件(AIRHelloWorld.mxml)，在Project Navigator视图中找到它并打开。

所有的Flex AIR程序都包含在MXML WindowedApplication标签内，它创建了一个简单的窗口，只包含标题栏和关闭按钮。

添加代码

1. 在WindowedApplication组件中添加一个title属性，赋值为"Hello World":

代码
<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" title="Hello World">

</mx:WindowedApplication>

2. 添加一个Label组件，设置text属性为"Hello AIR"，设置对齐方式：

代码
<?xml version="1.0" encoding="utf-8"?><?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" title="Hello World">
<mx:Label text="Hello AIR" horizontalCenter="0" verticalCenter="0"/>
</mx:WindowedApplication>

3. 添加下面的样式：

代码
<mx:Style>
Application
{
background-image:"";
background-color:"";
background-alpha:"0.5";
}
</mx:Style>

该样式会应用到整个程序，窗口背景有点灰色透明。

完整的代码如下：

代码
<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" title="Hello World">
<mx:Style>
Application
{
background-image:"";
background-color:"";
background-alpha:"0.5";
}
</mx:Style>
<mx:Label text="Hello AIR" horizontalCenter="0" verticalCenter="0"/>
</mx:WindowedApplication>

测试程序

1. 点击工具栏上的调试按钮。 FlexBuilderDebugIcon1.png ( 1.38KB ) 下载次数: 4

也可以选择 Run | Debug | AIRHelloWorld 命令

运行后的结果可能会是这样(用户桌面的背景为绿色)：

2. 使用Label组件的horizontalCenter和verrticalCenter属性，文本会放置在窗口的中央，你可以任意移动或改变窗口的大小，这和普通的桌面程序没什么不同。

打包并运行程序

现在可以用Flex Builder对"Hello World"程序打包为AIR文件以便分发。一个AIR文件是一个压缩文件，它包含程序文件(这些文件都包含在工程的bin目录中)，把这些AIR文件分发给用户以便用户用它进行安装。

确定你的程序没有编译错误信息以及运行异常。

选择菜单File | Export.

选择AIR Package 选项，点Next.

默认工程名和MXML文件被选中作为AIR包中的内容，点Finish 完成创建AIR包。

现在你可以在桌面上双击运行AIR文件。

第五章. 用Flex SDK创建第一个Flex AIR程序

创建应用程序的XML文件

每个AIR程序都需要一个应用程序描述文件，这个XML文件定义各种属性，并嵌入到AIR包中分发给用户。

要创建应用程序描述文件，可使用文本编辑器来创建一个XML文件并命名为AIRHelloWorld-app.xml ，然后加入一下内容：

代码
<?xml version="1.0" encoding="UTF-8"?>

<application xmlns="http://ns.adobe.com/air/application/1.0.M4"

appId="com.adobe.air.example.AIRHelloWorld" version="1.0">

<name>Hello World</name>

<description>A test AIR application.</description>

<copyright>2007</copyright>

<rootContent systemChrome="none" transparent="true" visible="true">AIRHelloWorld.swf</rootContent>

</application>

编写代码

和所有的Flex程序一样，用Flex framework构建的AIR程序也包含一个主MXML文件，但是不同的是其根组件不是Application而是WindowedApplication。WindowedApplication组件提供了作为桌面程序所需要的最基本的窗口以及窗口控件，下面的步骤将创建一个Hello World程序。

1. 使用文本编辑器，创建一个名为AIRHelloWorld.mxml 文件，其内容如下：

代码
<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml"
layout="absolute" title="Hello World">
</mx:WindowedApplication>

2. 下一步，添加Label组件，设置text属性为"Hello AIR"，设置对齐方式：

代码
<?xml version="1.0" encoding="utf-8"?><?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute"
title="Hello World">
<mx:Label text="Hello AIR" horizontalCenter="0" verticalCenter="0"/>
</mx:WindowedApplication>

3. 添加样式：

代码
<mx:Style>
Application
{
background-image:"";
background-color:"";
background-alpha:"0.5";
}
</mx:Style>

这些样式将应用与整个程序。

这么是完整代码：

代码
<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" title="Hello World">
<mx:Style>
Application
{
background-image:"";
background-color:"";
background-alpha:"0.5";
}
</mx:Style>
<mx:Label text="Hello AIR" horizontalCenter="0" verticalCenter="0"/>
</mx:WindowedApplication>

编译程序

在运行和调试程序之前需要把MXML编译为SWF文件。（确定已经把AIR命令行工具加入到ClassPath）。

打开控制台，定位到源文件所在目录

输入以下命令：

amxmlc AIRHelloWorld.mxml

测试程序

要在命令行下运行和测试程序，需要用AIR Debug Launcher (ADL) 根据应用程序描述文件来运行程序。

在控制台输入以下命令：

adl AIRHelloWorld-app.xml

使用Label组件的horizontalCenter和verticalCenter属性可使文本居中显示。

打包程序

现在准备把"Hello World"程序打包为AIR文件以便分发，一个AIR包是一个压缩文件，AIR包分发给用户，用户使用它进行安装。

1. 确定你的程序没有编译错误以及运行异常。

2. 在命令行中输入以下命令：

adt -package AIRHelloWorld.air AIRHelloWorld-app.xml AIRHelloWorld.swf

第一个参数指定AIR文件名，第二个参数指定应用程序描述文件，接下来的参数指定程序需要的模块，脚本，资源，这里只是指定一个文件，实际上可以是任意多个文件和目录。

AIR包创建后，双击，Ctrl-Click，或在命令行下输入AIR文件名安装。

第六章. 用Flex Bilder开发AIR程序

创建AIR工程

1. 打开Flex Builder 3.

2. 选择菜单File > New > AIR Project

3. 根据默认选项，点Next.

4. 输入工程名，点Next.

5. 使用ActionScript定义主类，改变主应用程序为as文件扩展(默认下为Flex MXML .mxml 文件扩展)

6. 点Next

7. 设定AIR application设置，点Finish.

调试AIR程序

Flex Builder完美支持AIR程序的调试，更多信息请看Flex Builder 帮助。

1. 打开程序源文件(如MXML文件)

2. 点击调试按钮.

也可选择菜单Run > Debug.

程序启动并在ADL(AIR Debugger Launcher)内运行，Flex Builder 调试器会捕获任何断点或运行时错误，跟调试Flex程序没什么不同。

你还可以使用AIR Debug Launcher 命令行工具调试程序。

打包AIR程序

当程序已经开发完成，并准备分发，可把它打包为AIR文件。

1. 打开工程并确认程序无编译错误以及运行异常。

2. 选择菜单 File > Export.

3. 选择部署为AIR文件，点Next.

4. 选择文件(如媒体文件或SWF文件) 加入AIR文件，application.xml 文件和主SWF文件默认已经加入。

5. 设置AIR文件描述信息，包括文件名，点Finish.

你也可以使用ADT命令行工具打包程序。

创建AIR库工程

Beta版本的Flex Builder 3没有提供创建AIR库工程的工程向导。因此要创建自定义AIR组件，必须先创建一个标准的库工程，然后手动编辑并创建指向AIR类的库工程。

1. 选择菜单File > New > Flex Library Project.

2. 设定工程名，点Next.

3. 点击Library Path 标签

4. 删除${FRAMEWORKS}/libs/playerglobal.swc.

5. 添加airglobal.swc ，设置link 类型为External.

6. 点Finish.

第七章. 使用Flex AIR组件

关于Flex AIR组件

Flext提供了下列AIR组件：

引用
WindowedApplication 容器

AIR应用程序的顶层组件，该组件提供一些与桌面窗口有关的功能。

HTML 控件

可显示HTML页面

FileSystemComboBox控件

定义一个组合框用于选择本地文件

FileSystemDataGrid 控件

用表格来显示文件信息，其信息包括文件名，创建日期，修改日期，类型，大小。

FileSystemHistoryButton 控件

使用FileSystemList或FileSystemDataGrid控件的时候用此控件可导航历史操作记录。

FileSystemList控件

显示文件系统目录内容。

FileSystemTree控件

以树结构的形式显示文件系统目录内容。

更多信息请参阅Flex 3 Language Reference.

例子：用Flex AIR显示一个目录结构

下面的例子使用了WindowedApplication容器和FileSystemTree以及FileSystemDataGrid控件。在这里例子中，FileSystemTree控件显示目录结构，FileSystemTree控件中的目录名，FileSystemDataGrid控件就显示该目录下的文件信息：

代码
<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml">
<mx:HDividedBox>
<mx:FileSystemTree id="tree"
width="200" height="100%"
directory="{new File('C:\')}"
enumerationMode="directoriesOnly"
change="dataGrid.directory = File(tree.selectedItem);"/>
<mx:FileSystemDataGrid id="dataGrid"
width="100%" height="100%"
directory="{new File('C:\')}"/>
</mx:HDividedBox>
</mx:WindowedApplication>

使用WindowedApplication组件

mx:WindowedApplication容器组件定义了包含AIR应用程序的窗口控件。在MXML AIR 程序里<Application> 标签被替换为<WindowedApplication>标签。

一个WindowedApplication组件提供下列控件：

1. 一个标题栏

2. 一个最小化按钮

3. 一个最大化按钮

4. 一个关闭按钮

WindowedApplication组件的窗口遵循底层操作系统的标准行为，比如可以拖到标题栏移动窗口以及改变窗口大小。

默认下，WindowedApplication组件创建的应用程序窗口，其windowMode 属性设置为systemChrome，visibile设置为true，这些设置都在application.xml 文件中。

下面的例子简单演示了WindowedApplication组件：

代码
<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication
xmlns:mx="http://www.adobe.com/2006/mxml"
layout="absolute"
<mx:Text text="Hello World" />
</mx:WindowedApplication>

关于HTML组件

HTML组件用于显示HTML网页内容，被用于在AIR程序中渲染外部的指定HTML内容。它提供了轻量级的浏览器的功能，包括载入HTML页面，历史记录导航，以及访问HTML内容的能力。HTML组件并不是用来代替Text 和 TextArea组件来显示格式化文本数据。

创建一个HTML 组件

使用<mx:HTML> 标签在MXML中定义一个HTML组件，下面的例子中，给其指定一个id以便在其他地方能够引用。

指定HTML页面的location 属性显示指定页面内容。

下面的例子演示如何使用HTML组件。HTML组件的location属性设置为"http://labs.adobe.com/"，这样当载入时URL地址将被打开，另外"back" 和"forward" 按钮调用组件的historyBack() 和historyForward()方法。TextInput 组件让用户输入url 地址，当"go"按钮被点击后，HTML组件的location属性被设置为TextInput 的text 属性值。

代码
<?xml version="1.0" encoding="utf-8"?>

<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml">

<mx:ControlBar width="100%">

<mx:Button label="< Back" click="content.historyBack();"/>

<mx:Button label="Forward >" click="content.historyForward();"/>

<mx:TextInput id="address" text="{content.location}" width="100%"/>

<mx:Button label="Go!" click="content.location = address.text"/>

</mx:ControlBar>

<mx:Canvas width="100%" height="100%">

<mx:HTML id="content" location="http://labs.adobe.com/"/>

</mx:Canvas>

</mx:WindowedApplication>

HTML 组件之用户交互能力

对于用户交互性而言，HTML组件就像一个简单的浏览器，没有菜单栏和导航按钮。HTML页面的内容显示在组件中。用户通过表单域，按钮和超链接操作内容，任何动作都会使浏览器载入新页面（比如点击一个连接或提交一个表单），改变组件的location属性可载入新的页面。

Window 容器

Window组件是一个Flex容器，用于定义一个程序运行后出现所包含的内容和布局的操作系统窗口，也就是说它不同于初始或主窗口（如WindowedApplication或Application组件）。除此之外和WindowedApplication组件具有共同的功能，Window组件允许定义窗口的特性如窗口类型，样式，是否包含特定的窗口操作（如改变大小和最大化）。这些都是通过组件初始化时（还没有显示出来）设置其属性来访问，但是，一旦窗口打开后，这些属性将不能被设置和访问。

创建和使用Window容器

<mx:Window>容器定义了包含自身的AIR程序对象。在MXML AIR程序里<mx:Window> 标签作为MXML部件的最顶层标签，MXML部件的文档内容作为window容器内容，Window 组件不能用在其他MXML文档中，只能通过ActionScript来创建组件实例。

因许多Window组件只能在window打开之前进行设置，所以其属性可以在 <mx:Window> MXML 标签中或用ActionScript代码进行设置。

一旦windows的初始属性设置完毕，调用Window组件的open() 方法后操作系统将会把它显示在用户桌面上。

下面是一个简单使用Window组件的例子，这个例子包含两个MXML文件，第一个使用Application容器且是程序的初始窗口，第二个使用Window容器作为程序的第二个窗口，在这个例子中，主窗口模拟一个应用程序的欢迎屏幕窗口，3秒后关闭欢迎屏幕且打开第二个窗口。

下面的代码定义主程序MXML文件，包含当程序运行时自动打开的初始化窗口(欢迎屏幕窗口)：

代码
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" creationComplete="init();">
<mx:Script>
<![CDATA[
private const LOAD_DELAY:int = 3;
private var timeElapsed:int = 0;
private var loadTimer:Timer;

private var splashScreen:NativeWindow;
private var docWindow:DocumentWindow;

private function init():void
{
// center the window on the screen
splashScreen = Shell.shell.openedWindows[0];
var screenBounds:Rectangle = Screen.mainScreen.bounds;
splashScreen.x = (screenBounds.width - splashScreen.width) / 2;
splashScreen.y = (screenBounds.height - splashScreen.height) / 2;

// start the timer, which simulates a loading delay
loadTimer = new Timer(1000);
loadTimer.addEventListener(TimerEvent.TIMER, incrementTime);
loadTimer.start();

updateStatus();
}

private function incrementTime(event:TimerEvent):void
{
timeElapsed++;

updateStatus();

// if the loading delay has passed, stop the timer,
// close the splash screen, and open the document window
if ((LOAD_DELAY - timeElapsed) == 0)
{
loadTimer.stop();
loadTimer.removeEventListener(TimerEvent.TIMER, incrementTime);
loadTimer = null;

splashScreen.close();

// open a new instance of the document window
docWindow = new DocumentWindow();
docWindow.open();
}
}

private function updateStatus():void
{
loadStatusMessage.text = "initializing... " + (LOAD_DELAY - timeElapsed).toString() + " seconds remaining.";
}
]]>
</mx:Script>
<mx:VBox horizontalCenter="0" verticalCenter="0">
<mx:Text text="My Splash Screen" fontFamily="Courier New" fontSize="36"/>
<mx:Text id="loadStatusMessage" text="initializing..."/>
</mx:VBox>
</mx:Application>

incrementTime()方法每秒钟调用一次，当时间结束时DocumentWindow实例被创建并调用其open()方法。DocumentWindow类被独立定义在MXML文件中，其顶层标签为<mx:Window>，也就是说它是Window类（Window组件）的子类。下面是DocumentWindow MXML文件代码：

代码
<?xml version="1.0" encoding="utf-8"?>

<mx:Window xmlns:mx="http://www.adobe.com/2006/mxml"

layout="absolute"

title="Document window"

width="550" height="450">

<mx:Text text="This is a document window." horizontalCenter="0" verticalCenter="0"/>

</mx:Window>

关于Window容器的更多信息，请参阅Flex 3 语言参考

第八章. 使用命令行工具创建AIR应用程序

使用amxmlc编译器编译程序代码

使用命令行MXML编译器（amxmlc）编译ActionScript和MXML 资源：

amxmlc [compiler options] -- MyAIRApp.mxml

这里的[compiler options] 指定编译器选项。

Amxmlc命令调用mxmlc，再加上额外的参数，+configname=air，它指示编译器使用air-config.xml代替flex_config.xml文件。

编译器根据air-config.xml配置文件编译AIR程序，你也可以使用本地的，工程级别的配置文件来代替全局配置文件，比如你可以先复制全局文件进行修改，然后通过-load-config选项载入：

-load-config=project-config.xml 替换全局文件

-load-config+=project-config.xml 增加额外的参数值到全局变量中，比如-library-path 选项

你也可以使用指定的命名约定，让编译器自动载入配置文件，例如如果你的程序主MXML文件名为RunningMan.mxml，那么配置文件名为RunningMan-config.xml。编译程序只需要输入：

amxmlc RunningMan.mxml

示例

下面的例子演示了如何使用amxmlc编译器

编译一个AIR MXML文件：

amxmlc myApp.mxml

编译并设置输出：

amxmlc -output anApp.swf -- myApp.mxml

编译一个AIR ActionScript 文件：

amxmlc myApp.as

指定编译器配置文件：

amxmlc -load-config config.xml -- myApp.mxml

从其他配置文件读取额外参数：

amxmlc -load-config+=moreConfig.xml -- myApp.mxml

添加外部库：

amxmlc -library-path+=/libs/libOne.swc,/libs/libTwo.swc -- myApp.mxml

不使用配置文件编译AIR MXML文件：

mxmlc -library-path [AIR SDK]/frameworks/libs/air/airframework.swc, ^

[AIR SDK]/frameworks/libs/air/airframework.swc, ^

-library-path [Flex 2 SDK]/frameworks/libs/framework.swc ^

-- myApp.mxml

使用runtime-shared library（RSL）编译AIR MXML文件：

amxmlc -external-library-path+=../lib/myLib.swc -runtime-shared-libraries=myrsl.swf -- myApp.mxml

使用Java版本的编译器：

java flex2.tools.Compiler +flexlib [Flex SDK 2]/frameworks +configname=air [additional compiler options] -- myApp.mxml

Flexlib选项指定Flex SDK frameworks目录，使编译器找到flex_config.xml文件。

java -jar [Flex SDK 2]/lib/mxmlc.jar +flexlib [Flex SDK 2]/frameworks +configname=air [additional compiler options] -- myApp.mxml

使用acompc编译器编译AIR组件或库

使用组件编译器acompc编译AIR库或独立组件。组件编译器很类似amxmlc编译器，只是需要注意以下事项：

1. 你必须指定哪些类将被编译进库或组件。

2. Acompc不会自己去寻找本地配置文件，你必须手动使用-load-config选项加载。

Acompc和compc一样，除了载入配置文件air-config.xml文件代替flex_config.xml文件。

组件编译器配置文件

下面的例子演示建立用两个类所建立的库：ParticleManager和Particle，都在com.adobe.samples.particles包中，存放在source/com/adobe/samples/particles目录下：

代码
<flex-config>

<compiler>

<source-path>

<path-element>source</path-element>

</source-path>

</compiler>

<include-classes>

<class>com.adobe.samples.particles.ParticleManager</class>

<class>com.adobe.samples.particles.Particle</class>

</include-classes>

</flex-config>

然后输入下面的命令：

代码
compc -source-path source -include-classes com.adobe.samples.particles.Particle

com.adobe.samples.particles.ParticleManager

示例编译AIR组件或库：

acompc -load-config myLib-config.xml -output lib/myLib.swc

编译runtime-shared library：

acompc -load-config myLib-config.xml -directory -output lib

注意，在运行此命令之前lib目录必须存在且空的

使用AIR Debug Launcher进行调试

在开发过程中可使用AIR Debug Launcher (ADL)来调试基于flex或HTML的AIR程序。使用ADL，你可不必先对程序打包和安装，使用ADL也不需要安装运行时。

ADL所支持的调试只限于trace语句的输出，如果你开发基于Flex的程序，可使用Flash Debugger (或Flex Builder) 调试复杂问题。

用ADL运行程序

使用下面的语法：

adl [-runtime <runtime-directory>] <application.xml> [<root-directory>] [-- arguments]

-runtime <runtime-directory> 指定要使用的运行时，如果没指定，则默认为ADL所在的SDK目录（如果ADL被移动到SDK目录外，则需要手动指定)

<application.xml> 应用程序描述文件

<root-directory> 应用程序运行所在的根目录，如果没有指定，则该目录就是程序描述文件所在目录。

-- arguments 任意字符串参数

注意：当你想运行的AIR程序已经在运行的话，新的实例将不能运行。

打印trace语句

要在ADL下输出trace 语句到控制台，可使用trace() 函数：

trace("debug message");

ADL示例

在当前目录下运行程序：

adl myApp-app.xml

在当前目录的子目录下运行程序：

adl source/myApp-app.xml release

运行程序并传递两个命令行参数，"foo"和"bar":

adl myApp-app.xml -- foo bar

用指定的运行时运行程序：

adl -runtime /AIR/XYZ/AIRSDK/bin myApp-app.xml

在Flash Debugger中设置断点

要在Flash Debugger中调试基于SWF的AIR程序，需要启动一个FDB会话，且运行debug版本的应用程序。Debug版本的SWF文件会自动连接到FDB会话。

1. 启动FDB，FDB命令在Flex 2 SDK的bin目录中。

在控制台中会显示FDB提示：<fdb>

2. 执行Run命令：<fdb>run 【回车】

3. 运行debug版本的程序：

adl myApp-debug.xml

4. 使用FDB命令设置断点。

输入：continue 【回车】

设置断点

输入：continue 【回车】

使用AIR开发工具打包程序

用AIR Developer Tool（ADT）打包程序为AIR文件。ADT创建基于SWF或HTML的安装文件（如果你使用Flex Builder，可用导出功能）

ADT是java程序，类似与Ant需要在命令行下运行。SDK中包含了命令行脚本用于执行该命令。

最简单的AIR程序至少需要一个程序描述文件和主SWF或HTML文件。任何其他用到的资源都会被打包进AIR文件。

ADT用法

使用下面的语法：

adt -package air_file app_xml [ file_or_dir | -C dir file_or_dir ... ] ...

air_file ：即将创建的AIR文件名。

app_xml ：程序描述文件路径，不管该文件名是什么，最后打包后都改为"application.xml"，该路径可以是相对也可以是绝对路径。

file_or_dir ：将被打包的文件和目录，可以指定任意数量的文件和目录，用空格符分隔开。如果是目录，则该目录下的所有文件和子目录，除了隐藏文件都被添加到安装包中。指定的文件和目录必须在当前目录下或是当前目录的子目录，可使用-C选项改变当前目录。

ADT 示例

在当前目录中打包指定的程序文件：

adt -package myApp.air myApp.xml myApp.swf components.swc

打包当前目录中的所有文件和子目录：

adt -package myApp.air myApp.xml .

只打包主文件和images 子目录：

adt -package myApp.air myApp.xml myApp.swf images

打包和(release\bin)目录下的程序描述文件和SWF文件：

adt -package myApp.air release\bin\myApp.xml -C release\bin myApp.swf

下面的例子演示如何打包多个目录下的文件：

代码
/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

下面的ADT命令在/devRoot/myApp目录下运行：

代码
adt -package myApp.air release/bin/myApp.xml -C release/bin myApp.swf

-C ../artwork/myApp images -C ../audio

该命令执行结果：

代码
/myAppRoot

/META-INF

/AIR

application.xml

hash

myApp.swf

mimetype

/images

image-1.png

image-n.png

/libs

lib-1.swf

lib-n.swf AIRAlias.js

运行ADT命令(没有设置classpath) ：

java -jar {AIRSDK}\lib\ADT.jar -package myApp.air myApp.xml myApp.swf

运行ADT命令(把ADT.jar包加入到classpath变量中) ：

java com.adobe.air.ADT -package -package myApp.air myApp.xml myApp.swf

在简单的工程项目中使用Ant

这个例子展示如何用Ant构建AIR程序，一个非常简单的工程，所有文件都放在一个目录里。

注意：这个例子使用的是AIR SDK而不是Flex Builder，Flex Builder中的工具和配置文件的目录结构有所不同。

为了使用更简单些，例子中定义了一些变量属性，这一组属性定义了命令行工具的所在路径：

代码
<property name="SDK_HOME" value="C:/FlexSDK"/>

<property name="MXMLC.JAR" value="${SDK_HOME}/lib/mxmlc.jar"/>

<property name="ADL" value="${SDK_HOME}/bin/adl.exe"/>

<property name="ADT.JAR" value="${SDK_HOME}/lib/adt.jar"/>

这一组定义了工程的一些属性，这些变量将被转换为应用程序描述文件。这里还定义了程序根目录，还有MXMLC debug参数为true ：

代码
<property name="APP_NAME" value="ExampleApplication"/>

<property name="APP_ROOT" value="."/>

<property name="MAIN_SOURCE_FILE" value="${APP_ROOT}/${APP_NAME}.mxml"/>

<property name="APP_DESCRIPTOR" value="${APP_ROOT}/${APP_NAME}-app.xml"/>

<property name="AIR_NAME" value="${APP_NAME}.air"/>

<property name="DEBUG" value="true"/>

调用编译器

要调用编译，这个例子使用一个java任务来运行mxmlc.jar ：

代码
<target name="compile">

<java jar="${MXMLC.JAR}" fork="true" failonerror="true">

<arg value="-debug=${DEBUG}"/>

<arg value="+flexlib=${SDK_HOME}/frameworks"/>

<arg value="+configname=air"/>

<arg value="-file-specs=${MAIN_SOURCE_FILE}"/>

</java>

</target>

当使用Java调用mxmlc时，必须指定+flexlib参数。+configname=air参数告诉mxmlc载入AIR配置文件来代替原来的Flex配置文件。

调用ADL来测试程序

要想用ADL运行程序，使用下面的任务：

代码
<target name="test" depends="compile">

<exec executable="${ADL}">

<arg value="${APP_DESCRIPTOR}"/>

</exec>

</target>

调用ADT打包程序

用下面的Java任务运行adt.jar工具：

代码
<target name="package" depends="compile">

<java jar="${ADT.JAR}" fork="true" failonerror="true">

<arg value="-package"/>

<arg value="${AIR_NAME}"/>

<arg value="${APP_DESCRIPTOR}"/>

<arg value="${APP_NAME}.swf"/>

<arg value="*.png"/>

</java>

</target>

如果你还想打包进更多的文件，可继续添加<arg> 元素。

在复杂的工程项目中使用Ant

因为有些程序会把所有的文件都放在一个目录中，下面的例子演示一个构建文件被用来编译，测试，打包AIR程序。

这个例子项目把源代码和图标都存在src目录，构建脚本创建了下面的工作目录：

build

存储正式版的SWF文件

debug

存储调试版的SWF文件和资源文件

release

存储最终的AIR包

Compiling

Mxmlc编译器允许指定编译后的文件存放路径，通过-output 选项指定。

Testing

ADL的第二个参数指定AIR程序的根目录

Packaging

代码
<?xml version="1.0" ?>
<project>

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


<property name="APP_NAME" value="ExampleApplication"/>
<property name="APP_ROOT_DIR" value="."/>
<property name="MAIN_SOURCE_FILE" value="${APP_ROOT_DIR}/src/${APP_NAME}.mxml"/>
<property name="APP_ROOT_FILE" value="${APP_NAME}.swf"/>
<property name="APP_DESCRIPTOR" value="${APP_ROOT_DIR}/${APP_NAME}-app.xml"/>
<property name="AIR_NAME" value="${APP_NAME}.air"/>
<property name="build" location="${APP_ROOT}/build"/>
<property name="debug" location="${APP_ROOT_DIR}/debug"/>
<property name="release" location="${APP_ROOT_DIR}/release"/>
<property name="assets" location="${APP_ROOT_DIR}/src/assets"/>

<target name="init" depends="clean">
<tstamp/>
<mkdir dir="${build}"/>
<mkdir dir="${debug}"/>
<mkdir dir="${release}"/>
</target>

<target name="debugcompile" depends="init">
<java jar="${MXMLC.JAR}" fork="true" failonerror="true">
<arg value="-debug=true"/>
<arg value="+flexlib=${SDK_HOME}/frameworks"/>
<arg value="+configname=air"/>
<arg value="-file-specs=${MAIN_SOURCE}"/>
<arg value="-output=${debug}/${APP_ROOT_FILE}"/>
</java>
<copy todir="${debug}">
<fileset dir="${assets}"/>
</copy>
</target>

<target name="releasecompile" depends="init">
<java jar="${MXMLC.JAR}" fork="true" failonerror="true">
<arg value="-debug=false"/>
<arg value="+flexlib=${SDK_HOME}/frameworks"/>
<arg value="+configname=air"/>
<arg value="-file-specs=${MAIN_SOURCE_FILE}"/>
<arg value="-output=${build}/${APP_ROOT_FILE}"/>
</java>
</target>

<target name="test" depends="debugcompile">
<exec executable="${ADL}">
<arg value="${APP_DESCRIPTOR}"/>
<arg value="${debug}"/>
</exec>
</target>

<target name="package" depends="releasecompile">
<java jar="${ADT.JAR}" fork="true" failonerror="true">
<arg value="-package"/>
<arg value="${release}/${AIR_NAME}"/>
<arg value="${APP_DESCRIPTOR}"/>
<arg value="-C"/>
<arg value="${build}"/>
<arg value="${APP_ROOT_FILE}"/>
<arg value="-C"/>
<arg value="${assets}"/>
<arg value="icons"/>
</java>
</target>

<target name="clean" description="clean up">
<delete dir="${build}"/>
<delete dir="${debug}"/>
<delete dir="${release}"/>
</target>
</project>

第九章. 设置应用程序属性

应用程序描述文件的结构

应用程序描述文件application.xml，包含了整个程序的属性，如名称，版本，版权等等。任何文件名都可作为程序描述文件，Flex Builder当创建工程时会自动创建描述文件。当打包程序时无论使用Flex Builder还是ADT，都会把描述文件重命名为application.xml。

这里是一个描述文件的例子：

代码
<?xml version="1.0" encoding="utf-8" ?>
<application appId="com.adobe.air.examples.HelloWorld" version="2.0"
xmlns="http://ns.adobe.com/air/application/1.0.M4">
<name>AIR Hello World</name>
<description>
This is the Hello World sample file from the Adobe AIR documentation.
</description>
<title>HelloWorld -- AIR Example</title>
<copyright>Copyright © 2006</copyright>
<rootContent systemChrome="none"
transparent="true"
visible="true"
width="640"
height="480">
HelloWorld-debug.swf
</rootContent>
<installFolder>Adobe/Examples</installFolder>
<icon>
<image16x16>icons/smallIcon.png</image16x16>
<image32x32>icons/mediumIcon.jpg</image32x32>
<image48x48>icons/bigIcon.gif</image48x48>
<image128x128>icons/biggestIcon.png</image128x128>
</icon>
<handleUpdates/>
<fileTypes>
<fileType>
<name>adobe.VideoFile</name>
<extension>avf</extension>
<description>Adobe Video File</description>
<contentType>application/vnd.adobe.video-file</contentType>
</fileType>
</fileTypes>
</application>

定义应用程序描述文件的属性

程序描述文件的根元素为application字段，其包含几个属性：

<application appId="com.adobe.air.HelloWorld" version="1.0"

xmlns="http://ns.adobe.com/air/application/1.0.M4">

appID ：程序唯一标识符，该属性可由下列字符组成：

代码
0-9

a-z

A-Z

. (点)

- (横杆)

该值必须包含17到255个字符。

version ：设定程序的版本信息

xmlns ：AIR名称空间，每个版本的AIR其名称空间都会不同。

定义程序名称，标题，描述，版权和安装目录

name ：应用程序名称，必须定义

<name>TestApp</name>

在Windows中，这个值会显示在程序的标题栏中

title (可选) ：在AIR程序安装器中显示

<title>TestApp from Adobe Systems Inc.</title>

description (可选) AIR程序安装时显示

<description>An MP3 player.</description>

copyright (可选) AIR程序的版权信息

<copyright>Copyright © 2006 [YourCompany, Inc.]</copyright>

installFolder (可选) 默认安装目录的子目录

<installFolder>Acme</installFolder>

在Windows中，默认安装子目录为Program Files目录，在Mac OS中，为/Applications 目录。例如安装目录属性为"Acme"和程序名称为"ExampleApp"，则程序将被安装在C:\Program Files\Acme\Example 。

使用反斜杠(/) 作为目录分隔符：

<installFolder>Acme/Power Tools</installFolder>

installFolder属性可以包含任意Unicode (UTF-8) 字符，除了下面的：

代码
Character Hex Code

various 0x00 - x1F

* x2A

" x22

: x3A

> x3C

< x3E

? x3F

\ x5C

| x7C

定义rootContent元素

Application.xml也指明了rootContent文件，因为这个文件是第一个被程序载入的。无论是SWF还是HTML文件。

rootContent元素值是一个URL，相对于application.xml文件所在路径，例如下面的rootContent 元素中AIRTunes.swf 文件和application.xml文件在同一个目录：

代码
<rootContent

systemChrome="none"

transparent="true"

visible="true"

height="400"

width="600">

AIRTunes.swf

</rootContent>

rootContent元素的属性值主要设定将被创建的窗口的属性。

systemChrome ：如果设置为standard，窗口继承操作系统窗口样式，程序没有透明，如果设置为false，则窗口不继承操作系统窗口样式。当使用Flex WindowedApplication组件时，该组件将应用自己的窗口样式。

transparent ：设置为true，则窗口支持Alpha混合，窗口被创建后transprent 属性将不可更改，透明的窗口需要更多内存且渲染速度慢。

重要提示：当systemChrome="none"时你只能设置transparent="true"。

visible ：设置为false，使窗口创建后被隐藏。

你可以需要在主窗口创建时先隐藏，等设置好位置和大小后，再通过stage.window.visible 属性设置为true.再显示主窗口。

height, width ：主窗口的高度和宽度。

指定图标文件

Icon属性指定一个或多个可使用的图标文件，该属性是可选的，即使没有指定，操作系统会显示默认图标。

图标路径是相对与程序的根目录，PNG, GIF, 和JPEG 格式都支持。

代码
<icon>

<image16x16>icons/smallIcon.png</image16x16>

<image32x32>icons/mediumIcon.jpg</image32x32>

<image48x48>icons/bigIcon.gif</image48x48>

<image128x128>icons/biggestIcon.png</image128x128>

</icon>

注意：图标不会自动被添加到AIR包中。

Signaling the inclusion of an update interface

一般情况，AIR 的安装和升级都是使用默认的安装对话框，但是，你可以定义自己的方法使用AIR Updater API来更新程序，要想这样，必须把handleUpdates 元素添加到描述文件中：

<handleUpdates/>

注册文件类型

fileTypes属性指定那些类型将被注册：

代码
<fileTypes>

<fileType>

<name>adobe.VideoFile</name>

<extension>avf</extension>

<description>Adobe Video File</description>

<contentType>application/vnd.adobe.video-file</contentType>

</fileType>

</fileTypes>

fileTypes元素是可选的。

Adobe AIR新增功能

这一节给AIR新增的功能做一个概览。

新的运行时类
运行时类的新功能
新的监控伺服类

新的运行时类（runtime classes）

下面都是Adobe AIR新增的运行时类，这些功能不能用于浏览器中运行的SWF：

引用
类包

Clipboard flash.desktop

ClipboardFormats flash.desktop

CompressionAlgorithm flash.utils

ClipboardTransferMode flash.desktop

DockIcon flash.display

DragActions flash.desktop

DragManager flash.desktop

DragOptions flash.desktop

DRMAuthenticateEvent flash.events

DRMStatusEvent flash.events

EncryptedLocalStore flash.filesystem

File flash.filesystem

FileListEvent flash.events

FileMode flash.filesystem

FileStream flash.filesystem

HTMLControl flash.html

HTMLHistoryItem flash.html

HTMLHost flash.html

HTMLPDFCapability flash.html

HTMLUncaughtJavaScriptExceptionEvent flash.html

HTMLWindowCreateOptions flash.html

Icon flash.desktop

InteractiveIcon flash.display

InvokeEvent flash.events

JavaScriptFunction flash.html

JavaScriptObject flash.html

NativeDragEvent flash.events

NativeMenu flash.display

NativeMenuItem flash.display

NativeWindow flash.display

NativeWindowBoundsEvent flash.events

NativeWindowDisplayState
flash.display

NativeWindowDisplayStateEvent
flash.events

NativeWindowErrorEvent
flash.events

NativeWindowIcon
flash.display

NativeWindowInitOptions
flash.display

NativeWindowResize
flash.display

NativeWindowSystemChrome
flash.display

NativeWindowType
flash.display

NotificationType
flash.display

OutputProgressEvent
flash.events

Screen
flash.display

Shell
flash.system

SQLCollationType
flash.data

SQLColumnNameStyle
flash.data

SQLColumnSchema
flash.data

SQLConnection
flash.data

SQLError
flash.errors

SQLErrorCode
flash.errors

SQLErrorEvent
flash.events

SQLErrorOperation
flash.errors

SQLEvent
flash.events

SQLIndexSchema
flash.data

SQLResult
flash.data

SQLSchema
flash.data

SQLSchemaResult
flash.data

SQLStatement
flash.data

SQLTableSchema
flash.data

SQLTransactionLockType
flash.data

SQLTriggerSchema
flash.data

SQLUpdateEvent
flash.events

SQLViewSchema
flash.data

SystemTrayIcon
flash.display

Updater
flash.system

URLRequestDefaults
flash.net

XMLSignatureValidator
flash.utils

TransferableTransferMode
flash.desktop

URLRequestDefaults
flash.net

Updater
flash.system

大多数类只能在AIR程序安全沙箱中可用，不过下面的这些类也可以用在其他沙箱之上：

Door
URLRequest.

运行时类新增功能

下面的类能用在浏览器上，但是AIR下提供了额外的属性和方法：

引用
类
属性和方法

HTTPStatusEvent
HTTP_RESPONSE_STATUS

responseURL

responseHeaders

URLRequest
followRedirects

manageCookies

shouldAuthenticate

shouldCacheResponse

userAgent

userCache

setLoginCredentials()

URLStream
httpResponseStatus event

Stage
nativeWindow

Security
APPLICATION

大多数这些属性和方法都在AIR程序安全沙漏中使用，不过URLRequest 类也可以用在其他安全沙箱中。

ByteArray.compress() 和ByteArray.uncompress()方法包含一个新的算法参数，允许你选择压缩或zlib 压缩。

新的Flex组件

下面的Flex组件在AIR程序开发时可用：

FileEvent

FileSystemComboBox

FileSystemDataGrid

FileSystemEnumerationMode

FileSystemHistoryButton

FileSystemList

FileSystemSizeDisplayMode

FileSystemTree

HTML

WindowedApplication

监控伺服类

Air.net包包含一些网络监测类，该包也只能在Adobe AIR中使用，需要引入ServiceMonitor.swc文件。

该包包含下列类：

ServiceMonitor
SocketMonitor
URLMonitor

第十章. 窗体（Windows）和菜单

AIR 窗体基础

窗体API 包含下列类：

引用
flash.display

NativeWindow, NativeWindowInitOptions 下面的类中定义了些Window字符常量：NativeWindowDisplayState, NativeWindowResize, NativeWindowSystemChrome

----------------

flash.events

NativeWindowBoundsEvent, NativeWindowDisplayStateEvent, NativeWindowErrorEvent

----------------

flash.system

NativeWindowCapabilities

AIR提供了易用的，跨平台的窗体API，使用Flash, Flex, 和HTML编程技术创建本地操作系统窗体。

用AIR，你可以很自由的创建应用程序的主题样式，创建的窗体看起来和标准桌面程序一样，在不同的操作系统上就有不同的系统窗体风格，或者使用皮肤，扩展窗体主题风格。你甚至可以用矢量图或位图绘制窗体。

AIR支持两种不同类型的APIs用于创建窗体：面向Flash的NativeWindow类和面向HTML的JavaScript Window类。通过Flash stage和显示列表可直接用NativeWindow创建窗体。要添加可视化对象到NativeWindow上，需要添加对象到window's stage的显示列表上。使用HTML，CSS和JavaScript创建窗体来显示内容，如果要添加可视化对象到HTML窗体上，需要用DOM添加对象。

以前的项目中的窗体都是通过AIR项目的描述文件自动创建的，因为已经指定了rootContent 元素属性值。如果根内容是一个SWF文件，则NativeWindow 被创建，SWF 被载入到窗体中。如果根内容为HTML文件，则HTML窗体被创建，HTML页被载入。

Native windows使用基于事件驱动的编程模型。改变任何属性或调用窗体的方法都将影响显示或组件的行为。例如当系统按钮最大化按钮被点击时，下列事件将被触发：

1. 用户点击了最大化按钮。

2. 窗体发出一个displayStateChanging事件。

3. 如果没有注册监听器取消事件，则窗体被最大化。

4. displayStateChange事件通知监听器。

另外，相关联的事件也会被触发：

1. 如果窗体左上角坐标因为最大化而改变则发出move事件。

2. 如果窗体大小因最大化发生变化则发出resize事件。

类似的事件还有minimizing, restoring, closing, moving, resizing window.

本地窗体的样式

窗体的基本外观和样式取决于三个属性：type, systemChrome, 和transparent。Type属性设置窗体的功能。systemChrome属性设置窗体是否遵循操作系统窗体样式。Transparent属性设置是否支持alpha混合。这些属性都是设置在将被创建的窗体的NativeWindowInitOptions 对象上且不能被改变。自动创建的初始窗体是根据描述文件的这些属性值进行设置的，且type属性不能在描述文件中设置，其值都是normal。

这些属性的设置有些是不兼容的，如当transparent 设置为true时或type为lightweight时systemChrome不能设置为standard 。

窗体类型

Type属性决定创建何种类型的窗体，且只有在创建新的NativeWindow.时可设置，AIR支持下列类型的窗体：

Normal

典型的窗体，Normal窗体具有操作系统普通窗体的功能。

Utility

一个面板窗体，Utility窗体是简化的窗体，且不显示在系统任务栏中。

Lightweight

Lightweight窗体也不显示在系统任务栏中，另外它没有系统菜单。它很适合做提示水泡窗体，当type设置为lightweight时，systemChrome 必须设置为"none".

注意：在Beta版本中，模态窗体类型还不支持

Window chrome

Window chrome 是一组操作窗体的控件，作为AIR 程序window chrome有一下几种：

System chrome

System chrome 显示的窗体具有操作系统窗体一样的一组控件和样式。使用system chrome是AIR窗体和普通桌面程序具有一样的样式风格。System chrome是由系统管理的，你的程序不能直接访问这些控件，但可以处理这些控件发出的事件，如果窗体被设置为system chrome ，则transparency 属性必须为false 。

Flex chrome

当使用Flex WindowedApplication 和 Window组件时，窗体样式由Flex framework提供，如果Flex 组件在system chrome下使用，则Flex chrome 不会被显示。

Custom chrome

如果你创建的窗体没有system chrome且不使用Flex mx:WindowedApplication组件，你必须添加自己的控件处理用户和窗体的交互。这里你可以制作透明的，不规则的窗体。

窗体透明

要允许窗体与桌面环境进行alpha混合，需要设置窗体的transparent 属性为true。Transparent属性必须在窗体创建之前设置，且不能改变。该属性在NativeWindowInitOptions对象上。

透明窗体在以下方面很有用：

1. 程序边框为不规则图形

2. 程序必须”淡出“或出现为不可视

当窗体设置为system chrome.时透明不可用。

MXML程序窗体的透明性

如果Flex程序使用CSS 样式设置背景色或颜色，则窗体不会透明。

Application

{

background-image:"";

background-color:"";

}

可视化窗体目录

下面的表格说明不同的属性值影响窗体的视觉效果：

keshishijue.gif ( 24.72KB ) 下载次数: 16

Beta版本的限制

下面的特性在beta版本中还不支持：

1. 窗体API 还不支持 Toolbars|OS X Toolbar 或 OS X Proxy Icon.

2. 系统托盘图标

3. 程序控制应用程序图标

4. 桌面屏幕信息

5. 本地窗体菜单

创建窗体

AIR 主要提供了下列方法用于创建程序窗体：

AIR 自动为每个程序创建第一个窗体。这个窗体根据应用程序描述文件设置进行初始化。如果root上下文已经在描述文件里定义，那么就可以通过Stage.window属性和NativeWindow API来访问window实例的属性和方法。另外，SWF文件的主类必须继承Sprite或Sprite的子类(WindowedApplication和Application组件都是Sprite之类) 如果root上下文是一个HTML文件，这可通过JavaScript Window 对象访问window的属性和方法。

可以创建NativeWindow类实例，通过NativeWindowInitOptions 对象实例作为NativeWindows构造函数的参数进行初始化。可直接通过该对象来访问属性和方法。

可以使用HTML组件的createRootWindow() 方法创建一个窗体用于显示HTML内容。

还可以使用JavaScript Window.open() 方法通过javascript打开一个新窗体。JavaScript创建的窗体只能通过javascript访问其属性和方法，且该窗体只能显示HTML内容。

创建一个新的本地窗体（NativeWindow）

要创建一个新的NativeWindow，可先创建一个NativeWindowInitOptions对象并传递给NativeWindow 构造函数。

代码
var options:NativeWindowInitOptions = new NativeWindowInitOptions();

options.systemChrome = NativeWindowSystemChrome.STANDARD;

options.transparent = false;

var newWin:NativeWindow = new NativeWindow(false, options);

NativeWindow构造函数第一个参数指定是否创建时立即显示该窗体，为了避免显示出如设置大小，位置和内容时窗体所处的中间状态，当你完成窗体初始化后，设置NativeWindow.visible 属性为true。第二个参数为NativeWindowInitOptions对象，该对象用于设置窗体的属性，一旦窗体创建后将不能更改。

注意：设置systemChrome="standard" 和transparent="true" 这种组合不支持。

一旦窗体被创建，你可以用stage属性和Flash显示列表初始化一些属性并载入内容到窗体之上。

注意：要确定操作系统窗体的最大化和最小化大小，可通过NativeWindowCapabilities类得到：

var maxOSSize:Point = NativeWindowsCapabilites.windowMaxSize;

var minOSSize:Point = NativeWindowsCapabilites.windowMinSize;

往窗体中添加内容

要添加内容到本地窗体上，可通过窗体的stage来添加可视化对象。你可以动态创建可视化对象或者通过flash.display.Loader类载入现成的内容。对于HTML窗体，可通过location属性来改变加载的内容或插入HTML内容到DOM。

当你载入包含JavaScript的SWF或HTML内容时必须要考虑到AIR安全模型。任何安全沙箱中的程序，无论是安装的内容或通过url载入的资源都有能力访问到AIR APIs，任何从沙箱外部载入的内容在访问受安全约束的AIR APIs和跨脚本内容时将受到限制。应用程序安全沙箱外部的JavaScript内容将不能使用JavaScript窗体对象的nativeWindow或htmlControl属性。

要想允许安全跨脚本访问，你可以使用flash.system.Door API创建一个严格受限的通讯网关，它提供有限的接口用于程序内容和非程序内容之间的访问。

载入一个SWF 或图片

可以使用flash.display.Loader类载入flash或图片到本地窗体的显示列表上。

代码
package ...{

import flash.display.Sprite;

import flash.events.Event;

import flash.net.URLRequest;

import flash.display.Loader;

public class LoadedSWF extends Sprite

...{

public function LoadedSWF()...{

var loader:Loader = new Loader();

loader.load(new URLRequest("visual.swf"));

loader.contentLoaderInfo.addEventListener(Event.COMPLETE,loadFlash);

}

private function loadFlash(event:Event):void...{

addChild(event.target.loader);

}

}

}

要在HTML窗体中载入可视化的Flash内容，必须显示在HTML内容的最顶层，或在透明的HTML内容之下。且大小和位置计算独立于HTML内容。

要想在基于HTML的程序中载入包含库代码的SWF文件，最简单的办法就是使用script 标签，也可以直接使用flash.display.Loader API 。

载入HTML内容到本地窗体（NativeWindow）上

要载入HTML内容到本地窗体上，必须在窗体的stage上添加一个HTMLControl控件，然后载入HTML内容到HTML控件上。

代码
//newWindow is a NativeWindow instance

var htmlView:HTMLControl = new HTMLControl();

html.width = newWindow.width;

html.height = newWindow.height;

//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) );

要载入HTML页面到HTML窗体上，使用JavaScript方法如window.open 。

要载入HTML页面到Flex 程序上，使用Flex HTML组件。

载入Flash 内容到HTML页面上

在这个Beta版本中，将不支持直接在HTML页面中嵌入Flash内容。页面中的任何Flash对象都将被显示为空白区域，但是使用AIR APIs载入或创建的Flash内容都将作为HTML层的形式存在。

在HTML窗体上层添加Flash内容

因为HTML窗体包含在NativeWindow 实例之内，可以在HTML层的上层或下层中添加Flash可视化对象。

要添加可视化对象到HTML层之上，可通过window.nativeWindow.stage属性的addChild() 方法，addChild()方法将把内容放在任何现成内容之上。

要添加可视化对象到HTML层之下，使用window.nativeWindow.stages属性的addChildAt()方法，传递一个0值作为索引参数，这将导致其他层都向上移动，最后把新加入的对象放在底部。要想让HTML层以下的内容可见，必须设置window.htmlControl对象的paintsDefaultBackground属性为false。

下面的例子演示如何添加一个flash对象，该例子创建了两个图形对象，一个添加在HTML层下面，一个在上面。

代码
<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

window.htmlControl.paintsDefaultBackground = false;

var bottom = new Bouncer(60,0xff2233);

var top = new Bouncer(30,0x2441ff);

//listen for the enterFrame event

window.htmlControl.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. Nemo enim ipsam voluptatem quia

voluptas sit aspernatur aut odit aut fugit, sed quia consequuntur magni dolores eos qui

ratione voluptatemsequi nesciunt. Neque porro quisquam est, qui dolorem ipsum quia

dolor sit amet, consectetur, adipisci velit, sed quia non numquam eius modi tempora

incidunt ut labore et dolore magnam aliquam quaerat voluptatem. Ut enim ad minima veniam,

quis nostrum exercitationem ullam corporis suscipit laboriosam, nisi ut aliquid ex ea

commodi consequatur? Quis autem vel eum iure reprehenderit qui in ea voluptate velit

esse quam nihil molestiae consequatur, vel illum qui dolorem eum fugiat quo voluptas

nulla pariatur?</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. Et harum quidem

rerum facilis est et expedita distinctio. Nam libero tempore, cum soluta nobis est

eligendi optio cumque nihil impedit quo minus id quod maxime placeat facere possimus,

omnis voluptas assumenda est, omnis dolor repellendus. Temporibus autem quibusdam

et aut officiis debitis aut rerum necessitatibus saepe eveniet ut et voluptates

repudiandae sint et molestiae non recusandae. Itaque earum rerum hic tenetur a

sapiente delectus, ut aut reiciendis voluptatibus maiores alias consequatur aut

perferendis doloribus asperiores repellat.</p>

</body>

</html>

示例：用ActionScript创建窗体

下面的例子演示如何创建新窗体：

代码
<?xml version="1.0" encoding="utf-8"?>

<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml"

layout="absolute" applicationComplete="createNativeWindow();">

<mx:Script>

<![CDATA[

public function createNativeWindow():void{

//create the init options

var options:NativeWindowInitOptions =

new NativeWindowInitOptions();

options.transparent = false;

options.systemChrome = NativeWindowSystemChrome.STANDARD;

options.type = NativeWindowType.NORMAL;

//create the window

var newWindow:NativeWindow = new NativeWindow(false,options);

newWindow.title = "A title";

newWindow.width = 600;

newWindow.height = 400;

//add a sprite to the window

newWindow.stage.align = StageAlign.TOP_LEFT;

newWindow.stage.scaleMode = StageScaleMode.NO_SCALE;

//show the new window

newWindow.visible = true;

}

]]>

</mx:Script>

</mx:WindowedApplication>

控制窗体

这一章节讨论如何使用NativeWindow类的属性和方法控制应用程序窗体的外观和行为。

得到NativeWindow实例

要想操作窗体，必须先得到窗体实例，可在下面这些地方得到窗体实例：

窗体构造函数

也就是新建NativeWindow所用的构造函数.

窗体的stage

也就是stage.nativeWindow

任何可视化对象的stage

也就是myDisplayObject.stage.nativeWindow.

窗体事件

Event对象的target属性指向窗体引用

HTMLControl或HTML窗体的全局属性nativeWindow

也就是window.nativeWindow.

Shell 对象

Shell.shell.activeWindow 指向应用程序的活动窗体（激活状态，如果没有任何窗体处于激活状态则返回null）。Shell.shell.openedWindows数组包含应用程序中所有未被打开的窗体。

因为Flex Application, WindowedApplication, 和Window 对象都是可视化对象，我们可以很容易通过stage属性得到窗体引用：

代码
<?xml version="1.0" encoding="utf-8"?>

<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" applicationComplete="init();">

<mx:Script>

<![CDATA[

import flash.display.NativeWindow;

public function init():void{

var appWindow:NativeWindow = this.stage.nativeWindow;

//set window properties

appWindow.visible = true;

}

]]>

</mx:Script>

</WindowedApplication>

激活，显示，隐藏窗体

调用NativeWindow.activate()方法激活一个窗体，激活窗体后将使窗体显示在最顶层，开始获得键盘和鼠标焦点，如果有必要可恢复window的visible属性或设置visible=true，激活一个窗体并不会改变其他窗体的顺序。

要想显示没有激活的隐藏窗体，可设置其visible属性为true，这将使窗体显示在最顶层，但是由于未激活，不能接收键盘和鼠标反应。

要隐藏窗体，可设置NativeWindow.visible属性为false。隐藏一个窗体将取消窗体的显示以及相关的任何栏图标。

最大化，最小化和还原窗体

使用NativeWindow.maximize()方法使窗体最大化显示

myWindow.maximize();

使用NativeWindow.minimize()方法使窗体最小化显示

myWindow.minimize();

还原一个窗体指恢复到最大化和最小化之前的状体。

myWindow.restore();

改变窗体显示顺序

AIR为窗体提供两组显示顺序，由alwaysInFront 属性进行控制。通过设置alwaysInFront=false，意思是把窗体放在正规的组群众，大多数窗体都放在这里。而第二个组群所放的窗体总是显示在正规组群窗体的上层。如果没有这个特殊组群的话，改变窗体顺序将会显得非常混乱，下列情况都将用到这个窗体组群：

l 临时的弹出式窗体，比如提示框，弹出式列表，自定义菜单或组合框，因为这些窗体用完即关闭。

l 屏幕保护

l 一些急需的错误信息框

l 生命周期很短的窗体

l 游戏或视频的全屏窗体

NativeWindow类提供下列方法用于设置窗体之间的显示顺序：

alwaysInFront 属性

指定使用哪个窗体组，一般情况下alwaysInFront=false ，如果设为true，这表示所有窗体都处于顶层位置（只是没有激活），如果在设为false，表示把窗体放入正规组的顶层（但是仍在顶层组的后面）。设置该值并不会改变窗体的顺序。

orderToFront()

设置该窗体为组群中最前

orderInFrontOf()

设置该窗体排在某窗体之前

orderToBack()

设置该窗体为组群中最后

orderBehind()

设置该窗体排在某窗体之后

注意：如果该窗体被隐藏或最小化，调用这些方法将无效。

关闭窗体

使用NativeWindow.close方法关闭窗体

关闭一个窗体将卸载该窗体所包含的内容，不过如果还有其他对象引用这些内容，将不会被销毁。NativeWindow.close()方法的执行是异步的，应用程序仍然在关闭窗体过程中继续运行，当关闭完成时，该close方法将触发一个close事件。窗体被关闭后将无法访问其大部分属性和方法，否则会抛出IllegalOperationError异常，关闭的窗体将不能再次打开，可通过closed属性检测窗体是否已被关闭。要简单的隐藏窗体，只要设置其visible属性为false就可以了。

如果Shell.autoExit属性为true（默认设置），当应用程序的所有窗体都关闭后，程序也将停止运行。

允许撤销对窗体的操作

当窗体使用操作系统窗体风格，用户与窗体的交互可通过一些事件进行取消，比如说，单用户点击一个窗体上系统菜单的关闭按钮，这closing事件将被触发，任何注册的监听器调用preventDefault()方法可以取消关闭窗体。

如果窗体不使用系统窗体风格，这需要手动出发相应的事件。如果你调用一个方法要关闭窗体或改变窗体大小或设置bounds属性，这些改变将不能被取消，除非在窗体发生变化之前通知应用程序，应用程序逻辑通过dispatchEvent()发出相关的事件。

看下面的例子，下面的逻辑实现了可取消的窗体关闭按钮。：

代码
public function onCloseCommand(event:MouseEvent):void...{

var closingEvent:Event = new Event(Event.CLOSING,true,true);

dispatchEvent(closing);

if(!closingEvent.isDefaultPrevented())...{

win.close();

}

}

注意：如果事件的preventDefault() 方法被监听器调用，则dispatchEvent()方法返回false，但是也有其他原因可能返回false，所以最好的办法是使用isDefaultPrevented()方法检测是否已经取消操作。

例子：最小化，最大化，还原和关闭窗体

下面的这段代码演示窗体的maximize(), minimize(), restore(), 和close() 方法。

代码
<?xml version="1.0" encoding="utf-8"?>

<mx:WindowedApplication

xmlns:mx="http://www.adobe.com/2006/mxml"

layout="vertical">

<mx:Script>

<![CDATA[

public function minimizeWindow():void

{

this.stage.nativeWindow.minimize();

}

public function maximizeWindow():void

{

this.stage.nativeWindow.maximize();

}

public function restoreWindow():void

{

this.stage.nativeWindow.restore();

}

public function closeWindow():void

{

this.stage.nativeWindow.close();

}

]]>

</mx:Script>

<mx:VBox>

<mx:Button label="Minimize" click="minimizeWindow()"/>

<mx:Button label="Restore" click="restoreWindow()"/>

<mx:Button label="Maximize" click="maximizeWindow()"/>

<mx:Button label="Close" click="closeWindow()"/>

</mx:VBox>

</mx:WindowedApplication>

例子：改变大小和移动窗体

使用NativeWindow.startResize()方法改变窗体大小，该方法实际上是触发系统控制功能来改变窗体大小。当该方法在mouseDown 事件里调用时，大小改变是由鼠标确定的，当系统接收到mouseUp事件则停止大小调整。

如果不改变大小只移动窗体，可使用NativeWindow.startMove()方法，和startResize()方法一样，当startMove()方法mouseDown 事件里调用时，窗体移动过程是由鼠标确定的，直到系统接收到鼠标的mouseUp事件。

下面的这个例子演示如何初始化改变窗体大小和移动窗体操作：

代码
package

...{

import flash.display.Sprite;

import flash.events.MouseEvent;

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 trigger a 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 trigger a 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();

}

}

}

监听窗体事件

如要监听窗体发出的事件，可通过窗体注册一个监听器，例如，要监听closing事件，用下面的代码注册：

myWindow.addEventListener(Event.CLOSING, onClosingEvent);

当事件发出时，窗体引用的target属性发出该事件。

大多数窗体事件都有两种消息，第一个消息是该窗体的变化快要临近（是可以取消的），而另一个消息表示变化已经发生。例如，当用户点击关闭按钮，则closing事件消息被触发，如果没有监听器取消该事件，则窗体被关闭。

flash.events.Event 类的相关事件：

ACTIVATE

DEACTIVATE

CLOSING

CLOSE

NativeWindowBoundsEvent:

使用beforeBounds和afterBounds属性来检测窗体边界是否即将改变或已经完成改变。

MOVING

MOVE

RESIZING

RESIZE

NativeWindowDisplayStateEvent:

使用beforeDisplayState和afterDisplayState 属性检测窗体改变状态是即将改变还是已经完成改变。

DISPLAY_STATE_CHANGING

DISPLAY_STATE_CHANGE

使用全屏模式

这是Stage的displayState属性为StageDisplayState.FULL_SCREEN使窗体进入全屏模式，全屏模式下鼠标和键盘仍有效。（如果在浏览器中运行的SWF，这键盘无效），如要退出全屏模式，只要点击ESC键即可。

例如，下面的Flex代码定义一个简单全屏模式的AIR应用程序：

代码
<?xml version="1.0" encoding="utf-8"?>

<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml"

layout="vertical"

applicationComplete="init()" backgroundColor="0x003030" focusRect="false">

<mx:Script>

<![CDATA[

private function init():void

{

stage.displayState = StageDisplayState.FULL_SCREEN;

focusManager.setFocus(terminal);

terminal.text = "Welcome to the dumb terminal app. Press the ESC key to exit.. ";

terminal.selectionBeginIndex = terminal.text.length;

terminal.selectionEndIndex = terminal.text.length;

}

]]>

</mx:Script>

<mx:TextArea

id="terminal"

height="100%" width="100%"

scroll="false"

backgroundColor="0x003030"

color="0xCCFF00"

fontFamily="Lucida Console"

fontSize="44"/>

</mx:WindowedApplication>

屏幕

根据AIR screen API可以获得系统桌面显示屏幕的信息。

屏幕简介

screen API包含一个简单类，Screen，获得系统屏幕信息和屏幕的详细描述。

计算机系统可能有多个监视器或显示设备，这样对应的多个桌面屏幕排列在虚拟空间上。AIR Screen类提供了关于屏幕信息，如果有多个监视器映射到同一个屏幕上，那只有一个屏幕可显示，如果屏幕的尺寸大于监视器显示范围，没有办法确定是哪一部分处于可视状态。

一个屏幕表示一个独立的桌面显示区域，被描述为虚拟桌面的一个矩形区域，屏幕左上角为初始坐标，单位为像素。

screen_bounds.png ( 36.98KB ) 下载次数: 9

上面的屏幕排列中，虚拟桌面上有两个屏幕，主屏幕（#1）的左上角坐标总是（0，0），如果屏幕排列设置屏幕#2作为主屏幕，则屏幕#1的坐标将为负坐标，一般指屏幕的可使用边界不包括菜单栏，任务栏。

枚举屏幕

通过下列屏幕方法和属性枚举虚拟桌面上的屏幕：

Screen.screens

数组对象，表示可用的屏幕，注意数组的元素顺序不是有效的。

Screen.mainScreen

表示代表主屏幕的屏幕对象，在Mac OS X系统中，主屏幕为显示菜单栏的所在屏幕，在Windows中为系统指定的主屏幕。

Screen.getScreensForRectangle()

通过指定的区域获得屏幕对象数组，该矩形区域作为参数传递给该方法，如果没有屏幕在范围内则返回空数组。

示例：在屏幕中移动窗体

这个例子使用screen API通过方向键在多个屏幕中移动窗体。

代码
package ...{

import flash.display.Sprite;

import flash.display.Screen;

import flash.events.KeyboardEvent;

import flash.ui.Keyboard;

import flash.display.StageAlign;

import 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.bounds.left < stage.nativeWindow.bounds.left)...{

stage.nativeWindow.x +=

left.bounds.left - currentScreen.bounds.left;

stage.nativeWindow.y += left.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.bounds.left > stage.nativeWindow.bounds.left)...{

stage.nativeWindow.x +=

left.bounds.left - currentScreen.bounds.left;

stage.nativeWindow.y += left.bounds.top - currentScreen.bounds.top;

}

}

}

private function moveUp():void...{

var currentScreen:Screen = getCurrentScreen();

var top:Array = Screen.screens;

top.sort(sortVertical);

for(var i:int = 0; i < top.length - 1; i++)...{

if(top.bounds.top < stage.nativeWindow.bounds.top)...{

stage.nativeWindow.x += top.bounds.left - currentScreen.bounds.left;

stage.nativeWindow.y += top.bounds.top - currentScreen.bounds.top;

break;

}

}

}

private function moveDown():void...{

var currentScreen:Screen = getCurrentScreen();

var top:Array = Screen.screens;

top.sort(sortVertical);

for(var i:int = top.length - 1; i > 0; i--)...{

if(top.bounds.top > stage.nativeWindow.bounds.top)...{

stage.nativeWindow.x += top.bounds.left - currentScreen.bounds.left;

stage.nativeWindow.y += top.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;

}

}

}

刷新页面返回顶部

Lee's 程序人生

公告

转：AIR应用开发中文指南(BETA2)