using Cysharp.Threading.Tasks;
|
using NativeWebSocket;
|
using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using UnityEngine;
|
|
/// <summary>
|
/// WebSocket 网络服务 - 用于小游戏平台
|
/// </summary>
|
public class WebSocketNetworkService : INetworkService
|
{
|
private WebSocket webSocket;
|
private NetworkState _state = NetworkState.Disconnected;
|
private string currentUrl;
|
|
// 统计信息（与 ClientSocket 对齐）
|
private long getBytesTotal = 0; // 接收的数据总量
|
private long sendBytesTotal = 0; // 发送的数据总量
|
private DateTime m_LastPackageTime = DateTime.MinValue;
|
|
/// <summary>
|
/// 最后收包时间（实现接口）
|
/// </summary>
|
public DateTime LastPackageTime { get { return m_LastPackageTime; } }
|
|
// 发送队列（与 ClientSocket 对齐）
|
private Queue<byte[]> sendQueue = new Queue<byte[]>();
|
private bool isSending = false;
|
|
// 编解码器（与 ClientSocket 对齐）
|
private GameNetEncode encoder = new GameNetEncode();
|
|
// 服务器类型（与 ClientSocket 对齐）
|
private ServerType socketType = ServerType.Main;
|
|
/// <summary>
|
/// 构造函数（与 ClientSocket 对齐）
|
/// </summary>
|
public WebSocketNetworkService(ServerType type)
|
{
|
this.socketType = type;
|
}
|
|
public NetworkState State
|
{
|
get => _state;
|
private set
|
{
|
if (_state != value)
|
{
|
_state = value;
|
OnStateChanged?.Invoke(value);
|
}
|
}
|
}
|
|
public bool IsConnected => State == NetworkState.Connected;
|
|
public event Action<NetworkState> OnStateChanged;
|
|
/// <summary>
|
/// 连接到 WebSocket 服务器
|
/// </summary>
|
public async UniTask<bool> ConnectAsync(string url)
|
{
|
if (IsConnected)
|
{
|
Debug.LogWarning($"[WebSocket] 已经连接到 {currentUrl}");
|
return true;
|
}
|
|
try
|
{
|
State = NetworkState.Connecting;
|
currentUrl = url;
|
|
Debug.Log($"[WebSocket] 开始连接: {url}");
|
|
// 创建 WebSocket 连接（不传 headers，使用默认行为）
|
webSocket = new WebSocket(url);
|
|
// 注册事件监听
|
webSocket.OnOpen += OnWebSocketOpen;
|
webSocket.OnMessage += OnWebSocketMessage;
|
webSocket.OnError += OnWebSocketError;
|
webSocket.OnClose += OnWebSocketClose;
|
|
// 开始连接
|
Debug.Log($"[WebSocket] 调用 Connect()...");
|
|
// 启动连接任务（不等待它完成，因为它会一直运行到连接关闭）
|
var connectTask = webSocket.Connect();
|
|
// 等待 OnOpen 触发（最多5秒）
|
var timeout = DateTime.Now.AddSeconds(5);
|
while (State != NetworkState.Connected && DateTime.Now < timeout)
|
{
|
await UniTask.Yield();
|
}
|
|
Debug.Log($"[WebSocket] 等待结束，当前状态: {State}, WebSocket.State: {webSocket.State}");
|
|
if (IsConnected)
|
{
|
Debug.Log("[WebSocket] ✓ 连接成功");
|
return true;
|
}
|
else
|
{
|
Debug.LogError($"[WebSocket] ✗ 连接超时或失败，State={State}, WebSocket.State={webSocket?.State}");
|
return false;
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogError($"[WebSocket] 连接异常: {ex.Message}\n{ex.StackTrace}");
|
return false;
|
}
|
}
|
|
/// <summary>
|
/// 断开连接（异步）
|
/// </summary>
|
public async UniTask DisconnectAsync()
|
{
|
Debug.LogWarning($"[WebSocket] DisconnectAsync 被调用! State={State}");
|
Debug.LogWarning($"[WebSocket] 调用堆栈:\n{System.Environment.StackTrace}");
|
|
if (webSocket != null)
|
{
|
// 清空发送队列
|
lock (sendQueue)
|
{
|
sendQueue.Clear();
|
isSending = false;
|
}
|
|
await webSocket.Close();
|
webSocket = null;
|
}
|
State = NetworkState.Disconnected;
|
}
|
|
/// <summary>
|
/// 断开连接（同步，适配 ClientSocket.CloseConnect）
|
/// </summary>
|
public void Disconnect()
|
{
|
Debug.LogWarning($"[WebSocket] Disconnect 被调用! State={State}");
|
Debug.LogWarning($"[WebSocket] 调用堆栈:\n{System.Environment.StackTrace}");
|
DisconnectAsync().Forget();
|
}
|
|
/// <summary>
|
/// 发送协议包（与 ClientSocket.SendInfo 完全对齐）
|
/// </summary>
|
public void SendInfo(GameNetPackBasic protocol)
|
{
|
if (!IsConnected)
|
{
|
Debug.LogError("[WebSocket] 未连接，无法发送协议包");
|
return;
|
}
|
|
if (protocol == null)
|
{
|
Debug.LogError("[WebSocket] 要发的信息对象为空");
|
return;
|
}
|
|
try
|
{
|
// 1. 准备协议数据
|
if (protocol.combineBytes == null)
|
{
|
protocol.WriteToBytes();
|
}
|
|
// 2. 组合数据（与 ClientSocket.SendInfo 一致）
|
protocol.CombineDatas(encoder);
|
|
#if UNITY_EDITOR
|
// 3. 记录包信息到 NetPackageWindow（与 ClientSocket 对齐）
|
NetPkgCtl.RecordPackage(socketType, protocol.vInfoCont, NetPackagetType.Client,
|
protocol.ToString(), FieldPrint.PrintFields(protocol), FieldPrint.PrintFieldsExpand(protocol, true));
|
#endif
|
|
byte[] data = protocol.dataBytes;
|
|
// 4. 加密
|
byte[] encryptedData = encoder.BaseXorAdd(data);
|
|
// 5. 添加包头（6字节：0xFF 0xCC + 4字节长度小端序，与 ClientSocket 一致）
|
int bodyLength = encryptedData.Length;
|
byte[] sendData = new byte[bodyLength + 6];
|
sendData[0] = 0xFF; // 与 ClientSocket 一致
|
sendData[1] = 0xCC; // 与 ClientSocket 一致
|
// 使用 BitConverter 小端序（与 ClientSocket 一致）
|
byte[] lengthBytes = BitConverter.GetBytes(bodyLength);
|
Array.Copy(lengthBytes, 0, sendData, 2, 4);
|
Array.Copy(encryptedData, 0, sendData, 6, bodyLength);
|
|
// 6. 更新统计（与 ClientSocket 对齐）
|
sendBytesTotal += sendData.Length;
|
|
// 7. 发送（异步）
|
SendAsync(sendData).Forget();
|
}
|
catch (Exception ex)
|
{
|
Debug.LogError($"[WebSocket] 发送协议包异常: {ex.Message}\n{ex.StackTrace}");
|
}
|
}
|
|
/// <summary>
|
/// 发送二进制数据（同步重载，适配 ClientSocket.SendInfo）
|
/// </summary>
|
public void SendInfo(byte[] data)
|
{
|
SendAsync(data).Forget();
|
}
|
|
/// <summary>
|
/// 发送二进制数据（带队列机制，与 ClientSocket 对齐）
|
/// </summary>
|
public async UniTask SendAsync(byte[] data)
|
{
|
if (!IsConnected)
|
{
|
Debug.LogError("[WebSocket] 未连接，无法发送数据");
|
return;
|
}
|
|
if (data == null || data.Length == 0)
|
{
|
Debug.LogError("[WebSocket] 发送数据为空");
|
return;
|
}
|
|
// 检查消息大小（最大 64KB）
|
if (data.Length > 65536)
|
{
|
Debug.LogError($"[WebSocket] 消息过大: {data.Length} bytes（最大 64KB）");
|
return;
|
}
|
|
// 队列机制：如果正在发送，加入队列
|
lock (sendQueue)
|
{
|
if (isSending)
|
{
|
sendQueue.Enqueue(data);
|
Debug.Log($"[WebSocket] 数据加入发送队列，队列长度: {sendQueue.Count}");
|
return;
|
}
|
else
|
{
|
isSending = true;
|
}
|
}
|
|
// 发送数据
|
await SendBytesInternal(data);
|
}
|
|
/// <summary>
|
/// 内部发送方法（处理队列）
|
/// </summary>
|
private async UniTask SendBytesInternal(byte[] data)
|
{
|
try
|
{
|
await webSocket.Send(data);
|
sendBytesTotal += data.Length;
|
Debug.Log($"[WebSocket] 发送成功: {data.Length} bytes，总发送: {sendBytesTotal} bytes");
|
|
// 处理队列中的下一个消息
|
byte[] nextData = null;
|
lock (sendQueue)
|
{
|
if (sendQueue.Count > 0)
|
{
|
nextData = sendQueue.Dequeue();
|
}
|
else
|
{
|
isSending = false;
|
}
|
}
|
|
if (nextData != null)
|
{
|
await SendBytesInternal(nextData);
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogError($"[WebSocket] 发送失败: {ex.Message}");
|
|
lock (sendQueue)
|
{
|
isSending = false;
|
}
|
}
|
}
|
|
/// <summary>
|
/// WebSocket 连接成功回调
|
/// </summary>
|
private void OnWebSocketOpen()
|
{
|
Debug.Log($"[WebSocket] ✓✓✓ OnOpen 事件触发 - 连接成功: {currentUrl}");
|
Debug.Log($"[WebSocket] WebSocket.State: {webSocket?.State}");
|
State = NetworkState.Connected;
|
Debug.Log($"[WebSocket] 当前状态已更新为: {State}");
|
}
|
|
/// <summary>
|
/// WebSocket 消息接收回调（与 ClientSocket.ReadInfo 对齐）
|
/// </summary>
|
private void OnWebSocketMessage(byte[] data)
|
{
|
// 完整的包处理流程（与 ClientSocket.ReadInfo 对齐）
|
try
|
{
|
if (data == null || data.Length < 6)
|
{
|
Debug.LogError($"[WebSocket] 收到无效数据包: {data?.Length ?? 0} bytes");
|
return;
|
}
|
|
// 更新统计信息
|
getBytesTotal += data.Length;
|
Debug.Log($"[WebSocket] 收到原始消息: {data.Length} bytes");
|
|
// 检查包头（0xFF 0xCC，与 ClientSocket 一致）
|
if (data[0] != 0xFF || data[1] != 0xCC)
|
{
|
Debug.LogError($"[WebSocket] 包头错误: 0x{data[0]:X2} 0x{data[1]:X2}，期望 0xFF 0xCC");
|
return;
|
}
|
|
// 读取包体长度（小端序，与 ClientSocket 一致）
|
int bodyLength = BitConverter.ToInt32(data, 2);
|
|
if (data.Length < bodyLength + 6)
|
{
|
Debug.LogError($"[WebSocket] 包长度不匹配: 声明 {bodyLength + 6}, 实际 {data.Length}");
|
return;
|
}
|
|
// 提取加密的包体（跳过6字节包头）
|
byte[] encryptedBody = new byte[bodyLength];
|
Array.Copy(data, 6, encryptedBody, 0, bodyLength);
|
|
// 解密包体（与 ClientSocket.ReadInfo 一致）
|
byte[] decryptedData = encoder.BaseXorSub(encryptedBody);
|
|
// 解析 CMD（前2字节）
|
byte[] cmdBytes = new byte[2];
|
Array.Copy(decryptedData, 0, cmdBytes, 0, 2);
|
var cmd = (ushort)((ushort)(cmdBytes[0] << 8) + cmdBytes[1]);
|
|
Debug.Log($"[WebSocket] 解密成功，CMD=0x{cmd:X4}");
|
|
bool isRegist = false;
|
|
// 转换协议包（与 ClientSocket.ReadInfo 一致）
|
if (PackageRegedit.Contain(cmd))
|
{
|
GameNetPackBasic pack = PackageRegedit.TransPack(socketType, cmd, decryptedData);
|
if (pack != null)
|
{
|
Debug.Log($"[WebSocket] 收到协议: {pack.GetType().Name}");
|
m_LastPackageTime = DateTime.Now;
|
|
// 直接推送到 GameNetSystem（与 ClientSocket 一致）
|
GameNetSystem.Instance.PushPackage(pack, socketType);
|
isRegist = true;
|
}
|
}
|
|
// 未注册封包处理（与 ClientSocket 一致）
|
if (!isRegist)
|
{
|
#if UNITY_EDITOR
|
PackageRegedit.TransPack(socketType, cmd, decryptedData);
|
#endif
|
}
|
}
|
catch (Exception ex)
|
{
|
Debug.LogError($"[WebSocket] 消息处理异常: {ex.Message}\n{ex.StackTrace}");
|
}
|
}
|
|
/// <summary>
|
/// WebSocket 错误回调
|
/// </summary>
|
private void OnWebSocketError(string error)
|
{
|
Debug.LogError($"[WebSocket] ✗ OnError 事件触发: {error}");
|
Debug.LogError($"[WebSocket] 当前状态: {State}, WebSocket.State: {webSocket?.State}");
|
}
|
|
/// <summary>
|
/// WebSocket 关闭回调（不自动重连，与 ClientSocket 一致）
|
/// </summary>
|
private void OnWebSocketClose(WebSocketCloseCode code)
|
{
|
Debug.LogError($"[WebSocket] ⊗ OnClose 事件触发!");
|
Debug.LogError($"[WebSocket] 关闭代码: {code} ({(int)code})");
|
Debug.LogError($"[WebSocket] 之前状态: {State}\n");
|
|
// 判断是谁关闭的
|
if (code == WebSocketCloseCode.Normal)
|
{
|
Debug.LogWarning("[WebSocket] → 正常关闭（客户端主动）");
|
}
|
else if (code == WebSocketCloseCode.Abnormal)
|
{
|
Debug.LogError("[WebSocket] → 异常关闭（连接丢失或服务器断开）");
|
}
|
else
|
{
|
Debug.LogError($"[WebSocket] → 其他原因关闭: {code}");
|
}
|
|
State = NetworkState.Disconnected;
|
|
// 注意：不自动重连，与 ClientSocket 一致，由 GameNetSystem 控制重连逻辑
|
Debug.Log("[WebSocket] 连接已断开，等待 GameNetSystem 处理");
|
}
|
|
/// <summary>
|
/// 获取接收统计信息
|
/// </summary>
|
public long GetBytesTotal() => getBytesTotal;
|
|
/// <summary>
|
/// 获取发送统计信息
|
/// </summary>
|
public long GetSendBytesTotal() => sendBytesTotal;
|
|
/// <summary>
|
/// 获取发送队列长度
|
/// </summary>
|
public int GetSendQueueCount()
|
{
|
lock (sendQueue)
|
{
|
return sendQueue.Count;
|
}
|
}
|
|
/// <summary>
|
/// 每帧处理 WebSocket 消息（必须在 MonoBehaviour 的 Update 中调用）
|
/// </summary>
|
public void Update()
|
{
|
#if !UNITY_WEBGL || UNITY_EDITOR
|
webSocket?.DispatchMessageQueue();
|
#endif
|
}
|
}
|
