JXSoftTools/Assets/MsgTransmitTools/src/DataEventModel.cs

using System;
using System.Collections;
using System.Collections.Generic;
using QFrameworkCP;
using UnityEngine;
using UnityEngine.Events;


namespace JXSoft { 
    //任何通讯类围绕DataEventModel进行
    public abstract class DataEventModel : AbstractModel
    {
        public IOCContainer mCommandContainer = new IOCContainer();
        public UnityStringEvent onDataRecived = new UnityStringEvent();
        public Color printColor = Color.white;
        private int linkStatus = 0;

        #region ReceiveFunctions
        public void sendResponseCommand<T>(string json) where T : IResponse, new()
        {
            //如果找不到对应命令，则添加命令
            if (mCommandContainer.Get<ExcuteResponseCommand<T>>() == null)
            {
                mCommandContainer.Register(new ExcuteResponseCommand<T>(new T()));
            }
            //找到命令后添加命令
            mCommandContainer.Get<ExcuteResponseCommand<T>>().setJson(json);
            this.SendCommand(mCommandContainer.Get<ExcuteResponseCommand<T>>());
        }
        /// <summary>
        /// 开启接收指定数据
        /// </summary>
        /// <typeparam name="T">数据格式类型</typeparam>
        public void onReceive<T>() where T : IResponse, new()
        {
            onDataRecived.AddListener(sendResponseCommand<T>);
        }
        /// <summary>
        /// 关闭接收指定数据
        /// </summary>
        /// <typeparam name="T">数据格式类型</typeparam>
        public void offReceive<T>() where T : IResponse, new()
        {
            onDataRecived.RemoveListener(sendResponseCommand<T>);
        }
        #endregion

        #region RequestFunctions
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="request">请求数据</param>
        public void sendRequestCommand<T>(T request) where T : IRequest
        {
            if (mCommandContainer.Get<SendRequestCommand<T>>() == null)
            {
                mCommandContainer.Register(new SendRequestCommand<T>(request));
            }
            mCommandContainer.Get<SendRequestCommand<T>>().setRequest(request);
            this.SendCommand(mCommandContainer.Get<SendRequestCommand<T>>());
        }
        #endregion

        #region LinkStatusManage
        public virtual void setLinkStatus(int linkStatus) {
            this.linkStatus = linkStatus;
            this.SendEvent(new LinkStateChangedEvent(linkStatus));
        }

        public virtual int getLinkStatus() {
            return linkStatus;
        }
        #endregion
    }

    #region Command
    /// <summary>
    /// 处理响应数据，添加对应的Command进行处理，需要提前生成命令池
    /// </summary>
    /// <typeparam name="TResponse">响应数据格式</typeparam>
    public class ExcuteResponseCommand<TResponse> : AbstractCommand where TResponse : IResponse
    {
        public string json;
        private TResponse response;
        private Color printColor = Color.white;
        public ExcuteResponseCommand(TResponse response)
        {
            if (this.response == null)
            {
                this.response = response;
            }
        }
        protected override void OnExecute()
        {
            bool isSet = response.trySetData(json);
            if (isSet)
            {
                Debug.Log("Received:" + response.toJson() + response.GetType());
                this.SendEvent(new ResponseMsgEvent(response));
            }
        }
        public void setJson(string json)
        {
            this.json = json;
        }
    }

    /// <summary>
    /// 发送数据
    /// </summary>
    /// <typeparam name="TRequest">发送数据格式</typeparam>
    public class SendRequestCommand<TRequest> : AbstractCommand where TRequest : IRequest
    {
        public TRequest request;
        public SendRequestCommand(TRequest request)
        {
            this.request = request;
        }
        protected override void OnExecute()
        {
            this.SendEvent(new RequestMsgEvent(request));
        }
        public void setRequest(TRequest request)
        {
            this.request = request;
        }
    }
    #endregion

    #region interface
    public interface IResponse
    {
        string toJson();
        /// <summary>
        /// 尝试填充数据，如果json不合法，则返回false，忽略该条数据响应
        /// </summary>
        /// <param name="json"></param>
        /// <returns></returns>
        bool trySetData(string json);
        string getException();
    }

    public interface IRequest
    {
        string toJson();
    }
    #endregion

    #region AbstractClass
    /// <summary>
    /// 使用抽象类时，必须满足可序列化
    /// </summary>
    [Serializable]
    public abstract class AbstractResponse : IResponse
    {
        private string exceptionMsg;
        public virtual string toJson()
        {
            return JsonUtility.ToJson(this, true);
        }
        public virtual bool trySetData(string json)
        {
            try
            {
                JsonUtility.FromJsonOverwrite(json, this);
                return true;
            }
            catch (Exception e)
            {
                exceptionMsg = e.ToString();
                return false;
            }
        }
        public string getException()
        {
            return exceptionMsg;
        }
    }
    #endregion

    #region event
    public struct ResponseMsgEvent
    {
        public IResponse res;
        public ResponseMsgEvent(IResponse res_)
        {
            res = res_;
        }
    };
    public struct RequestMsgEvent
    {
        public IRequest req;
        public RequestMsgEvent(IRequest req_)
        {
            req = req_;
        }
    }
    public struct LinkStateChangedEvent {
        public int linkState;
        public LinkStateChangedEvent(int linkState_) {
            linkState = linkState_;
        }
    }
    #endregion

    [Serializable]
    public class UnityStringEvent : UnityEvent<string>
    {

    }
}