/// <summary>
/// 开启服务器
/// </summary>
public bool StartServer()
{
try
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.Bind(new IPEndPoint(IPAddress.Parse(_host), _port));
_socket.Listen(0);
_listenLoop = true;
_listenThread = new Thread(new ThreadStart(OnListenConnectHandler));
_listenThread.IsBackground = true;
_listenThread.Start();
//入列 服务器启动成功
EasySocketEvent ese = new EasySocketEvent(EasySocketEvent.SERVER_START_SUCCESS, this);
_socketEventQueue.Enqueue(ese);
return(true);
}
catch (Exception ex)
{
EasySocketEvent ese = new EasySocketEvent(EasySocketEvent.SERVER_START_ERROR, this, ex.Message);
_socketEventQueue.Enqueue(ese);
return(false);
}
}
//定制服务器
public void StopServer()
{
//停止连接线程
_listenLoop = false;
if (_listenThread != null)
{
_listenThread.Interrupt();
_listenThread.Abort();
_listenThread = null;
}
//终端所有与客户端的连接
foreach (EasyTCPToken token in _tokenDic.Values)
{
EasySocketEvent se1 = new EasySocketEvent(EasySocketEvent.DISCONNECTED, token);
_socketEventQueue.Enqueue(se1);
token.Close();
}
_tokenDic.Clear();
if (_socket != null)
{
_socket.Close();
_socket = null;
}
EasySocketEvent se = new EasySocketEvent(EasySocketEvent.SERVER_SHUTDOWN, this);
_socketEventQueue.Enqueue(se);
}
//数据接收线程
private void OnReceiveDataHanadler()
{
while (_receiveLoop)
{
int length = _socket.Receive(_receiveBuffer);
try
{
if (length > 0)
{
byte[] buffers = new byte[length];
Buffer.BlockCopy(_receiveBuffer, 0, buffers, 0, length);
//更新心跳时间
_lastHeartBeatTime = System.DateTime.Now;
//转换消息
NetMessage msg = new NetMessage(buffers);
bytesReceived += msg.Bytes.Length;
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.DATA_RECEIVED, this, msg);
_socketEventQueue.Enqueue(nse);
}
else
{
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.DISCONNECTED, this, "服务器端主动关闭了此链接!");
_socketEventQueue.Enqueue(nse);
_receiveLoop = false;
_heartbeatLoop = false;
_onlinecheckLoop = false;
if (_autoReconnect)
{
LogError("连接服务器" + _host + ":" + _port + "失败,5秒后将再次尝试连接服务器! 原因:" + nse.Info);
//重连服务器
StartCoroutine(StartReconnectHandler());
}
}
}
catch (SocketException se)
{
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.SOCKET_ERROR, this, se.Message);
_socketEventQueue.Enqueue(nse);
_receiveLoop = false;
_heartbeatLoop = false;
_onlinecheckLoop = false;
}
catch (Exception ex)
{
//发送消息事件
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.READ_SOCKET_ERROR, this, ex.Message);
_socketEventQueue.Enqueue(nse);
_receiveLoop = false;
_heartbeatLoop = false;
_onlinecheckLoop = false;
}
}
}
void Update()
{
//处理新连接对象
while (_tmpSocketQueue.Count > 0)
{
//取出新连接Socket,穿件客户端
Socket sk = _tmpSocketQueue.Dequeue();
//开始构建EasyTCPToken
EasyTCPToken token = EasyTCPToken.CreateTCPToken(sk, this);
token.OnSocketEventHandler += OnTCPTokenEventHandler;
token.transform.SetParent(this.transform);
//同步用户列表
_tokenDic.Add(token.Ipe.ToString(), token);
//客户端连接事件
EasySocketEvent se = new EasySocketEvent(EasySocketEvent.NEW_CONNECTION, token);
_socketEventQueue.Enqueue(se);
}
//**********跳线用户检测***************/
List <EasyTCPToken> offlinetokens = new List <EasyTCPToken>();
//检测是否有用户掉线
foreach (var token in _tokenDic.Values)
{
TimeSpan sp = System.DateTime.Now - token.LastHeartTime;
if (sp.Seconds > 10)
{
offlinetokens.Add(token);
}
}
foreach (var token in offlinetokens)
{
EasySocketEvent se = new EasySocketEvent(EasySocketEvent.DISCONNECTED, token);
_socketEventQueue.Enqueue(se);
_tokenDic.Remove(token.Ipe.ToString());
token.Close();
}
offlinetokens.Clear();
//---------------------------------/
//服务器端变化事件
while (_socketEventQueue.Count > 0)
{
EasySocketEvent se = _socketEventQueue.Dequeue();
OnSocketEventHandler(se);
}
}
private void Client_OnSocketEventHandler(EasySocketEvent evt)
{
switch (evt.Type)
{
case EasySocketEvent.CONNECTED:
msgStr += "\n connected to server";
break;
case EasySocketEvent.CONNECT_ERROR:
msgStr += "\n connect failed to server" + evt.Info;
break;
}
}
private void OnlineCheckThreadHandler()
{
while (_onlinecheckLoop)
{
//监测自己是否已经掉线
TimeSpan sp = System.DateTime.Now - this._lastHeartBeatTime;
if (sp.Seconds > 15)
{
_onlinecheckLoop = false;
EasySocketEvent ese = new EasySocketEvent(EasySocketEvent.DISCONNECTED, this, "因长时间未收到心跳包而断开网络连接");
_socketEventQueue.Enqueue(ese);
}
}
}
public void InitNetworkt()
{
try
{
_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_socket.Connect(_host, _port);
_isOnline = true;
//连接成功时间
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.CONNECTED, this);
_socketEventQueue.Enqueue(nse);
//开启接收线程
_receiveLoop = true;
_receiveThread = new Thread(new ThreadStart(OnReceiveDataHanadler));
_receiveThread.IsBackground = true;
_receiveThread.Start();
//开启心跳线程
_heartbeatLoop = true;
_heartbeatThread = new Thread(new ThreadStart(OnSendHeartBeatHandler));
_heartbeatThread.IsBackground = true;
_heartbeatThread.Start();
//在线监测线程
_onlinecheckLoop = true;
_onlineCheckThread = new Thread(new ThreadStart(OnlineCheckThreadHandler));
_onlineCheckThread.IsBackground = true;
_onlineCheckThread.Start();
}
catch (Exception ex)
{
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.CONNECT_ERROR, this, ex.Message);
_socketEventQueue.Enqueue(nse);
_isOnline = false;
_onlinecheckLoop = false;
if (_autoReconnect)
{
LogError("5秒后将再次尝试连接服务器! 原因:" + nse.Info);
StopAllCoroutines();
//重连服务器
StartCoroutine(StartReconnectHandler());
}
}
}
private void Client_OnSocketEventHandler(EasySocketEvent evt)
{
switch (evt.Type)
{
case EasySocketEvent.SERVER_START_SUCCESS:
msgStr += "\nserver start success";
break;
case EasySocketEvent.NEW_CONNECTION:
msgStr += "\nnew client connected";
break;
case EasySocketEvent.DISCONNECTED:
msgStr += "\nclient lost" + evt.UserToken.Ipe.ToString();
break;
}
}
private void OnSocketEventHandler(EasySocketEvent evt)
{
if (OnServerEventHandler != null)
{
OnServerEventHandler(evt);
}
switch (evt.Type)
{
case EasySocketEvent.NEW_CONNECTION: //客户端连接服务器
Log("客户端" + evt.UserToken.Ipe.ToString() + "连接到了服务器");
break;
case EasySocketEvent.DISCONNECTED: //客户端掉线
LogError("客户端" + evt.UserToken.Ipe.ToString() + "掉线了" + evt.Info);
break;
case EasySocketEvent.DATA_RECEIVED: //收到客户端数据
Log("收到客户端" + evt.UserToken.Ipe.ToString() + "的消息" + evt.SocketData);
C2SMsgHandler handler = _msgMgr.FindHandlerById(evt.SocketData.MsgId);
if (handler != null)
{
handler.ProcessData(evt.UserToken, evt.SocketData);
}
break;
case EasySocketEvent.READ_SOCKET_ERROR: //读取数据出错
LogError("读取数据出错");
break;
case EasySocketEvent.SOCKET_ERROR: //Socket异常
LogError("Socket异常");
break;
case EasySocketEvent.SERVER_START_SUCCESS: //服务器启动成功
Log("服务器" + _host + ":" + _port + "启动成功");
break;
case EasySocketEvent.SERVER_START_ERROR: //服务器启动失败
LogError("服务器启动失败 " + evt.Info);
break;
case EasySocketEvent.SERVER_SHUTDOWN:
LogError("服务器ShutDown了");
break;
}
}
void Update()
{
//网络事件
while (_socketEventQueue.Count > 0)
{
EasySocketEvent ese = _socketEventQueue.Dequeue();
OnProcessSocketEventHandler(ese);
}
//心跳时差计算
//更新心跳时间戳
System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)); // 当地时区
long timeStamp = (long)(_lastHeartBeatTime - startTime).TotalSeconds; // 相差秒数
m_LastHeartBeatTimeStamp = timeStamp.ToString();
}
public void SendNetMessage(NetMessage msg)
{
if (_isOnline)
{
try
{
_socket.Send(msg.Bytes);
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.DATA_SENDED, this, msg);
_socketEventQueue.Enqueue(nse);
bytesSended += msg.Bytes.Length;
}
catch (SocketException se)
{
EasySocketEvent nse = new EasySocketEvent(EasySocketEvent.DISCONNECTED, this, se.Message);
_socketEventQueue.Enqueue(nse);
}
}
}
private void OnProcessSocketEventHandler(EasySocketEvent evt)
{
if (OnSocketEventHandler != null)
{
OnSocketEventHandler(evt);
}
switch (evt.Type)
{
case EasySocketEvent.CONNECTED:
Log("连接服务器成功");
break;
case EasySocketEvent.CONNECT_ERROR:
LogError("连接失败");
break;
case EasySocketEvent.READ_SOCKET_ERROR:
break;
case EasySocketEvent.SOCKET_ERROR:
break;
case EasySocketEvent.DISCONNECTED:
LogError("你掉线了" + evt.Info);
if (_autoReconnect)
{
LogError("5秒后将再次尝试连接服务器!");
//重连服务器
StartCoroutine(StartReconnectHandler());
}
break;
case EasySocketEvent.DATA_RECEIVED:
S2CMsgHandler handler = msgMgr.FindHandlerById(evt.SocketData.MsgId);
if (handler != null)
{
handler.ProcessData(this, evt.SocketData);
}
Log("收到数据" + evt.SocketData);
break;
case EasySocketEvent.DATA_SENDED:
Log("发送数据" + evt.SocketData.MsgId);
break;
case EasySocketEvent.CLIENT_SHUTDOWN:
LogError("客户端关闭");
break;
}
}
/// <summary>
/// 断开与服务器的连接
/// </summary>
public void ShutDown()
{
StopAllCoroutines();
_receiveLoop = false;
_heartbeatLoop = false;
_onlinecheckLoop = false;
_isOnline = false;
if (_receiveThread != null)
{
_receiveThread.Interrupt();
_receiveThread.Abort();
_receiveThread = null;
}
if (_heartbeatThread != null)
{
_heartbeatThread.Interrupt();
_heartbeatThread.Abort();
_heartbeatThread = null;
}
if (_onlineCheckThread != null)
{
_onlineCheckThread.Interrupt();
_onlineCheckThread.Abort();
_onlineCheckThread = null;
}
if (_socket != null)
{
_socket.Close();
_socket = null;
}
//关闭连接
EasySocketEvent ese = new EasySocketEvent(EasySocketEvent.CLIENT_SHUTDOWN, this);
_socketEventQueue.Enqueue(ese);
}
/// <summary>
/// 客户端事件触发
/// </summary>
/// <param name="evt"></param>
private void OnTCPTokenEventHandler(EasySocketEvent evt)
{
//将客户端事件入列
_socketEventQueue.Enqueue(evt);
}
