源码 中有两个工程,一个是VersionLoader 。一个是mainFrame。
VersionLoader负责加载 frame、和进行版本辨识。
VersionLoader通过xml文件 取得服务器文件版本。与SharedObject存储在本地的文件对比,判断是重新加载MainFrame,还是在SharedObject中取得。
使用了一个xml标志服务器版本。
希望对大家有帮助。
下面是源码:
package
{
import flash.display.Loader;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.IOErrorEvent;
import flash.events.NetStatusEvent;
import flash.events.SecurityErrorEvent;
import flash.net.SharedObject;
import flash.net.SharedObjectFlushStatus;
import flash.net.URLLoader;
import flash.net.URLLoaderDataFormat;
import flash.net.URLRequest;
import flash.utils.ByteArray;
[SWF(width="1000", height="600", frameRate="31")]
public class VersionLoader extends Sprite
{
private var configLoader : URLLoader;
private var frameLocalLoader : Loader;
private var frameRemoteLoader : URLLoader;
//版本标识
private var version : String;
private static const MAIN_FRAME_URL : String = "MainFrame.swf";
/**
* 构造函数
*/
public function VersionLoader()
{
super();
loadConfig();
}
/**
* 加载配置文件
*/
private function loadConfig():void
{
configLoader = new URLLoader();
configLoader.load(new URLRequest(("version.xml?v=" + new Date().getTime())));
configLoader.addEventListener(Event.COMPLETE, configLoadCompleted);
configLoader.addEventListener(IOErrorEvent.IO_ERROR, configLoadError);
}
/**
* 配置文件完成处理
*/
private function configLoadCompleted(evt : Event) : void
{
trace("config load completed");
configLoader.removeEventListener(Event.COMPLETE, configLoadCompleted);
configLoader.removeEventListener(IOErrorEvent.IO_ERROR, configLoadError);
configLoader.close();
var xmlData : XML = XML(evt.target.data);
version = xmlData.version;
loadMainFrame();
}
/**
* 加载配置文件失败
*/
private function configLoadError(evt : Event) : void
{
trace("config load error");
}
/**
* 加载主框架
*/
private function loadMainFrame() : void
{
var mainFrameData : ByteArray = (readLocal("MainFrame", version) as ByteArray);
// 本地加载到数据
if (mainFrameData)
{
trace("load shell from local sharedObject");
loadFrameFromBytes(mainFrameData);
}
// 重新加载数据
else
{
trace("load new Shell");
loadFrameFromRemote();
}
}
/**
* 以bytes方式加载主框架
*/
private function loadFrameFromBytes(byteData : ByteArray) : void
{
frameLocalLoader = new Loader();
frameLocalLoader.contentLoaderInfo.addEventListener(Event.INIT, frameLocalLoadCompleted);
frameLocalLoader.loadBytes(byteData);
}
/**
* 本地加载主框架完成
*/
private function frameLocalLoadCompleted(evt : Event) : void
{
addChildAt(frameLocalLoader, 0);
}
/**
* 远程加载主框架
*/
private function loadFrameFromRemote() : void
{
frameRemoteLoader = new URLLoader();
frameRemoteLoader.dataFormat = URLLoaderDataFormat.BINARY;
frameRemoteLoader.addEventListener(Event.COMPLETE, frameRemoteLoadCompleted);
frameRemoteLoader.addEventListener(IOErrorEvent.IO_ERROR, frameRemoteLoadError);
frameRemoteLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, frameRemoteLoadError);
frameRemoteLoader.load(new URLRequest((MAIN_FRAME_URL + "?v=" + version)));
}
/**
* 远程加载主框架完成
*/
private function frameRemoteLoadCompleted(evt : Event) : void
{
trace("load frame from remote completed");
var date:ByteArray = evt.target.data as ByteArray;
loadFrameFromBytes(date);
saveLocal("MainFrame", date, version)
}
/**
* 远程加载主框架失败
*/
private function frameRemoteLoadError(evt : Event) : void
{
trace("load frame from remote error");
}
/**
* 保存到本地
*/
private function saveLocal(name : String, data : Object, version : String) : void
{
trace("save data to local name:" + name + ",version:" + version);
var shared : * = null;
var flushResult : * = null;
var name : * = name;
var data : * = data;
var version : * = version;
try
{
shared = SharedObject.getLocal(name, "/");
if (shared)
{
shared.data["version"] = version;
shared.data["data"] = data;
flushResult = shared.flush();
if (flushResult == SharedObjectFlushStatus.PENDING)
{
shared.addEventListener(NetStatusEvent.NET_STATUS, sharedNetStatus);
}
}
}
catch(err : Error)
{
trace("save to local error");
}
}
/**
* 从本地读取
*/
public function readLocal(name : String, version : String) : Object
{
trace("read data from local name:" + name + ",version:" + version);
var shared : * = null;
var name : * = name;
var version : * = version;
try
{
shared = SharedObject.getLocal(name, "/");
if (shared)
{
if (shared.data["version"] != version)
{
shared.clear();
}
else
{
if (shared.data.hasOwnProperty("data"))
{
return (shared.data["data"]);
}
}
}
}
catch(err : Error)
{
trace("read from local error");
}
return (null);
}
private function sharedNetStatus(event : NetStatusEvent) : void
{
}
}
}