//加载失败处理
protected void OnFail()
{
if (m_errorStr == null)
{
m_errorStr = "load fail:" + m_url_str;
}
__print("×" + m_errorStr);
Stop();
SetProgress(1);
m_data = null;
m_done = true;
if (m_loadReq != null)
{
m_loadReq.done = true;
m_loadReq.error_str = m_errorStr; //记录错误码
LoadReq req = m_loadReq; //先保存引用, 因为在派发事件时, 可能会关闭加载
//失败时,不回调完成
//req.OnComplete();
NotifyAsynEvt(LOAD_EVT.FAIL, req);
}
else
{
NotifyAsynEvt(LOAD_EVT.FAIL);
}
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽数据操作∽-★-∽--------∽-★-∽------∽-★-∽--------//
protected override LoadReq ExcuteLoad(LoadReq req_)
{
LoadReq req = req_;
AbstractLoader loader = LoaderFactory.GetLoader(req_.type);
req = loader.LoadAsync(req);
if (loader.isDone)
{
LoaderFactory.CloseLoader(loader);
return req;
}
req.OnStart();
//m_isAsync = isAsync_;
//m_progress = 0;
//m_data = null;
//m_errorStr = null;
m_isOpen = true;
m_done = false;
m_loading = true;
m_loaders.Add(loader);
SchUpdate(true);
//__print("○load start: " + loader.UrlStr);
NotifyAsynEvt(LOAD_EVT.START, req);
return req;
}
//加载完成处理
protected void OnComplete()
{
if (m_url_str != null)
{
__print("●load complete: " + m_url_str);
}
Stop();
SetProgress(1);
m_done = true;
if (m_loadReq != null)
{
m_loadReq.done = true;
m_loadReq.data = m_data;
LoadReq req = m_loadReq; //先保存引用, 因为在派发事件时, 可能会关闭加载
req.OnComplete();
//派发事件要放在最后, 因为有可能在这里重启加载
NotifyAsynEvt(LOAD_EVT.COMPLETE, req);
}
else
{
NotifyAsynEvt(LOAD_EVT.COMPLETE);
}
}
protected AbstractLoader StartLoader(LoadReq req_)
{
AbstractLoader loader = LoaderFactory.GetLoader(req_.type);
loader.LoadAsync(req_);
return(loader);
}
static public void RemoveReq(LoadReq req_)
{
if (!m_reqHash.Contains(req_))
{
return;
}
m_reqHash.Remove(req_);
//Log.Debug("RemoveReq:" + (req_.url ?? req_.GetType().Name));
}
static HashSet <LoadReq> m_reqHash = new HashSet <LoadReq>(); //处于加载中的所有加载请求
static public void AddReq(LoadReq req_)
{
if (m_reqHash.Contains(req_))
{
return;
}
m_reqHash.Add(req_);
//Log.Debug("AddReq:" + (req_.url ?? req_.GetType().Name));
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽后台加载∽-★-∽--------∽-★-∽------∽-★-∽--------//
/// <summary>
/// 异步加载
/// </summary>
/// <param name="req_"></param>
/// <param name="onComplete_"></param>
/// <returns></returns>
static public LoadReq LoadAsync(LoadReq req_, CALLBACK_LoadReq onComplete_ = null)
{
if (onComplete_ != null)
{
req_.on_complete -= onComplete_;
req_.on_complete += onComplete_;
}
LoadReq req = m_subLoader.LoadAsync(req_);
return(req);
}
void LoadOne()
{
LoadReq req_ = m_loadReqQue.load_reqs[m_load_idx];
if (m_loader == null || m_loader.Req.type != req_.type)
{
LoaderFactory.CloseLoader(m_loader);
m_loader = LoaderFactory.GetLoader(req_.type);
}
m_loader.LoadAsync(req_);
CheckLoaded();
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽主加载∽-★-∽--------∽-★-∽------∽-★-∽--------//
static public void DoMainLoad(LoadReq req_, CALLBACK_0 onComplete_, string viewTp_)
{
m_mainLoader.LoadAsync(req_);
if (m_mainLoader.Loading)
{
ShowLoadView(viewTp_);
m_mainLoadBack = onComplete_;
}
else
{
if (onComplete_ != null)
{
onComplete_();
}
}
}
//加载完成
static private void FileLoadBack(LoadReq req_)
{
LoadReq req = req_;
DataConfigReg reg = req.userData as DataConfigReg;
TextAsset data = req_.data as TextAsset;
byte[] bytes = data.bytes;
object[] datas = m_parser.Parse(bytes, reg.data_tp);
if (datas == null)
{
return;
}
if (reg.on_complete != null)
{
reg.on_complete(datas);
}
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽数据管理∽-★-∽--------∽-★-∽------∽-★-∽--------//
//-------∽-★-∽------∽-★-∽--------∽-★-∽数据操作∽-★-∽--------∽-★-∽------∽-★-∽--------//
//-------∽-★-∽------∽-★-∽--------∽-★-∽配置加载∽-★-∽--------∽-★-∽------∽-★-∽--------//
/// <summary>
/// 获取加载项
/// </summary>
/// <returns></returns>
static public LoadReq[] GetLoadObjs()
{
LoadReq[] result = new LoadReq[m_regs.Length];
DataConfigReg reg;
LoadReq req;
for (int i = 0; i < m_regs.Length; ++i)
{
reg = m_regs[i];
req = new LoadReqRes(CC_RES_ID.CONFIG, reg.file_name);
req.on_complete = FileLoadBack;
req.userData = reg;
result[i] = req;
//req.SetRefer(m_refer);
}
return(result);
}
protected virtual LoadReq ExcuteLoad(LoadReq req_)
{
if (m_loadReq == req_)
{
return(m_loadReq);
}
//关闭当前加载
Close();
m_loadReq = req_;
m_url = m_loadReq.url;
m_url_str = m_url;
m_progress = 0;
m_data = null;
m_errorStr = null;
m_isOpen = true;
m_loading = true;
m_done = false;
__print("○load start: " + m_url_str);
NotifyAsynEvt(LOAD_EVT.START, m_loadReq);
if (m_assetCache.HasAsset(m_url))
{
//已加载,立刻完成
m_data = m_assetCache.GetAsset(m_url);
OnComplete();
}
else
{
StartLoad();
}
return(m_loadReq);
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽数据操作∽-★-∽--------∽-★-∽------∽-★-∽--------//
protected override LoadReq ExcuteLoad(LoadReq req_)
{
if (m_loadReq == req_)
{
return(m_loadReq);
}
m_loadReqQue = req_ as LoadReqQueue;
//关闭当前加载
Close();
m_load_num = m_loadReqQue.load_reqs.Length;
if (m_load_num == 0)
{
Log.Assert("加载列表为空", this);
return(m_loadReqQue);
}
m_loadReq = m_loadReqQue;
m_url = m_loadReqQue.load_reqs[0].url;
m_url_str = m_url + (m_load_num > 1 ? " <...>" : "");
m_progress = 0;
m_data = null;
m_errorStr = null;
m_isOpen = true;
m_done = false;
m_loading = true;
__print("○load start: " + m_url_str);
NotifyAsynEvt(LOAD_EVT.START, m_loadReq);
StartLoad();
return(m_loadReq);
}
/// <summary>
/// 关闭
/// </summary>
public void Close()
{
if (!m_isOpen)
{
return;
}
m_isOpen = false;
Stop();
__Close();
if (m_loadReq != null)
{
m_loadReq.OnDestroy();//销毁
m_loadReq = null;
}
m_data = null;
m_errorStr = null;
m_progress = 0;
m_done = false;
}
public LoadReq LoadAsync(LoadReq req_)
{
return(ExcuteLoad(req_));
}
//-------∽-★-∽------∽-★-∽--------∽-★-∽数据操作∽-★-∽--------∽-★-∽------∽-★-∽--------//
/// <summary>
/// 异步加载
/// </summary>
/// <param name="path_"></param>
/// <param name="on_complete_"></param>
/// <returns></returns>
public LoadReq LoadAsync(string path_, CALLBACK_LoadReq on_complete_ = null)
{
LoadReq req = new LoadReq(path_, on_complete_);
return(LoadAsync(req));
}
