AIR与本地应用程序的交互是AIR 2.0的一个重要更新，这个功能的实现可以帮助我们做到在AIR 1.5时代很难完成的事情，比如我在项目中就需要操作一些硬件，但AIR不能直接操作端口，所以只能借助其他的小程序来实现，现在我们就可以很容易的操作这些小程序以达到操作硬件的目的，而Flex (AIR)与JAVA的结合很早就已经开始了，但由于早期AIR的局限性，想要把JAVA直接部署在客户端还是比较麻烦的事情，但是从AIR2.0开始我们不用担心了。现在我们用很简单的方式就可以在AIR程序中集成TOMCAT, 一次性的将后台与AIR部署到客户端。

程序的原版（Flash Builder 4版）同样是从http://coenraets.org/获得，有兴趣的朋友可以关注这个博客。我的例子仍然使用FLEX 3.

Demo过程

1. 下载安装 AIR 2.0 beta runtime.
2. 下载AIRAppWithEmbeddedTomcat..exe 或者 AIRAppWithEmbeddedTomcat.dmg (NativeProcess 必须在程序发布为相应平台的应用程序后才可以使用，发布的方法这里就不介绍了，可以参看http://help.adobe.com/en_US/FlashPlatform/develop/air/building_apps/WS789ea67d3e73a8b22388411123785d839c-8000.html)
3. 安装运行AIRAppWithEmbeddedTomcat.exe, 修改JAVA_HOME，如果默认的路径不对
4. 点击 “启动” 可以开启TOMCAT(端口是8080)。在JSP实例和RemoteObject实例中可以看见加载JSP页面和使用RemoteObject获取数据的测试。

控制台

JSP 加载测试

RemoteObject 测试

源代码

<?xml version="1.0" encoding="utf-8"?>
<!--www.flextheworld.com-->
<mx:WindowedApplication applicationComplete="init()" xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" height="600" width="800" >
	<mx:Script>
        <![CDATA[
            import mx.controls.Alert;
 
            //用于启动和停止Tomcat的进程
            private var startTomcatProcess:NativeProcess;
            private var stopTomcatProcess:NativeProcess;
 
            private var tomcatHomeDir:File;
 
            public function init():void
            {
                if (!NativeProcess.isSupported)
                {
                    Alert.show("不支持进程控制，请先将程序发布为当前操作系统应用程序");
                }
 
                //如果tomcat不存在，重新复制到app store文件夹
                tomcatHomeDir = File.applicationStorageDirectory.resolvePath("tomcat");
                if (!tomcatHomeDir.exists)
                {
                    var tomcatOriginalDir:File = File.applicationDirectory.resolvePath("tomcat");
                    trace("Copying tomcat to appStorageDirectory...");
                    tomcatOriginalDir.copyTo(tomcatHomeDir);
                    var f:File;
                    f.openWithDefaultApplication()
                }
 
 
                tomcatHome.text = tomcatHomeDir.nativePath;             
 
                // 读取保存的配置（第一次运行以后生成）
                var xml:XML = readConfig();
                if (xml != null)
                {
                    javaHome.text = xml.javaHome;
                    return;
                }
 
                // 如果第一次使用，设置默认Path
                if (Capabilities.os.toLowerCase().indexOf("win") > -1)
                {
                    // 默认的JAVA_HOME (windows)
                    javaHome.text = "C:\\Program Files\\Java\\jdk1.6.0";
                }
                else if (Capabilities.os.toLowerCase().indexOf("mac") > -1)
                {
                    // 默认的JAVA_HOME (Mac)
                    javaHome.text = "/System/Library/Frameworks/JavaVM.framework/Versions/1.6.0";
                }
 
            }
 
            public function startTomcat():void
            {
                // 将本次的JAVA_HOMR写入配置文件
                writeConfig();
 
                log.text = "Starting Tomcat..." + File.lineEnding;
                startTomcatProcess = new NativeProcess();
                execute(startTomcatProcess, "start");
            }
 
            public function stopTomcat():void
            {
                log.text = "Stopping Tomcat..." + File.lineEnding;
                stopTomcatProcess = new NativeProcess();
                execute(startTomcatProcess, "stop");
            }
 
            public function execute(process:NativeProcess, arg:String):void
            {
                // 先获取JVM
                var file:File = new File(javaHome.text);
                if (Capabilities.os.toLowerCase().indexOf("win") > -1)
                {
                    file = file.resolvePath("bin/javaw.exe");
                }
                else
                {
                    file = file.resolvePath("Home/bin/java");
                }
 
                // 启动TOMCAT
                try
                {
                    var nativeProcessStartupInfo:NativeProcessStartupInfo = new NativeProcessStartupInfo();
                    nativeProcessStartupInfo.executable = file;
                    nativeProcessStartupInfo.workingDirectory = tomcatHomeDir.resolvePath("bin");
                    var processArgs:Vector.<String> = new Vector.<String>();
                    processArgs[0] = "-Dcatalina.home="+tomcatHomeDir.nativePath;
                    processArgs[1] = "-classpath";
                    processArgs[2] = tomcatHomeDir.resolvePath("bin/bootstrap.jar").nativePath;
                    processArgs[3] = "org.apache.catalina.startup.Bootstrap";
                    processArgs[4] = arg;
                    nativeProcessStartupInfo.arguments = processArgs;
                    startTomcatProcess = new NativeProcess();
                    startTomcatProcess.start(nativeProcessStartupInfo);
                    startTomcatProcess.addEventListener(ProgressEvent.STANDARD_OUTPUT_DATA,
                        outputDataHandler);
                    startTomcatProcess.addEventListener(ProgressEvent.STANDARD_ERROR_DATA,
                        errorOutputDataHandler);
                }
                catch (e:Error)
                {
                    Alert.show(e.message, "Error");
                }
            }
 
            public function outputDataHandler(event:ProgressEvent):void
            {
                var process:NativeProcess = event.target as NativeProcess;
                var data:String = process.standardOutput.readUTFBytes(process.standardOutput.bytesAvailable);
                log.text += data;
            }
 
            public function errorOutputDataHandler(event:ProgressEvent):void
            {
                var process:NativeProcess = event.target as NativeProcess;
                var data:String = process.standardError.readUTFBytes(startTomcatProcess.standardError.bytesAvailable);
                log.text += data;
            }
 
            private function readConfig():XML
            {
                var file:File = File.applicationStorageDirectory.resolvePath("config.xml");
                if (file.exists)
                {
                    var fileStream:FileStream = new FileStream();
                    fileStream.open(file, FileMode.READ);
                    var xml:XML = XML(fileStream.readUTFBytes(fileStream.bytesAvailable));
                    fileStream.close();
                    return xml;
                }
                else
                {
                    return null;
                }
            }
 
            private function writeConfig():void
            {
                var xml:String = '<?xml version="1.0" encoding="utf-8"?>' + File.lineEnding;
                xml += "<config>" + File.lineEnding;
                xml += "<javaHome>" + javaHome.text + "</javaHome>" + File.lineEnding;
                xml += "<tomcatHome>" + tomcatHome.text + "</tomcatHome>" + File.lineEnding;
                xml += "</config>" + File.lineEnding;
 
                var file:File = File.applicationStorageDirectory.resolvePath("config.xml");
                var fileStream:FileStream = new FileStream();
                fileStream.open(file, FileMode.WRITE);
                fileStream.writeUTFBytes(xml);
                fileStream.close();
            }
 
 
        ]]>
    </mx:Script>
 
<mx:RemoteObject id="srv" destination="contacts" endpoint="http://localhost:8080/messagebroker/amf" />
    <mx:TabNavigator width="100%" height="100%">
        <mx:VBox width="100%" height="100%" label="控制台" paddingLeft="8" paddingRight="8" paddingBottom="8">
 
            <mx:Form width="100%">
                <mx:FormItem label="Java Home" width="100%">
                    <mx:TextInput id="javaHome" width="100%"/>
                </mx:FormItem>
                <mx:FormItem label="Tomcat Home (嵌入的TOMCAT)" width="100%">
                    <mx:TextInput id="tomcatHome" width="100%" enabled="false"/>
                </mx:FormItem>
            </mx:Form>
 
            <mx:HBox>
                <mx:Button label="启动" click="startTomcat()"/>
                <mx:Button label="停止" click="stopTomcat()"/>
                <mx:Button label="清除信息" click="log.text=''"/>
 
            </mx:HBox>
            <mx:TextArea id="log" width="100%" height="100%"/>
 
        </mx:VBox>
 
        <mx:VBox label="嵌入的JSP实例" paddingLeft="8" paddingRight="8" paddingBottom="8">
            <mx:HTML id="html" width="100%" height="100%"/>
            <mx:Button label="读取JSP" click="html.location='http://localhost:8080'"/>
        </mx:VBox>
 
        <mx:VBox label="嵌入的RemoteObject实例" paddingLeft="8" paddingRight="8" paddingBottom="8">
            <mx:DataGrid width="100%" height="100%" dataProvider="{srv.findAll.lastResult}">
                <mx:columns>
                    <mx:DataGridColumn dataField="id" headerText="Id"/>
                    <mx:DataGridColumn dataField="firstName" headerText="First Name"/>
                    <mx:DataGridColumn dataField="lastName" headerText="Last Name"/>
                    <mx:DataGridColumn dataField="city" headerText="City"/>
                </mx:columns>
            </mx:DataGrid>
            <mx:Button label="获取数据" click="srv.findAll()"/>
        </mx:VBox>
 
    </mx:TabNavigator>
</mx:WindowedApplication>

下载

源代码: AIRAppWithEmbeddedTomcat.zip (221)

windows demo: AIRAppWithEmbeddedTomcat.exe (176)

Mac Demo: AIRAppWithEmbeddedTomcat.dmg (120)

这篇教程将使用ServerSocket功能做一个HTML服务器，这个不是我原创的，是看到一个老外写的，觉得很有意思，是一个ServerSocket的好例子，原文在 http://coenraets.org/blog/2009/12/air-2-0-web-server-using-the-new-server-socket-api/. 原文是Flash Builder 4 版本的，这里我给大家的是Flex 3版本, 使用源代码请先下载AIR 2.0 SDK

Demo过程

1. 下载安装 AIR 2.0 beta runtime.
2. 下载MiniAIRWebServer.air
3. 安装运行 MiniAIRWebServer.air.
4. 运行 http://localhost:8765/HelloWorld.html （端口以你在运行MiniAIRWebServer.air后输入的为准, 注意安装MiniAIRWebServer.air后安装文件夹下的webroot/HelloWorld.html, 我们运行的就是这个文件）

运行效果如下:

源代码

<?xml version="1.0" encoding="utf-8"?>
<mx:WindowedApplication xmlns:mx="http://www.adobe.com/2006/mxml" layout="vertical" close="closeHandler()" creationComplete="init()">
	<mx:Script>
		<![CDATA[
			import flash.events.Event;
            import flash.events.ProgressEvent;
            import flash.events.ServerSocketConnectEvent;
            import flash.net.ServerSocket;
            import flash.net.Socket;
            import flash.utils.ByteArray;
 
            import mx.controls.Alert;
 
 
            //ServerSocket，用于监听TCP下的链接
            private var serverSocket:ServerSocket;
 
            private var mimeTypes:Object = new Object();
 
            private function init():void
            {
                // 支持的类型
                mimeTypes[".css"]     = "text/css";
                mimeTypes[".gif"]     = "image/gif";
                mimeTypes[".htm"]     = "text/html";
                mimeTypes[".html"]     = "text/html";
                mimeTypes[".ico"]     = "image/x-icon";
                mimeTypes[".jpg"]     = "image/jpeg";
                mimeTypes[".js"]     = "application/x-javascript";
                mimeTypes[".png"]     = "image/png";
 
                // 初始化服务器文件夹
                var webroot:File = File.applicationStorageDirectory.resolvePath("webroot");
                if (!webroot.exists)
                {
                    File.applicationDirectory.resolvePath("webroot").copyTo(webroot);
                }
            }
 
            private function listen():void
            {
                try
                {
 
                    serverSocket = new ServerSocket();
                    //监听链接
                    serverSocket.addEventListener(Event.CONNECT, socketConnectHandler);
                    //绑定端口
                    serverSocket.bind(Number(port.text));
                    //开始
                    serverSocket.listen();
                    log.text += "正在监听 " + port.text + "端口...\n";
                }
                catch (error:Error)
                {
                    Alert.show("端口 " + port.text + 
                        " 也许正在被使用，请尝试另一个端口.\n(" +
                        error.message +")", "错误");
                }
            }
 
            private function socketConnectHandler(event:ServerSocketConnectEvent):void
            {
                var socket:Socket = event.socket;
                //监听数据
                socket.addEventListener(ProgressEvent.SOCKET_DATA, socketDataHandler);
            }
 
            private function socketDataHandler(event:ProgressEvent):void
            {
                try
                {
                    var socket:Socket = event.target as Socket;
                    var bytes:ByteArray = new ByteArray();
                    socket.readBytes(bytes);
                    var request:String = "" + bytes;
                    log.text += request;
                    var filePath:String = request.substring(4, request.indexOf("HTTP/") - 1);
                    var file:File = File.applicationStorageDirectory.resolvePath("webroot" + filePath);
                    if (file.exists && !file.isDirectory)
                    {
                        var stream:FileStream = new FileStream();
                        stream.open( file, FileMode.READ );
                        var content:ByteArray = new ByteArray();
                        stream.readBytes(content);
                        stream.close();
                        socket.writeUTFBytes("HTTP/1.1 200 OK\n");
                        socket.writeUTFBytes("Content-Type: " + getMimeType(filePath) + "\n\n");
                        socket.writeBytes(content);
                    }
                    else
                    {
                        socket.writeUTFBytes("HTTP/1.1 404 Not Found\n");
                        socket.writeUTFBytes("Content-Type: text/html\n\n");
                        socket.writeUTFBytes("<html><body><h2>Page Not Found</h2></body></html>");
                    }
                    socket.flush();
                    socket.close();
                }
                catch (error:Error)
                {
                    Alert.show(error.message, "错误");
                }
            }
 
            private function getMimeType(path:String):String
            {
                var mimeType:String;
                var index:int = path.lastIndexOf(".");
                if (index > -1)
                {
                    mimeType = mimeTypes[path.substring(index)];
                }
                return mimeType == null ? "text/html" : mimeType;
            }
 
 
            private function closeHandler():void{
            	if(serverSocket){
            		serverSocket.close()
            	}
 
            }
		]]>
	</mx:Script>
 
	<mx:HBox verticalAlign="middle">
        <mx:Label text="Port:"/>
        <mx:TextInput id="port" text="8765" width="50"/>
        <mx:Button label="Listen" click="listen()"/>
    </mx:HBox>
 
    <mx:TextArea id="log" width="100%" height="100%" />
</mx:WindowedApplication>

下载:

1. 用户在文本框中输入内容。文本框下方的保存按钮会动态显示当前网络状态: (在线)保存与(离线)保存.
2. 在用户点击保存按钮时如果网络在线，将对话框内容保存在服务器。
3. 如果保存时处于断线状态，将内容保存在本地文件中。
4. 当网络恢复时检查本地文件，如果有已经保存的内容，将内容传入服务器。

源代码很简单，不到100行，大家可以在最下方下载。现在我开始讲解

Demo操作方法

1. 按装运行demo，如果网络连接正常，你会看到文本框下的按钮为 (在线) 保存。
2. 输入任意信息，点击 （在线）保存 。你会看倒信息 “内容已上传服务器”。
3. 切断网络。大概3－5秒后你会看到文本框下方按钮变为（离线）保存。
4. 点击保存，你会看倒信息“内容已经在本地保存，会在下次连线时自动上传到服务器”。
5. 接痛网络,大概3－－5秒后你会看倒信息 “缓存内容已上传服务器”。
6. Demo结束。

1. 启动应用程序后监控网络状态。

我们在 App的CreationComplete()中调用netWorkSyc来监控网络状态。

private function networkSyc():void{
//创建一个联接，使用HEAD表示不需要加载玩全部的页面。
var request:URLRequest = new URLRequest( “http://www.google.com”);
request.method = “HEAD”;

//用url创建监测对象，每3秒检查一次网络状态，如果网络状态发生变化，将结果返回到netWorkStatusHandle()
urlMonitor = new URLMonitor(request);
urlMonitor.pollInterval = 3000;
urlMonitor.addEventListener(StatusEvent.STATUS,netWorkStatusHandle);
urlMonitor.start();
}

//网络状态改变时响应该事件
private function netWorkStatusHandle(e:StatusEvent):void{
if(urlMonitor.available){
//如果有本地文件，假装上传服务器
if(this.checkLoaclFile()){
//Kevin TODO 上传服务骑
this.showAlert(“缓存内容已上传服务器”);
}
saveBtn.label = “（在线）保存”
}else{
saveBtn.label = “（离线）保存”
}
}

上面的networkSyc()方法中我使用了两个类的对象来实现网络监控，URLRequest 和 URLMonitor。我用URLRequest来建立一个连接对象request，连接的地址是www.google.com。然后已request作为构造参数创建URLMonitor对象。我就是靠它来完成对网络状态的监控。

监控原理很简单，当第一次执行networkSyc()时，urlMonitor会尝试连接www.google.com，然后将连接的结果发回到 netWorkStatusHandle(), 如果连接成功，urlMonitor.available会为true,反之为false。接下来每3秒检查一次网络状态，如果发生改变(连接成功变为连接失败或者连接失败变为连接成功)，那么将再度触发StatusEvent.STATUS事件，调用netWorkStatusHandle()返回网络状态。

以上就是AIR监控网络的方式，大家如果感兴趣想知道更多URLMonitor的内容，可以在Help中搜索ServiceMonitor,它的sub class就是URLMonitor和SockterMonitor。

Demo中并没有真正在本地保存文件，保存与读取文件的方法我会在下一篇教程–“AIR的文件操作”中教给大家。

源文件下载
Demo

我们想想文件操作都会有什么内容，无非是创建，修改，删除，移动，拷贝。在这个过程中我们会涉及到一些周边的操作，比如文件夹，文件选择器，文件列表，文件信息获取等。 我就围绕创建，修改，删除，移动，拷贝来展开我们的教程。因为内容比较多，基于迷你教程每篇都短小，易读的原则。我分为两篇，今天先讲第一篇，基本的操作，下一篇我再加入上面所说周边的操作相对深一步的讲解。

Air的文件操做主要涉及两个类，FIle和FileStream。一般来说我们不会直接以文本形式保存文件，那样的内容不易于修改，所以这里我以xml 文件为例。

Note: 下面所有的function可以直接复制到你的代码中运行

1.创建新文件。

public function createFileDemo():void{

var file:File = File.desktopDirectory.resolvePath(“test.xml”) //尝试从系统桌面获取test.xml文件。
var fileStream:FileStream = new FileStream(); // 创建FileStream 对象，用于读写文件
fileStream.open(file,FileMode.WRITE); //以WRITE方式打开file, 如果file中对应的文件不存在，创建新文件

//准备文件的内容
var content:XML =
我们的第一个文件创建完毕

fileStream.writeUTFBytes(content.toXMLString()); //像文件中写入内容。
fileStream.close(); //完成写入，这时我们打开桌面的test.txt可以看到内容。

}

上面五句代码让我在我的桌面创建了名为test.xml的文件，并且写入了content。

这里有三个地方我们要注意

1. File.desktopDirectory — 因为AIR可以在Mac和Windows下运行，所以我们最好不要指定固定的地址，这里File.desktopDirectory的意思就是指向我系统的桌面，因为我是mac，所以实际返回的是 /kevinluo/Desktop. 除此之外我们还可以得到如下面这些地址

File.documentsDirectory; //指向用户文档文件夹
File.applicationDirectory; //应用程序安装目录
File.getRootDirectories(); //文件系统根目录

等等，我就不一一列举了，具体的大家可以看File帮助中描述。

2.File.desktopDirectory.resolvePath(“test.xml”) — 获取桌面下的test.xml。这里我们还可以这样写

var file:File = File.desktopDirectory
file = file.resolvePath(“test.xml”)

不过我建议还是直接写在一排，如果像这样分开写的话，当fileStream.open(file,FileMode.WRITE) 打开文件时，如果文件不存在就会报错而不会像上面那样创建新的文件。

3. fileStream.open(file,FileMode.WRITE) –FileMode.WRITE是打开文件的方法，打开文件的方法一共有如下四种

FileMode.READ // 只读方式打开文件
FileMode.WRITE // 写方式打开文件，文件的原有内容会被清除。文件不存在的话创建新文件
FileMode.APPEND //追加方式打开文件，写入的内容总是会添加到文件的末尾。文件不存在的话创建新文件
FileMode.UPDATE //直接打开文件，可以根据需要在指定位置插入数据。文件不存在的话创建新文件

这里我们以WRITE方式创建了新文件，并写入了“我们的第一个文件创建完毕”。

2. 读取已有的文件，修改内容，再更新文件。

publuc function modifyFileDemo():void{

var file2:File = File.desktopDirectory.resolvePath(“test.xml”); //读取刚才创建的test.xml
var fs:FileStream = new FileStream();
fs.open(file2,FileMode.READ); //以只读方式打开
var ct:XML = new XML(fs.readUTFBytes(fs.bytesAvailable)); //获取xml内容
ct.content = “我们的第一个文件修改完毕” //修改content节点下的内容
fs.open(file2,FileMode.WRITE); //重新以写方式打开文件，目的在于清除原有的内容
fs.writeUTFBytes(ct.toXMLString()) //写入修改过后的XML
fs.close()

}

这里我用了READ和WRITE的组合。在实际的使用中我们可以判断一个xml文件的大小来限制单个文件写入过大。

3.删除文件。

删除文件是最简单的。

public function deleteFIleDemo():void{

var file2:File = File.desktopDirectory.resolvePath(“test.xml”);
if(file2.exists){ //判断文件是否存在
file2.deleteFile() //删除文件
}

}

如果使用file2.moveToTrash()则将文件移到垃圾箱

4.拷贝文件/移动文件

public function copyFileDemo():void{

var sourceFile:File = File.desktopDirectory.resolvePath(“test.xml”) //获取源文件
var newFile:File = File.desktopDirectory.resolvePath(“test2.xml”) //创建目标文件
sourceFile.copyTo(newFile,true) //执行拷贝，如果是移动的话sourceFile.moveTo(newFile,true)

}

5. 异步与同步

AIR对文件的操作分为异步与同步两种方式。上面1–4介绍的是同步方式，其中的一些方法有另一个异步方式，看下面的列表

File.copyTo() — File.copyToAsync()
File.moveTo() — File.moveToAsync()
File.deleteDirectory() — File.deleteDirectoryAsync()
File.deleteFile() — File.deleteFileAsync()
File.getDirectoryListing() – File.getDirectoryListingAsync()
File.moveToTrash() — File.moveToTrashAsync()

FileStream.open — FileStream.openAsync()

使用异步方式时我们需要监听EVENT.COMPLETE和IOErrorEvent.IO_ERROR事件来获取file的操作结果。我拿上面的拷贝做个例子

pirvate funnction copyFile(sourceFIlePath:String, targetFIlePath:String):void{

var sourceFile:File = File.desktopDirectory.resolvePath(sourceFIlePath) //获取源文件
var newFile:File = File.desktopDirectory.resolvePath(targetFIlePath) //创建目标文件
sourceFile.addEventListener(Event.COMPLETE,completeHandle) //监听文件操作complete事件
sourceFile.copyToAsync(newFile,true) ; //开始拷贝，异步方式
this. showLoadingBar() //打开loading图标

}

private function completeHandle():void{

Alert.show(“拷贝文件完成”)
this.closeLoadingBar() //关闭loading图标

}

异步方式的好处是我们可以从中实行一些别的操作，比如出现一个loading的提示之类。

OK, 休息了

Demo主要有以下功能

1. 简单继承window类创建MyWindow。加入parentWindow属性以及advOpen()方法, 设置MyWindow默认样式。
2. 从主程序中弹出窗口1，从窗口1中弹出窗口2。每个窗口里有image和button
3. 窗口1可以关闭主程序窗口，窗口2可以关闭窗口1。（关闭父窗口）

1. 简单继承window类创建MyWindow。加入parentWindow属性以及advOpen()方法, 设置MyWindow默认样式。

下面是我继承于WIndow的MyWindow，构造方法中设置了默认样式，parentWindow用于在打开窗口时保存父窗口对象。

public class MyWindow extends Window
{
public var parentWindow:Object;

public function MyWindow()
{
this.systemChrome = “none”; //不显示系统窗口
this.showStatusBar = false; //不显示底部状态栏
this.showGripper = false; //不显示底部大小控制按钮
}

/**
* 自定义open()打开窗口并且保存调用此方法的对象
*/
public function advOpen(parentWindow:Object,openWindowActive:Boolean = true):void{
this.parentWindow = parentWindow;
this.open(true)
}

}

2. 从主程序中弹出窗口1，从窗口1中弹出窗口2。每个窗口里有image和button

3. 窗口1可以关闭主程序窗口，窗口2可以关闭窗口1。（关闭父窗口）

下面是窗口1类，继承于MyWindow。在主程序中用了与下面相同的openWin打开窗口1，可以看倒在调用winX.advOpen时传入了当前对象作为被打开窗口的parentWindow. 下面的closeParent()中利用保存的 parentWindow关闭父窗口。

<local:MyWindow xmlns:mx=”http://www.adobe.com/2006/mxml” layout=”absolute” width=”435″ height=”320″ xmlns:local=”*”>
<mx:Script>
<![CDATA[
import mx.core.Window;

//打开窗口2
private function openWin():void{
var win2:PicTwo = new PicTwo();
win2.advOpen(this);
win2.move(500,50)
}

//关闭父窗口
private function closeParent():void{
if(this.parentWindow.hasOwnProperty("close")){ //检查父窗口中是否有close方法。
this.parentWindow.close(); //调用父窗口的close方法
}
}
]]>
</mx:Script>
<mx:Canvas>
<mx:Image source=”@Embed(‘images/2.png’)” />
<mx:Button label=”打开我的表情2″ click=”openWin()” x=”325″ y=”174″/>
<mx:Button label=”关闭父窗口” click=”closeParent()” x=”342″ y=”204″/>
</mx:Canvas>
</local:MyWindow>

主程序

<mx:WindowedApplication showStatusBar=”false” showGripper=”false” xmlns:mx=”http://www.adobe.com/2006/mxml” width=”430″ height=”328″ layout=”absolute”>
<mx:Script>
<![CDATA[
import mx.core.Window;
private function openWin():void{
//新建window对象
var win:PicOne = new PicOne();
win.advOpen(this); //弹出窗口
win.move(50,50);

}
]]>
</mx:Script>
<mx:Canvas>
<mx:Image source=”@Embed(‘images/1.png’)” />
<mx:Button label=”打开我的表情1″ click=”openWin()” x=”325″ y=”174″/>
</mx:Canvas>

</mx:WindowedApplication>

源文件下载
Demo

罗嗦的话到次为止，下面正式开始主题，本教程主要实现了以下功能。

1. 屏蔽系统窗口、 flash窗口、窗口底部状态栏。使用自定义窗口。
2. 对自定义窗口的缩放、移动、关闭。

在实现以上操作的过程中，我加入了一些额外的操作来丰富我们的demo，都是很简单，很实用的东西。

3. 移动窗口时实现半透明效果，移动结束时还原。
4. 关闭窗口动画。
5. 窗口背景填充。

1. 屏蔽系统窗口， flash窗口，窗口底部状态栏。使用自定义窗口。

当一个AIR项目创建成功后，你会发现相对与 web项目，你的工程目录下多了一个名为 XXX-app.xml的文件，这是我们项目的配制文件，实现自定义窗口就是靠它。打开它，修改如下代码:

<!– The type of system chrome to use (either “standard” or “none”). Optional. Default standard. –>
<!–<systemChrome></systemChrome> –>

去掉对systemChrome的注释，改为

<!– The type of system chrome to use (either “standard” or “none”). Optional. Default standard. –>
<systemChrome>none</systemChrome>

这样我们就去掉了系统窗口，转而使用了flash的自带窗口，下面我们把flash窗口也去掉。在你的主mxml文件中设置WindowedApplication 的这些属性

<mx:WindowedApplication showTitleBar=”false” borderThickness=”0″ showStatusBar=”false” showGripper=”false” ….. />

这样就完全去掉了所有的窗口，程序运行后只显现应用程序的内容。大家可以参考帮助手册来了解以上属性的意思。说到这里就引出了下一个问题，屏蔽了所有窗口以后如何对窗口进行基本的，放大，缩放，关闭操作呢。我们看下面。

2. 对自定义窗口的缩放，移动，关闭。

AIR比flex web应用多了一个类叫NativeWindow,我们就是靠这个类对窗口就行操作。在demo中，我用了以下几个方法来移定窗口，他们都在鼠标MouseDown event中被触发。

this.nativeWindow.startResize(“L”);
this.nativeWindow.startResize(“R”);
this.nativeWindow.startResize(“T”);
this.nativeWindow.startResize(“B”);
this.nativeWindow.startResize(“TL”);
this.nativeWindow.startResize(“RB”);

很容易可以看出，L R B T代表 Left, Right, Bottom 和 Top, 所以在调用startResize时设置适当的参数我们就可以轻易的实现对窗口各个方向的缩放。对于窗口的移定，在mouseDown event中使用

this.nativeWindow.startMove();

而对窗口的关闭，则很简单的在按钮click事件调用this.close()。

好了，以上就是对自定义窗口的操作。下面的东西我是用来完善我的demo，使它cool一点。相信大家在自己的应用程序中也会需要类似的东西，一个应用程序除了功能，细节上的处理也是很重要的。

3. 移动窗口时实现半透明效果，移动结束时还原。

要实现这个效果我们需要重新打开我们的XXX-app.xml文件，设置以下内容。

<!– Whether the window is transparent. Only applicable when systemChrome is none. Optional. Default false. –>
<transparent>true</transparent>

这个可以允许我们让应用程序的背景透明，这个很有用，比方说QQ宠物就是一个背景透明的应用程序，利用背景透明，我们可以开发出很独特的应用程序。接下来要做的就简单了。

在上面移动窗口的mouseDown事件中加入 this.alpha = 0.x; 下面是demo中的代码。我将透明度设为0.6,this. alpha只针对应用程序的背景设置透明，如果你想让更多的东西透明，只需要对相应的控件设置alpha既可。

private function moveMe():void{
this.nativeWindow.startMove();
this.alpha = 0.6;
}

让透明还原我在mouseUp事件中设置alpha =1;

private function mouseUpHandle():void{
this.alpha = 1;
}

这样简单的设置也许就会使你的应用程序看起来不一样，怎么不试试呢：）

4. 关闭窗口动画。

我使用了下面的Iris效果对在窗口关闭时使用。有什么效果呢，大家关闭一下就知道了。 flex中内置了很多效果给我们使用，很多时候我们只需要适当的组合，就能得到意想不到的效果，比如 Move与 WipeDown一起可以实现Mac系统，菜单向下滑出的效果。诸如此类，只要有想像力，我们可以用很简单的代码，实现很有用的功能。 在demo 中，如下设置得到关闭动画

<mx:WindowedApplication closeEffect=”irisIn” ….. />

<mx:Iris id=”irisIn” duration=”500″ showTarget=”false” />

5. 窗口背景填充。

这个功能其实在开发程序的时候用的不多，我是不想让demo看起来太单调所以加了背景，我们知道flex是不能像Html那样轻易的让背景重复显示的，所以我们的用一些特殊方法处理以下，demo中的 setBackground方法用于设置整个背景。这里面涉及到的 Bitmap, BitmapData, Graphics类的具体作用，大家感兴趣的话可以看帮助手册，我的观点是当里用到的时候查帮助也不迟，只要知道有这么些个类可以为你干什么活就好。

private function setBackground():void{

var backgroundImage :Bitmap;
var backgroundBitmapData :BitmapData;

backgroundImage = new bg();
backgroundBitmapData = new BitmapData( backgroundImage.width, backgroundImage.height );
backgroundBitmapData.draw( backgroundImage );

workarea.graphics.beginBitmapFill( backgroundBitmapData, null,true );
workarea.graphics.drawRect(0,0, 2000, 2000);
workarea.graphics.endFill();
}

以上就是demo的全部内容，下面有源文件和Demo给大家下载。 因为AIR是跨平台的应用程序，所以不管在Mac或者Window上开发过程都是一样的。Demo是在 Leopard下开发。

源文件下载
Demo

下面我们开始讲解以下的内容。

1. 准备工作。
2. 第一个 AIR程序（编写、运行、调试）
3. 发布AIR程序。
4. 安装已发布的AIR安装包。

1.准备工作。

AIR 的开发环境非常简单，你唯一需要的就是FlexBuilder3,下载地址我就不提供了，只需要在google中搜索”Flex builder3 下载”，你会得到一大把地址。 Flexbuilder的安装也很简单，直接运行安装程序，然后一路按照导航菜单下去既可。

2. 第一个 AIR程序（编写、运行、调试）（图片点击可以放大）

现在我们打开刚安装好的FlexBuilder3,见下图,选择 打开File — New — Flex project.

接 下来是输入程序名，我写的是My first air app, 在Applicaiton Type那选择Desktop application(runs in Adobe AIR),接这直接点Finish,项目将创建在安装FlexBuilder时设置的work space里，这个文件夹没什么特别（你以后可以把你的项目放在任意的文件夹中，使用File — Import — Flex project导入）

现 在你可以在左侧的导航中看见你的项目My first air app。你可以看倒项目主程序main.mxml和配制文件main-app.xml（在AIR迷你教程–使用自定义窗口…,中我们有用到这个文 件，现在不需要管他）。右边的主窗口区域就是已经打开的main.mxml的内容。

按 照下图的内容写我们的第一个air程序，也可以算我们第一个flex程序(Flex和AIR开发完全一样，只是在 AIR中多了一些包的支持使我们的程序成为桌面程序)。程序中有一个按钮，点击触发click事件，接着trace(trace是flex中用来在控制面 版输出信息的命令，在Debug模式中我们经常会使用它来帮助我们调试程序)出 event 的内容，并且执行弹出窗口现在一段文字。

下面我们运行程序，按照下图，右键点击main.mxml — Run As — Adobe AIR Application.

运行后我们点击按钮，完成我们整个demo的内容。

好，现在我们已经结束从编写到运行的过程。下面我们来调试(Debug)。如图，我们在第9行代码左边蓝色小点的位置，左键单击，这样你应该可以看倒和图上一样的蓝色小点了，这就是我们设置的程序断点，在调试模式中，程序会在这样的位置停下来。

我们开始调试，右键点击main.mxml — Debug As — Adobe AIR Application.

然 后你可能会看倒这样的提示，这是问你是否要将我们的主窗口切换到调试模式。你可以看见图片右上角有显示“Flex” 旁边有一个flex的图标，你可以点开那个菜单看见里面有三种视图Debugging, Development和Profiling。 我们已经用了其中2个，Development就是我们上面写程序的视图，Debugging是我们即将要切换到的视图，Profiling是用来帮助我 们检查程序的性能的工具，可以帮助我们解决Memory leak等等的问题，这个不需要知道，以后有机会用到的时候再研究也不迟。 现在点Yes继续。

程 序运行后，点击按钮，你会发现程序停在了下面的位置，一个绿色的横杠标示出程序现在停在了短点的位置，这个时候我们就可以查看这一时刻当前对象的各种我们 感兴趣的信息了，你可以试着切换屏幕右上窗口的 Variables选像卡，会看到当前活动的对象，这里我们也不多说，尝试多调试下程序后你自然就明白Variables里面的内容了，都是很直观的信 息。 接下来如果我们点上面绿色的箭头，程序会继续执行直到遇到下一个断点，如果按F6，会单步执行。

以上就是全部第2点的内容。

3. 发布AIR程序。

既然 AIR是桌面应用程序，那它自然也需要按装，现在我们就来看怎么把我们写好的程序发布成按装包。点击图上红色圆圈的按钮，弹出如图所示窗口。在Export file中填上你想要的按装包的名字，点击Next

这里我们发布程序需要有一个Key,那是你程序的证书。因为第一次发布，所以点Create。

打开如图所示窗口，填上名字，密码，点击Browser选择保存位置。我的是Mac击所以界面有些不一样，但是操作和windows是一样的。我保存了名叫MyKey的证书。

上图点击OK后你可以看倒证书已经选择完毕。填上你的密码，点击Finish.

如下红色圆圈所示，在你的项目文件夹里出现一个main.air的文件，那就是我们发布的AIR程序安装包了。

4. 安装已发布的AIR安装包。

使 用AIR程序的人当然不需要flexbuilder这样的东西，他们只需要按装已下air程序的运行环境。就像run java app需要java runtime, 运行 air需要 air runtime,这里是下载地址 http://labs.adobe.com/downloads/air.html. 下载 windows版或者mac版。 下载后安装既可。

按装完runtime之后，双击main.air就可以开始将air程序，安装过程和普通应用程序无异。

好了，看完以上内容，相信你已经可以开始自己的AIR程序。至于更深入的内容大家可以继续看以后的AIR教程。