/// <summary>添加会话。子类可以在添加会话前对会话进行一些处理</summary>
/// <param name="session"></param>
protected virtual void AddSession(INetSession session)
{
// 估算完成时间，锁争夺过大时提示
using (var tc = new TimeCost("NetServer.AddSession", 100))
{
tc.Log = Log;
//var dic = Sessions;
//lock (dic)
//{
if (session.Host == null)
{
session.Host = this;
}
session.OnDisposed += (s, e) =>
{
//var dic2 = Sessions;
//lock (dic2)
//{
// dic2.Remove((s as INetSession).ID);
//}
var id = (s as INetSession).ID;
if (id > 0)
{
Sessions.Remove(id);
}
};
Sessions[session.ID] = session;
//}
}
}
/// <summary>关闭</summary>
/// <returns>是否成功</returns>
public virtual Boolean Close(String reason = null)
{
if (!Active)
{
return(true);
}
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Close".F(GetType().Name), 500))
{
tc.Log = Log;
if (OnClose(reason))
{
Active = false;
}
_RecvCount = 0;
// 触发关闭完成的事件
Closed?.Invoke(this, EventArgs.Empty);
}
// 如果是动态端口，需要清零端口
if (DynamicPort)
{
Port = 0;
}
return(!Active);
}
IEnumerator T2()
{
TimeCost.Begin("2层");
yield return(new WaitForSeconds(1));
Debug.Log(TimeCost.End());
}
/// <summary>添加新会话，并设置会话编号</summary>
/// <param name="session"></param>
/// <returns>返回添加新会话是否成功</returns>
public Boolean Add(ISocketSession session)
{
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Add".F(GetType().Name), 100))
{
tc.Log = Server.Log;
var key = session.Remote.EndPoint + "";
if (_dic.ContainsKey(key))
{
return(false);
}
lock (_dic)
{
if (_dic.ContainsKey(key))
{
return(false);
}
session.OnDisposed += (s, e) => { lock (_dic) { _dic.Remove((s as ISocketSession).Remote.EndPoint + ""); } };
_dic.Add(key, session);
if (clearTimer == null)
{
clearTimer = new TimerX(RemoveNotAlive, null, ClearPeriod, ClearPeriod);
}
}
}
return(true);
}
/// <summary>获取会话，加锁</summary>
/// <param name="key"></param>
/// <returns></returns>
public ISocketSession Get(String key)
{
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Get".F(GetType().Name), 100))
{
tc.Log = Server.Log;
ISocketSession session = null;
if (!_dic.TryGetValue(key, out session))
{
return(null);
}
// 加锁后获取，本方法平均执行时间143.48ns
lock (_dic)
{
if (!_dic.TryGetValue(key, out session))
{
return(null);
}
return(session);
}
}
}
/// <summary>
/// decides which timecost will seted after interacting
/// </summary>
void SetTimeCost()
{
//do not continue when list is empty
if (executionList.Count == 0)
{
return;
}
//start counter when list got one entry or more
count += Time.deltaTime;
//speed timer for certain amount of time
if (count <= duration)
{
//check first entry in list and get timecost
timer.SpeedTime(GetValue(executionList[0]));
}
if (count > duration)
{
//reset counter
count = 0;
//remove first entry in list
executionList.RemoveAt(0);
}
// reset time cost when list gets empty
timeCost = TimeCost.NoCost;
}
/// <summary>添加会话。子类可以在添加会话前对会话进行一些处理</summary>
/// <param name="session"></param>
protected virtual void AddSession(INetSession session)
{
// 估算完成时间，锁争夺过大时提示
using (var tc = new TimeCost("NetServer.AddSession", 100))
{
tc.Log = Log;
var dic = Sessions;
lock (dic)
{
if (session.Host == null)
{
session.Host = this;
}
session.OnDisposed += (s, e) =>
{
var dic2 = Sessions;
lock (dic2)
{
dic2.Remove((s as INetSession).ID);
}
};
dic[session.ID] = session;
}
}
}
/// <summary>打开</summary>
/// <returns>是否成功</returns>
public virtual Boolean Open()
{
if (Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (Active)
{
return(true);
}
LogPrefix = "{0}.".F((Name + "").TrimEnd("Server", "Session", "Client"));
BufferSize = Setting.Current.BufferSize;
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost(GetType().Name + ".Open", 1500))
{
tc.Log = Log;
_RecvCount = 0;
Active = OnOpen();
if (!Active)
{
return(false);
}
if (Timeout > 0)
{
Client.ReceiveTimeout = Timeout;
}
if (!Local.IsUdp)
{
// 管道
var pp = Pipeline;
pp?.Open(pp.CreateContext(this));
}
}
// 统计
if (StatSend == null)
{
StatSend = new PerfCounter();
}
if (StatReceive == null)
{
StatReceive = new PerfCounter();
}
ReceiveAsync();
// 触发打开完成的事件
Opened?.Invoke(this, EventArgs.Empty);
return(true);
}
/// <summary>打开</summary>
/// <returns>是否成功</returns>
public virtual Boolean Open()
{
if (Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (Active)
{
return(true);
}
lock (this)
{
if (Active)
{
return(true);
}
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost(GetType().Name + ".Open", 1500))
{
tc.Log = Log;
_RecvCount = 0;
// 本地和远程协议栈不一致时需要配对
FixAddressFamily();
var rs = OnOpen();
if (!rs)
{
return(false);
}
var timeout = Timeout;
if (timeout > 0)
{
Client.SendTimeout = timeout;
Client.ReceiveTimeout = timeout;
}
// Tcp需要初始化管道
if (Local.IsTcp)
{
Pipeline?.Open(CreateContext(this));
}
}
Active = true;
ReceiveAsync();
// 触发打开完成的事件
Opened?.Invoke(this, EventArgs.Empty);
}
return(true);
}
/// <summary>移除不活动的会话</summary>
void RemoveNotAlive(Object state)
{
if (_dic.Count < 1)
{
return;
}
var timeout = 30;
if (Server != null)
{
timeout = Server.SessionTimeout;
}
var keys = new List <String>();
var values = new List <ISocketSession>();
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.RemoveNotAlive".F(GetType().Name), 100))
{
tc.Log = Server.Log;
lock (_dic)
{
if (_dic.Count < 1)
{
return;
}
// 这里可能有问题，曾经见到，_list有元素，但是value为null，这里居然没有进行遍历而直接跳过
// 操作这个字典的时候，必须加锁，否则就会数据错乱，成了这个样子，无法枚举
foreach (var elm in _dic)
{
var item = elm.Value;
// 判断是否已超过最大不活跃时间
if (item == null || item.Disposed || timeout > 0 && IsNotAlive(item, timeout))
{
keys.Add(elm.Key);
values.Add(elm.Value);
}
}
// 从会话集合里删除这些键值，现在在锁内部，操作安全
foreach (var item in keys)
{
_dic.Remove(item);
}
}
}
// 已经离开了锁，慢慢释放各个会话
foreach (var item in values)
{
item.WriteLog("超过{0}秒不活跃销毁 {1}", timeout, item);
//item.Dispose();
item.TryDispose();
}
}
void ProcessAccept(SocketAsyncEventArgs se)
{
if (!Active || Client == null)
{
se.TryDispose();
return;
}
// 判断成功失败
if (se.SocketError != SocketError.Success)
{
// 未被关闭Socket时，可以继续使用
//if (!se.IsNotClosed())
{
var ex = se.GetException();
if (ex != null)
{
OnError("AcceptAsync", ex);
}
se.TryDispose();
return;
}
}
else
{
// 直接在IO线程调用业务逻辑
try
{
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.OnAccept".F(GetType().Name), 200))
{
tc.Log = Log;
OnAccept(se.AcceptSocket);
}
}
catch (Exception ex)
{
if (!ex.IsDisposed())
{
OnError("EndAccept", ex);
}
}
finally
{
se.AcceptSocket = null;
}
}
// 开始新的征程
AcceptAsync(se, true);
}
///// <summary>执行单一参数和返回值的委托</summary>
///// <typeparam name="T"></typeparam>
///// <typeparam name="TResult"></typeparam>
///// <param name="control"></param>
///// <param name="method"></param>
///// <param name="arg"></param>
///// <returns></returns>
//public static TResult Invoke<T, TResult>(this Control control, Func<T, TResult> method, T arg)
//{
// if (control.IsDisposed) return default(TResult);
// return (TResult)control.Invoke(method, arg);
//}
/// <summary>执行二参数无返回值的委托</summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="T2"></typeparam>
/// <param name="control"></param>
/// <param name="method"></param>
/// <param name="arg"></param>
/// <param name="arg2"></param>
public static void Invoke <T, T2>(this Control control, Action <T, T2> method, T arg, T2 arg2)
{
if (control.IsDisposed)
{
return;
}
control.BeginInvoke(new Action(() =>
{
using var tc = new TimeCost("Control.Invoke", 500);
method(arg, arg2);
}));
}
/// <summary>执行无参委托</summary>
/// <param name="control"></param>
/// <param name="method"></param>
/// <returns></returns>
public static void Invoke(this Control control, Action method)
{
if (control.IsDisposed)
{
return;
}
control.BeginInvoke(new Action(() =>
{
using var tc = new TimeCost("Control.Invoke", 500);
method();
}));
}
/// <summary>获取会话，加锁</summary>
/// <param name="key"></param>
/// <returns></returns>
public ISocketSession Get(String key)
{
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Get".F(GetType().Name), 100))
{
tc.Log = Server.Log;
if (!_dic.TryGetValue(key, out var session))
{
return(null);
}
return(session);
}
}
///// <summary>执行仅返回值委托</summary>
///// <typeparam name="TResult"></typeparam>
///// <param name="control"></param>
///// <param name="method"></param>
///// <returns></returns>
//public static TResult Invoke<TResult>(this Control control, Func<TResult> method)
//{
// if (control.IsDisposed) return default(TResult);
// return (TResult)control.Invoke(method);
//}
/// <summary>执行单一参数无返回值的委托</summary>
/// <typeparam name="T"></typeparam>
/// <param name="control"></param>
/// <param name="method"></param>
/// <param name="arg"></param>
/// <returns></returns>
public static void Invoke <T>(this Control control, Action <T> method, T arg)
{
if (control.IsDisposed)
{
return;
}
control.BeginInvoke(new Action(() =>
{
using (var tc = new TimeCost("Control.Invoke", 500))
{
method(arg);
}
}));
}
/// <summary>打开</summary>
/// <returns>是否成功</returns>
public virtual Boolean Open()
{
if (Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (Active)
{
return(true);
}
// 即使没有事件，也允许强行打开异步接收
if (!UseReceiveAsync && Received != null)
{
UseReceiveAsync = true;
}
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Open".F(GetType().Name), 1500))
{
tc.Log = Log;
Active = OnOpen();
if (!Active)
{
return(false);
}
if (Timeout > 0)
{
Client.ReceiveTimeout = Timeout;
}
// 触发打开完成的事件
if (Opened != null)
{
Opened(this, EventArgs.Empty);
}
}
if (UseReceiveAsync)
{
ReceiveAsync();
}
return(true);
}
private TimeCost TimeCostTest(Action action)
{
TimeCost cost = new TimeCost();
System.Diagnostics.Stopwatch stopwatch = new Stopwatch();
stopwatch.Start(); // 开始监视代码运行时间
stopwatch.Stop(); // 停止监视
TimeSpan timespan = stopwatch.Elapsed; // 获取当前实例测量得出的总时间
cost.Hours = timespan.TotalHours.ToString("#0.00000000 "); // 总小时
cost.Minutes = timespan.TotalMinutes.ToString("#0.00000000 "); // 总分钟
cost.Seconds = timespan.TotalSeconds.ToString("#0.00000000 "); // 总秒数
cost.Milliseconds = timespan.TotalMilliseconds.ToString("#0.00000000 "); // 总毫秒数
return(cost);
}
/// <summary>
/// Time behaviour after interacting with gameobjects and areas
/// </summary>
void GetTimeCost()
{
//Check which cost is choosed
switch (timeCost)
{
default: timeCost = TimeCost.NoCost; break;
case TimeCost.VeryLowCost: executionList.Add(TimeCost.VeryLowCost); break;
case TimeCost.LowCost: executionList.Add(TimeCost.LowCost); break;
case TimeCost.MiddleCost: executionList.Add(TimeCost.MiddleCost); break;
case TimeCost.HighCost: executionList.Add(TimeCost.HighCost); break;
}
}
/// <summary>移除不活动的会话</summary>
void RemoveNotAlive(Object state)
{
if (!_dic.Any())
{
return;
}
var timeout = 30;
if (Server != null)
{
timeout = Server.SessionTimeout;
}
var keys = new List <String>();
var values = new List <ISocketSession>();
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.RemoveNotAlive".F(GetType().Name), 100))
{
tc.Log = Server.Log;
foreach (var elm in _dic)
{
var item = elm.Value;
// 判断是否已超过最大不活跃时间
if (item == null || item.Disposed || timeout > 0 && IsNotAlive(item, timeout))
{
keys.Add(elm.Key);
values.Add(elm.Value);
}
}
// 从会话集合里删除这些键值，现在在锁内部，操作安全
foreach (var item in keys)
{
_dic.Remove(item);
}
}
// 已经离开了锁，慢慢释放各个会话
foreach (var item in values)
{
item.WriteLog("超过{0}秒不活跃销毁 {1}", timeout, item);
//item.Dispose();
item.TryDispose();
}
}
/// <summary>收到连接时，建立会话，并挂接数据接收和错误处理事件</summary>
/// <param name="session"></param>
protected virtual INetSession OnNewSession(ISocketSession session)
{
Interlocked.Increment(ref _SessionCount);
session.OnDisposed += (s, e2) => Interlocked.Decrement(ref _SessionCount);
if (_SessionCount > MaxSessionCount)
{
MaxSessionCount = _SessionCount;
}
var ns = CreateSession(session);
// sessionID变大后，可能达到最大值，然后变为-1，再变为0，所以不用担心
//ns.ID = ++sessionID;
// 网络会话改为原子操作，避免多线程冲突
if (ns is NetSession)
{
(ns as NetSession).ID = Interlocked.Increment(ref sessionID);
}
ns.Host = this;
ns.Server = session.Server;
ns.Session = session;
if (ns is NetSession)
{
(ns as NetSession).Log = SessionLog ?? Log;
}
if (UseSession)
{
AddSession(ns);
}
ns.Received += OnReceived;
ns.MessageReceived += OnMessageReceived;
//session.Error += OnError;
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("NetServer.OnNewSession", 500))
{
tc.Log = Log;
// 开始会话处理
ns.Start();
}
return(ns);
}
/// <summary>
/// Geting value from current time cost
/// </summary>
/// <param name="currentTimeCost"></param>
/// <returns></returns>
float GetValue(TimeCost currentTimeCost)
{
//check which timecost is activated
switch (currentTimeCost)
{
//returns float to speed the time
default: return(0);
case TimeCost.VeryLowCost: return(veryLowCost);
case TimeCost.LowCost: return(lowCost);
case TimeCost.MiddleCost: return(middleCost);
case TimeCost.HighCost: return(highCost);
}
}
/// <summary>添加新会话，并设置会话编号</summary>
/// <param name="session"></param>
/// <returns>返回添加新会话是否成功</returns>
public Boolean Add(ISocketSession session)
{
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Add".F(GetType().Name), 100))
{
tc.Log = Server.Log;
var key = session.Remote.EndPoint + "";
if (_dic.ContainsKey(key))
{
return(false);
}
session.OnDisposed += (s, e) => { _dic.Remove((s as ISocketSession).Remote.EndPoint + ""); };
_dic.TryAdd(key, session);
}
return(true);
}
private void OnImportComplete(SerializationCompletionReason completionReason, WorldAnchorTransferBatch deserializedTransferBatch)
{
if (completionReason != SerializationCompletionReason.Succeeded)
{
Debug.Log("Failed to import: " + completionReason.ToString());
if (retryCount > 0)
{
retryCount--;
indicator.GetComponent <MeshRenderer>().material.color = Color.cyan;
WorldAnchorTransferBatch.ImportAsync(anchorData, OnImportComplete);
}
return;
}
GameObject rb = GameObject.Find("anchor1");
if (rb != null)
{
foreach (string anid in deserializedTransferBatch.GetAllIds())
{
Debug.Log("the anchor id contained is: " + anid);
if (anid == "anchor1")
{
deserializedTransferBatch.LockObject(anid, anchorObject1);
}
else if (anid == "anchor2")
{
deserializedTransferBatch.LockObject(anid, anchorObject2);
}
}
indicator.GetComponent <MeshRenderer>().material.color = Color.green;
TimeCost tc3 = new TimeCost("OFALL", Time.time.ToString() + "successfully locate the anchor");
tCP.SocketSendByte(tc3);
syncOrNot = true;
//syncPlantInfor = true;
}
else
{
Debug.Log("Failed to find object for anchor id: " + spaceId);
indicator.GetComponent <MeshRenderer>().material.color = Color.red;
}
}
/// <summary>打开</summary>
/// <returns>是否成功</returns>
public virtual Boolean Open()
{
if (Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (Active)
{
return(true);
}
LogPrefix = "{0}.".F((Name + "").TrimEnd("Server", "Session", "Client"));
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Open".F(GetType().Name), 1500))
{
tc.Log = Log;
_RecvCount = 0;
Active = OnOpen();
if (!Active)
{
return(false);
}
if (Timeout > 0)
{
Client.ReceiveTimeout = Timeout;
}
// 触发打开完成的事件
Opened?.Invoke(this, EventArgs.Empty);
}
ReceiveAsync();
return(true);
}
/// <summary>添加会话。子类可以在添加会话前对会话进行一些处理</summary>
/// <param name="session"></param>
protected virtual void AddSession(INetSession session)
{
// 估算完成时间，锁争夺过大时提示
using (var tc = new TimeCost("NetServer.AddSession", 100))
{
tc.Log = Log;
if (session.Host == null)
{
session.Host = this;
}
session.OnDisposed += (s, e) =>
{
var id = (s as INetSession).ID;
if (id > 0)
{
_Sessions.Remove(id);
}
};
_Sessions.TryAdd(session.ID, session);
}
}
/// <summary>根据会话ID查找会话</summary>
/// <param name="sessionid"></param>
/// <returns></returns>
public INetSession GetSession(Int32 sessionid)
{
if (sessionid == 0)
{
return(null);
}
// 估算完成时间，锁争夺过大时提示
using (var tc = new TimeCost("NetServer.GetSession", 100))
{
tc.Log = Log;
//var dic = Sessions;
//lock (dic)
//{
if (!Sessions.TryGetValue(sessionid, out var ns))
{
return(null);
}
return(ns);
//}
}
}
/// <summary>打开</summary>
/// <returns>是否成功</returns>
public virtual Boolean Open()
{
if (Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (Active)
{
return(true);
}
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Open".F(GetType().Name), 1500))
{
tc.Log = Log;
Active = OnOpen();
if (!Active)
{
return(false);
}
if (Timeout > 0)
{
Client.ReceiveTimeout = Timeout;
}
// 触发打开完成的事件
Opened?.Invoke(this, EventArgs.Empty);
}
ReceiveAsync();
return(true);
}
IEnumerator DownloadAnchor(string id)
{
imgSet.SetActive(true);
indicator.GetComponent <MeshRenderer>().material.color = Color.yellow;
AnchorRequire ar = new AnchorRequire(id);
TimeCost tc = new TimeCost("OFALL", Time.time.ToString() + "send request to server to download anchor");
tCP.SocketSendByte(tc);
tCP.SocketSendByte(ar);
yield return(new WaitUntil(() => tCP.anchorData.Length != 0));
TimeCost tc1 = new TimeCost("OFALL", Time.time.ToString() + "get the anchor done");
tCP.SocketSendByte(tc1);
//Debug.Log("the size of anchor: " + tCP.anchorData.Length.ToString());
anchorData = tCP.anchorData;
tCP.anchorData = null;
//Debug.Log("start to change colour of cube");
if (indicator.GetComponent <MeshRenderer>().material.color != Color.green)
{
//TextAsset asset = Resources.Load("AnchorData/CSIRO_Lab") as TextAsset;
//anchorData = asset.bytes;
indicator.GetComponent <MeshRenderer>().material.color = Color.blue;
TimeCost tc2 = new TimeCost("OFALL", Time.time.ToString() + "start locating the anchor");
tCP.SocketSendByte(tc2);
ImportWorldAnchor(anchorData);
}
else
{
syncOrNot = true;
//syncPlantInfor = true;
}
//unit test:
//syncOrNot = true;
//syncPlantInfor = true;
}
/// <summary>根据会话ID查找会话</summary>
/// <param name="sessionid"></param>
/// <returns></returns>
public INetSession GetSession(Int32 sessionid)
{
if (sessionid == 0)
{
return(null);
}
// 估算完成时间，锁争夺过大时提示
using (var tc = new TimeCost("NetServer.GetSession", 100))
{
tc.Log = Log;
var dic = Sessions;
lock (dic)
{
INetSession ns = null;
if (!dic.TryGetValue(sessionid, out ns))
{
return(null);
}
return(ns);
}
}
}
void ProcessReceive(SocketAsyncEventArgs se)
{
if (!Active)
{
se.TryDispose();
return;
}
// 判断成功失败
if (se.SocketError != SocketError.Success)
{
// 未被关闭Socket时，可以继续使用
//if (!se.IsNotClosed())
if (OnReceiveError(se))
{
var ex = se.GetException();
if (ex != null) OnError("ReceiveAsync", ex);
se.TryDispose();
return;
}
}
else
{
// 拷贝走数据，参数要重复利用
var data = se.Buffer.ReadBytes(se.Offset, se.BytesTransferred);
var ep = se.RemoteEndPoint as IPEndPoint;
// 在用户线程池里面去处理数据
//Task.Factory.StartNew(() => OnReceive(data, ep)).LogException(ex => OnError("OnReceive", ex));
//ThreadPool.QueueUserWorkItem(s => OnReceive(data, ep));
// 直接在IO线程调用业务逻辑
try
{
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.OnReceive".F(GetType().Name), 1000))
{
tc.Log = Log;
OnReceive(data, ep);
}
}
catch (Exception ex)
{
if (!ex.IsDisposed()) OnError("OnReceive", ex);
}
}
// 开始新的监听
if (Active && !Disposed)
ReceiveAsync(se, true);
else
se.TryDispose();
}
internal Boolean SendAsync_(Byte[] buffer, IPEndPoint remote)
{
if (!Open()) return false;
var count = buffer.Length;
if (StatSend != null) StatSend.Increment(count);
if (Log.Enable && LogSend) WriteLog("SendAsync [{0}]: {1}", count, buffer.ToHex(0, Math.Min(count, 32)));
LastTime = DateTime.Now;
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.SendAsync".F(GetType().Name), 500))
{
tc.Log = Log;
// 同时只允许一个异步发送，其它发送放入队列
// 考虑到超长数据包，拆分为多个包
var max = 1472;
if (buffer.Length <= max)
{
var qi = new QueueItem();
qi.Buffer = buffer;
qi.Remote = remote;
_SendQueue.Enqueue(qi);
}
else
{
var ms = new MemoryStream(buffer);
while (true)
{
var remain = (Int32)(ms.Length - ms.Position);
if (remain <= 0) break;
var len = Math.Min(remain, max);
var qi = new QueueItem();
qi.Buffer = ms.ReadBytes(len);
qi.Remote = remote;
_SendQueue.Enqueue(qi);
}
}
CheckSendQueue(false);
}
return true;
}
/// <summary>打开</summary>
/// <returns>是否成功</returns>
public virtual Boolean Open()
{
if (Disposed) throw new ObjectDisposedException(GetType().Name);
if (Active) return true;
// 即使没有事件，也允许强行打开异步接收
if (!UseReceiveAsync && Received != null) UseReceiveAsync = true;
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Open".F(GetType().Name), 1500))
{
tc.Log = Log;
Active = OnOpen();
if (!Active) return false;
if (Timeout > 0) Client.ReceiveTimeout = Timeout;
// 触发打开完成的事件
if (Opened != null) Opened(this, EventArgs.Empty);
}
if (UseReceiveAsync) ReceiveAsync();
return true;
}
public void PressAndGenerate()
{
if (Choice == Selection.CreateNew)
{
//TextAsset asset = Resources.Load("data_demonstration") as TextAsset;
//anchorData = asset.bytes;
//WorldAnchorTrans wat = new WorldAnchorTrans
//{
// header = "wa",
// spaceName = spaceId,
// data = anchorData
//};
//tCP.SendWorlAnchor(wat);
TimeCost tc4 = new TimeCost("OFALL", Time.time.ToString() + "start generating the anchor");
tCP.SocketSendByte(tc4);
//GameObject parentanchor = GameObject.Find("anchor1");
WorldAnchor wa1 = anchorObject1.AddComponent <WorldAnchor>();
WorldAnchorTransferBatch watb = new WorldAnchorTransferBatch();
watb.AddWorldAnchor(anchorObject1.name, wa1);
WorldAnchor wa2 = anchorObject2.AddComponent <WorldAnchor>();
watb.AddWorldAnchor(anchorObject2.name, wa2);
TimeCost tc5 = new TimeCost("OFALL", Time.time.ToString() + "Generating anchor done");
tCP.SocketSendByte(tc5);
imgSet.SetActive(true);
//tCP.InitSocket();
exportedData = new byte[0];
e = new List <byte>();
indicator.GetComponent <MeshRenderer>().material.color = Color.yellow;
syncOrNot = true;
TimeCost tc6 = new TimeCost("OFALL", Time.time.ToString() + "start serializing the anchor");
tCP.SocketSendByte(tc6);
WorldAnchorTransferBatch.ExportAsync(watb,
(data) =>
{
e.AddRange(data);
exportedData = data;
},
(reason) =>
{
if (reason == SerializationCompletionReason.Succeeded)
{
WorldAnchorTrans wat = new WorldAnchorTrans
{
header = "wa",
spaceName = spaceId,
data = e.ToArray()
};
TimeCost tc7 = new TimeCost("OFALL", Time.time.ToString() + "start sending anchor data");
tCP.SocketSendByte(tc7);
tCP.SendWorlAnchor(wat);
//CreateNewAnchorInManager();
indicator.GetComponent <MeshRenderer>().material.color = Color.green;
syncOrNot = true;
}
else
{
Debug.Log("failed to upload world anchor, please try agagin");
indicator.GetComponent <MeshRenderer>().material.color = Color.red;
}
});
}
else if (Choice == Selection.SycnDirectly)
{
//tCP.InitSocket();
StartCoroutine(DownloadAnchor(spaceId));
}
else if (Choice == Selection.LocationSync)
{
SendMsg msgNeed = new SendMsg("NeedToSyncPlantSet");
tCP.SocketSendByte(msgNeed);
}
else if (Choice == Selection.CreateNew_multi)
{
WorldAnchor wa1 = anchorObject1.AddComponent <WorldAnchor>();
WorldAnchorTransferBatch watb = new WorldAnchorTransferBatch();
watb.AddWorldAnchor(anchorObject1.name, wa1);
WorldAnchor wa2 = anchorObject2.AddComponent <WorldAnchor>();
watb.AddWorldAnchor(anchorObject2.name, wa2);
WorldAnchor wa3 = anchorObject3.AddComponent <WorldAnchor>();
WorldAnchor wa4 = anchorObject4.AddComponent <WorldAnchor>();
WorldAnchor wa5 = anchorObject5.AddComponent <WorldAnchor>();
WorldAnchor wa2_1 = anchorObject2_1.AddComponent <WorldAnchor>();
WorldAnchor wa3_1 = anchorObject3_1.AddComponent <WorldAnchor>();
imgSet.SetActive(true);
}
else if (Choice == Selection.Version1)
{
anchorObject1.SetActive(true);
anchorObject2_1.SetActive(true);
anchorObject3_1.SetActive(true);
}
else if (Choice == Selection.Version2)
{
anchorObject1.SetActive(true);
anchorObject2.SetActive(true);
anchorObject3.SetActive(true);
anchorObject4.SetActive(true);
anchorObject5.SetActive(true);
}
}
/// <summary>关闭</summary>
/// <returns>是否成功</returns>
public virtual Boolean Close(String reason = null)
{
if (!Active) return true;
// 估算完成时间，执行过长时提示
using (var tc = new TimeCost("{0}.Close".F(GetType().Name), 500))
{
tc.Log = Log;
if (OnClose(reason)) Active = false;
_RecvCount = 0;
// 触发关闭完成的事件
if (Closed != null) Closed(this, EventArgs.Empty);
}
// 如果是动态端口，需要清零端口
if (DynamicPort) Port = 0;
return !Active;
}
