old_flsystem/类库/Chat.Framework/WXSdk/IPAD/ISocket.cs

using Sodao.FastSocket.Client;
using Sodao.FastSocket.Client.Messaging;
using Sodao.FastSocket.Client.Protocol;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading.Tasks;
using Chat.Framework.WXSdk.Implement;
using Sodao.FastSocket.SocketBase;
using Chat.Framework.WXSdk.Events;

namespace Chat.Framework.WXSdk.IPAD
{
    interface ISocket
    {

        FastSocketStatus Status { get; set; }


        bool Connection(List<string> host, int port);
        bool Connection(string host, int port);
        void Stop();
    }
    public enum FastSocketStatus
    {
        未连接 = 1,
        连接中 = 2,
        已连接 = 3,
        已断开 = 4
    }
    internal class FastSocket : ISocket,IDisposable
    {
        public FastSocket(WXClientImpl_IPAD client) {
            this.client = client;
        }
        WXClientImpl_IPAD client { get; set; }
        public FastSocketStatus Status { get;  set; }
        public SocketClient<WeChatMessage> WeChatClient { get; set; }
        public void Stop()
        {
            try
            {
                Status = FastSocketStatus.未连接;
                if (WeChatClient != null)
                {
                    WeChatClient.ReceivedNotifyMessage -= WeChatClient_ReceivedNotifyMessage;
                    WeChatClient.ReceivedUnknowMessage -= WeChatClient_ReceivedUnknowMessage;
                    this.WeChatClient.UnRegisterEndPoint("WeChat");
                    this.WeChatClient.Stop();
                    this.WeChatClient = null;
                }
            }
            catch { }
        }

        public bool Connection(List<string> host, int port)
        {
            try
            {
                this.Stop();
                //先不改了 - -5s
                WeChatClient = new SocketClient<WeChatMessage>(new WeChatProtocol(), 1024, 1024, 60000, 60000);
                WeChatClient.ReceivedNotifyMessage += WeChatClient_ReceivedNotifyMessage;

                WeChatClient.ReceivedUnknowMessage += WeChatClient_ReceivedUnknowMessage;
                //绑定Unknow 未知包 异常包 事件


                List<IPEndPoint> IPEnds = new List<IPEndPoint>();
                foreach (string item in host)
                {
                    var ip = Dns.GetHostAddresses(item);
                    IPEnds.Add(new IPEndPoint(ip[0], port));
                }
                return WeChatClient.TryRegisterEndPoint("WeChat", IPEnds.ToArray(),
                  connection =>
                  {
                      var source = new TaskCompletionSource<bool>();
                      connection.Disconnected += Connection_Disconnected;//如果触发这个事件呢 你好像吧原有的事件叠加了 - -
                      //在这里绑定
                      //此包保持长链接 若链接成功后不发包 则会断开 底层socket 已处理了重连机制
                      Request<WeChatMessage> request = null;
                      if (client.Status!= WxStatus.在线 || true)//全局登录成功的标志位有么 //meijinzheli 不要改 这里是断线重连才会触发的 连接首次连接也会触发 
                      {
                          request = WeChatClient.NewRequest("noping", Util.StrToHex("00 00 00 10 00 10 00 01 00 00 00 01 00 00 00 01"), 10000,
                           //绑定异常回调
                           ex =>
                           {   //IsAsync=false时 接收超时也会触发断开链接并且重连IsAsync=ture 不会断开重连 超时？由于计算引起的？
                               //超时会自动废弃包
                               Console.WriteLine("连接失败：" + ex);
                               source.TrySetException(ex);
                               //Connection_Disconnected(connection,ex);
                               source.TrySetResult(false);

                           },

                          //绑定返回请求的回调
                          onResultMessage =>
                          {
                              Console.WriteLine("long.weixin.qq.com  Connect success!");
                              //触发此回调说明已经从底层的_receivingQueue 队列中移除了

                              //byte[] buff = onResultMessage.Msg.BaseMsg.Payloads.ToByteArray();
                              this.Status = FastSocketStatus.已连接;
                              source.TrySetResult(true);
                          });
                          connection.BeginSend(request);
                          var task = source.Task; 
                        
                          return task;
                      }
                      else
                      {
                          //这里还没改呢 - -
                          //绑定SYNC同步消息的包 你改一下，表示没看懂，你让我怎么改~ 告诉sync同步消息的包在？我知道了 - -
                          source.SetResult(true);
                          client.AsyncSyncMessage();
                          return source.Task;
                      }
                  });
            }
            catch (Exception ex)
            {
                Console.WriteLine("异常：" + ex.Message);
            }
            return false;
        }

        private void WeChatClient_ReceivedUnknowMessage(IConnection i, WeChatMessage message)
        {
            try
            {
                int Ret = Sodao.FastSocket.SocketBase.Utils.NetworkBitConverter.ToInt32(message.Msg.BaseMsg.Payloads.ToByteArray(), 18);
                Console.WriteLine("ReceivedUnknowMessage  CMD" + message.CmdID + "  异常返回Ret:" + Ret);
                if (Ret == -13 && client.Status == WxStatus.在线)
                {
                    client.ResetConnection();
                }
            }
            catch { }
        }

        private void WeChatClient_ReceivedNotifyMessage(IConnection i, WeChatMessage message)
        {
            try
            {
                switch (message.CmdID)
                {
                    case 24:
                        client.AsyncSyncMessage();
                        break;
                    case 318:
                        var data = message.Msg.BaseMsg.Payloads.ToByteArray(); //这个DATa就是一个完整的包
                        client.DecodeSecureNotifyThread(data);
                        break;
                    default:
                        Console.WriteLine("ReceivedNotifyMessage 未知 CMD:" + message.CmdID);
                        //client.WriteLog("ReceivedNotifyMessage 未知 CMD" + message.CmdID,true);
                        break;

                }
            }
            catch { }
        }

        private void Connection_Disconnected(IConnection connection, Exception ex)
        {
            Console.WriteLine("当前状态:"+Status);
            if (connection != null && Status == FastSocketStatus.已连接 )
            {
          
                Status = FastSocketStatus.已断开;
                if (client.Status == WxStatus.在线)
                {
                    client.ResetConnection();
                }
                //else
                //{
                //    client.connection_grpc();
                //}
              
            }
        }

        public bool Connection(string host, int port)
        {
            var list = new List<string>();
            list.Add(host);
            return Connection(list, port);
        }



        public void Send(Request<WeChatMessage> request)
        {
            WeChatClient.Send(request);
        }

        public void Dispose()
        {
           
        }
      

   
    }
}