提交修改

Assets/Scripts/ThirdParty/Fantasy.Unity/Runtime/Plugins/WSocket/Implementation/WebGL/WebSocket.cs

@@ -0,0 +1,154 @@
+#if !UNITY_EDITOR && UNITY_WEBGL
+using System;
+
+namespace UnityWebSocket
+{
+    public class WebSocket : IWebSocket
+    {
+        public string Address { get; private set; }
+        public string[] SubProtocols { get; private set; }
+        public WebSocketState ReadyState { get { return (WebSocketState)WebSocketManager.WebSocketGetState(instanceId); } }
+
+        public event EventHandler<OpenEventArgs> OnOpen;
+        public event EventHandler<CloseEventArgs> OnClose;
+        public event EventHandler<ErrorEventArgs> OnError;
+        public event EventHandler<MessageEventArgs> OnMessage;
+
+        internal int instanceId = 0;
+
+        public WebSocket(string address)
+        {
+            this.Address = address;
+            AllocateInstance();
+        }
+
+        public WebSocket(string address, string subProtocol)
+        {
+            this.Address = address;
+            this.SubProtocols = new string[] { subProtocol };
+            AllocateInstance();
+        }
+
+        public WebSocket(string address, string[] subProtocols)
+        {
+            this.Address = address;
+            this.SubProtocols = subProtocols;
+            AllocateInstance();
+        }
+
+        internal void AllocateInstance()
+        {
+            instanceId = WebSocketManager.AllocateInstance(this.Address);
+            Log($"Allocate socket with instanceId: {instanceId}");
+            if (this.SubProtocols == null) return;
+            foreach (var protocol in this.SubProtocols)
+            {
+                if (string.IsNullOrEmpty(protocol)) continue;
+                Log($"Add Sub Protocol {protocol}, with instanceId: {instanceId}");
+                int code = WebSocketManager.WebSocketAddSubProtocol(instanceId, protocol);
+                if (code < 0)
+                {
+                    HandleOnError(GetErrorMessageFromCode(code));
+                    break;
+                }
+            }
+        }
+
+        ~WebSocket()
+        {
+            Log($"Free socket with instanceId: {instanceId}");
+            WebSocketManager.WebSocketFree(instanceId);
+        }
+
+        public void ConnectAsync()
+        {
+            Log($"Connect with instanceId: {instanceId}");
+            WebSocketManager.Add(this);
+            int code = WebSocketManager.WebSocketConnect(instanceId);
+            if (code < 0) HandleOnError(GetErrorMessageFromCode(code));
+        }
+
+        public void CloseAsync()
+        {
+            Log($"Close with instanceId: {instanceId}");
+            int code = WebSocketManager.WebSocketClose(instanceId, (int)CloseStatusCode.Normal, "Normal Closure");
+            if (code < 0) HandleOnError(GetErrorMessageFromCode(code));
+        }
+
+        public void SendAsync(string text)
+        {
+            Log($"Send, type: {Opcode.Text}, size: {text.Length}");
+            int code = WebSocketManager.WebSocketSendStr(instanceId, text);
+            if (code < 0) HandleOnError(GetErrorMessageFromCode(code));
+        }
+
+        public void SendAsync(byte[] data)
+        {
+            Log($"Send, type: {Opcode.Binary}, size: {data.Length}");
+            int code = WebSocketManager.WebSocketSend(instanceId, data, 0, data.Length);
+            if (code < 0) HandleOnError(GetErrorMessageFromCode(code));
+        }
+
+        public void SendAsync(byte[] data, int offset, int len)
+        {
+            Log($"Send, type: {Opcode.Binary}, offset: {offset}, len: {len}, size: {data.Length}");
+            int code = WebSocketManager.WebSocketSend(instanceId, data, offset, len);
+            if (code < 0) HandleOnError(GetErrorMessageFromCode(code));
+        }
+
+        internal void HandleOnOpen()
+        {
+            Log("OnOpen");
+            OnOpen?.Invoke(this, new OpenEventArgs());
+        }
+
+        internal void HandleOnMessage(byte[] rawData)
+        {
+            Log($"OnMessage, type: {Opcode.Binary}, size: {rawData.Length}");
+            OnMessage?.Invoke(this, new MessageEventArgs(Opcode.Binary, rawData));
+        }
+
+        internal void HandleOnMessageStr(string data)
+        {
+            Log($"OnMessage, type: {Opcode.Text}, size: {data.Length}");
+            OnMessage?.Invoke(this, new MessageEventArgs(Opcode.Text, data));
+        }
+
+        internal void HandleOnClose(ushort code, string reason)
+        {
+            Log($"OnClose, code: {code}, reason: {reason}");
+            OnClose?.Invoke(this, new CloseEventArgs(code, reason));
+            WebSocketManager.Remove(instanceId);
+        }
+
+        internal void HandleOnError(string msg)
+        {
+            Log("OnError, error: " + msg);
+            OnError?.Invoke(this, new ErrorEventArgs(msg));
+        }
+
+        internal static string GetErrorMessageFromCode(int errorCode)
+        {
+            switch (errorCode)
+            {
+                case -1: return "WebSocket instance not found.";
+                case -2: return "WebSocket is already connected or in connecting state.";
+                case -3: return "WebSocket is not connected.";
+                case -4: return "WebSocket is already closing.";
+                case -5: return "WebSocket is already closed.";
+                case -6: return "WebSocket is not in open state.";
+                case -7: return "Cannot close WebSocket, An invalid code was specified or reason is too long.";
+                case -8: return "Not support buffer slice. ";
+                default: return $"Unknown error code {errorCode}.";
+            }
+        }
+
+        [System.Diagnostics.Conditional("UNITY_WEB_SOCKET_LOG")]
+        static void Log(string msg)
+        {
+            var time = DateTime.Now.ToString("HH:mm:ss.fff");
+            UnityEngine.Debug.Log($"[{time}][UnityWebSocket] {msg}");
+        }
+    }
+}
+#endif

Assets/Scripts/ThirdParty/Fantasy.Unity/Runtime/Plugins/WSocket/Implementation/WebGL/WebSocket.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 74a5b3c22251243d2a2f33e74741559d
+timeCreated: 1466578513
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/ThirdParty/Fantasy.Unity/Runtime/Plugins/WSocket/Implementation/WebGL/WebSocketManager.cs

@@ -0,0 +1,159 @@
+#if !UNITY_EDITOR && UNITY_WEBGL
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using AOT;
+
+namespace UnityWebSocket
+{
+    /// <summary>
+    /// Class providing static access methods to work with JSLIB WebSocket
+    /// </summary>
+    internal static class WebSocketManager
+    {
+        /* Map of websocket instances */
+        private static Dictionary<int, WebSocket> sockets = new Dictionary<int, WebSocket>();
+
+        /* Delegates */
+        public delegate void OnOpenCallback(int instanceId);
+        public delegate void OnMessageCallback(int instanceId, IntPtr msgPtr, int msgSize);
+        public delegate void OnMessageStrCallback(int instanceId, IntPtr msgStrPtr);
+        public delegate void OnErrorCallback(int instanceId, IntPtr errorPtr);
+        public delegate void OnCloseCallback(int instanceId, int closeCode, IntPtr reasonPtr);
+
+        /* WebSocket JSLIB functions */
+        [DllImport("__Internal")]
+        public static extern int WebSocketConnect(int instanceId);
+
+        [DllImport("__Internal")]
+        public static extern int WebSocketClose(int instanceId, int code, string reason);
+
+        [DllImport("__Internal")]
+        public static extern int WebSocketSend(int instanceId, byte[] dataPtr, int offset, int dataLength);
+
+        [DllImport("__Internal")]
+        public static extern int WebSocketSendStr(int instanceId, string data);
+
+        [DllImport("__Internal")]
+        public static extern int WebSocketGetState(int instanceId);
+
+        /* WebSocket JSLIB callback setters and other functions */
+        [DllImport("__Internal")]
+        public static extern int WebSocketAllocate(string url);
+
+        [DllImport("__Internal")]
+        public static extern int WebSocketAddSubProtocol(int instanceId, string protocol);
+
+        [DllImport("__Internal")]
+        public static extern void WebSocketFree(int instanceId);
+
+        [DllImport("__Internal")]
+        public static extern void WebSocketSetOnOpen(OnOpenCallback callback);
+
+        [DllImport("__Internal")]
+        public static extern void WebSocketSetOnMessage(OnMessageCallback callback);
+
+        [DllImport("__Internal")]
+        public static extern void WebSocketSetOnMessageStr(OnMessageStrCallback callback);
+
+        [DllImport("__Internal")]
+        public static extern void WebSocketSetOnError(OnErrorCallback callback);
+
+        [DllImport("__Internal")]
+        public static extern void WebSocketSetOnClose(OnCloseCallback callback);
+        
+        [DllImport("__Internal")]
+        public static extern void WebSocketSetSupport6000();
+
+        /* If callbacks was initialized and set */
+        private static bool isInitialized = false;
+
+        /* Initialize WebSocket callbacks to JSLIB */
+        private static void Initialize()
+        {
+            WebSocketSetOnOpen(DelegateOnOpenEvent);
+            WebSocketSetOnMessage(DelegateOnMessageEvent);
+            WebSocketSetOnMessageStr(DelegateOnMessageStrEvent);
+            WebSocketSetOnError(DelegateOnErrorEvent);
+            WebSocketSetOnClose(DelegateOnCloseEvent);
+#if UNITY_6000_0_OR_NEWER
+            WebSocketSetSupport6000();
+#endif
+
+            isInitialized = true;
+        }
+
+        [MonoPInvokeCallback(typeof(OnOpenCallback))]
+        public static void DelegateOnOpenEvent(int instanceId)
+        {
+            if (sockets.TryGetValue(instanceId, out var socket))
+            {
+                socket.HandleOnOpen();
+            }
+        }
+
+        [MonoPInvokeCallback(typeof(OnMessageCallback))]
+        public static void DelegateOnMessageEvent(int instanceId, IntPtr msgPtr, int msgSize)
+        {
+            if (sockets.TryGetValue(instanceId, out var socket))
+            {
+                var bytes = new byte[msgSize];
+                Marshal.Copy(msgPtr, bytes, 0, msgSize);
+                socket.HandleOnMessage(bytes);
+            }
+        }
+
+        [MonoPInvokeCallback(typeof(OnMessageStrCallback))]
+        public static void DelegateOnMessageStrEvent(int instanceId, IntPtr msgStrPtr)
+        {
+            if (sockets.TryGetValue(instanceId, out var socket))
+            {
+                string msgStr = Marshal.PtrToStringAuto(msgStrPtr);
+                socket.HandleOnMessageStr(msgStr);
+            }
+        }
+
+        [MonoPInvokeCallback(typeof(OnErrorCallback))]
+        public static void DelegateOnErrorEvent(int instanceId, IntPtr errorPtr)
+        {
+            if (sockets.TryGetValue(instanceId, out var socket))
+            {
+                string errorMsg = Marshal.PtrToStringAuto(errorPtr);
+                socket.HandleOnError(errorMsg);
+            }
+        }
+
+        [MonoPInvokeCallback(typeof(OnCloseCallback))]
+        public static void DelegateOnCloseEvent(int instanceId, int closeCode, IntPtr reasonPtr)
+        {
+            if (sockets.TryGetValue(instanceId, out var socket))
+            {
+                string reason = Marshal.PtrToStringAuto(reasonPtr);
+                socket.HandleOnClose((ushort)closeCode, reason);
+            }
+        }
+
+        internal static int AllocateInstance(string address)
+        {
+            if (!isInitialized) Initialize();
+            return WebSocketAllocate(address);
+        }
+
+        internal static void Add(WebSocket socket)
+        {
+            if (!sockets.ContainsKey(socket.instanceId))
+            {
+                sockets.Add(socket.instanceId, socket);
+            }
+        }
+
+        internal static void Remove(int instanceId)
+        {
+            if (sockets.ContainsKey(instanceId))
+            {
+                sockets.Remove(instanceId);
+            }
+        }
+    }
+}
+#endif

Assets/Scripts/ThirdParty/Fantasy.Unity/Runtime/Plugins/WSocket/Implementation/WebGL/WebSocketManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 246cdc66a1e2047148371a8e56e17d3a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: