Laya LoaderManager小记

LoaderManager 类用于用于批量加载资源。此类是单例，不要手动实例化此类，请通过Laya.loader访问。全部队列加载完成，会派发 Event.COMPLETE 事件；如果队列中任意一个加载失败，会派发 Event.ERROR 事件，事件回调参数值为加载出错的资源地址。

LoaderManager 类提供了以下几种功能： 多线程：默认5个加载线程，可以通过maxLoader属性修改线程数量； 多优先级：有0-4共5个优先级，优先级高的优先加载。0最高，4最低； 重复过滤：自动过滤重复加载（不会有多个相同地址的资源同时加载）以及复用缓存资源，防止重复加载； 错误重试：资源加载失败后，会重试加载（以最低优先级插入加载队列），retryNum设定加载失败后重试次数，retryDelay设定加载重试的时间间隔。

LoaderManager是Laya加载资源的统一入口，管理laya的加载器（Laya.Loader），负责控制加载优先级，加载线程维护与上限上线控制，加载失败后重试等操作。在laya中使用的Laya.loader是LoaderManager的实例，而不是Laya.Loader的实例。

源码阅读

属性简介

		/**@private */
		private static var _resMap:Object = {};				//@资源map，url做key，resInfo为value， 用于检测资源是否已经在队列中，防止重复加载。
		/**@private */
		public static var createMap:Object = {atlas: [null, Loader.ATLAS]};   //@用于检测create方法的类型。

		/** 加载出错后的重试次数，默认重试一次*/
		public var retryNum:int = 1;
		/** 延迟时间多久再进行错误重试，默认立即重试*/
		public var retryDelay:int = 0;
		/** 最大下载线程，默认为5个*/
		public var maxLoader:int = 5;

		/**@private */
		private var _loaders:Array = [];     //@缓存的loader列表
		/**@private */
		private var _loaderCount:int = 0;	 //@正在使用的loader数量、加载线程数量
		/**@private */
		private var _resInfos:Array = [];	 //@加载资源列表，存放所有需要加载的资源，按优先级和队列顺序排列

		/**@private */
		private var _infoPool:Array = [];	 //@加载数据对象的缓存池
		/**@private */
		private var _maxPriority:int = 5;	 //@优先级数量  0-4
		/**@private */
		private var _failRes:Object = {};	 //@失败资源的加载次数，用于失败后重试计数

初始化

• LoaderManager在Laya.init时创建，赋值给Laya.loader。
• 按照优先级，创建5（_maxPriority）个队列，用于存放需要加载的资源数据。队列的索引就是加载的优先级，0-4，数字越小，优先级越高。加载时，按照优先级和队列顺序依次加载。

		/**
		 * <p>创建一个新的 <code>LoaderManager</code> 实例。</p>
		 * <p><b>注意：</b>请使用Laya.loader加载资源，这是一个单例，不要手动实例化此类，否则会导致不可预料的问题。</p>
		 */
		public function LoaderManager() {
			for (var i:int = 0; i < this._maxPriority; i++) this._resInfos[i] = [];is._resInfos[i] = [];
		}

单个资源加载流程

• 判断资源是否存在，如果存在则直接调用progress和complete。加载的资源存放在Laya.Loader中，不在LoaderManager中。
• 判断资源是否在加载队列中：
  • 如果存在，则监听COMPLETE和PROFRESS事件。注：添加时不能设置offBefore，防止后续加载的资源的回调覆盖之前的加载完成事件。
  • 如果不存在，则创建ResInfo，将info放到对应优先级队列的末尾，监听COMPLETE事件。调用next方法，尝试加载。
• 检测当前正在使用的loader的数量，如果数量不足maxLoader个数，则按优先级查找队列，再取队列的第一个数据去加载。如果当前正在使用的loader的count为0，则触发Laya.loader（LoaderManager）的COMPLETE事件。
• 加载是使用Laya.Loader执行加载逻辑。
• 加载完成后（或者失败），回收当前loader，更新loader数量，如果加载失败，则重新放入加载队列，并且优先级设置为最低。如果失败多次，则出发Error事件，将url传递出去。加载成功或者失败都会出发COMPLETE事件，调用complete方法。清理和回收相关数据。
• 尝试调用next，尝试选择下一个资源加载。

		/**
		 * <p>加载资源。资源加载错误时，本对象会派发 Event.ERROR 事件，事件回调参数值为加载出错的资源地址。</p>
		 * <p>因为返回值为 LoaderManager 对象本身，所以可以使用如下语法：Laya.loader.load(...).load(...);</p>
		 * @param	url			要加载的单个资源地址或资源信息数组。比如：简单数组：["a.png","b.png"]；复杂数组[{url:"a.png",type:Loader.IMAGE,size:100,priority:1},{url:"b.json",type:Loader.JSON,size:50,priority:1}]。
		 * @param	complete	加载结束回调。根据url类型不同分为2种情况：1. url为String类型，也就是单个资源地址，如果加载成功，则回调参数值为加载完成的资源，否则为null；2. url为数组类型，指定了一组要加载的资源，如果全部加载成功，则回调参数值为true，否则为false。
		 * @param	progress	加载进度回调。回调参数值为当前资源的加载进度信息(0-1)。
		 * @param	type		资源类型。比如：Loader.IMAGE。
		 * @param	priority	(default = 1)加载的优先级，优先级高的优先加载。有0-4共5个优先级，0最高，4最低。
		 * @param	cache		是否缓存加载结果。
		 * @param	group		分组，方便对资源进行管理。
		 * @param	ignoreCache	是否忽略缓存，强制重新加载。
		 * @return 此 LoaderManager 对象本身。
		 */
		public function load(url:*, complete:Handler = null, progress:Handler = null, type:String = null, priority:int = 1, cache:Boolean = true, group:String = null, ignoreCache:Boolean = false):LoaderManager {
			if (url is Array) return _loadAssets(url as Array, complete, progress, type, priority, cache, group);
			var content:* = Loader.getRes(url);
			if (content != null) {
				//增加延迟回掉
				Laya.timer.frameOnce(1, null, function():void {
					progress && progress.runWith(1);
					complete && complete.runWith(content);
					//判断是否全部加载，如果是则抛出complete事件
					_loaderCount || event(Event.COMPLETE);
				});
			} else {
				var info:ResInfo = _resMap[url];
				if (!info) {
					info = _infoPool.length ? _infoPool.pop() : new ResInfo();
					info.url = url;
					info.type = type;
					info.cache = cache;
					info.group = group;
					info.ignoreCache = ignoreCache;
					//@收到ResInfo的COMPLETE事件则执行complete方法
					complete && info.on(Event.COMPLETE, complete.caller, complete.method, complete.args);
					progress && info.on(Event.PROGRESS, progress.caller, progress.method, progress.args);
					_resMap[url] = info;
					//@选择对应优先级队列
					priority = priority < this._maxPriority ? priority : this._maxPriority - 1;
					this._resInfos[priority].push(info);
					_next();
				} else {
					//@如果已经在加载队列，则只注册事件，不创建加载数据。
					//@注:这里offBefore设置为false，防止事件被覆盖，导致complete执行不全。
					complete && info._createListener(Event.COMPLETE, complete.caller, complete.method, complete.args, false, false);
					progress && info._createListener(Event.PROGRESS, progress.caller, progress.method, progress.args, false, false);
				}
			}
			return this;
		}

		private function _next():void {
			//@loader满了则返回等待空闲loader
			if (this._loaderCount >= this.maxLoader) return;
			//@按优先级查找列表
			for (var i:int = 0; i < this._maxPriority; i++) {
				var infos:Array = this._resInfos[i];
				while (infos.length > 0) {
					var info:ResInfo = infos.shift();
					if (info) return _doLoad(info);
				}
			}
			//@所有loader都空闲，则触发LoaderManager的加载完成
			_loaderCount || event(Event.COMPLETE);
		}

		private function _doLoad(resInfo:ResInfo):void {
			this._loaderCount++;
			var loader:Loader = this._loaders.length ? this._loaders.pop() : new Loader();
			loader.on(Event.COMPLETE, null, onLoaded);
			loader.on(Event.PROGRESS, null, function(num:Number):void {
				resInfo.event(Event.PROGRESS, num);
			});
			loader.on(Event.ERROR, null, function(msg:*):void {
				onLoaded(null);
			});

			var _this:LoaderManager = this;
			function onLoaded(data:* = null):void {
				//@清理、回收loader
				loader.offAll();
				loader._data = null;
				loader._customParse = false;
				_this._loaders.push(loader);
				_this._endLoad(resInfo, data is Array ? [data] : data);
				_this._loaderCount--;
				_this._next();
			}
			//@具体加载流程在Loader中实现
			loader._class = resInfo.clas;
			loader.load(resInfo.url, resInfo.type, resInfo.cache, resInfo.group, resInfo.ignoreCache);
		}

		private function _endLoad(resInfo:ResInfo, content:*):void {
			//如果加载后为空，放入队列末尾重试
			var url:String = resInfo.url;
			if (content == null) {
				var errorCount:int = this._failRes[url] || 0;
				//@记录失败次数
				if (errorCount < this.retryNum) {
					console.warn("[warn]Retry to load:", url);
					this._failRes[url] = errorCount + 1;
					//@重新放回加载队列
					Laya.timer.once(retryDelay, this, _addReTry, [resInfo], false);
					return;
				} else {
					//超过retryNum则直接抛出ERROR事件
					console.warn("[error]Failed to load:", url);
					event(Event.ERROR, url);
				}
			}
			if (_failRes[url]) _failRes[url] = 0;
			delete _resMap[url];
			//@通知info执行complete方法
			resInfo.event(Event.COMPLETE, content);
			resInfo.offAll();
			_infoPool.push(resInfo);
		}

		private function _addReTry(resInfo:ResInfo):void {
			this._resInfos[this._maxPriority - 1].push(resInfo);
			_next();
		}

加载多个资源流程

LoaderManager.load支持传入简单类型数组，比如：简单数组：["a.png","b.png"]；复杂数组[{url:"a.png",type:Loader.IMAGE,size:100,priority:1},{url:"b.json",type:Loader.JSON,size:50,priority:1}]。

• 遍历所有数组，记录总数，用于计算progress。记录下载的总数。
• 分别调用load方法，加载每一个元素。
• 每加载完一个资源，检查加载的数量是否等于本次的总数量，如果是，则执行complete操作。

		/**
		 * @private
		 * 加载数组里面的资源。
		 * @param arr 简单：["a.png","b.png"]，复杂[{url:"a.png",type:Loader.IMAGE,size:100,priority:1},{url:"b.json",type:Loader.JSON,size:50,priority:1}]*/
		private function _loadAssets(arr:Array, complete:Handler = null, progress:Handler = null, type:String = null, priority:int = 1, cache:Boolean = true, group:String = null):LoaderManager {
			var itemCount:int = arr.length;
			var loadedCount:int = 0;
			var totalSize:int = 0;
			var items:Array = [];
			var success:Boolean = true;
			for (var i:int = 0; i < itemCount; i++) {
				var item:Object = arr[i];
				if (item is String) item = {url: item, type: type, size: 1, priority: priority};
				if (!item.size) item.size = 1;
				item.progress = 0;
				totalSize += item.size;
				items.push(item);
				var progressHandler:* = progress ? Handler.create(null, loadProgress, [item], false) : null;
				var completeHandler:* = (complete || progress) ? Handler.create(null, loadComplete, [item]) : null;
				load(item.url, completeHandler, progressHandler, item.type, item.priority || 1, cache, item.group || group);
			}

			function loadComplete(item:Object, content:* = null):void {
				loadedCount++;
				item.progress = 1;
				if (!content) success = false;
				if (loadedCount === itemCount && complete) {
					complete.runWith(success);
				}
			}

			function loadProgress(item:Object, value:Number):void {
				if (progress != null) {
					item.progress = value;
					var num:Number = 0;
					for (var j:int = 0; j < items.length; j++) {
						var item1:Object = items[j];
						num += item1.size * item1.progress;
					}
					var v:Number = num / totalSize;
					progress.runWith(v);
				}
			}
			return this;
		}

create方法

根据clas类型创建一个未初始化资源的对象，随后进行异步加载，资源加载完成后，初始化对象的资源，并通过此对象派发 Event.LOADED 事件，事件回调参数值为此对象本身。套嵌资源的子资源会保留资源路径"?"后的部分。

如果url为数组，返回true；否则返回指定的资源类对象，可以通过侦听此对象的 Event.LOADED 事件来判断资源是否已经加载完毕。

注意：cache参数只能对文件后缀为atlas的资源进行缓存控制，其他资源会忽略缓存，强制重新加载。

• create方法可以先创建一个指定类型的壳，同步返回给调用者。壳里的资源则通过异步的方式加载。

• create方法主要是在Laya3D中使用，主要是Laya内部组件使用。使用create创建的类型有严格限制，在2D下支持Atlas，在3D有一定扩展。

• 这些类型都要实现ICreateResource方法，提供onAsynLoaded，_setUrl等方法。如果创建一些不支持的类型，会直接抛出异常。

• 同load方法一样，支持传入一个或者多个资源地址。

• 使用create方法加载Atlas资源时，会返回null。

• Laya3D所支持的类型：

    //在Laya3D初始化时设置
    var createMap:Object = LoaderManager.createMap;
    createMap["lh"] = [Sprite3D, Laya3D.HIERARCHY];
    createMap["ls"] = [Scene, Laya3D.HIERARCHY];
    createMap["lm"] = [Mesh, Laya3D.MESH];
    createMap["lmat"] = [StandardMaterial, Laya3D.MATERIAL];
    createMap["lpbr"] = [PBRMaterial, Laya3D.MATERIAL];
    createMap["ltc"] = [TextureCube, Laya3D.TEXTURECUBE];
    createMap["jpg"] = [Texture2D, "nativeimage"];
    createMap["jpeg"] = [Texture2D, "nativeimage"];
    createMap["png"] = [Texture2D, "nativeimage"];
    createMap["pkm"] = [Texture2D, Loader.BUFFER];
    createMap["lsani"] = [AnimationTemplet, Loader.BUFFER];
    createMap["lrani"] = [AnimationTemplet, Loader.BUFFER];
    createMap["raw"] = [DataTexture2D, Loader.BUFFER];
    createMap["mipmaps"] = [DataTexture2D, Loader.BUFFER];
    createMap["thdata"] = [TerrainHeightData, Loader.BUFFER];
    createMap["lt"] = [TerrainRes, Laya3D.TERRAIN];
    createMap["lani"] = [AnimationClip, Loader.BUFFER];
    createMap["lav"] = [Avatar, Loader.JSON];
    createMap["ani"] = [AnimationTemplet, Loader.BUFFER];//兼容接口