/// <summary>
/// 发送网络包
/// </summary>
public void SendPackage(INetworkPackage package)
{
if (_channel != null)
{
_channel.SendPackage(package);
}
}
/// <summary>
/// Message deserialization an initiation of handling methods.
/// </summary>
/// <param name="serializedData">Message string containing data.</param>
private void GetData(string serializedData)
{
// don't need to handle empty messages
if (string.IsNullOrEmpty(serializedData))
{
return;
}
try
{
// convert package string into stub
NetworkPackageStub stub = JsonConvert.DeserializeObject <NetworkPackageStub>(serializedData);
// check if calltype belongs to a known message type
Type type;
if (!m_PackageTypes.TryGetValue(stub.call, out type))
{
AciLog.LogFormat(LogType.Error, GetType().ToString(), "Can't handle NetworkPackage with calltype \"{0}\".", stub.call);
return;
}
// deserialize into package instance
INetworkPackage package = JsonConvert.DeserializeObject(serializedData, type) as INetworkPackage;
// call handler mathods
UnityMainThreadDispatcher.Instance().Enqueue(() => m_PackageRegistry.Handle(package));
}
catch (Exception e)
{
AciLog.LogException(e);
}
}
/// <summary>
/// Sends a <see cref="NetworkPackage" /> to all specified receivers.
/// </summary>
/// <param name="pkg">
/// <see cref="NetworkPackage" /> to send.
/// </param>
public void Send(INetworkPackage pkg)
{
if (_client == null)
{
// Do NOT call AciLog here to prevent looped method call
Debug.unityLogger.LogWarning(GetType().Name, "Not properly initialized. Please call the Initialize() method before sending data.");
return;
}
string json = JsonConvert.SerializeObject(pkg);
// Do NOT call AciLog here to prevent looped method call
Debug.unityLogger.Log(GetType().Name, "Sending package \"" + json + "\"");
try
{
// Convert to binary
byte[] data = Encoding.UTF8.GetBytes(json);
for (int i = 0; i < _remoteEndPoints.Length; ++i)
{
// Send msg to receiver
_client.Send(data, data.Length, _remoteEndPoints[i]);
}
}
catch (Exception err)
{
AciLog.LogError(GetType().Name, err);
}
}
/// <summary>
/// 本地模拟接收网络包
/// </summary>
public void Simulate(INetworkPackage package)
{
if (package != null)
{
NetworkPackageCallback?.Invoke(package);
}
}
void IModule.OnUpdate()
{
if (_client == null)
{
return;
}
// 更新网络客户端
_client.Update();
// 拉取网络包
// 注意：如果服务器意外断开，未拉取的网络包将会丢失
while (true)
{
INetworkPackage package = (INetworkPackage)_client.PickPackage();
if (package == null)
{
break;
}
NetworkPackageCallback?.Invoke(package);
}
// 侦测服务器主动断开连接
if (States == ENetworkStates.Connected)
{
if (_client.IsConnected() == false)
{
States = ENetworkStates.Disconnect;
NetworkEventDispatcher.SendDisconnectMsg();
CloseClient();
MotionLog.Warning("Server disconnect.");
}
}
}
/// <summary>
/// 发送网络包
/// </summary>
public void SendPackage(INetworkPackage package)
{
lock (_sendQueue)
{
_sendQueue.Enqueue(package);
}
}
private void UpdateSending()
{
if (_isSending == false && _sendQueue.Count > 0)
{
_isSending = true;
// 清空缓存
_sendBuffer.Clear();
// 合并数据一起发送
while (_sendQueue.Count > 0)
{
// 如果不够写入一个最大的消息包
if (_sendBuffer.WriteableBytes < _packageMaxSize)
{
break;
}
// 数据压码
INetworkPackage package = _sendQueue.Dequeue();
_packageCoder.Encode(_sendBuffer, package);
}
// 请求操作
_sendArgs.SetBuffer(0, _sendBuffer.ReadableBytes);
bool willRaiseEvent = _socket.SendAsync(_sendArgs);
if (!willRaiseEvent)
{
ProcessSend(_sendArgs);
}
}
}
/// <summary>
/// 接收消息回调函数
/// </summary>
private void OnHandleHotfixMsg(INetworkPackage pack)
{
DefaultNetworkPackage package = pack as DefaultNetworkPackage;
Type msgType = _types.GetValueByKey(package.MsgID);
HotfixLogger.Log($"Handle hotfix net message : {msgType}");
object instance = Activator.CreateInstance(msgType);
var message = ProtobufHelper.Decode(instance, package.BodyBytes);
HotfixLogger.Log(message.ToString());
}
/// <summary>
/// 发送网络消息
/// </summary>
public void SendMessage(INetworkPackage package)
{
if (States != ENetworkStates.Connected)
{
MotionLog.Warning("Network is not connected.");
return;
}
if (_client != null)
{
_client.SendPackage(package);
}
}
/// <summary>
/// 获取网络包
/// </summary>
public INetworkPackage PickPackage()
{
INetworkPackage package = null;
lock (_receiveQueue)
{
if (_receiveQueue.Count > 0)
{
package = _receiveQueue.Dequeue();
}
}
return(package);
}
/// <summary>
/// 本地模拟接收网络包
/// </summary>
public void Simulate(INetworkPackage package)
{
if (package != null)
{
if (package.IsHotfixPackage)
{
HotfixPackageCallback.Invoke(package);
}
else
{
MonoPackageCallback.Invoke(package);
}
}
}
private void OnHandleNetworkPackage(INetworkPackage pack)
{
DefaultNetworkPackage package = pack as DefaultNetworkPackage;
// 先判断是否为主工程接收的消息
Type msgType = NetworkMessageRegister.TryGetMessageType(package.MsgID);
if (msgType != null)
{
//TODO ProtoBuffer处理
}
else
{
// 传递给LUA层去解析消息包
_funNetMessage(package.MsgID, package.BodyBytes);
}
}
void IModule.OnUpdate()
{
if (_client == null)
{
return;
}
// 更新网络客户端
_client.Update();
// 拉取网络包
// 注意：如果服务器意外断开，未拉取的网络包将会丢失
INetworkPackage package = (INetworkPackage)_client.PickPackage();
if (package != null)
{
if (package.IsHotfixPackage)
{
HotfixPackageCallback.Invoke(package);
}
else
{
MonoPackageCallback.Invoke(package);
}
}
// 侦测服务器主动断开连接
if (States == ENetworkStates.Connected)
{
if (_client.IsConnected() == false)
{
States = ENetworkStates.Disconnect;
NetworkEventDispatcher.SendDisconnectMsg();
CloseClient();
MotionLog.Log(ELogLevel.Warning, "Server disconnect.");
}
}
}
public void Send(INetworkPackage package)
{
try
{
byte[] buffer = package.Encode();
m_ClientSocket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, new AsyncCallback(SendCallback), null);
}
catch (Exception ex)
{
Debug.LogError(ex.Message);
if (OnNetworkError != null)
OnNetworkError(ex.Message);
Connect();
}
}
private void OnHandleHotfixPackage(INetworkPackage pack)
{
DefaultNetworkPackage package = pack as DefaultNetworkPackage;
_funNetMessage(package.MsgID, package.BodyBytes);
}
/// <inheritdoc cref="INetworkPackageHandler"/>
void INetworkPackageHandler.Handle(INetworkPackage package)
{
Handle((T)package);
}
/// <summary> /// 编码 /// </summary> /// <param name="sendBuffer">编码填充的字节缓冲区</param> /// <param name="sendPackage">发送的包裹</param> public abstract void Encode(ByteBuffer sendBuffer, INetworkPackage sendPackage);
/// <summary>
/// 编码
/// </summary>
public override void Encode(ByteBuffer sendBuffer, INetworkPackage sendPackage)
{
DefaultNetworkPackage package = (DefaultNetworkPackage)sendPackage;
if (package == null)
{
HandleError(false, $"The package object is invalid : {sendPackage.GetType()}");
return;
}
// 检测逻辑是否合法
if (package.BodyBytes == null)
{
HandleError(false, $"The package BodyBytes field is null : {sendPackage.GetType()}");
return;
}
// 获取包体数据
byte[] bodyData = package.BodyBytes;
// 检测包体长度
if (bodyData.Length > PackageBodyMaxSize)
{
HandleError(false, $"The package {package.MsgID} body size is larger than NetworkDefine.PackageBodyMaxSize");
return;
}
// 写入长度
int packetSize = (int)MessageIDFieldType + bodyData.Length;
if (PackageSizeFieldType == EPackageSizeFieldType.UShort)
{
// 检测是否越界
if (packetSize > ushort.MaxValue)
{
HandleError(true, $"The package {package.MsgID} size is larger than ushort.MaxValue.");
return;
}
sendBuffer.WriteUShort((ushort)packetSize);
}
else
{
sendBuffer.WriteInt(packetSize);
}
// 写入包头
{
// 写入消息ID
if (MessageIDFieldType == EMessageIDFieldType.UShort)
{
// 检测是否越界
if (package.MsgID > ushort.MaxValue)
{
HandleError(true, $"The package {package.MsgID} ID is larger than ushort.MaxValue");
return;
}
sendBuffer.WriteUShort((ushort)package.MsgID);
}
else
{
sendBuffer.WriteInt(package.MsgID);
}
}
// 写入包体
sendBuffer.WriteBytes(bodyData, 0, bodyData.Length);
}
