WingRtcService/WingRtcService/RtcService.Live.cs

using WingServerCommon.Service;
using WingInterfaceLibrary.Internal.Interface;
using WingInterfaceLibrary.DTO.RtcRoom;
using WingInterfaceLibrary.DB.Request;
using WingInterfaceLibrary.DTO.LiveRoom;
using WingInterfaceLibrary.Internal.Request;
using WingInterfaceLibrary.Rtc;
using WingInterfaceLibrary.Enum;
using WingInterfaceLibrary.LiveConsultation;
using WingServerCommon.Interfaces.Cache;
using WingServerCommon.Utilities;
using WingServerCommon.Log;
using WingInterfaceLibrary.Request;
using Newtonsoft.Json;

namespace WingRtcService
{
    /// <summary>
    /// RTC服务
    /// </summary>
    public partial class RtcService : JsonRpcService, IRtcService
    {
        /// <summary>
        /// 获取房间详情和发送关闭推流通知给设备端
        /// </summary>
        /// <returns></returns>
        public async Task<LiveRoomDTO> GetOrCloseDeviceAsync(GetOrCloseDeviceRequest request)
        {
            var liveRoomCode = request.LiveRoomCode;
            var deviceShortCode = request.DeviceShortCode;
            var closeDevicePush = request.CloseDevicePush;
            Logger.WriteLineInfo($"RtcService GetOrCloseDeviceAsync liveRoomCode:{liveRoomCode}, deviceShortCode:{deviceShortCode}, closeDevicePush:{closeDevicePush}");

            RtcRoom room = null;
            if (!string.IsNullOrWhiteSpace(liveRoomCode))
            {
                room = _rtcRoomManager.Get(liveRoomCode, false);
            }
            else if (!string.IsNullOrWhiteSpace(deviceShortCode))
            {
                var device = await _deviceDBService.FindDeviceInfoByShortCodeAsync(deviceShortCode);
                if (device != null)
                {
                    room = _rtcRoomManager.GetInitiatingRoomByDeviceCode(device.DeviceCode, "");
                }
            }
            if (room != null && closeDevicePush && room.DeviceInfos != null && room.DeviceInfos.Any())
            {
                room.CloseDevicePushAction();
                room = _rtcRoomManager.Get(room.LiveRoomCode, false);
                await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = room });
                var syncInfo = new BaseLiveConsultationJson
                {
                    ConsultationRecordCode = room.LiveRoomCode,
                    RoomCode = room.LiveRoomCode,
                    InitatorCode = room.InitiatorCode,
                    OperatorCode = "",
                };
                await SyncToMasterAsync(SyncTypeEnum.CloseDeviceLive, room.LiveRoomCode, room.Name, syncInfo);
            }
            return await Task.FromResult<LiveRoomDTO>(room);
        }

        /// <summary>
        /// 检查关闭设备直播
        /// </summary>
        /// <returns></returns>
        public async Task CheckDeviceLiveRoomAsync(TokenRequest request)
        {
            var cacheRooms = _rtcRoomManager.GetCacheRooms();
            var deviceRooms = cacheRooms.Where(x => x.Status == LiveRoomStatus.Initiating && x.DeviceInfos.Any(u => u.Code == x.LiveRoomCode && u.Status == LiveMemberStatus.Joined))?.ToList() ?? new List<RtcRoom>();
            foreach (var room in deviceRooms)
            {
                var timeoutTime = DateTime.UtcNow.AddSeconds(-1 * (_reportStateIntervalSeconds + 60));
                if (!room.ViewerInfos.Any(x => x.LastReportTime >= timeoutTime))
                {
                    var device = room.UserInfos?.FirstOrDefault(x => x.Code == room.LiveRoomCode) ?? new LiveMemberDTO();
                    Logger.WriteLineInfo($"RtcService CheckDeviceLiveRoomAsync, roomId:{room.LiveRoomCode}, device:{device.Name}");
                    room.CloseDevicePushAction();
                    var liveRoom = _rtcRoomManager.Get(room.LiveRoomCode, false);
                    await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = liveRoom });
                }
            }
        }

        /// <summary>
        /// 创建或更新房间信息
        /// </summary>
        /// <returns></returns>
        public async Task<LiveRoomDTO> AddOrUpdateLiveRoomAsync(AddOrUpdateLiveRoomRequest request)
        {
            var req = new AddOrUpdateLiveRoomDBRequest
            {
                Data = request.LiveRoom
            };
            var roomId = await _liveRoomDBService.AddOrUpdateLiveRoomAsync(req);
            var room = _rtcRoomManager.Get(roomId, true);
            return await Task.FromResult(room);
        }

        /// <summary>
        /// 获取房间信息
        /// </summary>
        /// <returns></returns>
        public async Task<LiveRoomDTO> GetLiveRoomAsync(GetLiveRoomRequest request)
        {
            var roomId = request.LiveRoomCode;
            var room = _rtcRoomManager.Get(roomId);
            return await Task.FromResult(room);
        }

        /// <summary>
        /// 查询房间白板交互数据
        /// </summary>
        /// <returns></returns>
        public async Task<IList<LiveBoardDataDTO>> GetLiveBoardDatasAsync(GetLiveBoardDatasRequest request)
        {
            var roomId = request.LiveRoomCode;
            var room = _rtcRoomManager.Get(roomId);
            return await Task.FromResult(room?.BoardDataInfos ?? new List<LiveBoardDataDTO>());
        }

        /// <summary>
        /// 查询房间用户列表
        /// </summary>
        /// <returns></returns>
        public async Task<List<LiveConsultationMember>> GetLiveMemberInfosAsync(GetLiveMemberInfosRequest request)
        {
            var roomId = request.LiveRoomCode;
            var members = _rtcRoomManager.GetLiveMemberInfos(roomId);
            return await Task.FromResult(members);
        }

        /// <summary>
        /// 根据用户codes查询房间用户状态
        /// </summary>
        /// <returns></returns>
        public async Task<IList<LiveMemberStatusDTO>> GetLiveMemberStatusInfosAsync(GetLiveMemberStatusInfosRequest request)
        {
            var members = _rtcRoomManager.GetLiveMemberStatusInfos(request.UserCodes);
            return await Task.FromResult(members);
        }

        /// <summary>
        /// 查询正在推流的设备房间
        /// </summary>
        /// <returns></returns>
        public async Task<LiveRoomDTO> GetInitiatingRoomByDeviceCodeAsync(GetInitiatingRoomByDeviceCodeRequest request)
        {
            var deviceCode = request.DeviceCode;
            var room = _rtcRoomManager.GetInitiatingRoomByDeviceCode(deviceCode, "");
            return await Task.FromResult(room);
        }

        /// <summary>
        /// 开始直播
        /// </summary>
        /// <returns></returns>
        public async Task<LiveRoomDTO> InitiateAsync(InitiateRequest request)
        {
            var roomId = request.LiveRoomCode;
            var initiatorCode = request.InitiatorCode;
            var room = _rtcRoomManager.Get(roomId);
            
            Logger.WriteLineInfo($"RTCService InitiateAsync 1, room:{ JsonConvert.SerializeObject(room) }");
            var deviceCode = room.DeviceInfos.FirstOrDefault()?.Code ?? string.Empty;
            var existedRoom = _rtcRoomManager.GetInitiatingRoomByDeviceCode(deviceCode, room.LiveRoomCode);
            Logger.WriteLineInfo($"RTCService InitiateAsync 2, existedRoom:{JsonConvert.SerializeObject(existedRoom)}");
            var rtcRoomId = room.RtcRoomId;
            var existedLiveRooms = new List<LiveMemberDTO>();
            if (rtcRoomId == 0 || room.Status != LiveRoomStatus.Initiating)
            {
                if (existedRoom != null)
                {
                    rtcRoomId = existedRoom.RtcRoomId;
                    existedLiveRooms = existedRoom.GetRoomMemberInfos() ?? new List<LiveMemberDTO>();
                    
                    Logger.WriteLineInfo($"RTCService InitiateAsync 3, existedRoom:{JsonConvert.SerializeObject(existedRoom)}");
                }
                else
                {
                    var getRoomIdRequest = new GetRoomIdRequest
                    {
                        UniqueId = roomId
                    };
                    var getRoomIdResult = await GetRoomIdAsync(getRoomIdRequest);
                    rtcRoomId = (int)getRoomIdResult.RoomId;
                    
                    Logger.WriteLineInfo($"RTCService InitiateAsync 4, getRoomIdResult:{JsonConvert.SerializeObject(getRoomIdResult)}");
                }
            }
            var deviceTokenInfo = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => x.ClientId == deviceCode).FirstOrDefault();
            if (deviceTokenInfo != null && deviceTokenInfo.IsOnline && deviceTokenInfo.IsOldPlatform)
            {
                await _deviceForwardService.GetDeviceVideoInfosAsync(new GetDeviceVideoInfosRequest { DeviceCode = deviceCode });
            }
            var appId = TRTCHelper.GetAppId();
            room.Initiate(initiatorCode, rtcRoomId, appId, request.LoginSource, true, existedLiveRooms);
            if (room.UserInfos != null && room.UserInfos.Any())
            {
                foreach (var user in room.UserInfos)
                {
                    _rtcRoomManager.AddToCheckTimeoutSequence(roomId, user.Code, user.Name);
                }
            }
            Logger.WriteLineInfo($"RTCService InitiateAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, rtcRoomId:{room.RtcRoomId}, initiator:{room.Initiator?.Name}");
            var liveRoom = await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = room });

            var syncInfo = new InitiateLiveConsultationJson
            {
                ConsultationRecordCode = liveRoom.LiveRoomCode,
                RoomCode = liveRoom.LiveRoomCode,
                InitatorCode = initiatorCode,
                OperatorCode = initiatorCode,
                LoginSource = request.LoginSource,
                IntegerRoomId = liveRoom.RtcRoomId,
                DeviceCode = deviceCode,
                LiveMemberInfos = room.GetRoomMemberInfos(),
            };
            await SyncToMasterAsync(SyncTypeEnum.Initiate, roomId, liveRoom.Name, syncInfo);
            return liveRoom;
        }

        /// <summary>
        /// 同意
        /// </summary>
        /// <returns></returns>
        public async Task<LiveMemberDTO> AcceptAsync(AcceptRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            LiveMemberDTO accepter = null;
            if (!string.IsNullOrEmpty(request.DeviceCode))
            {
                accepter = room.AcceptDevice(request.DeviceCode, request.UserCode, new List<LiveMemberDTO>());
            }
            else
            {
                accepter = room.Accept(userCode, request.LoginSource, new List<LiveMemberDTO>());
            }
            Logger.WriteLineInfo($"RTCService AcceptAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, accepter:{accepter.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, accepter);
            await AppletLiveMemberAcceptAsync(roomId, userCode);

            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = userCode,
                LoginSource = request.LoginSource,
                LiveMemberInfos = room.GetRoomMemberInfos(),
            };
            if (!string.IsNullOrEmpty(request.DeviceCode))
            {
                syncInfo.OperatorCode = request.DeviceCode;
                syncInfo.ReferCodes = new List<string>() { request.UserCode };
                await SyncToMasterAsync(SyncTypeEnum.AcceptDevice, roomId, room.Name, syncInfo);
            }
            else
            {
                await SyncToMasterAsync(SyncTypeEnum.Accept, roomId, room.Name, syncInfo);
            }
            return accepter;
        }

        /// <summary>
        /// 拒绝
        /// </summary>
        /// <returns></returns>
        public async Task<bool> RejectAsync(RejectRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var rejecter = room.Reject(userCode);
            Logger.WriteLineInfo($"RTCService RejectAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, accepter:{rejecter.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, rejecter);

            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = userCode,
            };
            await SyncToMasterAsync(SyncTypeEnum.Reject, roomId, room.Name, syncInfo);
            return true;
        }

        /// <summary>
        /// 取消直播
        /// </summary>
        /// <returns></returns>
        public async Task<bool> CancelAsync(CancelRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            room.CancelInitiate();
            Logger.WriteLineInfo($"RTCService CancelAsync, roomId:{room.LiveRoomCode}, name:{room.Name}");
            await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = room });
            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
            };
            await SyncToMasterAsync(SyncTypeEnum.CancelInitiate, roomId, room.Name, syncInfo);
            return true;
        }

        /// <summary>
        /// 切换是否开启静音
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ChangeMuteOpenedAsync(ChangeMuteOpenedRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var liveMember = room.ChangeMuteState(userCode, request.MuteOpened);
            Logger.WriteLineInfo($"RTCService ChangeMuteOpenedAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            var syncInfo = new MuteLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
                Mute = request.MuteOpened
            };
            await SyncToMasterAsync(SyncTypeEnum.ChangeMuteState, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 切换是否开启视频
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ChangeVideoOpenedAsync(ChangeVideoOpenedRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var liveMember = room.ChangeVideoOpenState(userCode, request.VideoOpened);
            Logger.WriteLineInfo($"RTCService ChangeVideoOpenedAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            var syncInfo = new SwitchLiveConsultationVideoJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
                VideoOpend = request.VideoOpened,
            };
            await SyncToMasterAsync(SyncTypeEnum.ChangeVideoOpenState, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 离开房间
        /// </summary>
        /// <returns></returns>
        public async Task<bool> LeaveAsync(LeaveRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            LiveMemberDTO liveMember;
            if (!string.IsNullOrEmpty(request.DeviceCode))
            {
                liveMember = room.DeviceLeave(request.DeviceCode, request.UserCode);
            }
            else
            {
                liveMember = room.Leave(userCode, request.Closed);
            }
            var joindMembers = room.UserInfos.Where(x => x.Status == LiveMemberStatus.Joined)?.ToList() ?? new List<LiveMemberDTO>();
            Logger.WriteLineInfo($"RTCService LeaveAsync, closed:{request.Closed.ToString()}, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}, joinedMembers:{string.Join(";", joindMembers.Select(x => x.Name))}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            if (request.Closed)
            {
                await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = room });
                await AppletLiveMemberLeaveAsync(roomId);
            }
            var syncInfo = new LeaveLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
                Closed = request.Closed
            };
            if (!string.IsNullOrEmpty(request.DeviceCode))
            {
                //删掉超声机
                RemoveLiveMemberAsync(roomId, liveMember, room.InitiatorCode);
                Logger.WriteLineInfo($"RtcRoom LeaveAsync 1, roomId:{roomId}, room:{ JsonConvert.SerializeObject(room) }");
                room.DeviceInfos.Remove(liveMember);
                Logger.WriteLineInfo($"RtcRoom LeaveAsync 2, roomId:{roomId}, room:{ JsonConvert.SerializeObject(room) }");
                syncInfo.OperatorCode = request.DeviceCode;
                syncInfo.ReferCodes = new List<string>() { request.UserCode };
                await SyncToMasterAsync(SyncTypeEnum.LeaveDevice, roomId, room.Name, syncInfo);
            }
            else
            {
                await SyncToMasterAsync(SyncTypeEnum.Leave, roomId, room.Name, syncInfo);
            }
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 关闭直播
        /// </summary>
        /// <returns></returns>

        public async Task<bool> CloseAsync(CloseRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            room.Close();
            Logger.WriteLineInfo($"RTCService CloseAsync, roomId:{room.LiveRoomCode}, name:{room.Name}");
            await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = room });
            await AppletLiveMemberLeaveAsync(roomId);
            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
            };
            await SyncToMasterAsync(SyncTypeEnum.Close, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        private bool CloseRtcRoom(string roomId, string operatorCode)
        {
            try
            {
                var room = _rtcRoomManager.Get(roomId);
                if (room != null && room.Status == LiveRoomStatus.Initiating)
                {
                    room.Close();
                    var appletLiveMemberLeaveResult = AppletLiveMemberLeaveAsync(roomId).Result;
                    Logger.WriteLineInfo($"RTCService CloseAsync, roomId:{room.LiveRoomCode}, name:{room.Name}");
                    var updateLiveRoomResult = AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = room }).Result;
                    var syncInfo = new BaseLiveConsultationJson
                    {
                        ConsultationRecordCode = room.LiveRoomCode,
                        RoomCode = room.LiveRoomCode,
                        InitatorCode = room.InitiatorCode,
                        OperatorCode = operatorCode,
                    };
                    SyncToMasterAsync(SyncTypeEnum.Close, roomId, room.Name, syncInfo);
                }
            }
            catch (Exception ex)
            {
                Logger.WriteLineWarn($"RtcService CloseRtcRoom err, roomId:{roomId}, ex:{ex}");
            }
            return true;
        }

        /// <summary>
        /// 发送白板数据
        /// </summary>
        /// <returns></returns>
        public async Task<bool> SendBoardDataAsync(SendBoardDataRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var interactiveTime = DateTime.UtcNow;
            room.SendBoardData(userCode, request.BoardData, interactiveTime, request.IsClear);
            var syncInfo = new SendInteractiveBoardDataConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
                UserCode = userCode,
                IsClear = request.IsClear,
                BoardData = request.BoardData,
                InteractiveTime = interactiveTime,
            };
            await SyncToMasterAsync(SyncTypeEnum.SendInteractiveBoardData, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 进入房间-心跳
        /// </summary>
        /// <returns></returns>
        public async Task<bool> HeartRateJoinedAsync(HeartRateJoinRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var liveMember = room.HeartRateJoin(userCode);
            Logger.WriteLineInfo($"RTCService HeartRateJoinedAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            await AppletLiveMemberAcceptAsync(roomId, userCode);
            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
            };
            await SyncToMasterAsync(SyncTypeEnum.HeartRateJoin, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 网络质量不佳
        /// </summary>
        /// <returns></returns>
        public async Task<bool> NetworkErrorAsync(NetworkErrorRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            room.NetworkErr(userCode);
            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
            };
            await SyncToMasterAsync(SyncTypeEnum.NetworkErr, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 离开房间-心跳
        /// </summary>
        /// <returns></returns>
        public async Task<bool> HeartRateLeavedAsync(HeartRateLeavedRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var liveMember = room.HeartRateLeave(userCode);
            Logger.WriteLineInfo($"RTCService HeartRateLeavedAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = room.LiveRoomCode,
                RoomCode = room.LiveRoomCode,
                InitatorCode = room.InitiatorCode,
                OperatorCode = userCode,
            };
            await SyncToMasterAsync(SyncTypeEnum.HeartRateLeave, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }


        /// <summary>
        /// 直播中邀请
        /// </summary>
        /// <returns></returns>
        public async Task<bool> InviteInAsync(InviteInRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            room.InviteIn(userCode, request.InviteCodes);
            if (request.InviteCodes != null && request.InviteCodes.Any())
            {
                var inviteUsers = await _userDBService.FindUserListByUserCodesAsync(request.InviteCodes);
                if (inviteUsers != null && inviteUsers.Any())
                {
                    foreach (var user in inviteUsers)
                    {
                        _rtcRoomManager.AddToCheckTimeoutSequence(roomId, user.UserCode, user.DisplayName);
                    }
                }
            }
            Logger.WriteLineInfo($"RTCService InviteInAsync, roomId:{room.LiveRoomCode}, name:{room.Name},OperationCode:{userCode}, inviteCodes:{string.Join(",", request.InviteCodes)}");
            var syncInfo = new InviteInLiveConsultationJson
            {
                ConsultationRecordCode = roomId,
                RoomCode = roomId,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = userCode,
                UserCodes = request.InviteCodes.ToList(),
            };
            await SyncToMasterAsync(SyncTypeEnum.InviteIn, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 取消直播中邀请
        /// </summary>
        /// <returns></returns>
        public async Task<bool> CancelInviteInAsync(CancelInviteInRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            room.CancelInviteIn(userCode, request.InviteCodes);
            Logger.WriteLineInfo($"RTCService CancelInviteInAsync, roomId:{room.LiveRoomCode}, name:{room.Name}");
            var syncInfo = new CancelInviteInLiveConsultationJson
            {
                ConsultationRecordCode = roomId,
                RoomCode = roomId,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = userCode,
                UserCodes = request.InviteCodes.ToList(),
            };
            await SyncToMasterAsync(SyncTypeEnum.CancelInviteIn, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 直播中加入房间
        /// </summary>
        /// <returns></returns>
        public async Task<LiveMemberDTO> JoinInAsync(JoinInRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var liveMember = room.JoinIn(userCode, request.SortLevel, request.LoginSource, new List<LiveMemberDTO>());
            Logger.WriteLineInfo($"RTCService JoinInAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            var syncInfo = new JoinInConsultationJson
            {
                ConsultationRecordCode = roomId,
                RoomCode = roomId,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = userCode,
                LoginSource = request.LoginSource,
                SortLevel = request.SortLevel,
                LiveMemberInfos = room.GetRoomMemberInfos(),
            };
            await SyncToMasterAsync(SyncTypeEnum.AcceptIn, roomId, room.Name, syncInfo);
            return await Task.FromResult(liveMember);
        }

        /// <summary>
        /// 拒绝直播中邀请
        /// </summary>
        /// <returns></returns>
        public async Task<bool> RejectInviteAsync(RejectInviteRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            room.RejectIn(userCode);
            var syncInfo = new BaseLiveConsultationJson
            {
                ConsultationRecordCode = roomId,
                RoomCode = roomId,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = userCode,
            };
            await SyncToMasterAsync(SyncTypeEnum.RejectIn, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 加入房间
        /// </summary>
        /// <returns></returns>
        public async Task<bool> AgreeInAsync(AgreeInRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            var liveMember = room.AcceptIn(userCode, request.SortLevel, new List<LiveMemberDTO>());
            Logger.WriteLineInfo($"RTCService AgreeInAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            var syncInfo = new AgreeInConsultationJson
            {
                ConsultationRecordCode = roomId,
                RoomCode = roomId,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = userCode,
                SortLevel = request.SortLevel,
                LiveMemberInfos = room.GetRoomMemberInfos(),
            };
            await SyncToMasterAsync(SyncTypeEnum.Agree, roomId, room.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 切换房间
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ChangeRoomAsync(ChangeRoomRequest request)
        {
            var roomId = request.OriginalCode;
            var currentRoomId = request.CurrentCode;
            var userCode = request.UserCode;
            var original = _rtcRoomManager.Get(roomId);
            var current = _rtcRoomManager.Get(currentRoomId);
            original.ChangeRoom(userCode, current, original.GetRoomMemberInfos());
            await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = original });
            await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = current });
            var syncInfo = new ChangeConsultationJson
            {
                ConsultationRecordCode = original.LiveRoomCode,
                RoomCode = original.LiveRoomCode,
                InitatorCode = original.Initiator?.Code,
                OperatorCode = userCode,
                ReferCodes = new List<string> { roomId, currentRoomId },
                OriginalRoomId = roomId,
                CurrentRoomId = currentRoomId,
                LiveMemberInfos = current.GetRoomMemberInfos(),
            };
            await SyncToMasterAsync(SyncTypeEnum.ChangeRoom, roomId, original.Name, syncInfo);
            return await Task.FromResult(true);
        }

        /// <summary>
        /// 切换调参状态
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ChangeControllingStateAsync(ChangeControllingStateRequest request)
        {
            var userCode = request.UserCode;
            RtcRoom room = null;
            if (!string.IsNullOrWhiteSpace(request.LiveRoomCode))
            {
                room = _rtcRoomManager.Get(request.LiveRoomCode);
            }
            else
            {
                room = _rtcRoomManager.GetRoomInfoByConditionCode(request.UserCode, request.DeviceCode);
            }
            if (room != null)
            {
                var liveMember = room.ChangeControllingParameterState(userCode, request.IsControllingParameter);
                await AddOrUpdateLiveMemberAsync(room.LiveRoomCode, liveMember);
                var syncInfo = new ControllingParameterInLiveConsultationJson
                {
                    ConsultationRecordCode = room.LiveRoomCode,
                    RoomCode = room.LiveRoomCode,
                    InitatorCode = room.Initiator?.Code,
                    OperatorCode = userCode,
                    IsControllingParameter = request.IsControllingParameter
                };
                await SyncToMasterAsync(SyncTypeEnum.ChangeControllingParameter, room.LiveRoomCode, room.Name, syncInfo);
                return await Task.FromResult(true);
            }
            return await Task.FromResult(false);
        }

        /// <summary>
        /// 记录直播观看人信息
        /// </summary>
        /// <param name="request">请求实体</param>
        /// <returns>false</returns>
        public async Task<bool> SaveViewerAsync(SaveViewerRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            if (room != null)
            {
                room.AddOrUpdateViewer(request.UserCode, request.UserName);
                await _liveRoomDBService.AddOrUpdateViewerAsync(new AddOrUpdateViewerDBRequest
                {
                    LiveRoomCode = request.LiveRoomCode,
                    UserCode = request.UserCode,
                    UserName = request.UserName,
                });
                var syncInfo = new BaseLiveConsultationJson
                {
                    ConsultationRecordCode = roomId,
                    RoomCode = roomId,
                    InitatorCode = room.Initiator?.Code,
                    OperatorCode = userCode
                };
                await SyncToMasterAsync(SyncTypeEnum.SaveViewer, roomId, room.Name, syncInfo);
                return await Task.FromResult(true);
            }
            return await Task.FromResult(false);
        }

        /// <summary>
        /// 删除直播观看人信息
        /// </summary>
        /// <param name="request">请求实体</param>
        /// <returns>false</returns>
        public async Task<bool> RemoveViewerAsync(RemoveViewerRequest request)
        {
            var roomId = request.LiveRoomCode;
            var userCode = request.UserCode;
            var room = _rtcRoomManager.Get(roomId);
            if (room != null)
            {
                room.DeleteViewer(request.UserCode);
                await _liveRoomDBService.DeleteViewerAsync(new DeleteViewerDBRequest
                {
                    LiveRoomCode = request.LiveRoomCode,
                    UserCode = request.UserCode,
                });
                var syncInfo = new BaseLiveConsultationJson
                {
                    ConsultationRecordCode = roomId,
                    RoomCode = roomId,
                    InitatorCode = room.Initiator?.Code,
                    OperatorCode = userCode
                };
                await SyncToMasterAsync(SyncTypeEnum.DeleteViewer, roomId, room.Name, syncInfo);
                return await Task.FromResult(true);
            }
            return await Task.FromResult(false);
        }

        /// <summary>
        /// 查询用户在房间的状态
        /// </summary>
        /// <param name="request">请求实体</param>
        /// <returns>用户房间信息</returns>
        public async Task<LiveMemberDTO> GetLiveMemberByRoomIdAsync(GetLiveMemberByRoomIdRequest request)
        {
            var userCode = request.UserCode;
            var roomId = request.LiveRoomCode;
            LiveMemberDTO liveMember = null;
            var room = _rtcRoomManager.Get(roomId);
            if (room != null && room.UserInfos != null && room.UserInfos.Any(x => x.Code == userCode && x.Status == LiveMemberStatus.Joined))
            {
                liveMember = room.UserInfos.FirstOrDefault(x => x.Code == userCode);
            }
            return await Task.FromResult(liveMember);
        }

        private RtcRoom GetLiveRoomAsync(string liveRoomCode)
        {
            var getLiveRoomRequest = new GetLiveRoomByCodeDBRequest
            {
                LiveRoomCode = liveRoomCode,
            };
            var liveRoom = _liveRoomDBService.GetLiveRoomByCodeAsync(getLiveRoomRequest).Result;
            if (!string.IsNullOrWhiteSpace(liveRoom?.LiveRoomCode))
            {
                return new RtcRoom(liveRoom.LiveRoomCode, liveRoom.Name, liveRoom.RtcRoomId, liveRoom.SdkAppId, liveRoom.InitiatorCode
                , liveRoom.Status, liveRoom.BusinessModule, liveRoom.RelatedCode
                , liveRoom.UserInfos, liveRoom.DeviceInfos, liveRoom.ViewerInfos);
            }
            return null;
        }

        private async Task AddOrUpdateLiveMemberAsync(string liveRoomCode, LiveMemberDTO liveMember)
        {
            var saveLiveMemberRequest = new AddOrUpdateLiveMemberDBRequest
            {
                LiveRoomCode = liveRoomCode,
                MemberCode = liveMember.Code,
                MemberType = liveMember.MemberType,
                Name = liveMember.Name,
                HeadImageToken = liveMember.HeadImageToken,
                Status = liveMember.Status,
                MuteOpened = liveMember.MuteOpened,
                VideoOpened = liveMember.VideoOpened,
                IsControllingParameter = liveMember.IsControllingParameter,
                SortLevel = liveMember.SortLevel,
                LoginSource = liveMember.LoginSource,
                VideoDeviceInfos = liveMember.VideoDeviceInfos,
                InviterCode = liveMember.InviterCode ?? "",
                BackgroundRole = liveMember.BackgroundRole
            };
            if (liveMember.Status == LiveMemberStatus.Joined || liveMember.Status == LiveMemberStatus.Left)
            {
                saveLiveMemberRequest.Status = LiveMemberStatus.Accepted;
            }
            if (liveMember.LiveData != null)
            {
                var liveData = liveMember.LiveData;
                saveLiveMemberRequest.LiveData = new LiveDataDTO
                {
                    Width = liveData.Width,
                    Height = liveData.Height,
                    RtmpPullUrl = liveData.RtmpPullUrl,
                    RtmpPushUrl = liveData.RtmpPushUrl,
                    HlsPullUrl = liveData.HlsPullUrl,
                    HttpPullUrl = liveData.HttpPullUrl,
                };
            }
            await _liveRoomDBService.AddOrUpdateLiveMemberAsync(saveLiveMemberRequest);
        }

        /// <summary>
        /// 移除成员
        /// </summary>
        /// <returns></returns>
        private async Task RemoveLiveMemberAsync(string liveRoomCode, LiveMemberDTO liveMember, string initiatorCode)
        {
            if (initiatorCode != liveMember.Code)
            {
                var removeLiveMemberRequest = new RemoveLiveMemberDBRequest
                {
                    LiveRoomCode = liveRoomCode,
                    MemberCode = liveMember.Code,
                    MemberType = liveMember.MemberType
                };
                await _liveRoomDBService.RemoveLiveMemberAsync(removeLiveMemberRequest);
            }
        }

        private bool DeviceInitiatingRoomExisted(string deviceCode, string excludeRoomId)
        {
            return _rtcRoomManager.GetInitiatingRoomByDeviceCode(deviceCode, excludeRoomId) != null;
        }

        /// <summary>
        /// 设备直播中加入房间
        /// </summary>
        /// <returns></returns>
        public async Task<LiveMemberDTO> DeviceJoinInAsync(DeviceJoinInRequest request)
        {
            var roomId = request.LiveRoomCode;
            var deviceCode = request.DeviceCode;
            var room = _rtcRoomManager.Get(roomId);
            var deviceTokenInfo = CacheMaintenance.Instance.Get<ITokensManager>().Where(x => x.ClientId == deviceCode).FirstOrDefault();
            if (deviceTokenInfo != null && deviceTokenInfo.IsOnline && deviceTokenInfo.IsOldPlatform)
            {
                await _deviceForwardService.GetDeviceVideoInfosAsync(new GetDeviceVideoInfosRequest { DeviceCode = deviceCode });
            }
            var liveMember = room.DeviceJoinIn(deviceCode, new List<LiveMemberDTO>());
            Logger.WriteLineInfo($"RTCService DeviceJoinInAsync, roomId:{room.LiveRoomCode}, name:{room.Name}, user:{liveMember.Name}");
            await AddOrUpdateLiveMemberAsync(roomId, liveMember);
            var syncInfo = new JoinInConsultationJson
            {
                ConsultationRecordCode = roomId,
                RoomCode = roomId,
                InitatorCode = room.Initiator?.Code,
                OperatorCode = deviceCode,
                LiveMemberInfos = room.GetRoomMemberInfos(),
            };
            await SyncToMasterAsync(SyncTypeEnum.DeviceAcceptIn, roomId, room.Name, syncInfo);
            return await Task.FromResult(liveMember);
        }


        /// <summary>
        /// 开启关闭共享信息
        /// </summary>
        /// <param name="request">请求实体</param>
        /// <returns>true</returns>
        /// <show>false</show>
        public async Task<bool> ChangedShareInfoAsync(ChangedShareInfoRequest request)
        {
            var roomId = request.LiveRoomCode;
            var room = _rtcRoomManager.Get(roomId);
            var result = room.SetShareInfo(request.OperatorCode, request.ShareInfo);
            Logger.WriteLineInfo($"RTCService ChangedShareInfoAsync, roomId:{room.LiveRoomCode}, name:{room.Name},");
            room.ShareInfo = request.ShareInfo;
            var liveRoom = await AddOrUpdateLiveRoomAsync(new AddOrUpdateLiveRoomRequest { LiveRoom = room });

            var syncInfo = new ChangedShareInfoCourseJson
            {
                ConsultationRecordCode = liveRoom.LiveRoomCode,
                RoomCode = liveRoom.LiveRoomCode,
                InitatorCode = request.OperatorCode,
                OperatorCode = request.OperatorCode,
                // LoginSource = request.LoginSource,
                CurrentShareState = (int)request.ShareInfo?.CurrentShareState,
                CurrentShareType = (int)request.ShareInfo?.CurrentShareType,
                CurrentShareMemberCode = request.ShareInfo?.CurrentShareMemberCode,
                CurrentShareMemberName = request.ShareInfo?.CurrentShareMemberName,
            };
            await SyncToMasterAsync(SyncTypeEnum.SetShareInfo, roomId, liveRoom.Name, syncInfo);
            return await Task.FromResult(true);
        }
    }
}