protected void MessageHandler(ActorCmd cmd)
{
if (mState != NetworkState.Connected)
{
mLogger.LogError("mState != NetworkState.Connected", "MessageHandler");
return;
}
if (mRevMsgCallback == null)
{
return;
}
IMessage msg = cmd.Param0 as IMessage;
if (msg == null)
{
mLogger.LogError("msg == null", "MessageHandler");
return;
}
try
{
mRevMsgCallback(msg);
}
catch (Exception e)
{
mLogger.LogError("Process message error:" + e, "MessageHandler");
}
}
protected override ThreadResult OnCmd(ActorCmd cmd)
{
if (cmd.Cmd < 0 || cmd.Cmd >= mHandler.Length)
{
mLogger.LogError("cmd.cmd < 0 || cmd.cmd >= mHandler.Length", "OnCmd");
return(ThreadResult.Sleep);
}
return(mHandler[cmd.Cmd](cmd));
}
protected override bool OnInput(ActorCmd cmd)
{
if (cmd.Cmd == NetworkInCmd.Close)
{
CloseSocket(mSocket);
return(false);
}
return(true);
}
/// <summary>
/// 处理消息
/// 在socket线程处理
/// </summary>
/// <param name="reader"></param>
/// <param name="msgLen"></param>
private void ProcessMsg(IByteArrayReader reader, int msgLen)
{
UInt16 msgId = 0;
reader.ReadU16(ref msgId);
if (msgId < 1)
{
mLogger.LogError("msgID = " + msgId + ", msgID < 1", "ProcessMsg");
return;
}
if (MsgTransferLog)
{
mLogger.LogInfo("rev msg, msgId=" + GetMessageTypeString(msgId), "ProcessMsg");
}
IMessage msg = mMsgPool.GetMsgInst(msgId);
if (msg == null)
{
mLogger.LogWarning("MsgPool is not find the msg, msgId = " + msgId, "ProcessMsg");
return;
}
if (RecodeDump)
{
ActorCmd dumpCmd = new ActorCmd(NetworkOutCmd.Dump)
{
Param0 = (uint)msgId,
Param1 = msgLen,
Param2 = reader.Dump(),
};
SendToOutput(dumpCmd);
}
try
{
msg.MergeFrom(reader.GetStream());
}
catch (Exception e)
{
mLogger.LogError("msgID = " + msgId + ", MergeFrom error, " + e.Message, "ProcessMsg");
return;
}
SendToOutput(new ActorCmd(NetworkOutCmd.Message, msg));
}
private void DumpHandler(ActorCmd cmd)
{
try
{
uint msgId = (uint)cmd.Param0;
int msgLen = (int)cmd.Param1;
byte[] msgData = (byte[])cmd.Param2;
if (msgLen != msgData.Length)
{
Debug.LogWarning("msgLen != msgData.Length");
byte[] msgDataCopy = new byte[msgLen];
Array.Copy(msgData, msgDataCopy, msgLen);
msgData = msgDataCopy;
}
DumpSave(false, msgId, msgData);
}
catch (Exception e)
{
mLogger.LogError("Recode dump error: " + e, "TestRecodeDump");
}
}
public void Connect(string ip, int port)
{
if (mState == NetworkState.Connecting)
{
mLogger.LogInfo("mState = NetworkState.Connecting", "Network");
return;
}
if (mNetwork != null)
{
mNetwork.Dispose();
}
if (RecodeDump)
{
try
{
if (mDumpCount < 1 && Directory.Exists(SaveDumpPath))
{
Directory.Delete(SaveDumpPath, true);
}
}
catch (Exception e)
{
mLogger.LogError("Network dump error: delete dump error, " + e, "mNetwork");
}
}
mNetwork = new NetworkThread(mBufferSize, mMsgPool);
mNetwork.RecodeDump = RecodeDump;
mNetwork.SendBeforCallback = SendBeforCallback;
ActorCmd connectCmd = new ActorCmd(NetworkInCmd.Connect)
{
Param0 = ip,
Param1 = port
};
mNetwork.Input(connectCmd);
mState = NetworkState.Connecting;
}
protected void CloseHandler(ActorCmd cmd)
{
if (mState == NetworkState.Closed)
{
mLogger.LogError("mState == NetworkState.Closed", "CloseHandler");
return;
}
mState = NetworkState.Closed;
if (mConnectCallback == null)
{
return;
}
try
{
mConnectCallback("close");
}
catch (Exception e)
{
mLogger.LogError("ConnectCallback(\"close\") error::" + e.Message, "CloseHandler");
}
}
protected void ConnErrHandler(ActorCmd cmd)
{
if (mState != NetworkState.Connecting)
{
mLogger.LogError("mState != NetworkState.Connecting", "ConnErrHandler");
return;
}
mState = NetworkState.ConnectError;
if (mConnectCallback == null)
{
return;
}
try
{
mConnectCallback("error");
}
catch (Exception e)
{
mLogger.LogError("ConnectCallback(\"error\") error:" + e.Message, "ConnErrHandler");
}
}
protected void SalfClose()
{
ActorCmd cmd = new ActorCmd(NetworkInCmd.Close);
CloseHandler(cmd);
}
/// <summary>
/// 处理关闭
/// </summary>
/// <param name="cmd"></param>
/// <returns></returns>
protected ThreadResult CloseHandler(ActorCmd cmd)
{
//不会执行到这里，国为OnInput那里已经被截断了
mThread.Dispose();
return(ThreadResult.Stop);
}
/// <summary>
/// 处理连接
/// </summary>
/// <param name="cmd"></param>
/// <returns></returns>
protected ThreadResult ConnectHandler(ActorCmd cmd)
{
if (mState == NetState.Connecting)
{
return(ThreadResult.Sleep);
}
if (mState != NetState.None)
{
mLogger.LogError("mState != NetState.None, mState = " + mState, "ConnectHandler");
return(ThreadResult.Stop);
}
string ip = cmd.Param0.ToString();
int port = (int)cmd.Param1;
try
{
mState = NetState.Connecting;
IPAddress serverIp;
if (!IPAddress.TryParse(ip, out serverIp))
{
IPAddress[] address = Dns.GetHostAddresses(ip);
if (address.Length < 1)
{
mLogger.LogError("ipHost.AddressList.Length < 1", "ConnectHandler");
return(ThreadResult.Stop);
}
serverIp = address[0];
}
mSocket = new Socket(serverIp.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
mSocket.Connect(serverIp, port);
mLogger.LogInfo("Socket connect success", "ConnectHandler");
if (mReader == null)
{
mBuffer = new byte[mBuffSize];
mReader = new ByteArray(mBuffer);
}
else
{
mReader.Reset();
}
//初始化读取数据的参数
mNeedSize = HEAD_SIZE;
mIsHead = true;
mPosition = 0;
mState = NetState.Connected;
SendToOutput(new ActorCmd(NetworkOutCmd.Connected));
}
catch (SocketException e)
{
mState = NetState.None;
mLogger.LogError(e.Message, "ConnectHandler");
SendToOutput(new ActorCmd(NetworkOutCmd.ConnectError));
//CloseSocket(mSocket);
//return ThreadResult.Stop;
}
return(ThreadResult.Sleep);
}
