FISLib_Old/Vinno.vCloud.Common.FIS/Consultation/ConsultationClientV2.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Vinno.IUS.Common.Log;
using Vinno.vCloud.Common.FIS.Helper;
using Vinno.vCloud.FIS.CrossPlatform.Common;
using Vinno.vCloud.FIS.CrossPlatform.Common.Consultation;
using Vinno.vCloud.FIS.CrossPlatform.Common.Enum;
using Vinno.vCloud.Protocol.Infrastructures;
using WingInterfaceLibrary.Interface;
using WingInterfaceLibrary.LiveConsultation;

namespace Vinno.vCloud.Common.FIS.Consultation
{
    internal abstract class ConsultationClientV2 : IDisposable
    {
        private ConsultationInfo _consultationInfo;
        private double _usInkCanvasWidth = 800;
        private double _usInkCanvasHeight = 600;
        private double _flyinsonoWidth = 10000;
        private double _flyinsonoHeight = 10000;
        private List<string> _muteVideoUserList;
        private readonly object _interactiveBoardLocker = new object();
        protected Dictionary<string, List<StrokePointList>> StrokeDict = new Dictionary<string, List<StrokePointList>>();
        protected readonly object ConsultationInfoLocker = new object();
        protected readonly ILiveConsultationService LiveConsultationService;
        protected readonly IUserService UserService;
        protected readonly IDeviceService DeviceService;
        protected string AccountId;
        protected string AccountToken;
        protected string AccountName;
        protected bool IsOnlyForRtmpPushing;
        protected int count = 0;
        protected ConsultationLiveVideoProviderV2 VideoProvider { get; }

        protected ConsultationManagerV2 ConsultationManager { get; }

        public bool IsSecondViewMode { get; protected set; }

        /// <summary>
        /// Gets or sets the current live status
        /// </summary>
        public LiveStates CurrentLiveStatus { get; set; }

        /// <summary>
        /// Raised when meeting disconnected.
        /// </summary>
        public event EventHandler<ConsultationDisconnectedType> ConsultationDisconnected;

        /// <summary>
        /// Raised when meeting member changed
        /// </summary>
        public event EventHandler<ConsultationMemberNotificaiton> ConsultationMemberChangedNotificationArrived;

        /// <summary>
        /// 接收到其他用户的白板信息
        /// </summary>
        public event EventHandler<InteractiveBoardInfo> InteractiveBoardInfoArrived;

        /// <summary>
        /// 接收到清除白板信息
        /// </summary>
        public event EventHandler<string> ClearInteractiveBoardArrived;

        public event EventHandler<List<string>> MuteVideoUserListNotifyArrived;

        public ConsultationInfo ConsultationInfo
        {
            get => _consultationInfo;
            set
            {
                if (_consultationInfo != value)
                {
                    _consultationInfo = value;
                    count = 0;
                }
            }
        }

        protected ConsultationClientV2(ConsultationLiveVideoProviderV2 videoProvider, ConsultationManagerV2 consultationManager, ILiveConsultationService liveConsultationService, IUserService userService, IDeviceService deviceService)
        {
            _muteVideoUserList = new List<string>();
            LiveConsultationService = liveConsultationService;
            UserService = userService;
            DeviceService = deviceService;
            CurrentLiveStatus = LiveStates.Idle;
            ConsultationManager = consultationManager;
            VideoProvider = videoProvider;
            VideoProvider.RemoteUserLeaveRoomArrived += OnRemoteUserLeaveRoomArrived;
            VideoProvider.CloseConsultation += OnCloseMeeting;
            VideoProvider.TryToReconnect += OnTryToReconnect;
        }

        protected void OnTryToReconnect(object sender, EventArgs e)
        {
        }

        private void OnRemoteUserLeaveRoomArrived(object sender, RemoteUserLeaveRoomArgs e)
        {
        }

        private void OnCloseMeeting(object sender, EventArgs e)
        {
            OnDisconnected(ConsultationDisconnectedType.SelfClientOffline);
        }

        protected void OnDisconnected(ConsultationDisconnectedType e)
        {
            try
            {
                StopConsultation();
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Consultationclient- error happended while disconnectting: {ex}");
            }
            finally
            {
                if (!IsOnlyForRtmpPushing)
                {
                    ConsultationDisconnected?.Invoke(this, e);
                }
                lock (ConsultationInfoLocker)
                {
                    Logger.WriteLineInfo($"Current consultation info is set to null on reson: {e}");
                    ConsultationInfo = null;
                }
                lock (_interactiveBoardLocker)
                {
                    StrokeDict.Clear();
                }
                CurrentLiveStatus = LiveStates.Disconnected;
            }
        }

        protected void StopConsultation()
        {
            var isMeetting = CurrentLiveStatus == LiveStates.RecipientAcceptted || CurrentLiveStatus == LiveStates.RecipientAcceptting;
            if (isMeetting)
            {
                VideoProvider.Hangup();
                CurrentLiveStatus = LiveStates.Idle;
            }
            else
            {
                Logger.WriteLineInfo($"Don't do stop consultation video since no rtc consultation is not started");
            }
        }

        protected void StartConsultation(string cameraHardwareId, string micHardwareId, string speakerHardwareId, bool isOnlyForRtmpPushing)
        {
            try
            {
                VideoProvider.StartConsultationVideo(ConsultationInfo, AccountId, AccountName, AccountToken, cameraHardwareId, micHardwareId, speakerHardwareId, isOnlyForRtmpPushing);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"Error happened while start meeting {ex}");
            }
        }

        public ResultInfoDTO Hangup(bool isFakeHangup = false)
        {
            try
            {
                if (ConsultationInfo == null)
                {
                    Logger.WriteLineWarn($"ConsultationHangup Fail: Current is not Consultating");
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = "ConsultationHangup Fail: Current is not Consultating"
                    };
                }
                if (isFakeHangup)
                {
                    lock (ConsultationInfoLocker)
                    {
                        ConsultationInfo = null;
                        _muteVideoUserList.Clear();
                    }
                    lock (_interactiveBoardLocker)
                    {
                        StrokeDict.Clear();
                    }
                    return new ResultInfoDTO
                    {
                        IsSuccess = true,
                    };
                }
                var leaveLiveConsultationRequest = new LeaveLiveConsultationRequest
                {
                    ConsultationCode = ConsultationInfo?.ConsultationId,
                    Token = AccountToken,
                };
                var leaveResult = JsonRpcHelper.LeaveLiveConsultation(LiveConsultationService, leaveLiveConsultationRequest);
                if (leaveResult == null || leaveResult.ConsultationCode != ConsultationInfo?.ConsultationId)
                {
                    Logger.WriteLineError($"Hangup Fail, leaveResult.ConsultationCode is {leaveResult?.ConsultationCode}");
                }
                lock (ConsultationInfoLocker)
                {
                    ConsultationInfo = null;
                    _muteVideoUserList.Clear();
                }
                lock (_interactiveBoardLocker)
                {
                    StrokeDict.Clear();
                }
                StopConsultation();
                CurrentLiveStatus = LiveStates.ChatHangup;
                Logger.WriteLineInfo($"ConsultationLive-- {AccountName} hangup end with result {CurrentLiveStatus}");
                return new ResultInfoDTO
                {
                    IsSuccess = true,
                };
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"ConsultationHangup error: {ex}");
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = $"ConsultationHangup Fail: {ex}"
                };
            }
            finally
            {
                IsOnlyForRtmpPushing = false;
                IsSecondViewMode = false;
            }
        }

        protected virtual void HandleConsultationMemberNotificationArrived(ConsultationMemberNotificaiton consultationMemberNotificaiton)
        {
            ConsultationMemberChangedNotificationArrived?.Invoke(this, consultationMemberNotificaiton);
        }

        protected void ConsultationMemberChange(ConsultationMemberChangeDTO meetingChangeMember)
        {
            VideoProvider.ConsultationMemberChange(meetingChangeMember);
        }

        internal ResultInfoDTO ReceiveWhiteBoardData(WhiteBoardDataDTO whiteBoardDataDTO)
        {
            if (whiteBoardDataDTO == null)
            {
                Logger.WriteLineError($"ReceiveWhiteBoardData Error:Args is invalid");
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = "Args is invalid",
                };
            }
            if (string.IsNullOrEmpty(whiteBoardDataDTO.UserId))
            {
                Logger.WriteLineError($"ReceiveWhiteBoardData Error:Args:UserId is empty");
                return new ResultInfoDTO
                {
                    IsSuccess = false,
                    FailMessage = "Args:UserId is empty",
                };
            }
            if (whiteBoardDataDTO.IsClear == "true")
            {
                lock (_interactiveBoardLocker)
                {
                    if (StrokeDict.ContainsKey(whiteBoardDataDTO.UserId))
                    {
                        StrokeDict.Remove(whiteBoardDataDTO.UserId);
                    }
                    InteractiveBoardInfoArrived?.Invoke(this, new InteractiveBoardInfo(whiteBoardDataDTO.UserId, AccountId, null, ""));
                }
                return new ResultInfoDTO
                {
                    IsSuccess = true
                };
            }
            else
            {
                if (uint.TryParse(whiteBoardDataDTO.Color, out var color))
                {
                    if (whiteBoardDataDTO.Points.Length % 8 != 0)
                    {
                        Logger.WriteLineError($"ReceiveWhiteBoardData Error:Args:Point is invalid,is not divisible by 8");
                        return new ResultInfoDTO
                        {
                            IsSuccess = false,
                            FailMessage = "Args:Point is invalid,is not divisible by 8",
                        };
                    }
                    List<StrokePointList> strokePointLists;
                    var strokePointList = ConvertToSrokePointList(whiteBoardDataDTO.Points);
                    if (strokePointList != null)
                    {
                        lock (_interactiveBoardLocker)
                        {
                            if (StrokeDict.ContainsKey(whiteBoardDataDTO.UserId))
                            {
                                StrokeDict[whiteBoardDataDTO.UserId].Add(strokePointList);
                            }
                            else
                            {
                                StrokeDict[whiteBoardDataDTO.UserId] = new List<StrokePointList>
                                {
                                    strokePointList
                                };
                            }
                            strokePointLists = StrokeDict[whiteBoardDataDTO.UserId].ToList();
                        }
                        if (CrossPlatformHelper.Instance.Platform == EnumPlatform.Windows)
                        {
                            var jsonData = CrossPlatformHelper.Instance.StrokeHelper.GetStrokeJson(strokePointLists, color);
                            InteractiveBoardInfoArrived?.Invoke(this, new InteractiveBoardInfo(whiteBoardDataDTO.UserId, AccountId, null, jsonData));
                            return new ResultInfoDTO
                            {
                                IsSuccess = true,
                            };
                        }
                        else
                        {
                            var strokePointsInfo = new StrokePointsInfo(color, strokePointLists);
                            var jsonData = JsonSerializer.Serialize(strokePointsInfo);
                            InteractiveBoardInfoArrived?.Invoke(this, new InteractiveBoardInfo(whiteBoardDataDTO.UserId, AccountId, null, jsonData));
                            return new ResultInfoDTO
                            {
                                IsSuccess = true,
                            };
                        }
                    }
                    else
                    {
                        Logger.WriteLineError($"ReceiveWhiteBoardData Error:Args is invalid");
                        return new ResultInfoDTO
                        {
                            IsSuccess = false,
                            FailMessage = "Args is invalid",
                        };
                    }
                }
                else
                {
                    Logger.WriteLineError($"ReceiveWhiteBoardData Error:Args:Color is invalid");
                    return new ResultInfoDTO
                    {
                        IsSuccess = false,
                        FailMessage = "Args:Color is invalid",
                    };
                }
            }
        }

        private StrokePointList ConvertToSrokePointList(string pointstring)
        {
            try
            {
                List<StrokePoint> pointsList = new List<StrokePoint>();
                for (int i = 0; i < pointstring.Length; i += 8)
                {
                    var xString = pointstring.Substring(i, 4);
                    var yString = pointstring.Substring(i + 4, 4);
                    var xBeforeAdjust = double.Parse(xString);
                    var yBeforeAdjust = double.Parse(yString);
                    var xAfterAdjust = xBeforeAdjust / _flyinsonoWidth * _usInkCanvasWidth;
                    var yAfterAdjust = yBeforeAdjust / _flyinsonoHeight * _usInkCanvasHeight;
                    pointsList.Add(new StrokePoint(xAfterAdjust, yAfterAdjust));
                }
                return new StrokePointList() { StrokePoints = pointsList };
            }
            catch (Exception ex)
            {
                Logger.WriteLineError($"ConvertToSrokePointList Error:{ex}");
                return null;
            }
        }

        internal ResultInfoDTO SwitchVideoPlay(string userId, bool isVideoOpen)
        {
            var existUser = ConsultationInfo?.ConsultationMemberInfos?.FirstOrDefault(x => x.Id == userId);
            if (existUser != null)
            {
                if (isVideoOpen)
                {
                    if (_muteVideoUserList.Contains(userId))
                    {
                        _muteVideoUserList.Remove(userId);
                        MuteVideoUserListNotifyArrived?.Invoke(this, _muteVideoUserList.ToList());
                    }
                }
                else
                {
                    if (!_muteVideoUserList.Contains(userId))
                    {
                        _muteVideoUserList.Add(userId);
                        MuteVideoUserListNotifyArrived?.Invoke(this, _muteVideoUserList.ToList());
                    }
                }
            }
            return new ResultInfoDTO
            {
                IsSuccess = true,
            };
        }

        public virtual void Dispose()
        {
            VideoProvider.RemoteUserLeaveRoomArrived -= OnRemoteUserLeaveRoomArrived;
            VideoProvider.CloseConsultation -= OnCloseMeeting;
            VideoProvider.TryToReconnect -= OnTryToReconnect;
        }
    }
}