public void OnPause()
{
SocketTask task = new SocketTask(ThreadType.BackGround);
task.AppendCmdParam(InternalRequestType.HOLDING_ON);
HandleInternalTask(task);
}
public void Dispose()
{
SocketTask task = new SocketTask(ThreadType.BackGround);
task.AppendCmdParam(InternalRequestType.SHUT_DOWN);
HandleInternalTask(task);
}
public void CloseWorldChatSocket()
{
SocketTask task = new SocketTask(ThreadType.MainThread, TaskResponse.Default_Response);
task.AppendCmdParam(InternalRequestType.SHUT_DOWN);
task.DispatchToRealHandler();
}
public override SocketTasks StartClient()
{
var socketTask = SocketTask.Working;
m_ServerHostId = RelayTransport.AddHost(new HostTopology(GetConfig(), 1), false);
m_ServerConnectionId = RelayTransport.Connect(m_ServerHostId, ConnectAddress, ConnectPort, 0, out byte error);
var connectError = (NetworkError)error;
switch (connectError)
{
case NetworkError.Ok:
socketTask.Success = true;
socketTask.TransportCode = error;
socketTask.SocketError = System.Net.Sockets.SocketError.Success;
socketTask.IsDone = false;
// We want to continue to wait for the successful connect
m_ConnectTask = socketTask;
break;
default:
socketTask.Success = false;
socketTask.TransportCode = error;
socketTask.SocketError = System.Net.Sockets.SocketError.SocketError;
socketTask.IsDone = true;
break;
}
return(socketTask.AsTasks());
}
public override SocketTasks StartClient()
{
serverUser = new User(new CSteamID(ConnectToSteamID));
SocketTask task = SocketTask.Working;
if (SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, EP2PSend.k_EP2PSendReliable, (int)InternalChannelType.Connect))
{
_p2PSessionConnectFailCallback = Callback <P2PSessionConnectFail_t> .Create((sessionConnectFailInfo) =>
{
OnP2PSessionConnectFail(sessionConnectFailInfo);
task.IsDone = true;
task.Success = false;
task.TransportCode = sessionConnectFailInfo.m_eP2PSessionError;
});
}
else
{
P2PSessionConnectFail_t sessionConnectFailInfo = new P2PSessionConnectFail_t()
{
m_eP2PSessionError = (byte)EP2PSessionError.k_EP2PSessionErrorMax,
m_steamIDRemote = serverUser.SteamId
};
task.IsDone = true;
task.Success = false;
task.TransportCode = sessionConnectFailInfo.m_eP2PSessionError;
OnP2PSessionConnectFail(sessionConnectFailInfo);
}
return(task.AsTasks());
}
public override SocketTasks StartClient()
{
SocketConfig config = GetConfig(false, NetworkingManager.Singleton.NetworkConfig);
socket = new RuffleSocket(config);
isConnector = true;
if (!socket.Start())
{
return(SocketTask.Fault.AsTasks());
}
serverConnection = socket.Connect(new IPEndPoint(IPAddress.Parse(ConnectAddress), Port));
if (serverConnection == null)
{
return(SocketTask.Fault.AsTasks());
}
else
{
connectTask = SocketTask.Working;
return(connectTask.AsTasks());
}
}
private void HandleTask(SocketTask task)
{
if (task != null && task.request != null)
{
HandldCommonTask(task);
HandleInternalTask(task);
}
}
private void SendAllenTcpClose()
{
SocketTask task = new SocketTask(ThreadType.MainThread, TaskResponse.Default_Response);
task.AppendCmdParam(InternalRequestType.SHUT_DOWN);
task.DispatchToRealHandler();
}
public void SendWorldChat2(string _Content)
{
SocketTask task = new SocketTask(ThreadType.MainThread, TaskResponse.Default_Response);
task.AppendCommonParam(RequestType.SOCK_WORLDCHAT, new SockSendWorldChatParam(_Content));
task.ErrorOccured = SocketResp_Error;
task.afterCompleted = SocketResp_UI;
task.DispatchToRealHandler();
}
//聊天Socket的请求处理
public void RegisterChatSock()
{
SocketTask task = new SocketTask(ThreadType.MainThread, TaskResponse.Default_Response);
task.AppendCommonParam(RequestType.SOCK_WORLDCHAT, new SockSendWorldChatParam(""));
task.ErrorOccured = SocketResp_Error;
task.afterCompleted = SocketResp_UI;
Core.NetEng.SockEngine.RegisterSocketTask(task);
}
void INetEventListener.OnNetworkError(IPEndPoint endPoint, SocketError socketError)
{
// Ignore
if (connectTask != null)
{
connectTask.SocketError = socketError;
connectTask.IsDone = true;
connectTask = null;
}
}
private void HandleTask()
{
while (workQueue.Count > 0)
{
SocketTask task = null;
if (workQueue.TryDequeue(out task))
{
HandleTask(task);
}
}
}
private void sendAllenTcpOpen()
{
SocketTask task = new SocketTask(ThreadType.MainThread, TaskResponse.Default_Response);
task.AppendCommonParam(RequestType.SOCK_LOGIN, new SockLoginParam("656679", null, 0));
task.ErrorOccured = SocketResp_Error;
task.afterCompleted = SocketRespUI;
task.DispatchToRealHandler();
}
/// <summary>
/// Register Task for UI layer.
/// </summary>
/// <param name="task">Task.</param>
public void RegisterSocketTask(SocketTask task)
{
if (task != null)
{
SocketRequest sockReq = task.request as SocketRequest;
if (sockReq != null && !TaskQueue.ContainsKey(sockReq.Act))
{
TaskQueue[sockReq.Act] = task;
}
}
}
void INetEventListener.OnPeerConnected(NetPeer peer)
{
if (m_ConnectTask != null)
{
m_ConnectTask.Success = true;
m_ConnectTask.IsDone = true;
m_ConnectTask = null;
}
var peerId = GetMlapiClientId(peer);
InvokeOnTransportEvent(NetworkEvent.Connect, peerId, NetworkChannel.DefaultMessage, default, Time.time);
public void SendWorldChatLogin()
{
RegisterChatSock();
SocketTask task = new SocketTask(ThreadType.MainThread, TaskResponse.Default_Response);
task.AppendCommonParam(RequestType.SOCK_WORLDCHATLOGIN, new SockWorldChatLoginParam(Core.Data.playerManager.PlayerID, "abc",
Core.Data.playerManager.NickName, Core.Data.playerManager.Lv, Core.SM.curServer.sid, (long)Core.Data.playerManager.RTData.headID));
task.ErrorOccured = SocketResp_Error;
task.afterCompleted = SocketResp_UI;
task.DispatchToRealHandler();
}
void ICore.Dispose()
{
if (httpEngine != null)
{
HttpTask shutdownTask = new HttpTask(ThreadType.BackGround, TaskResponse.Default_Response);
shutdownTask.AppendCmdParam(InternalRequestType.SHUT_DOWN);
httpEngine.sendHttpTask(shutdownTask);
}
// Socket is still empty
if (SockEngine != null)
{
SocketTask shutdownTask = new SocketTask(ThreadType.BackGround, TaskResponse.Default_Response);
shutdownTask.AppendCmdParam(InternalRequestType.SHUT_DOWN);
SockEngine.sendSocketTask(shutdownTask);
}
}
private void HandldCommonTask(SocketTask task)
{
if (task.request.type == BaseSocketRequestType.Common_Socket_Request)
{
SocketRequest sockReq = task.request as SocketRequest;
//记录下已经发送数据的 Task
TaskQueue[sockReq.Act] = task;
//send to server
if (task.respType != TaskResponse.Donot_Send)
{
ConsoleEx.DebugLog("Socket to be sent : " + sockReq.toJson());
Conn.Write(sockReq.toJson());
}
}
}
void Sock_OnException(SocketTask task)
{
ConsoleEx.DebugLog(" --> Event Center Recevied Socket Exception");
if (task != null)
{
//we should send following code to the main thread
AsyncTask.QueueOnMainThread(() => { task.handleErrorOcurr(); });
//Default handler if ErrorOccured is null
if (DefaultSockExce != null && task.ErrorOccured == null)
{
AsyncTask.QueueOnMainThread(() => { DefaultSockExce(task); });
}
}
}
public override NetworkEvent PollEvent(out ulong clientId, out NetworkChannel channel, out ArraySegment <byte> payload, out float receiveTime)
{
NetworkEventInfo info = networkEvents.Count > 0 ? networkEvents.Dequeue() : null;
if (info != null)
{
if (info.error)
{
payload = default;
channel = default;
clientId = info.clientId;
receiveTime = Time.realtimeSinceStartup;
throw info.exception;
}
clientId = info.clientId;
channel = (NetworkChannel)info.channel;
payload = info.payload;
receiveTime = info.receiveTime;
if (connectTask != null && client != null && client.isConnecting && clientId == ServerClientId &&
(info.eventType == NetworkEvent.Connect || info.eventType == NetworkEvent.Disconnect))
{
Debug.Log("Connection with server:" + info.eventType);
if (info.eventType == NetworkEvent.Connect)
{
connectTask.Success = true;
}
if (info.eventType == NetworkEvent.Disconnect)
{
connectTask.Success = false;
}
connectTask.IsDone = true;
connectTask = null;
}
return(info.eventType);
}
payload = default;
channel = default;
clientId = default;
receiveTime = Time.realtimeSinceStartup;
return(NetworkEvent.Nothing);
}
static void SocketTaskProc(SocketTask task)
{
var i = (ulong)task.ConnId;
// 模拟业务处理
var sleep = new Random().Next(1, 1000);
Thread.Sleep(sleep);
Console.WriteLine("{0}\t{1},\tsleep: {2}", Thread.CurrentThread.ManagedThreadId, i, sleep);
if (Interlocked.Decrement(ref count) == 1)
{
t2 = Environment.TickCount;
}
}
public override SocketTasks StartClient()
{
serverUser = new User(ConnectToSteamID);
SocketTask task = SocketTask.Working;
if (SteamNetworking.SendP2PPacket(serverUser.SteamId, new byte[] { 0 }, 1, (int)InternalChannelType.Connect, P2PSend.Reliable))
{
clientOnFail = (id, error) => ClientOnP2PSessionConnectFail(id, error, task);
SteamNetworking.OnP2PConnectionFailed += clientOnFail;
}
else
{
ClientOnP2PSessionConnectFail(serverUser.SteamId, P2PSessionError.Max, task);
}
return(task.AsTasks());
}
void Sock_OnCommonExcption(string error)
{
ConsoleEx.DebugLog(" --> Event Center Recevied Common Socket Exception. " + error);
//Default handler if ErrorOccured is null
if (DefaultSockExce != null)
{
SocketTask sTask = new SocketTask(ThreadType.MainThread);
sTask.errorInfo = error;
AsyncTask.QueueOnMainThread(() => { DefaultSockExce(sTask); });
}
if (CommonSockExce != null)
{
SocketTask sTask = new SocketTask(ThreadType.MainThread);
sTask.errorInfo = error;
AsyncTask.QueueOnMainThread(() => { CommonSockExce(sTask); });
}
}
private void OpenSocketTask(string tag)
{
if (string.IsNullOrEmpty(this.Url))
{
throw new Exception("Socket.url = " + this.Url);
}
if (!IsSocketStatus("connect") && !IsSocketStatus("close"))
{
ReconnectTimer.SetTimer(() => OpenSocketTask("open"), Config.ReconnectInterval);
}
if (!IsSocketStatus("close"))
{
return;
}
ReconnectTimes++;
// 重连超时：关闭连接，不会继续重连
if (ReconnectTimes > Config.ReconnectMaxTimes)
{
ReconnectTimes = 0;
Debugger.Log("SOCKET_RECONNECT_TIMEOUT");
return;
}
ReconnectTimer.Stop();
ForceClose = false;
// Debugger.Log ("socket enable: {0}", _enableUdp && Config.EnableUdp);
if (_enableUdp && Config.EnableUdp)
{
this._socketTask = new KcpSocket(Url, _enableUdp);
}
else
{
this._socketTask = new CommSocket(Url);
}
this._socketTask.onOpen = HandleSocketOpen;
this._socketTask.onClose = HandleSocketClose;
this._socketTask.onError = HandleSocketError;
this._socketTask.onMessage = HandleSocketMessage;
this._socketTask.Connect();
}
public static Action <BaseSocketRequest, BaseResponse> getAction(SocketTask task)
{
if (task != null)
{
SocketRequest request = task.request as SocketRequest;
if (request != null && ACTION_LIST.ContainsKey(request.Type))
{
return(ACTION_LIST[request.Type]);
}
else
{
return(null);
}
}
else
{
return(null);
}
}
void INetEventListener.OnPeerConnected(NetPeer peer)
{
if (connectTask != null)
{
connectTask.Success = true;
connectTask.IsDone = true;
connectTask = null;
}
Event @event = new Event()
{
dateTime = DateTime.UtcNow,
type = NetEventType.Connect,
clientId = GetMLAPIClientId(peer)
};
peers[@event.clientId] = peer;
eventQueue.Enqueue(@event);
}
void INetEventListener.OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo)
{
if (connectTask != null)
{
connectTask.Success = false;
connectTask.IsDone = true;
connectTask = null;
}
Event @event = new Event()
{
dateTime = DateTime.UtcNow,
type = NetEventType.Disconnect,
clientId = GetMLAPIClientId(peer)
};
peers.Remove(@event.clientId);
eventQueue.Enqueue(@event);
}
public void SendWorldChat(string _Content)
{
if (SensitiveFilterManager.getInstance().check(_Content, false))
{
SQYAlertViewMove.CreateAlertViewMove(Core.Data.stringManager.getString(75003));
return;
}
if (string.IsNullOrEmpty(_Content))
{
SQYAlertViewMove.CreateAlertViewMove(Core.Data.stringManager.getString(75002));
return;
}
SocketTask task = new SocketTask(ThreadType.MainThread, TaskResponse.Default_Response);
task.AppendCommonParam(RequestType.SOCK_WORLDCHAT, new SockSendWorldChatParam(_Content));
task.ErrorOccured = SocketResp_Error;
task.afterCompleted = SocketResp_UI;
task.DispatchToRealHandler();
ComLoading.Open();
}
async void StartClient(SocketTask task)
{
try
{
IPAddress[] addresses = Dns.GetHostAddresses(m_ConnectAddress);
IPAddress ip = null;
foreach (var tmp in addresses)
{
if (tmp.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
{
ip = tmp;
}
}
ServerConnectSettings setting;
if (!string.IsNullOrWhiteSpace(m_RsaXmlPath))
{
var xml = Resources.Load <TextAsset>(m_RsaXmlPath);
setting = ServerConnectSettings.FromXML(xml.text, new IPEndPoint(ip, m_Port));
}
else
{
setting = new ServerConnectSettings
{
EndPoint = new IPEndPoint(ip, m_Port),
};
}
m_ClientConn = await Connection.ConnectToServer(setting);
Setup(m_ClientConn);
task.Success = true;
task.IsDone = true;
}
catch (Exception ex)
{
task.Success = false;
task.TransportException = ex;
task.IsDone = true;
}
}
public bool OnData(NonBlockingConnection conn)
{
IList <string> json = conn.ReadStrings();
if ((json == null) || (json.Count == 0))
{
return(true);
}
foreach (string s in json)
{
string acknowledge = s.Trim();
int Act = getAct(acknowledge);
SocketTask task = null;
if (TaskQueue.TryGetValue(Act, out task))
{
if (task.respType == TaskResponse.Default_Response || task.respType == TaskResponse.Donot_Send)
{
if (Utils.checkJsonFormat(acknowledge))
{
SocketResponseFactory.createResponse(task, acknowledge);
Socket_OnReceive(task);
}
else
{
ExceptionResponse exResp = new ExceptionResponse();
exResp.HttpError = acknowledge;
task.response = exResp;
Socket_OnException(task);
}
}
}
else
{
Socket_CommException(acknowledge);
}
}
return(true);
}
