BITKit/Packages/Runtime~/Core/Net/NetProvider.cs

/*
 * 该接口为基础的网络接口，包括了网络服务，服务端接口，客户端接口的基本定义 e.g.
 * ⭐INetProvider    网络服务接口的基本定义
 * ⭐INetServer      服务端接口的基本定义
 * ⭐INetClient      客户端接口的基本定义
 */

using System;
using Cysharp.Threading.Tasks;
#if UNITY
using UnityEngine;
#endif

namespace BITKit
{
    /// <summary>
    /// 网络指令类型
    /// </summary>
    public enum NetCommandType:byte
    {
        Undefined=0,
        Command=1,
        TargetCommand=2,
        File=3,
        Rpc=4,
        AllClientCommand=5,
    }
    /// <summary>
    /// 网络提供服务，包括了基础网络服务，e.g
    /// ⭐向服务器发送指令
    /// ⭐向所有客户端发送指令
    /// ⭐向单个客户端发送指令
    /// ⭐监听与取消监听网络命令
    /// ⭐从服务器获取数据
    /// ⭐从客户端获取数据
    /// ⭐添加Rpc处理服务
    /// ⭐向服务器发送Rpc
    /// ⭐向所有客户端发送Rpc
    /// </summary>
    public interface INetProvider
    {
        /// <summary>
        /// 向服务端发送指令
        /// </summary>
        /// <typeparam name="T">远程指令类型</typeparam>
        void ServerCommand<T>(T command = default);

        /// <summary>
        /// 向所有客户端发送指令
        /// </summary>
        /// <typeparam name="T">远程指令类型</typeparam>
        void RpcClientCommand<T>(T command = default);

        /// <summary>
        /// 向单个客户端发送指令
        /// </summary>
        /// <param name="id">客户端ID</param>
        /// <param name="command">指令实例</param>
        /// <typeparam name="T">远程指令类型</typeparam>
        void ClientCommand<T>(int id, T command);

        /// <summary>
        /// 从服务端获取数据
        /// </summary>
        /// <param name="addressablePath">可寻址路劲 e.g. Key</param>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        UniTask<T> GetFromServer<T>(string addressablePath = Constant.System.Internal);

        /// <summary>
        /// 从客户端获取数据
        /// </summary>
        /// <param name="id">客户端ID</param>
        /// <param name="addressablePath">可寻址路劲 e.g. Key</param>
        /// <typeparam name="T">远程指令类型</typeparam>
        /// <returns></returns>
        UniTask<T> GetFromClient<T>(int id, string addressablePath = Constant.System.Internal);

        /// <summary>
        /// 添加RPC远程服务，服务类型为需要的方法标记[RPC]
        /// </summary>
        /// <param name="rpcHandle">RPC服务实例</param>
        void AddRpcHandle(object rpcHandle);

        /// <summary>
        /// 监听远程指令
        /// </summary>
        /// <param name="handle">远程指令回调</param>
        /// <typeparam name="T">远程指令类型</typeparam>
        void AddCommandListener<T>(Action<T> handle);

        /// <summary>
        /// 取消监听远程指令
        /// </summary>
        /// <param name="handle">远程指令回调</param>
        /// <typeparam name="T">远程指令类型</typeparam>
        void RemoveCommandListener<T>(Action<T> handle);

        /// <summary>
        /// 向服务端发送Rpc
        /// </summary>
        /// <param name="rpcName">RPC名称</param>
        /// <param name="pars">RPC参数</param>
        void SendRT(string rpcName, params object[] pars);

        /// <summary>
        /// 向指定客户端发送Rpc
        /// </summary>
        /// <param name="id">远程客户端Id</param>
        /// <param name="rpcName">RPC名称</param>
        /// <param name="pars">RPC参数</param>
        void SendTargetRT(int id, string rpcName, params object[] pars);

        /// <summary>
        /// 向所有客户端发送Rpc
        /// </summary>
        /// <param name="rpcName">RPC名称</param>
        /// <param name="pars">RPC参数</param>
        void SendAllRT(string rpcName, params object[] pars);
    }

    /// <summary>
    /// 服务端接口，支持服务端的基本功能
    /// ⭐开启服务器(支持指定端口)
    /// ⭐停止服务器
    /// ⭐服务器运行状态
    /// </summary>
    public interface INetServer
    {
        /// <summary>
        /// 回调:当客户端连接时
        /// </summary>
        public event Action<int> OnClientConnect;

        /// <summary>
        /// 回调:当客户端断开连接时
        /// </summary>
        public event Action<int> OnClientDisconnected;
        /// <summary>
        /// 开启服务端的回调
        /// </summary>
        public event Action OnStartServer;
        /// <summary>
        /// 关闭服务端的回调
        /// </summary>
        public event Action OnStopServer; 

        /// <summary>
        /// 运行服务端
        /// </summary>
        /// <param name="port">端口，默认为27014</param>
        void StartServer(ushort port = 27014);

        /// <summary>
        /// 停止服务端
        /// </summary>
        /// <param name="dispose">可选参数：强行释放，默认为false</param>
        void StopServer(bool dispose=false);

        /// <summary>
        /// (只读)服务器是否正在运行
        /// </summary>
        bool IsRunningServer { get; }
    }
    /// <summary>
    /// 基本网络客户端的接口定义,包括了基本客户端的功能
    /// ⭐基本客户端回调
    /// ⭐是否已连接到服务器
    /// ⭐连接服务端的延迟
    /// ⭐客户端Id
    /// ⭐开启客户端
    /// ⭐关闭客户端
    /// </summary>
    public interface INetClient
    {
        //基本客户端回调
        public event Action OnStartConnect;
        public event Action OnConnected;
        public event Action OnDisconnected;
        public event Action OnConnectedFailed;
        /// <summary>
        /// 是否已连接到服务端
        /// </summary>
        bool IsConnected { get; }
        /// <summary>
        /// 连接服务端的延迟
        /// </summary>
        int Ping { get; }
        /// <summary>
        /// 客户端Id
        /// </summary>
        int Id { get; }
        /// <summary>
        /// 断开链接
        /// </summary>
        void Disconnect();
        /// <summary>
        /// 异步开始链接
        /// </summary>
        /// <param name="address">服务端地址</param>
        /// <param name="port">端口</param>
        /// <returns></returns>
        UniTask<bool> Connect(string address = "localhost", ushort port = 27014);
    }

#if UNITY
    /// <summary>
    /// 有关NetProvider的Unity代理
    /// </summary>
    [Serializable]
    public class NetProviderProxy : INetProvider
    {
        [SerializeField] private MonoBehaviour monoBehaviour;
        INetProvider netProvider => monoBehaviour as INetProvider;
        void INetProvider.ServerCommand<T>(T command) => netProvider.ServerCommand(command);
        void INetProvider.RpcClientCommand<T>(T command) => netProvider.RpcClientCommand(command);
        void INetProvider.ClientCommand<T>(int id, T command) => netProvider.ClientCommand(id, command);

        async UniTask<T> INetProvider.GetFromServer<T>(string addressablePath) =>
            await netProvider.GetFromServer<T>(addressablePath);

        UniTask<T> INetProvider.GetFromClient<T>(int id, string addressablePath) =>
            netProvider.GetFromClient<T>(id, addressablePath);

        void INetProvider.AddRpcHandle(object rpcHandle) => netProvider.AddRpcHandle(rpcHandle);

        void INetProvider.AddCommandListener<T>(Action<T> handle) => netProvider.AddCommandListener<T>(handle);

        void INetProvider.RemoveCommandListener<T>(Action<T> handle) => netProvider.RemoveCommandListener<T>(handle);

        void INetProvider.SendRT(string rpcName, params object[] pars) => netProvider.SendRT(rpcName, pars);

        void INetProvider.SendTargetRT(int id, string rpcName, params object[] pars) =>
            netProvider.SendTargetRT(id, rpcName, pars);

        void INetProvider.SendAllRT(string rpcName, params object[] pars) => netProvider.SendAllRT(rpcName, pars);
    }

    /// <summary>
    /// 有关Unity的NetClient的代理
    /// </summary>
    [Serializable]
    public class GDNetClientProxy : INetClient
    {
        [SerializeField] private MonoBehaviour monoBehaviour;
        private INetClient _netClientImplementation=>monoBehaviour as INetClient;
        event Action INetClient.OnStartConnect
        {
            add => _netClientImplementation.OnStartConnect += value;
            remove => _netClientImplementation.OnStartConnect -= value;
        }

        event Action INetClient.OnConnected
        {
            add => _netClientImplementation.OnConnected += value;
            remove => _netClientImplementation.OnConnected -= value;
        }

        event Action INetClient.OnDisconnected
        {
            add => _netClientImplementation.OnDisconnected += value;
            remove => _netClientImplementation.OnDisconnected -= value;
        }

        event Action INetClient.OnConnectedFailed
        {
            add => _netClientImplementation.OnConnectedFailed += value;
            remove => _netClientImplementation.OnConnectedFailed -= value;
        }

        UniTask<bool> INetClient.Connect(string address, ushort port)
        {
            return _netClientImplementation.Connect(address, port);
        }

        bool INetClient.IsConnected => _netClientImplementation.IsConnected;

        int INetClient.Ping => _netClientImplementation.Ping;
        public int Id => _netClientImplementation.Id;
        void INetClient.Disconnect()
        {
            _netClientImplementation.Disconnect();
        }
    }
#endif
}