public RFLoader getLoader(string url, string id)
{
RFLoader loader = null;
if (_loadingPool.TryGetValue(id, out loader) == false)
{
string version = "";
if (fileVersion != null)
{
version = fileVersion.urlversion(url);
}
if (loaderFactory != null)
{
loader = loaderFactory.getLoader(url, id);
}
else
{
loader = new AssetLoader(url, id);
}
loader.hashVersion = version;
loader.addEventListener(EventX.COMPLETE, onLoaderComplete);
loader.addEventListener(EventX.FAILED, onLoaderComplete);
_loadingCount++;
_loadingPool[id] = loader;
}
return(loader);
}
protected virtual void _loadImp(int priority = 0, bool progress = false, uint retryCount = 0)
{
ResourceLoaderManager loaderManager = ResourceLoaderManager.sharedInstance();
RFLoader newLoader = loaderManager.getLoader(url, id);
if (newLoader != loader && loader != null)
{
loader.removeEventListener(EventX.COMPLETE, loadComplete);
loader.removeEventListener(EventX.FAILED, failedLoad);
if (progress)
{
loader.removeEventListener(EventX.PROGRESS, progressHandle);
}
}
loader = newLoader;
if (retryCount > 0)
{
loader.autoRetry = true;
loader.autoTryLimit = retryCount;
}
loader.checkProgress = progress;
loader.addEventListener(EventX.COMPLETE, loadComplete);
loader.addEventListener(EventX.FAILED, failedLoad);
if (progress)
{
loader.addEventListener(EventX.PROGRESS, progressHandle);
}
loaderManager.queue(loader, priority);
}
/**
* 加载资源成功
* @param event
*
*/
protected virtual void loadComplete(EventX e)
{
loader = e.target as RFLoader;
loader.removeEventListener(EventX.COMPLETE, loadComplete);
loader.removeEventListener(EventX.PROGRESS, progressHandle);
loader.removeEventListener(EventX.FAILED, failedLoad);
bool b = true;
string eventType = e.type;
_data = loader.parser(parserType);
if (_data != null)
{
b = parser(_data);
}
if (_data == null)
{
_data = "_data is null";
eventType = EventX.FAILED;
}
if (b)
{
resourceComplete(eventType);
}
}
/**
* 加载资源成功
* @param event
*
*/
protected virtual void loadComplete(EventX e)
{
loader = e.target as RFLoader;
AssetsManager.bindEventHandle(loader, loadComplete, false);
loader.removeEventListener(EventX.CANCEL, loadCancelHandle);
if (loader.checkProgress)
{
loader.removeEventListener(EventX.PROGRESS, progressHandle);
}
if (e.type == EventX.FAILED)
{
_data = null;
this.simpleDispatch(EventX.DEPEND_READY);
resourceComplete(EventX.FAILED, (string)e.data);
return;
}
_data = e.data;
if (_data == null)
{
_data = "_data is null";
this.simpleDispatch(EventX.DEPEND_READY);
resourceComplete(EventX.FAILED, (string)_data);
}
else
{
_data = parserData(_data);
this.simpleDispatch(EventX.DEPEND_READY);
resourceComplete(EventX.COMPLETE);
}
}
public bool add(RFLoader loader)
{
if (runingList.Contains(loader) || queue.Contains(loader))
{
return(false);
}
queue.Enqueue(loader);
return(true);
}
public void onLoaderComplete(EventX e)
{
// 加载记录
RFLoader loader = e.target as RFLoader;
loader.removeEventListener(EventX.COMPLETE, onLoaderComplete);
loader.removeEventListener(EventX.FAILED, onLoaderComplete);
_loadingPool.Remove(loader.id);
_loadingCount--;
}
private void loadHandle(EventX e)
{
_concurrence--;
RFLoader target = e.target as RFLoader;
//trace("loaderQueue",_concurrence,event.type,target.url);
target.removeEventListener(EventX.COMPLETE, loadHandle);
target.removeEventListener(EventX.FAILED, loadHandle);
target.removeEventListener(EventX.DISPOSE, loadHandle);
CallLater.Add(next);
}
internal void dispose(RFLoader loader)
{
string id = loader.id;
if (_loadingPool.ContainsKey(id))
{
_loadingPool.Remove(id);
_loadingCount--;
}
loader.removeEventListener(EventX.COMPLETE, onLoaderComplete);
loader.removeEventListener(EventX.FAILED, onLoaderComplete);
_coreLoaderQueue.remove(loader);
}
private void Update()
{
if (running < CONCURRENCE && queue.Count > 0)
{
RFLoader loader = queue.Dequeue();
loader.addEventListener(EventX.COMPLETE, loadHandle, MAX);
loader.addEventListener(EventX.FAILED, loadHandle, MAX);
loader.addEventListener(EventX.DISPOSE, loadHandle, MAX);
runingList.Add(loader);
running++;
Log("CorStart: {0} {1} {2}", running, loader._url, loader.ToString());
loader.load();
}
}
private void loadHandle(EventX e)
{
RFLoader target = (RFLoader)e.target;
runingList.Remove(target);
running--;
Log("CorEnd: {0} {1},{2}", running, e.type, target._url);
if (running < 0)
{
DebugX.LogError("coreLoaderQueue error {0} {1},{2}", running, e.type, target._url);
}
target.removeEventListener(EventX.COMPLETE, loadHandle);
target.removeEventListener(EventX.FAILED, loadHandle);
target.removeEventListener(EventX.DISPOSE, loadHandle);
}
public bool remove(RFLoader value)
{
if (value == null)
{
return(false);
}
LoaderNode t = null;
if (maping.TryGetValue(value, out t) == false)
{
return(false);
}
LoaderNode pre = t.pre;
LoaderNode next = t.next;
if (pre != null)
{
pre.next = next;
}
else
{
firstNode = next;
}
if (next != null)
{
next.pre = pre;
}
else
{
lastNode = pre;
}
maping.Remove(value);
if (nodePool.Count < MAX)
{
t.data = null;
nodePool.Push(t);
}
return(false);
}
public RFLoader getLoader(AssetResource resource)
{
RFLoader loader = null;
string url = resource.url;
LoaderXDataType parserType = resource.parserType;
if (_loadingPool.TryGetValue(resource.url, out loader))
{
return(loader);
}
string locaPath = versionLoaderFactory.getLocalPathByURL(url, true);
if (resource.isForceRemote == false)
{
//先验证是否有热更新的资源
string fullLocalPath = PathDefine.getPersistentLocal(locaPath);
if (File.Exists(fullLocalPath) == true)
{
loader = new FileStreamLoader(fullLocalPath, url, parserType);
}
else
{
fullLocalPath = PathDefine.getStreamingAssetsLocal(locaPath, true);
///ios强制使用WebRequest;
loader = new WebRequestLoader(fullLocalPath, parserType);
}
}
if (loader == null)
{
loader = new WebRequestLoader(url, parserType);
loader.isLocalFile = false;
if (resource.isForceRemote)
{
loader.postData = resource.postData;
loader.timeout = resource.timeout;
}
}
_loadingPool[resource.url] = loader;
return(loader);
}
protected virtual void _loadImp(int priority = 0, bool progress = false, uint retryCount = 0)
{
if (loader == null)
{
if (LoaderFactory == null)
{
LoaderFactory = new ResourceLoaderManager();
}
loader = LoaderFactory.getLoader(this);
}
loader.checkProgress = progress;
loader.retryCount = retryCount;
AssetsManager.bindEventHandle(loader, loadComplete);
if (progress)
{
loader.addEventListener(EventX.PROGRESS, progressHandle);
}
loader.addEventListener(EventX.CANCEL, loadCancelHandle);
AbstractApp.coreLoaderQueue.add(loader);
}
public virtual void __dispose()
{
if (loader != null)
{
loader.removeEventListener(EventX.COMPLETE, loadComplete);
loader.removeEventListener(EventX.PROGRESS, progressHandle);
loader.removeEventListener(EventX.FAILED, loadComplete);
loader.Dispose();
loader = null;
}
if (pool != null)
{
PoolItem[] list = pool.ToArray();
foreach (PoolItem item in list)
{
item.Dispose();
}
pool.Clear();
pool = null;
}
_status = AssetState.NONE;
if (_data != null)
{
_data = null;
//todo data;
}
if (_sprite != null)
{
GameObject.Destroy(_sprite);
_sprite = null;
}
Log("AssetDispose:{0}", url);
_disposed = true;
this.simpleDispatch(EventX.DISPOSE);
_clear();
}
public void __dispose()
{
if (loader != null)
{
loader.removeEventListener(EventX.COMPLETE, loadComplete);
loader.removeEventListener(EventX.FAILED, failedLoad);
ResourceLoaderManager.sharedInstance().dispose(loader);
loader.dispose();
loader = null;
}
if (_data != null)
{
//todo data;
}
_status = AssetState.NONE;
this.simpleDispatch(EventX.DISPOSE);
_clear();
_disposed = true;
}
internal bool unQueue(RFLoader loader)
{
return(_coreLoaderQueue.remove(loader));
}
internal void queue(RFLoader loader, int priority = 0)
{
_coreLoaderQueue.add(loader, priority);
_coreLoaderQueue.next();
}
public bool add(RFLoader value, int priority = 0)
{
LoaderNode t = null;
if (maping.TryGetValue(value, out t))
{
return(false);
}
LoaderNode newNode;
if (nodePool.Count > 0)
{
newNode = nodePool.Pop();
newNode.next = newNode.pre = null;
}
else
{
newNode = new LoaderNode();
}
newNode.data = value;
newNode.priority = priority;
maping.Add(value, newNode);
if (firstNode == null)
{
lastNode = firstNode = newNode;
return(true);
}
LoaderNode findNode = null;
if (priority > lastNode.priority)
{
t = firstNode;
LoaderNode pre;
while (t != null)
{
if (priority > t.priority)
{
pre = t.pre;
newNode.next = t;
t.pre = newNode;
if (pre != null)
{
pre.next = newNode;
newNode.pre = pre;
}
else
{
firstNode = newNode;
}
findNode = t;
break;
}
t = t.next;
}
}
if (findNode == null)
{
lastNode.next = newNode;
newNode.pre = lastNode;
lastNode = newNode;
}
return(true);
}
