XiuXianProject/ServerET/Server/Model/ExtNetwork/NetworkTCP/WChannel_WebGL.cs

#if UNITY_WEBGL
using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Runtime.InteropServices.ComTypes;
using BestHTTP.WebSocket;
using GFGGame;

namespace ET
{
    public class WChannel : AChannel
    {
        private readonly WService Service;

        private WebSocket webSocket;

        private Queue<MemoryStream> waitSend = new Queue<MemoryStream>();

        //address=webgltest.goufuguiwxw.com/ws
        public WChannel(long id, IPEndPoint ipEndPoint, WService service, string address)
        {
            this.Service = service;
            this.ChannelType = ChannelType.Connect;
            this.Id = id;

            string wsStr = $"ws://{ipEndPoint}";
            if (!string.IsNullOrEmpty(address))
            {
                wsStr = wsStr = $"ws://{address}";
                if (LauncherConfig.isHttps)
                {
                    //wsStr = $"wss://webgltest.goufuguiwxw.com/ws";
                    wsStr = $"wss://{address}";
                }
            }
            else
            {
                if (LauncherConfig.isHttps)
                {
                    wsStr = $"wss://{ipEndPoint}";
                }

                this.RemoteAddress = ipEndPoint;
            }

            WebSocket ws = new WebSocket(new Uri(wsStr));

            if (LauncherConfig.isHttps)
            {
                this.RemoteAddress = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 0);
            }
            else
            {
                this.RemoteAddress = ipEndPoint;
            }
            
            // Subscribe to the WS events
            ws.OnOpen += OnOpen;
            ws.OnClosed += OnClosed;
            ws.OnError += OnError;
            ws.OnBinary += OnRead;

            // Start connecting to the server
            ws.Open();
        }

        public override void Dispose()
        {
            if (this.IsDisposed)
            {
                return;
            }

            this.Id = 0;

            this.webSocket?.Close();
            this.webSocket = null;
        }

        public void Send(MemoryStream memoryBuffer)
        {
            switch (this.Service.ServiceType)
            {
                case ServiceType.Inner:
                    break;
                case ServiceType.Outer:
                    memoryBuffer.Seek(Packet.ActorIdLength, SeekOrigin.Begin);
                    ;
                    break;
            }

            if (this.webSocket == null)
            {
                this.waitSend.Enqueue(memoryBuffer);
                return;
            }

            SendOne(memoryBuffer);
        }

        private void SendOne(MemoryStream memoryBuffer)
        {
            this.webSocket.Send(memoryBuffer.GetBuffer(), (ulong)memoryBuffer.Position,
                (ulong)(memoryBuffer.Length - memoryBuffer.Position));
        }

        private void OnOpen(WebSocket ws)
        {
            if (ws == null)
            {
                this.OnError(ErrorCore.ERR_WebsocketConnectError);
                return;
            }

            if (this.IsDisposed)
            {
                return;
            }

            this.webSocket = ws;

            while (this.waitSend.Count > 0)
            {
                MemoryStream memoryBuffer = this.waitSend.Dequeue();
                this.SendOne(memoryBuffer);
            }
        }

        /// <summary>
        /// Called when we received a text message from the server
        /// </summary>
        private void OnRead(WebSocket ws, byte[] data)
        {
            if (this.IsDisposed)
            {
                return;
            }

            MemoryStream memoryBuffer = this.Service.Fetch();
            memoryBuffer.Write(data, 0, data.Length); // 写入整个 data
            memoryBuffer.Seek(2, SeekOrigin.Begin);
            this.Service.ReadCallback(this.Id, memoryBuffer);
        }

        /// <summary>
        /// Called when the web socket closed
        /// </summary>
        private void OnClosed(WebSocket ws, UInt16 code, string message)
        {
            if (this.IsDisposed)
            {
                return;
            }

            Log.Error($"wchannel closed: {code} {message}");
            this.OnError(0);
        }

        /// <summary>
        /// Called when an error occured on client side
        /// </summary>
        private void OnError(WebSocket ws, string error)
        {
            if (this.IsDisposed)
            {
                return;
            }

            //Log.Error($"WChannel error: {this.Id} {ws.GetHashCode()} {error}");

            this.OnError(ErrorCore.ERR_WebsocketError);
        }

        private void OnError(int error)
        {
            Log.Info($"WChannel error: {this.Id} {error}");

            long channelId = this.Id;

            this.Service.Remove(channelId);

            this.Service.ErrorCallback(channelId, error);
        }
    }
}
#endif