使用SharedObject缓存游戏框架到本地和版本更新的demo

源码中有两个工程，一个是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
        {
           
        }
    }
}