001 工具类 加载文件工具LoadFileUtil
LoadFileUtil
单线程加载文件工具类,主要加载txt,xml,swf,png,jpg,gif文件
- addLoadFile:往加载列表中添加欲加载的文件，若没有处于加载文件状态，则加载启动
- start:开始加载
- stop:停止加载
- mode:设置文件加载的模式
package tunie.util
{
import flash.display.Loader;
import flash.display.LoaderInfo;
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IOErrorEvent;
import flash.events.ProgressEvent;
import flash.net.URLLoader;
import flash.net.URLRequest;
import flash.net.URLRequestMethod;
import flash.net.URLVariables;
import flash.system.ApplicationDomain;
import flash.system.LoaderContext;
import tunie.error.BaseError;
import tunie.error.BaseErrorType;
/**
* Author:Tunie
* Date: Jul 9, 2013 11:47:32 AM
* Synopsis:单线程加载文件工具类,主要加载txt,xml,swf,png,jpg,gif文件
* <li>addLoadFile:往加载列表中添加欲加载的文件，若没有处于加载文件状态，则加载启动</li>
* <li>start:开始加载</li>
* <li>stop:停止加载</li>
* <li>mode:设置文件加载的模式</li>
*/
public class LoadFileUtil
{
/**
* 懒惰模式，在这种模式下加载文件时，一旦有文件出错，或者停止加载，将会终止
* 已经加入加载列表中的欲加载项
*/
public static const LAZY:String="lazy";
/**
* 贪婪模式，在这种模式下加载文件时，当文件出错时，将会跳过些文件，继续加载下
* 一个文件，停止加载时，只是暂停加载而已
*/
public static const GREEDY:String="greedy";
private var _mode:String="lazy";
private var _loadFiles:Vector.<LoadFile>;
private var _loading:Boolean;
/**
*用于加载文本之类的文件
*/
private var _bitLoader:URLLoader;
/**
*用于加载图片之类的文件
*/
private var _mapLoader:Loader;
public function LoadFileUtil(sign:Sign)
{
if(!sign) throw new BaseError(BaseErrorType.CANT_INSTANTIATION);
_loadFiles=new Vector.<LoadFile>();
_loading=false;
}
/**
* 添加需要加载的文件
* @param url 文件路径
* @param loadComp 加载完成
* @param loadProgress 加载进度
* @param loadError 加载失败
* @param vars 参数
*
*/
public function addLoadFile(url:String,loadComp:Function=null,vars:URLVariables=null,loadProgress:Function=null,loadError:Function=null):void
{
_loadFiles.push(new LoadFile(url,loadComp,vars,loadError,loadProgress));
start();
}
/**
* 添加需要加载的文件
* @param url 文件路径
* @param loadComp 加载完成
* @param loadProgress 加载进度
* @param loadError 加载失败
* @param vars 参数
*
*/
public static function addLoadFile(url:String,loadComp:Function=null,vars:URLVariables=null,loadProgress:Function=null,loadError:Function=null):void
{
instance.addLoadFile(url,loadComp,vars,loadProgress,loadError);
}
/**
*只有是_loading为true时才能调用
*/
private function load():void
{
if(_loadFiles.length<=0)
{
stop();
return;
}
switch(_loadFiles[0].type)
{
case LoadFile.BIT_TYPE:
bitLoad();
break;
case LoadFile.MAP_TYPE:
mapLoad();
break;
default:
throw new BaseError(BaseErrorType.DISALLOWED_VALUE);
}
}
private function bitLoad():void
{
checkBitLoader();
setupEvent(_bitLoader);
_bitLoader.load(createRequest());
}
private function mapLoad():void
{
checkMapLoader();
setupEvent(_mapLoader.contentLoaderInfo);
_mapLoader.load(createRequest(),new LoaderContext(false,ApplicationDomain.currentDomain));
}
private function setupEvent(load:EventDispatcher):void
{
load.addEventListener(Event.COMPLETE,loadComp);
load.addEventListener(ProgressEvent.PROGRESS,loadProgress);
load.addEventListener(IOErrorEvent.IO_ERROR,loadError);
}
private function removeEvent(load:EventDispatcher):void
{
load.removeEventListener(Event.COMPLETE,loadComp);
load.removeEventListener(ProgressEvent.PROGRESS,loadProgress);
load.removeEventListener(IOErrorEvent.IO_ERROR,loadError);
}
private function loadComp(e:Event):void
{
removeEvent(e.target as EventDispatcher);
if(_loadFiles[0].compCallback!=null)
{
var b_data:Object;
if(e.target is LoaderInfo)
b_data=e.target.content;
else if(e.target is URLLoader)
b_data=e.target.data;
_loadFiles[0].compCallback.call(null,b_data);
}
next();
}
private function loadProgress(e:ProgressEvent):void
{
if(_loadFiles[0].progressCallback!=null)
{
_loadFiles[0].progressCallback.call(null,e);
}
}
private function loadError(e:IOErrorEvent):void
{
removeEvent(e.target as EventDispatcher);
if(_loadFiles[0].errorCallback!=null)
{
_loadFiles[0].errorCallback.call(null,e);
}
if(_mode==LAZY)
{
stop();
}
else if(_mode==GREEDY)
{
next();
}
}
private function checkBitLoader():void
{
if(!_bitLoader)
_bitLoader=new URLLoader();
else
{
removeEvent(_bitLoader);
_bitLoader.close();
}
}
private function checkMapLoader():void
{
if(!_mapLoader)
_mapLoader=new Loader();
else
{
removeEvent(_mapLoader.contentLoaderInfo);
try
{
_mapLoader.close();
}
catch(error:Error)
{
//
}
}
}
private function createRequest():URLRequest
{
var b_loadFile:LoadFile=_loadFiles[0];
var b_path:String=b_loadFile.path;
var b_request:URLRequest=new URLRequest(b_path);
if(b_loadFile.vars)
{
b_request.data=b_loadFile.vars;
b_request.method=URLRequestMethod.POST;
}
return b_request;
}
/**
*准备加载下一个
*/
private function next():void
{
_loadFiles.shift();
loading=true;
}
/**
*清空状态
*/
private function clear():void
{
_loading=false;
if(_bitLoader){
removeEvent(_bitLoader);
_bitLoader.close();
_bitLoader=null;
}
if(_mapLoader){
removeEvent(_mapLoader.contentLoaderInfo);
try
{
_mapLoader.close();
}
catch(error:Error)
{
}
finally
{
_mapLoader=null;
}
}
if(_mode==LAZY)
{
_loadFiles.length=0;
}
else if(_mode==GREEDY)
{
}
}
/**
*开始加载
*/
public function start():void
{
if(!_loading)
loading=true;
}
/**
*开始加载
*/
public static function start():void
{
instance.start();
}
/**
*停止加载文件，预备加载的文件都将取消加载
*/
public function stop():void
{
clear();
}
/**
*停止加载文件，预备加载的文件都将取消加载
*/
public static function stop():void
{
instance.stop();
}
/**
*加载模式
*/
public function set mode(value:String):void
{
_mode = value;
}
/**
* 加载模式
*/
public static function set mode(value:String):void
{
instance.mode=value;
}
/**
*标记是否处于加载过程中
*/
protected function set loading(value:Boolean):void
{
_loading = value;
if(_loading)
{
load();
}
else
stop();
}
//------------------------------single pattern
private static var _instanse:LoadFileUtil;
public static function get instance():LoadFileUtil
{
if(!_instanse)
_instanse=new LoadFileUtil(new Sign());
return _instanse;
}
}
}
import flash.net.URLVariables;
class Sign{}
/**
* 加载的文件
* @author Tunie
*
*/
class LoadFile
{
/**
*txt,xml
*/
public static const BIT_TYPE:String="bitType";
/**
*swf,png,jpg,gif
*/
public static const MAP_TYPE:String="mapType";
public var path:String;
public var compCallback:Function;
public var errorCallback:Function;
public var progressCallback:Function;
public var vars:URLVariables;
/**
*文件类型
*/
public var type:String;
public function LoadFile(path:String,fComp:Function=null,vars:URLVariables=null,fError:Function=null,fProgress:Function=null)
{
this.path=path;
compCallback=fComp;
errorCallback=fError;
progressCallback=fProgress;
this.vars=vars;
analysisPath();
}
private function analysisPath():void
{
var b_index:int=path.lastIndexOf(".");
var b_type:String=path.substr(b_index+1).toLowerCase();
switch(b_type)
{
case "txt":
case "xml":
type=BIT_TYPE;
break;
case "swf":
case "png":
case "jpg":
case "gif":
type=MAP_TYPE;
break;
default:
type="";
}
}
}