/// <summary>
/// 添加到事件队列
/// </summary>
public void AddEvent(ThreadEvent ev, Action<NotiData> func)
{
lock (m_lockObj) {
this.func = func;
events.Enqueue(ev);
}
}
private void ConnectCompleted(object obj, SocketAsyncEventArgs evt)
{
//쓰레드 제어연결할땐 다른 쓰레드 발동ㄴㄴdd
ThreadEvent.Set();
Console.WriteLine("Connect Test {0}", ClientSocket.Connected);
if (ClientSocket.Connected)
{
ConnectCondition = true;
try
{
//연결
SocketAsyncEventArgs receiveAsync = new SocketAsyncEventArgs();
receiveAsync.SetBuffer(RecvBuf, 0, RecvBuf.Length);
receiveAsync.Completed += new EventHandler <SocketAsyncEventArgs>(ReceiveCompleted);
ClientSocket.ReceiveAsync(receiveAsync);
}
catch (Exception e)
{
Console.WriteLine("ConnectedCompleted Error :{0}", e.Message);
}
_Message = "연결 완료";
}
else
{
//재접속
//Reconnect();
_Message = "연결중..";
}
}
private bool Connection()
{
//이미 연결되어있으면 여기서 나가도록
if (ClientSocket != null && ClientSocket.Connected)
{
return(false);
}
//소켓 설정
ClientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
ClientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontLinger, true);
ClientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
ClientSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
try
{
//비동기설정
SocketAsyncEventArgs ConnectAsync = new SocketAsyncEventArgs();
ConnectAsync.RemoteEndPoint = new IPEndPoint(IPAddress.Parse(_ip), _port);
ConnectAsync.Completed += new EventHandler <SocketAsyncEventArgs>(ConnectCompleted);
ClientSocket.ConnectAsync(ConnectAsync);
}
catch (Exception e)
{
Console.WriteLine("Connection Error : {0}", e.Message);
}
//쓰레드 제어
ThreadEvent.WaitOne();
return(ClientSocket.Connected);
}
static int AddEvent(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
LuaFramework.ThreadManager obj = (LuaFramework.ThreadManager)ToLua.CheckObject(L, 1, typeof(LuaFramework.ThreadManager));
ThreadEvent arg0 = (ThreadEvent)ToLua.CheckObject(L, 2, typeof(ThreadEvent));
System.Action <NotiData> arg1 = null;
LuaTypes funcType3 = LuaDLL.lua_type(L, 3);
if (funcType3 != LuaTypes.LUA_TFUNCTION)
{
arg1 = (System.Action <NotiData>)ToLua.CheckObject(L, 3, typeof(System.Action <NotiData>));
}
else
{
LuaFunction func = ToLua.ToLuaFunction(L, 3);
arg1 = DelegateFactory.CreateDelegate(typeof(System.Action <NotiData>), func) as System.Action <NotiData>;
}
obj.AddEvent(arg0, arg1);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// 添加到事件队列
/// </summary>
public void AddEvent(ThreadEvent ev, Action <NotiData> func)
{
lock (m_lockObj) {
this.func = func;
events.Enqueue(ev);
}
}
private static int AddEvent(IntPtr L)
{
int result;
try
{
ToLua.CheckArgsCount(L, 3);
ThreadManager threadManager = (ThreadManager)ToLua.CheckObject(L, 1, typeof(ThreadManager));
ThreadEvent ev = (ThreadEvent)ToLua.CheckObject(L, 2, typeof(ThreadEvent));
LuaTypes luaTypes = LuaDLL.lua_type(L, 3);
Action <NotiData> func;
if (luaTypes != LuaTypes.LUA_TFUNCTION)
{
func = (Action <NotiData>)ToLua.CheckObject(L, 3, typeof(Action <NotiData>));
}
else
{
LuaFunction func2 = ToLua.ToLuaFunction(L, 3);
func = (DelegateFactory.CreateDelegate(typeof(Action <NotiData>), func2) as Action <NotiData>);
}
threadManager.AddEvent(ev, func);
result = 0;
}
catch (Exception e)
{
result = LuaDLL.toluaL_exception(L, e, null);
}
return(result);
}
private void EventThreadProc()
{
while (!StoppingThread)
{
BadgeEvent.WaitOne();
if (CancelOps)
{
return;
}
Clock.Stop();
WaitDoor = true;
OpenDoor();
Clock.Start();
CptDoor = 10;
DoorEventNormal.Reset();
if (DoorEventNormal.WaitOne(10000, false))
{
continue; // next loop iteration
}
WaitDoor = false;
WaitDoor = false;
DisplayBadge = false;
CloseDoor();
CurrenRfidReader.NotifyRelock();
Clock.Start();
}
if (ThreadEvent != null)
{
ThreadEvent.Set();
}
}
// Update is called once per frame
void OnUpdate()
{
while (true)
{
lock (m_lockObject)
{
if (events.Count > 0)
{
ThreadEvent e = events.Dequeue();
try
{
switch (e.Key)
{
case NotiConst.EXTRACT_FILE:
OnExtractFile(e.evParams);
break;
case NotiConst.EXTRACT_STREAM:
OnExtractStream(e.evParams);
break;
}
}
catch (System.Exception ex)
{
UnityEngine.Debug.LogError(ex.Message);
}
}
}
Thread.Sleep(1);
}
}
public Message(PlayStationClient client, ThreadEvent message)
{
this.Client = client;
this._message = message;
_sender = new Lazy <User>(() => new User(client, _message.MessageEventDetail.Sender.OnlineId));
}
/// <summary>
/// 建構子
/// </summary>
/// <param name="socketPort"></param>
/// <param name="isKeepNewConnectionWhenOverLimit">是否保留新連線</param>
/// <param name="clientHeartBeatFrequency">客端心跳間隔</param>
/// <param name="clientSameIPLimitCount">同 IP 的最大連線數</param>
/// <param name="outputMessage">輸出訊息</param>
public ProxyServer(int socketPort, bool isKeepNewConnectionWhenOverLimit, int clientHeartBeatFrequency, int clientSameIPLimitCount, Action <string> outputMessage)
{
fOutputMessage = outputMessage;
fIsKeepNewConnectionWhenOverLimit = isKeepNewConnectionWhenOverLimit;
fClientHeartBeatFrequency = clientHeartBeatFrequency;
fClientSameIPLimitCount = clientSameIPLimitCount;
// Listener worker
fTcpListener = new TcpListener(IPAddress.Any, socketPort);
fToken = new CancellationTokenSource();
//事件處理
OnStatus = new ThreadEvent <string>();
OnData = new ThreadEvent <string>();
OnConnectionStatus = new ThreadEvent <ProxyClient>();
// 平行結構
fClientTmpQueue = new ThreadBridge <ProxyClient>();
fClientMoveQueue = new ThreadBridge <ProxyClient>();
fCastingMessage = new ThreadBridge <AckTask>();
// connection pool
fClientPool = new List <ProxyClient>();
//connection worker
fTaskListener = Task.Factory.StartNew(ListenerAsync, fToken.Token);
// boradcastor
fBroadcastor = Task.Factory.StartNew(BroadcastingAsync, fToken.Token);
}
void OnUpdate()
{
while (true)
{
lock ( _lockObj )
{
if (_events.Count > 0)
{
ThreadEvent e = _events.Dequeue();
try
{
switch (e.Key)
{
case NotifyConst.DOWNLOAD:
{ //下载文件
OnDownloadFile(e.evParams);
}
break;
case NotifyConst.UPLOAD:
{ // 上传文件
OnUploadFile(e.evParams);
}
break;
}
}
catch (System.Exception ex)
{
UnityEngine.Debug.LogError(ex.Message);
}
}
}
Thread.Sleep(1);
}
}
// Update is called once per frame
void OnUpdate()
{
while (true)
{
lock (m_lockObj)
{
if (events.Count > 0)
{
ThreadEvent e = events.Dequeue();
try
{
switch (e.Key)
{
case MessagesType.UPDATE_EXTRACT:
{ //解压文件
OnExtractFile(e.evParams);
}
break;
case MessagesType.UPDATE_DOWNLOAD:
{ //下载文件
OnDownloadFile(e.evParams);
}
break;
}
}
catch (System.Exception ex)
{
UnityEngine.Debug.LogError(ex.Message);
}
}
}
Thread.Sleep(1);
}
}
// 添加到事件队列
public void AddEvent(ThreadEvent ev, Action <NotifyData> func)
{
lock ( _lockObj )
{
_func = func;
_events.Enqueue(ev);
}
}
/// <summary>
/// 添加到事件队列
/// </summary>
public void AddEvent(ThreadEvent ev, Action <NotiData> func)
{
lock (mLockObj)
{
mFunc = func;
mEvents.Enqueue(ev);
}
}
/// <summary>
/// 添加到事件队列
/// </summary>
public void AddEvent(ThreadEvent ev, Action<NotiData> func)
{
lock (mLockObj)
{
mFunc = func;
mEvents.Enqueue(ev);
}
}
private void OnCameraMove(lib.Event evt)
{
ThreadEvent e = evt as ThreadEvent;
cameraPosition[0] = e.X;
cameraPosition[1] = e.Y;
mainCamera.transform.position = new Vector3(e.X, e.Y);
}
private void OnInitCamera(lib.Event e)
{
ThreadEvent te = e as ThreadEvent;
CameraData2D camera = GameData.Instance.camera;
UnityEngine.Rect rect = (UnityEngine.Rect)te.Data;
camera.Range = new lib.Rect(rect.x, rect.y, rect.width, rect.height);
}
public void AddEvent(ThreadEvent ev, Action <NotiData> func)
{
object lockObj = ThreadManager.m_lockObj;
lock (lockObj)
{
this.func = func;
ThreadManager.events.Enqueue(ev);
}
}
/// <summary>
/// 线程下载
/// </summary>
void BeginDownload(string url, string file)
{
//线程下载
object[] param = new object[2] { url, file };
ThreadEvent ev = new ThreadEvent();
ev.Key = NotiConst.UPDATE_DOWNLOAD;
ev.evParams.AddRange(param);
ThreadManager.AddEvent(ev, OnThreadCompleted); //线程下载
}
private void OnUpdate()
{
while (true)
{
object lockObj = ThreadManager.m_lockObj;
lock (lockObj)
{
if (ThreadManager.events.Count > 0)
{
ThreadEvent threadEvent = ThreadManager.events.Dequeue();
try
{
string key = threadEvent.Key;
if (key != null)
{
if (ThreadManager.< > f__switch$map1 == null)
{
ThreadManager.< > f__switch$map1 = new Dictionary <string, int>(2)
{
{
"UpdateExtract",
0
},
{
"UpdateDownload",
1
}
};
}
int num;
if (ThreadManager.< > f__switch$map1.TryGetValue(key, out num))
{
if (num != 0)
{
if (num == 1)
{
this.OnDownloadFile(threadEvent.evParams);
}
}
else
{
this.OnExtractFile(threadEvent.evParams);
}
}
}
}
catch (Exception ex)
{
UnityEngine.Debug.LogError(ex.Message);
}
}
}
Thread.Sleep(1);
}
}
/// <summary>
/// 检测是否有放不下的
/// </summary>
private void CheckOut()
{
List <LevelConfig> levels = LevelConfig.Configs;
for (int i = 0; i < levels.Count; i++)
{
ThreadEvent te = ThreadEvent.Create("check", levels[i]);
te.URL = "gameLevel/level1/SceneBackground";
ThreadEventList.GetList(EditorMainThread.ThreadId, CheckThread.ThreadId).AddEvent(te);
}
}
/// <summary>
/// 线程下载
/// </summary>
void BeginDownload(string url, string file) //线程下载
{
object[] param = new object[2] {
url, file
};
ThreadEvent ev = new ThreadEvent();
ev.Key = QFrameworkMsg.UPDATE_DOWNLOAD;
ev.evParams.AddRange(param);
}
/// <summary>
/// 下载文件
/// </summary>
void DownloadFile(string url, string file)
{
object[] param = new object[2] {
url, file
};
ThreadEvent ev = new ThreadEvent();
ev.Key = NotifyConst.UPDATE_DOWNLOAD;
ev.evParams.AddRange(param);
GetComponent <ThreadManager>().AddEvent(ev, OnThreadDownLoadProc);
}
/// <summary>
/// 下载文件
/// </summary>
void Download(string url, string file)
{
object[] param = new object[2] {
url, file
};
ThreadEvent ev = new ThreadEvent();
ev.Key = NotifyConst.DOWNLOAD;
ev.evParams.AddRange(param);
ThreadManager.instance.AddEvent(ev, OnThreadDownLoadProc);
}
/// <summary>
/// 线程下载
/// </summary>
void BeginDownload(string url, string file)
{ //线程下载
object[] param = new object[2] {
url, file
};
ThreadEvent ev = new ThreadEvent();
ev.mKey = NotiConst.UPDATE_DOWNLOAD;
ev.mParams.AddRange(param);
ThreadMgr.AddEvent(ev, OnThreadCompleted); //线程下载
}
void BeginDownload(string url, string file)
{ //线程下载
object[] param = new object[2] {
url, file
};
ThreadEvent ev = new ThreadEvent();
ev.Key = NotiData.UPDATE_DOWNLOAD;
ev.evParams.AddRange(param);
ThreadManager.Instance.AddEvent(ev, OnThreadCompleted); //线程下载
}
public IEnumerable <M> Emit(Func <bool> Cancel = null)
{
var cancel = Cancel ?? new Func <bool>(() => false);
while (!Finished && !Cancel())
{
ThreadEvent.WaitOne(1000);
while (MemoryQueue.TryDequeue(out M message))
{
yield return(message);
}
}
}
void BeginDownload(string url, string file)
{ //线程下载
object[] param = new object[2] {
url, file
};
Debug.LogWarning(string.Format("更新資源url：{0}", url));
Debug.LogWarning(string.Format("更新資源file：{0}", file));
ThreadEvent ev = new ThreadEvent();
ev.Key = NotiData.UPDATE_DOWNLOAD;
ev.evParams.AddRange(param);
UnityLuaThreadManager.Instance.AddEvent(ev, OnThreadCompleted); //线程下载
}
/// <summary>
/// 线程下载
/// </summary>
void BeginDownload(string url, string file)
{
//线程下载
object[] param = new object[2] {
url, file
};
ThreadEvent ev = new ThreadEvent();
ev.Key = NotiConst.UPDATE_DOWNLOAD;
ev.evParams.AddRange(param);
AppFacade.Instance.GetManager <ThreadManager>(ManagerName.Thread).AddEvent(ev, OnThreadCompleted); //线程下载
}
/// <summary>
/// 开始下载 注意：此处下载完成的文件,存放的地址位于file
/// </summary>
/// <param name="url"></param> 服务器文件路径(下载路径)
/// <param name="file"></param> 本地文件路径
void BeginDownload(string url, string file)
{
object[] param = new object[2] {
url, file
};
ThreadEvent ev = new ThreadEvent();
ev.key = NotiConst.UPDATE_DOWNLOAD;
//添加实现了ICollection接口的一个集合的所有元素到指定集合的末尾
ev.evParams.AddRange(param);
//添加线程事件.通过线程开始执行下载
FrameworkMain.Instance.ThreadMgr.AddEvent(ev, OnThreadCompleted);
}
static private ThreadEvent _get_event()
{
ThreadEvent evt = ThreadEvent.TEVT_NONE;
lock (m_evt_lock) {
if (m_evt_queue.Count > 0)
{
evt = m_evt_queue.Dequeue();
}
}
return(evt);
}
static int AddEvent(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
LuaFramework.ThreadManager obj = (LuaFramework.ThreadManager)ToLua.CheckObject(L, 1, typeof(LuaFramework.ThreadManager));
ThreadEvent arg0 = (ThreadEvent)ToLua.CheckObject(L, 2, typeof(ThreadEvent));
obj.AddEvent(arg0);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
static int AddEvent(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 3);
LuaFramework.ThreadManager obj = (LuaFramework.ThreadManager)ToLua.CheckObject <LuaFramework.ThreadManager>(L, 1);
ThreadEvent arg0 = (ThreadEvent)ToLua.CheckObject <ThreadEvent>(L, 2);
System.Action <NotiData> arg1 = (System.Action <NotiData>)ToLua.CheckDelegate <System.Action <NotiData> >(L, 3);
obj.AddEvent(arg0, arg1);
return(0);
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
/// <summary>
/// Wartet asyncron auf alle noch laufenden Threads und führt <see cref="beforeWaitingHandler"/> vor dem warten
/// und <see cref="threadsFinishedHandler"/> nach dem Warteprozess aus
/// </summary>
/// <param name="beforeWaitingHandler">Funktion die vor dem Warten ausgeführt wird (z.B. um die Oberfläche zu sperren)</param>
/// <param name="threadsFinishedHandler">Funktion die nach dem Warten ausgeführt wird (z.B. um die Oberfläche wieder freizugeben)</param>
public static void WaitForThreadsAsnc(ThreadEvent beforeWaitingHandler, ThreadEvent threadsFinishedHandler)
{
beforeWaitingHandler.Invoke();
ThreadPool.QueueUserWorkItem(WaitHelper, threadsFinishedHandler);
}
