WEP_V2.1.3/SourceCode/WeApp.3D.Test/WeApp.3D/Assets/Plugins/WeMessageService/MessageClientManager.cs

using System;
using System.Reflection;
using Assets.Plugins.CommonTool;
using Assets.Plugins.Log;
using UnityEngine;
using uPLibrary.Networking.M2Mqtt.Messages;
using Random = System.Random;

namespace Assets.Plugins.WeMessageService
{ 
    public class MessageClientManager : MonoBehaviour
    {
        private static MessageClientManager _instance;
        //public static MessageClientManager Instance => _instance ??= new MessageClientManager();

        public static MessageClientManager Instance
        {
            get
            {
                if (_instance == null)
                {
                    GameObject obj = new GameObject("MessageClientManagerObj");
                    _instance = obj.AddComponent<MessageClientManager>();
                    DontDestroyOnLoad(obj);
                    _instance.RegisterClient();
                }
                return _instance;
            }
        }

        private static MessageM2MqttClient Client = new MessageM2MqttClient(true,3);

        public string ClientId { get; set; }= "WeApp3D";

        public delegate void MsgReceiveHandler(WeMessage msg);
        public delegate void MsgReceiveHandlerString(string msg);

        public event MsgReceiveHandlerString ReceiveError;
        public event MsgReceiveHandlerString ReceiveHeartbeat;
        public event MsgReceiveHandler ReceiveStart;
        public event MsgReceiveHandler ReceiveEnd;
        public event MsgReceiveHandler ReceiveRunningInfo;
        public event MsgReceiveHandler ReceiveRoundScore;
        public event MsgReceiveHandler ReceiveScene;
        public event MsgReceiveHandler ReceiveGuide;
        public event MsgReceiveHandler ReceiveEnvironment;
        public event MsgReceiveHandler ReceiveMatchSuccess;
        public event MsgReceiveHandler ReceiveCommonMsg;


        /// <summary>
        /// 强制刷新客户端
        /// </summary>
        public void RefreshClient()
        {
            this.LogInfo($"客户端{ClientId}开始强制刷新！");
            Client.DisConnect();
            Client = new MessageM2MqttClient(true);
            RegisterClient();
            SendMessage(ClientId, $"客户端{ClientId}已强制刷新！");
            SendMessage("WeEngine", $"客户端{ClientId}已强制刷新！");
        }

        /// <summary>
        /// 注册客户端
        /// </summary>
        public void RegisterClient()
        {
            ClientId = "WeApp3D";
            var result = new MsgClientDto()
            {
                AppId = ClientId,
                Name = "智慧演练系统3D",
                SecretKey = "WePlatformWeApp3D",
                //SecretKey = "WePlatformWeOnlineApp",
                ServerIp = "www.shvber.com",
                //ServerIp = "47.112.30.247",
                ServerPort = 1885,
            };
            //ClientId = "WeApp3D";
#if DEBUG
            //ClientId = "WeApp3D"+"-Test";
            //var result = new MsgClientDto()
            //{
            //    AppId = ClientId,
            //    Name = "智慧演练系统",
            //    SecretKey = "WePlatformWeApp",
            //    ServerIp = "shvber.com",
            //    ServerPort = 1885,
            //};
#else
            //MsgClientDto result = CacheManager.GetMsgClientDto(ClientId, _url);
            //if (result == null)
            //{
            //    //throw new UserFriendlyException("未查询到消息客户端配置！");
            //    this.LogError($"未查询到消息客户端{ClientId}的配置！");
            //    return;
            //}
#endif



            Client.SetOptions(result.ServerIp, result.ServerPort, ClientId, result.Name, result.SecretKey);
            Client.SetReceivedHandler(ReceivedHandler);
            Subscribe();
            SendMessage(ClientId, $"客户端{ClientId}注册！");
            SendMessage("WeEngine", $"客户端{ClientId}注册！");
        }
        private void Subscribe()
        {
            if (Client.CheckClient())
            {
                Client.SubscribeTopic(ClientId, false);
                Client.SubscribeTopic("Heartbeat");
                var t = typeof(MessageType);
                var fts = t.GetFields(BindingFlags.Static | BindingFlags.Public);
                foreach (var f in fts)
                {
                    Client.SubscribeTopic($"{f.Name}/+");
                }
            }
        }
        public void SendMessage(WeMessage message, MessageType type, string clientId = null)
        {
            if (Client.NotValidate)
            {
                RegisterClient();
            }

            var msg = message.Obj2String();
            Client.SendMsg(type.ToString(), msg, clientId);
        }
        public void SendMessage(WeMessage message)
        {
            if (Client.NotValidate)
            {
                RegisterClient();
            }

            var msg = message.Obj2String();
            Client.SendMsg(message.Type.ToString(), msg, message.TargetClientId);
        }
        public  void SendSelfMessage(string msg)
        {
            if (Client.NotValidate)
            {
                RegisterClient();
            }
            Client.SendMessage(ClientId, msg);
        }
        public void SendMessage(string topic, string msg)
        {
            if (Client.NotValidate)
            {
                RegisterClient();
            }
            Client.SendMessage(topic, msg);
        }

        /// <summary>
        /// 消息接受回调处理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ReceivedHandler(object sender, MqttMsgPublishEventArgs e)
        {
            string msg = System.Text.Encoding.UTF8.GetString(e.Message);
            if (e.Topic == ClientId || e.Topic == $"{ClientId}/Heartbeat")
            {
                ReceiveHeartbeat?.Invoke(msg);
                return;
            }
            ReceiveMsgHandler(msg);
        }

        /// <summary>
        /// 消息接受回调处理
        /// </summary>
        /// <param name="msg"></param>
        private void ReceiveMsgHandler(string msg)
        {
            try
            {
                var message = msg.Str2Obj<WeMessage>();
                if (message != null)
                {
                    switch (message.Type)
                    {
                        case MessageType.Start:
                            ReceiveStart?.Invoke(message);
                            break;
                        case MessageType.End:
                            ReceiveEnd?.Invoke(message);
                            break;
                        case MessageType.RunningInfo:
                            ReceiveRunningInfo?.Invoke(message);
                            break;
                        case MessageType.RoundScore:
                            ReceiveRoundScore?.Invoke(message);
                            break;
                        case MessageType.SceneInfo:
                            ReceiveScene?.Invoke(message);
                            break;
                        case MessageType.GuideInfo:
                            ReceiveGuide?.Invoke(message);
                            break;
                        case MessageType.Environment:
                            ReceiveEnvironment?.Invoke(message);
                            break;
                        case MessageType.CommandMatchSuccess:
                            ReceiveMatchSuccess?.Invoke(message);
                            break;
                        case MessageType.CommonMessage:
                            ReceiveCommonMsg?.Invoke(message);
                            break;
                    }
                }
                else
                {
                    ReceiveError?.Invoke(msg);
                    LogHelper.LogError("MSG ERROR:" + msg);
                }
            }
            catch (Exception e)
            {
                LogHelper.LogError(e);
            }

        }


    }

    public class MsgClientDto
    {
        public string AppId { get; set; }
        public string Name { get; set; }
        public string SecretKey { get; set; }
        public string ServerIp { get; set; }
        public int ServerPort { get; set; }
    }

    public enum MessageType
    {
        /// <summary>
        /// 内部消息
        /// </summary>
        InternalMessage,
        /// <summary>
        /// 开始运行
        /// </summary>
        Start,
        /// <summary>
        /// 结束运行
        /// </summary>
        End,
        /// <summary>
        /// 运行信息
        /// </summary>
        RunningInfo,
        /// <summary>
        /// 轮次评分
        /// </summary>
        RoundScore,
        /// <summary>
        /// 情景信息
        /// </summary>
        SceneInfo,
        /// <summary>
        /// 环境信息
        /// </summary>
        Environment,
        /// <summary>
        /// 引导信息
        /// </summary>
        GuideInfo,
        /// <summary>
        /// 指令成功消息
        /// </summary>
        CommandMatchSuccess,
        /// <summary>
        /// 普通消息
        /// </summary>
        CommonMessage,


    }

    public class WeMessage
    {
        public WeMessage()
        {
            Id = $"IWB-{DateTime.Now:MMddHHmmssffff}{new Random(1000).Next(1000, 9999)}";
            SendCount = 0;
            LastSendDateTime = DateTime.Now;
            IsReSend = false;
        }
        public WeMessage(string msg) : this()
        {
            Content = msg;
        }
        public WeMessage(MessageType type, string msg) : this(msg)
        {
            Type = type;
        }
        public WeMessage(MessageType type, string runningId, string targetClientId, string msg) : this(msg)
        {
            Type = type;
            TargetClientId = targetClientId;
            RunningId = runningId;
        }

        public string RunningId { get; set; }
        [Newtonsoft.Json.JsonIgnore()]
        public string TargetClientId { get; set; }

        public MessageType Type { get; set; }
      
        public string Id { get; set; }
        public string Content { get; set; }
        [Newtonsoft.Json.JsonIgnore()]
        public int SendCount { get; set; }
        [Newtonsoft.Json.JsonIgnore()]
        public DateTime LastSendDateTime { get; set; }
        [Newtonsoft.Json.JsonIgnore()]
        public bool IsReSend { get; set; }
    }
}