public virtual void Request(RequestArg reqArg)
{
lock (reqQueueLock)
{
reqQueue.Enqueue(reqArg);
Monitor.PulseAll(reqQueueLock);
}
}
public int Push(string rId, RequestArg reqArg)
{
if (string.IsNullOrEmpty(rId))
{
throw new ArgumentNullException("rId == null");
}
if (reqArg == null)
{
throw new ArgumentNullException("reqArg == null");
}
return(this.client.Request(rId, reqArg));
}
public int Push(string rId, RequestArg reqArg)
{
lock (reqQueueLock)
{
Request request = new Request(Int32.Parse(rId));
request.TwoWay = false;
//TODO generate auto increase sequence
request.Sequence = 1;
request.Content = reqArg;
reqQueue.Enqueue(request);
Monitor.PulseAll(reqQueueLock);
return(request.Sequence);
}
}
public virtual int Request(string evtType, RequestArg reqArg)
{
lock (reqQueueLock)
{
Request request = new Request(Int32.Parse(evtType));
request.TwoWay = true;
//TODO generate auto increase sequence
request.Sequence = 1;
request.Content = reqArg;
reqQueue.Enqueue(request);
Monitor.PulseAll(reqQueueLock);
return(request.Sequence);
}
}
public void Encode(Remoting.Channel ch, object message, ByteArray output)
{
ByteArray data = new ByteArray();
Dataoutput binOutput = new BinaryDataOutput(data);
byte pType = 0, commpressed = 0;
if (message is HandSankeReq)
{
pType = Packet.FLAG_HANDSNAKE;
commpressed = PacketHeader.UNCOMPRESSED;
HandSankeReq req = message as HandSankeReq;
req.SerializaTo(binOutput);
}
else if (message is HeartBeatReq)
{
pType = Packet.FLAG_HEARTBEAT;
commpressed = PacketHeader.UNCOMPRESSED;
HeartBeatReq req = message as HeartBeatReq;
req.SerializaTo(binOutput);
}
else if (message is Request)
{
pType = Packet.FLAG_MESSAGE;
commpressed = PacketHeader.UNCOMPRESSED;
Request req = message as Request;
binOutput.WriteInt(req.Id);
binOutput.WriteByte(req.Type);
binOutput.WriteInt(req.Sequence);
binOutput.WriteBool(req.TwoWay);
RequestArg content = (RequestArg)req.Content;
content.SerializaTo(binOutput);
}
Dataoutput wholeOutput = new BinaryDataOutput(output);
wholeOutput.WriteByte(MAGIC_HIGH);
wholeOutput.WriteByte(MAGIC_LOW);
wholeOutput.WriteByte(pType);
wholeOutput.WriteByte(commpressed);
wholeOutput.WriteInt(data.Length);
output.WriteBytes(data.Bytes);
}
private void OnRequestPackageFail(RequestArg request_arg, int nError)
{
switch (request_arg.eType)
{
case TRequestType.EResource:
{
RequestArg_Resource arg = (RequestArg_Resource)request_arg;
arg.resource_ref.SetError(nError);
}
break;
case TRequestType.EScene:
{
RequestArg_Scene arg = (RequestArg_Scene)request_arg;
if (arg.evtSceneListener != null)
{
arg.evtSceneListener(this, new SceneEventArgs(false));
}
}
break;
case TRequestType.EInitPackage:
{
RequestArg_InitPackage arg = (RequestArg_InitPackage)request_arg;
if (arg.evtListener != null)
{
arg.evtListener(this, new InitPackageArgs(false));
}
}
break;
}
}
//协程加载资源包，同时存在多个协程
IEnumerator LoadResourceCoroutineMulti(string rootPackage, RequestArg request_arg)
{
while (null == assetBundleManifest)
yield return new WaitForSeconds(0.1f);
do
{
//如果协程数量超过最大数量限制，在这里等待直到协程数量减少后开始继续执行
if (m_nCoroutineCount < m_nCurrentMaxCoroutineCount)
break;
yield return new WaitForSeconds(0.1f);
} while (true);
if (request_arg.eType == TRequestType.EResource)
{
((RequestArg_Resource)request_arg).resource_ref.AddRef();
}
//协程计数加1
m_nCoroutineCount++;
List<PackageRef> ltPackageRefed = new List<PackageRef>(); //当前协成中所有引用到的包，为了防止垃圾回收，要在这个协成执行过程中增加包的引用技术
List<WWWPakcageLoader> ltLoader = new List<WWWPakcageLoader>();
List<WWWPakcageLoader> ltLoaderFinish = new List<WWWPakcageLoader>();
List<string> ltPackageToLoad = new List<string>();
ltPackageToLoad.Add(rootPackage);
int nPackageIndex = 0;
while (ltLoader.Count > 0 || ltPackageToLoad.Count > 0)
{
//看看正在加载的资源有没有加载完
for (int i = 0; i < ltLoader.Count; i++)
{
if (ltLoader[i].www.isDone)
{
ltLoader[i].Pack.bundle = ltLoader[i].www.assetBundle;
if (ltLoader[i].Pack.bundle == null)
{
ltLoader[i].Pack.error = 2;
OnRequestPackageFail(request_arg, ltLoader[i].Pack.error);
DebugTool.LogError("load error, bundle is null with name: ", ltLoader[i].Pack.name, " strConDebugName: ");
}
ltLoaderFinish.Add(ltLoader[i]);
if (ltLoader[i].www.error != null)
{
//包加载错误
ltLoader[i].Pack.error = 1;
OnRequestPackageFail(request_arg, ltLoader[i].Pack.error);
DebugTool.LogError("load package error: [", ltLoader[i].Pack.name, "]");
}
ltLoader[i].www.Dispose();
ltLoader[i].www = null;
}
}
//从加载列表中移除已经加载完毕的资源包
for (int j = 0; j < ltLoaderFinish.Count; ++j)
{
ltLoader.Remove(ltLoaderFinish[j]);
}
ltLoaderFinish.Clear();
if (ltPackageToLoad.Count > 0 && ltLoader.Count < m_nCurrentMaxLoaderCount)
{
string load_package_name = ltPackageToLoad[0];
ltPackageToLoad.RemoveAt(0);
if (onLoadingPackage != null)
onLoadingPackage("loading: " + load_package_name);
PackageRef load_package = GetExistPackageRef(load_package_name);
if (load_package == null)
{
//此包在所有的加载协程里未找到
load_package = new PackageRef(load_package_name);
AddPackageRef(load_package);
ltPackageRefed.Add(load_package);
load_package.use++;
WWWPakcageLoader loader = null;
string url = "";
url = SourcePath + GetBundleNameInManifest(load_package_name);
if (!url.Contains("://"))
{
url = "file://" + url;
}
loader = new WWWPakcageLoader(load_package, url);
ltLoader.Add(loader);
}
else if (load_package.error != 0)
{
ltPackageRefed.Add(load_package);
load_package.use++;
DebugTool.LogError("other load package error: [", load_package.name, "]");
OnRequestPackageFail(request_arg, load_package.error);
}
else if (load_package.bundle == null)
{
//此包其它协程正在加载,添加到链表里,在while里做检测
// ltOtherPakcageToLoad.Add(load_package);
//
// ltPackageRefed.Add(load_package);
// load_package.use++;
}
else
{
ltPackageRefed.Add(load_package);
load_package.use++;
}
nPackageIndex++;
if (nPackageIndex == 1)
{
UFileInfo fileInfo = UFile.Instance.GetFileInfo(load_package_name);
if (null == fileInfo)
{
Debug.LogError("cant find fileInfo : " + load_package_name);
}
else
{
string[] deps = fileInfo.dependencies;
for (int i = 0; i < deps.Length; i++)
{
ltPackageToLoad.Add(deps[i]);
}
}
}
}
yield return new WaitForEndOfFrame();
}
if (onLoadingPackage != null)
{
if (request_arg.eType == TRequestType.EResource)
onLoadingPackage("loading model...");
else if (request_arg.eType == TRequestType.EScene)
onLoadingPackage("loading scene...");
else
onLoadingPackage("loading init package...");
}
switch (request_arg.eType)
{
case TRequestType.EResource:
{
RequestArg_Resource arg_resource = (RequestArg_Resource)request_arg;
PackageRef package = GetExistPackageRef(rootPackage);
if (package != null && package.bundle != null)
{
AssetBundleRequest objRequest = null;
objRequest = package.bundle.LoadAssetAsync(UnityTools.GetAssetnameInPackage(arg_resource.path).Trim().ToLower(), typeof(UnityEngine.Object));
yield return objRequest;
UnityEngine.Object resObject = null;
try
{
resObject = objRequest.asset;
}
catch (System.Exception e)
{
DebugTool.LogError("Get asset Error: ", arg_resource.path, " error: ", e.Message);
}
if (resObject != null)
{
arg_resource.resource_ref.SetObject(resObject);
}
else
{
arg_resource.resource_ref.SetError(EObjectError);
}
}
else
{
arg_resource.resource_ref.SetError(EObjectError);
}
}
break;
case TRequestType.EScene:
//LoadSceneInPackage((RequestArg_Scene)request_arg);
break;
case TRequestType.EInitPackage:
{
RequestArg_InitPackage arg_initpackage = (RequestArg_InitPackage)request_arg;
if (arg_initpackage != null && arg_initpackage.evtListener != null)
{
arg_initpackage.evtListener(GetExistPackageRef(rootPackage), new InitPackageArgs(true));
}
}
break;
}
if (request_arg.eType != TRequestType.EInitPackage)
{
//ReleasePackageUseCnt(ltPackageRefed, strConDebugName);
}
if (request_arg.eType == TRequestType.EResource)
{
//在减引用计数之后在调用回调，这样在回调里就可以释放资源包了
((RequestArg_Resource)request_arg).resource_ref.SendNotify();
((RequestArg_Resource)request_arg).resource_ref.DelRef();
}
m_nCoroutineCount--;
}
