FISLib_Old/Vinno.vCloud.Common.FIS/Chat/ChatConnectionKeeper.cs

using System;
using System.Threading;
using System.Threading.Tasks;
using Vinno.IUS.Common.Log;
using Vinno.IUS.Common.Network.Leaf;
using Vinno.IUS.Common.Network.Tcp;
using Vinno.IUS.Common.Network.Transfer;
using Vinno.vCloud.Protocol.Messages.Client;
using Vinno.vCloud.Protocol.Messages.Live;

namespace Vinno.vCloud.Common.FIS.Chat
{
    class ChatConnectionKeeper
    {
        private ClientLeaf _clientLeaf;
        private string _roomId;
        private string _accountId;
        private bool _stopped;
        private int _heartBeatInterval = 2;
        private bool _heartBeatAlive;
        private double _chechInterminal = 3;
        private readonly ManualResetEvent _waitEvent = new ManualResetEvent(false);

        /// <summary>
        /// The envent connection off line when a wrong eche result happened
        /// </summary>
        public event EventHandler Offlined;

        /// <summary>
        /// Raised when the client leaf closed or not online.
        /// </summary>
        public event EventHandler ClientLeafClosed;

        /// <summary>
        /// Gets the value to indicate the heart beat is alive or not.
        /// </summary>
        public bool HeartBeatAlive => _heartBeatAlive;

        public ChatConnectionKeeper(string roomId, string accountId, string liveServiceUrl)
        {
            if (string.IsNullOrEmpty(liveServiceUrl))
            {
                throw new ArgumentNullException("Url");
            }

            var args = liveServiceUrl.Split(':');
            var host = args[0];
            var port = Convert.ToInt32(args[1]);
            var tcpCreator = new TcpCreator(host, port);
            var rtyCount = 0;
            Logger.WriteLineInfo("Start To Create Client Leaf for ChatConnectionKeeper");
            _clientLeaf = new ClientLeaf(new LeafIdContext(), LeafMode.Dual, tcpCreator);
            Logger.WriteLineInfo("Create Client Leaf End for ChatConnectionKeeper");
            while (!_clientLeaf.Online && rtyCount < 1)
            {
                _clientLeaf.Close();
                Logger.WriteLineError($"Chat connectionKeeper create leaf offline! url:{liveServiceUrl}, Retry Count {rtyCount}");
                rtyCount++;
                Thread.Sleep(10);
                Logger.WriteLineInfo("Start To Create Client Leaf for ChatConnectionKeeper");
                _clientLeaf = new ClientLeaf(new LeafIdContext(), LeafMode.Dual, tcpCreator);
                Logger.WriteLineInfo("Create Client Leaf End for ChatConnectionKeeper");
            }
            if (!_clientLeaf.Online)
            {
                Logger.WriteLineError($"Chat connectionKeeper create leaf offline! url:{liveServiceUrl}, Retry Count {rtyCount}");
            }
            else
            {
                Logger.WriteLineInfo($"Chat connectionKeeper create leaf online! url:{liveServiceUrl}, Retry Count {rtyCount}");
            }
            _roomId = roomId;
            _accountId = accountId;
        }

        /// <summary>
        /// Start the Heartrate to keep the session available.
        /// </summary>
        public async void Start(bool isDelay = true)
        {
            _stopped = false;
            Logger.WriteLineInfo($"Chat connection keeper is started for room: {_roomId}, isDelay{isDelay}");
            if (isDelay)
            {
                await Task.Delay(5000);
            }
            DoCheck();
        }

        /// <summary>
        /// Stop the Heartrate
        /// </summary>
        public void Stop()
        {
            _stopped = true;
            _waitEvent.Set();
            Logger.WriteLineInfo($"Chat connection keeper is stopped for room: {_roomId}");
            if (_clientLeaf != null)
            {
                _clientLeaf.Close();
                _clientLeaf = null;
            }
        }

        private void DoCheck()
        {
            Task.Run(new Action(ExecuteDoCheck));
        }

        private void ExecuteDoCheck()
        {
            try
            {
                using (var message = new LiveHeartRateRequest())
                {
                    message.RoomId = _roomId;
                    message.SubscriberId = _accountId;

                    var result = _clientLeaf.Send(message);
                    var shouldStop = false;
                    if (result == null)
                    {
                        Logger.WriteLineError($"ChatConnectionKeeper Offlined occurred since result null");
                        shouldStop = true;
                    }
                    else
                    {
                        var messageResult = ResultMessage.Convert(result);
                        if (messageResult == CCR.OK)
                        {
                            _heartBeatInterval = 2;
                            _heartBeatAlive = true;
                        }
                        else
                        {
                            Logger.WriteLineInfo($"ChatConnectionKeeper Offline occurred sinc none ok result.roomid: {_roomId}, subscriberid:{_accountId}, " +
                               $"message result: {result?.ToString()}, {result?.GetType()}");
                            shouldStop = true;
                        }
                    }

                    if (shouldStop)
                    {
                        if (_clientLeaf.Online)
                        {
                            _clientLeaf.Close();
                        }
                        if (!_stopped)
                        {
                            Logger.WriteLineInfo($"ChatConnectionKeeper Offlined called since shouldStop");
                            //Do offline when server has no current chat room
                            OnOfflined();
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"ChatConnection keeper ExecuteDoCheck error:{ex}");
                _heartBeatAlive = false;
                if (!_stopped && _clientLeaf != null)
                {
                    if (_clientLeaf.IsClosed || !_clientLeaf.Online)
                    {
                        if (_heartBeatInterval == 2)
                        {
                            ClientLeafClosed.Invoke(this, null);
                            return;
                        }
                    }
                    else
                    {
                        if (_heartBeatInterval <= 0)
                        {
                            OnOfflined();
                            return;
                        }
                    }
                    _heartBeatInterval--;
                }
            }
            if (!_stopped)
            {
                _waitEvent.WaitOne(TimeSpan.FromSeconds(_chechInterminal));
                if (!_stopped)
                {
                    if (_chechInterminal == 0)
                    {
                        _chechInterminal = 3;
                    }
                    DoCheck();
                }
            }
        }

        private void OnOfflined()
        {
            Logger.WriteLineInfo($"ChatConnection keeper is offline");
            Offlined?.Invoke(this, EventArgs.Empty);
        }
    }
}