@tencentcloud/roomkit-electron-vue3 2.5.0 → 2.6.0

package/src/TUIRoom/services/manager/userManager.ts

@@ -1,7 +1,12 @@
-import TUIRoomEngine from '@tencentcloud/tuiroom-engine-electron';
+import TUIRoomEngine, {
+  TUIRoomEvents,
+  TUIUserInfo,
+  TUIChangeReason,
+  TUIVideoStreamType,
+  TUISeatInfo,
+} from '@tencentcloud/tuiroom-engine-electron';
 import { IRoomService } from '../types';
 import { UserInfo } from '../../stores/room';
-
 interface IUserManager {
   setSelfInfo(options: SelfInfoOptions): Promise<void>;
   setCustomInfoForUser(options: CustomInfoForUser): Promise<void>;
@@ -10,7 +15,7 @@ interface IUserManager {
 export type CustomInfoForUser = {
   userId: string;
   customInfo: Record<string, string>;
-}
+};
 export type SelfInfoOptions = {
   userName?: string;
   avatarUrl?: string;
@@ -22,6 +27,7 @@ export class UserManager implements IUserManager {
 
   constructor(service: IRoomService) {
     this.service = service;
+    this.bindRoomEngineEvents();
   }
 
   public async setSelfInfo(options: SelfInfoOptions): Promise<void> {
@@ -40,7 +46,205 @@ export class UserManager implements IUserManager {
   }
 
   public getDisplayName(options: UserInfo) {
-    const { nameCard, userName, userId} = options
-    return nameCard || userName || userId
+    const { nameCard, userName, userId } = options;
+    return nameCard || userName || userId;
+  }
+
+  public setLocalUser(userInfo: { userId: string }) {
+    this.service.roomStore.addUserInfo(userInfo);
+    this.service.roomStore.addStreamInfo(
+      userInfo.userId,
+      TUIVideoStreamType.kCameraStream
+    );
+  }
+
+  private onRemoteUserEnterRoom(eventInfo: { userInfo: TUIUserInfo }) {
+    const { userInfo } = eventInfo;
+    this.service.roomStore.addUserInfo(
+      Object.assign(userInfo, { isInRoom: true })
+    );
+    if (this.service.roomStore.isFreeSpeakMode) {
+      this.service.roomStore.addStreamInfo(
+        userInfo.userId,
+        TUIVideoStreamType.kCameraStream
+      );
+    }
+  }
+
+  private onRemoteUserLeaveRoom(eventInfo: { userInfo: TUIUserInfo }) {
+    const { userId } = eventInfo.userInfo;
+    this.service.roomStore.removeUserInfo(userId);
+    this.service.roomStore.removeStreamInfo(
+      userId,
+      TUIVideoStreamType.kCameraStream
+    );
+    this.service.roomStore.removeStreamInfo(
+      userId,
+      TUIVideoStreamType.kScreenStream
+    );
+  }
+
+  private onSeatListChanged(eventInfo: {
+    seatList: TUISeatInfo[];
+    seatedList: TUISeatInfo[];
+    leftList: TUISeatInfo[];
+  }) {
+    const { seatedList, leftList } = eventInfo;
+
+    seatedList.forEach(seat => {
+      const { userId } = seat;
+      const user = this.service.roomStore.userInfoObj[userId];
+      if (user) {
+        this.service.roomStore.updateUserInfo({ userId, onSeat: true });
+      } else {
+        this.service.roomStore.addUserInfo({
+          userId,
+          onSeat: true,
+          isInRoom: true,
+        });
+      }
+      this.service.roomStore.addStreamInfo(
+        userId,
+        TUIVideoStreamType.kCameraStream
+      );
+    });
+    leftList?.forEach(seat => {
+      const { userId } = seat;
+      const user = this.service.roomStore.userInfoObj[userId];
+      if (user) {
+        Object.assign(user, { onSeat: false });
+        this.service.roomStore.updateUserInfo({ userId, onSeat: false });
+      }
+      this.service.roomStore.removeStreamInfo(
+        userId,
+        TUIVideoStreamType.kCameraStream
+      );
+      this.service.roomStore.removeStreamInfo(
+        userId,
+        TUIVideoStreamType.kScreenStream
+      );
+    });
+  }
+
+  private onUserAudioStateChanged(eventInfo: {
+    userId: string;
+    hasAudio: boolean;
+    reason: TUIChangeReason;
+  }) {
+    const { userId, hasAudio } = eventInfo;
+    let userInfo = this.service.roomStore.userInfoObj[userId];
+    if (!userInfo && hasAudio) {
+      this.service.roomStore.addUserInfo({ userId, isInRoom: true });
+    }
+    userInfo = this.service.roomStore.userInfoObj[userId];
+    if (!userInfo) {
+      return;
+    }
+
+    this.service.roomStore.updateUserInfo({ userId, hasAudioStream: hasAudio });
+
+    const streamInfo =
+      this.service.roomStore.streamInfoObj[
+        `${userId}_${TUIVideoStreamType.kCameraStream}`
+      ];
+    if (!streamInfo) {
+      this.service.roomStore.addStreamInfo(
+        userId,
+        TUIVideoStreamType.kCameraStream
+      );
+    }
+    this.service.roomStore.updateStreamInfo({
+      userId,
+      streamType: TUIVideoStreamType.kCameraStream,
+      hasAudioStream: hasAudio,
+    });
+  }
+
+  private onUserVideoStateChanged = (eventInfo: {
+    userId: string;
+    streamType: TUIVideoStreamType;
+    hasVideo: boolean;
+    reason: TUIChangeReason;
+  }) => {
+    const { userId, streamType, hasVideo } = eventInfo;
+    let userInfo = this.service.roomStore.userInfoObj[userId];
+    if (!userInfo && hasVideo) {
+      this.service.roomStore.addUserInfo({ userId, isInRoom: true });
+    }
+    userInfo = this.service.roomStore.userInfoObj[userId];
+    if (!userInfo) {
+      return;
+    }
+    const updateInfo =
+      streamType === TUIVideoStreamType.kScreenStream
+        ? { hasScreenStream: hasVideo }
+        : { hasVideoStream: hasVideo };
+    this.service.roomStore.updateUserInfo({ userId, ...updateInfo });
+
+    if (
+      streamType === TUIVideoStreamType.kCameraStream ||
+      (streamType === TUIVideoStreamType.kScreenStream && hasVideo)
+    ) {
+      const streamInfo =
+        this.service.roomStore.streamInfoObj[`${userId}_${streamType}`];
+      if (!streamInfo) {
+        this.service.roomStore.addStreamInfo(userId, streamType);
+      }
+      this.service.roomStore.updateStreamInfo({
+        userId,
+        streamType,
+        hasVideoStream: hasVideo,
+      });
+    } else if (streamType === TUIVideoStreamType.kScreenStream && !hasVideo) {
+      this.service.roomStore.removeStreamInfo(userId, streamType);
+    }
+  };
+
+  private bindRoomEngineEvents() {
+    TUIRoomEngine.once('ready', () => {
+      this.service.roomEngine.instance?.on(
+        TUIRoomEvents.onRemoteUserEnterRoom,
+        this.onRemoteUserEnterRoom.bind(this)
+      );
+      this.service.roomEngine.instance?.on(
+        TUIRoomEvents.onRemoteUserLeaveRoom,
+        this.onRemoteUserLeaveRoom.bind(this)
+      );
+      this.service.roomEngine.instance?.on(
+        TUIRoomEvents.onSeatListChanged,
+        this.onSeatListChanged.bind(this)
+      );
+      this.service.roomEngine.instance?.on(
+        TUIRoomEvents.onUserVideoStateChanged,
+        this.onUserVideoStateChanged.bind(this)
+      );
+      this.service.roomEngine.instance?.on(
+        TUIRoomEvents.onUserAudioStateChanged,
+        this.onUserAudioStateChanged.bind(this)
+      );
+    });
+  }
+
+  private unbindRoomEngineEvents() {
+    this.service.roomEngine.instance?.off(
+      TUIRoomEvents.onRemoteUserEnterRoom,
+      this.onRemoteUserEnterRoom
+    );
+    this.service.roomEngine.instance?.off(
+      TUIRoomEvents.onRemoteUserLeaveRoom,
+      this.onRemoteUserLeaveRoom
+    );
+    this.service.roomEngine.instance?.off(
+      TUIRoomEvents.onSeatListChanged,
+      this.onSeatListChanged
+    );
+    this.service.roomEngine.instance?.off(
+      TUIRoomEvents.onUserVideoStateChanged,
+      this.onUserVideoStateChanged
+    );
+    this.service.roomEngine.instance?.off(
+      TUIRoomEvents.onUserAudioStateChanged,
+      this.onUserAudioStateChanged
+    );
   }
 }

package/src/TUIRoom/services/roomService.ts

@@ -17,19 +17,31 @@ import logger from '../utils/common/logger';
 import { isMobile } from '../utils/environment';
 import i18n from '../locales';
 import { MESSAGE_DURATION } from '../constants/message';
-import { ComponentConfig, ComponentManager, ComponentName } from './manager/componentManager';
-import { ConfigManager, LanguageOption, ThemeOption } from './manager/configManager';
+import {
+  ComponentConfig,
+  ComponentManager,
+  ComponentName,
+} from './manager/componentManager';
+import { ConfigManager, LanguageOption, Theme } from './manager/configManager';
 import { SelfInfoOptions, UserManager } from './manager/userManager';
 import { LifeCycleManager } from './manager/lifeCycleManager';
-import { JoinParams, RoomActionManager, StartParams } from './manager/roomActionManager';
+import { MediaManager } from './manager/MediaManager';
+import {
+  JoinParams,
+  RoomActionManager,
+  StartParams,
+  RoomParamsInfo,
+} from './manager/roomActionManager';
 import { WaterMark } from './function/waterMark';
 import { VirtualBackground } from './function/virtualBackground';
 import { ScheduleConferenceManager } from './manager/scheduleConferenceManager';
+import { ConferenceInvitationManager } from './manager/conferenceInvitationManager';
 import { ErrorHandler } from './function/errorHandler';
 
 const { t } = i18n.global;
 
 const logPrefix = '[RoomService]';
+
 export const roomEngine = useGetRoomEngine();
 export class RoomService implements IRoomService {
   static instance?: RoomService;
@@ -37,11 +49,15 @@ export class RoomService implements IRoomService {
   public componentManager = new ComponentManager(this);
   public configManager = new ConfigManager(this);
   public userManager = new UserManager(this);
+  public mediaManager = new MediaManager(this);
   public lifeCycleManager: LifeCycleManager = new LifeCycleManager(this);
   public roomActionManager: RoomActionManager = new RoomActionManager(this);
   public waterMark = new WaterMark(this);
   public virtualBackground = new VirtualBackground(this);
-  public scheduleConferenceManager: ScheduleConferenceManager = new ScheduleConferenceManager(this);
+  public scheduleConferenceManager: ScheduleConferenceManager =
+    new ScheduleConferenceManager(this);
+  public conferenceInvitationManager: ConferenceInvitationManager =
+    new ConferenceInvitationManager(this);
   public errorHandler: ErrorHandler = new ErrorHandler(this);
 
   public roomEngine = roomEngine;
@@ -73,14 +89,19 @@ export class RoomService implements IRoomService {
     this.onError = this.onError.bind(this);
     this.onRoomDismissed = this.onRoomDismissed.bind(this);
     this.onUserVoiceVolumeChanged = this.onUserVoiceVolumeChanged.bind(this);
-    this.onUserNetworkQualityChanged = this.onUserNetworkQualityChanged.bind(this);
+    this.onUserNetworkQualityChanged =
+      this.onUserNetworkQualityChanged.bind(this);
     this.onKickedOutOfRoom = this.onKickedOutOfRoom.bind(this);
-    this.onSendMessageForUserDisableChanged = this.onSendMessageForUserDisableChanged.bind(this);
+    this.onSendMessageForUserDisableChanged =
+      this.onSendMessageForUserDisableChanged.bind(this);
     this.onUserSigExpired = this.onUserSigExpired.bind(this);
     this.onKickedOffLine = this.onKickedOffLine.bind(this);
-    this.onAllUserCameraDisableChanged = this.onAllUserCameraDisableChanged.bind(this);
-    this.onAllUserMicrophoneDisableChanged = this.onAllUserMicrophoneDisableChanged.bind(this);
-    this.onScreenShareForAllUserDisableChanged = this.onScreenShareForAllUserDisableChanged.bind(this);
+    this.onAllUserCameraDisableChanged =
+      this.onAllUserCameraDisableChanged.bind(this);
+    this.onAllUserMicrophoneDisableChanged =
+      this.onAllUserMicrophoneDisableChanged.bind(this);
+    this.onScreenShareForAllUserDisableChanged =
+      this.onScreenShareForAllUserDisableChanged.bind(this);
     this.onUserInfoChanged = this.onUserInfoChanged.bind(this);
   }
 
@@ -97,16 +118,23 @@ export class RoomService implements IRoomService {
     RoomService.instance.unBindRoomEngineEvents();
     RoomService.instance.waterMark.dispose();
     RoomService.instance.virtualBackground.dispose();
-    RoomService.instance.scheduleConference.dispose();
+    RoomService.instance.scheduleConferenceManager.dispose();
+    RoomService.instance.conferenceInvitationManager.dispose();
+    RoomService.instance.mediaManager.dispose();
     RoomService.instance = undefined;
   }
 
   public useExtension(extension: any) {
+    // eslint-disable-next-line no-underscore-dangle
     extension._bind(this);
   }
 
   public getRoomContainer(): HTMLElement | Element {
-    return document.fullscreenElement || document.getElementById('roomContainer') || document.body;
+    return (
+      document.fullscreenElement ||
+      document.getElementById('roomContainer') ||
+      document.body
+    );
   }
 
   public initMediaDeviceList() {
@@ -115,41 +143,98 @@ export class RoomService implements IRoomService {
 
   public bindRoomEngineEvents() {
     roomEngine.instance?.on(TUIRoomEvents.onError, this.onError);
-    roomEngine.instance?.on(TUIRoomEvents.onRoomDismissed, this.onRoomDismissed);
-    roomEngine.instance?.on(TUIRoomEvents.onUserVoiceVolumeChanged, this.onUserVoiceVolumeChanged);
-    roomEngine.instance?.on(TUIRoomEvents.onUserNetworkQualityChanged, this.onUserNetworkQualityChanged);
-    roomEngine.instance?.on(TUIRoomEvents.onKickedOutOfRoom, this.onKickedOutOfRoom);
+    roomEngine.instance?.on(
+      TUIRoomEvents.onRoomDismissed,
+      this.onRoomDismissed
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onUserVoiceVolumeChanged,
+      this.onUserVoiceVolumeChanged
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onUserNetworkQualityChanged,
+      this.onUserNetworkQualityChanged
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onKickedOutOfRoom,
+      this.onKickedOutOfRoom
+    );
     roomEngine.instance?.on(
       TUIRoomEvents.onSendMessageForUserDisableChanged,
-      this.onSendMessageForUserDisableChanged,
+      this.onSendMessageForUserDisableChanged
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onUserSigExpired,
+      this.onUserSigExpired
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onKickedOffLine,
+      this.onKickedOffLine
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onAllUserCameraDisableChanged,
+      this.onAllUserCameraDisableChanged
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onAllUserMicrophoneDisableChanged,
+      this.onAllUserMicrophoneDisableChanged
     );
-    roomEngine.instance?.on(TUIRoomEvents.onUserSigExpired, this.onUserSigExpired);
-    roomEngine.instance?.on(TUIRoomEvents.onKickedOffLine, this.onKickedOffLine);
-    roomEngine.instance?.on(TUIRoomEvents.onAllUserCameraDisableChanged, this.onAllUserCameraDisableChanged);
-    roomEngine.instance?.on(TUIRoomEvents.onAllUserMicrophoneDisableChanged, this.onAllUserMicrophoneDisableChanged);
     roomEngine.instance?.on(
       TUIRoomEvents.onScreenShareForAllUserDisableChanged,
-      this.onScreenShareForAllUserDisableChanged,
+      this.onScreenShareForAllUserDisableChanged
+    );
+    roomEngine.instance?.on(
+      TUIRoomEvents.onUserInfoChanged,
+      this.onUserInfoChanged
     );
-    roomEngine.instance?.on(TUIRoomEvents.onUserInfoChanged, this.onUserInfoChanged);
   }
 
   public unBindRoomEngineEvents() {
     roomEngine.instance?.off(TUIRoomEvents.onError, this.onError);
-    roomEngine.instance?.off(TUIRoomEvents.onRoomDismissed, this.onRoomDismissed);
-    roomEngine.instance?.off(TUIRoomEvents.onUserVoiceVolumeChanged, this.onUserVoiceVolumeChanged);
-    roomEngine.instance?.off(TUIRoomEvents.onUserNetworkQualityChanged, this.onUserNetworkQualityChanged);
-    roomEngine.instance?.off(TUIRoomEvents.onKickedOutOfRoom, this.onKickedOutOfRoom);
-    roomEngine.instance?.off(TUIRoomEvents.onSendMessageForUserDisableChanged, this.onSendMessageForUserDisableChanged);
-    roomEngine.instance?.off(TUIRoomEvents.onUserSigExpired, this.onUserSigExpired);
-    roomEngine.instance?.off(TUIRoomEvents.onKickedOffLine, this.onKickedOffLine);
-    roomEngine.instance?.off(TUIRoomEvents.onAllUserCameraDisableChanged, this.onAllUserCameraDisableChanged);
-    roomEngine.instance?.off(TUIRoomEvents.onAllUserMicrophoneDisableChanged, this.onAllUserMicrophoneDisableChanged);
+    roomEngine.instance?.off(
+      TUIRoomEvents.onRoomDismissed,
+      this.onRoomDismissed
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onUserVoiceVolumeChanged,
+      this.onUserVoiceVolumeChanged
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onUserNetworkQualityChanged,
+      this.onUserNetworkQualityChanged
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onKickedOutOfRoom,
+      this.onKickedOutOfRoom
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onSendMessageForUserDisableChanged,
+      this.onSendMessageForUserDisableChanged
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onUserSigExpired,
+      this.onUserSigExpired
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onKickedOffLine,
+      this.onKickedOffLine
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onAllUserCameraDisableChanged,
+      this.onAllUserCameraDisableChanged
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onAllUserMicrophoneDisableChanged,
+      this.onAllUserMicrophoneDisableChanged
+    );
     roomEngine.instance?.off(
       TUIRoomEvents.onScreenShareForAllUserDisableChanged,
-      this.onScreenShareForAllUserDisableChanged,
+      this.onScreenShareForAllUserDisableChanged
+    );
+    roomEngine.instance?.off(
+      TUIRoomEvents.onUserInfoChanged,
+      this.onUserInfoChanged
     );
-    roomEngine.instance?.off(TUIRoomEvents.onUserInfoChanged, this.onUserInfoChanged);
   }
 
   private onError(error: any) {
@@ -164,6 +249,7 @@ export class RoomService implements IRoomService {
       title: t('Note'),
       message: t('The host closed the room.'),
       confirmButtonText: t('Sure'),
+      duration: 5000,
       callback: async () => {
         this.emit(EventType.ROOM_DISMISS, {});
         this.resetStore();
@@ -180,7 +266,11 @@ export class RoomService implements IRoomService {
     this.basicStore.setLocalQuality(eventInfo.userNetworkList);
   }
 
-  private async onKickedOutOfRoom(eventInfo: { roomId: string; reason: TUIKickedOutOfRoomReason; message: string }) {
+  private async onKickedOutOfRoom(eventInfo: {
+    roomId: string;
+    reason: TUIKickedOutOfRoomReason;
+    message: string;
+  }) {
     const { roomId, reason, message } = eventInfo;
     try {
       let notice = '';
@@ -209,10 +299,15 @@ export class RoomService implements IRoomService {
     }
   }
 
-  private onSendMessageForUserDisableChanged(data: { userId: string; isDisable: boolean }) {
+  private onSendMessageForUserDisableChanged(data: {
+    userId: string;
+    isDisable: boolean;
+  }) {
     const { userId, isDisable } = data;
     if (userId === this.roomStore.localUser.userId) {
-      const tipMessage = isDisable ? t('You have been banned from text chat') : t('You are allowed to text chat');
+      const tipMessage = isDisable
+        ? t('You have been banned from text chat')
+        : t('You are allowed to text chat');
       this.emit(EventType.ROOM_NOTICE_MESSAGE, {
         code: -1,
         type: 'warning',
@@ -231,6 +326,7 @@ export class RoomService implements IRoomService {
       confirmButtonText: t('Sure'),
       callback: () => {
         this.emit(EventType.USER_SIG_EXPIRED, {});
+        this.resetStore();
       },
     });
   }
@@ -239,7 +335,9 @@ export class RoomService implements IRoomService {
     const { message } = eventInfo;
     this.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
       title: t('Note'),
-      message: t('The system has detected that your account has been kicked offline'),
+      message: t(
+        'The system has detected that your account has been kicked offline'
+      ),
       confirmButtonText: t('Sure'),
       callback: async () => {
         this.emit(EventType.KICKED_OFFLINE, { message });
@@ -247,11 +345,14 @@ export class RoomService implements IRoomService {
     });
   }
 
-  private async onAllUserCameraDisableChanged(eventInfo: { roomId: string; isDisable: boolean }) {
+  private async onAllUserCameraDisableChanged(eventInfo: {
+    roomId: string;
+    isDisable: boolean;
+  }) {
     const { isDisable } = eventInfo;
     if (
-      isDisable !== this.roomStore.isCameraDisableForAllUser
-      && this.roomStore.localUser.userRole === TUIRole.kGeneralUser
+      isDisable !== this.roomStore.isCameraDisableForAllUser &&
+      this.roomStore.localUser.userRole === TUIRole.kGeneralUser
     ) {
       this.roomStore.setCanControlSelfVideo(!isDisable);
     }
@@ -260,7 +361,9 @@ export class RoomService implements IRoomService {
   }
 
   private async handleVideoStateChange(isDisableVideo: boolean) {
-    const tipMessage = isDisableVideo ? t('All videos disabled') : t('All videos enabled');
+    const tipMessage = isDisableVideo
+      ? t('All videos disabled')
+      : t('All videos enabled');
     this.emit(EventType.ROOM_NOTICE_MESSAGE, {
       type: 'success',
       message: tipMessage,
@@ -271,26 +374,27 @@ export class RoomService implements IRoomService {
      * If the host open and does not actively turn up the user camera
      *
      **/
-    if (isDisableVideo && this.roomStore.localUser.userRole === TUIRole.kGeneralUser) {
+    if (
+      isDisableVideo &&
+      this.roomStore.localUser.userRole === TUIRole.kGeneralUser
+    ) {
       await roomEngine.instance?.closeLocalCamera();
     }
   }
 
-  private async onUserInfoChanged(eventInfo: { userInfo: UserInfo })  {
+  private async onUserInfoChanged(eventInfo: { userInfo: UserInfo }) {
     const { userId, nameCard } = eventInfo.userInfo;
-    const isLocal = this.roomStore.localUser.userId === userId;
-    if (isLocal) {
-      this.roomStore.setLocalUser({ nameCard });
-    } else {
-      this.roomStore.setRemoteUserNameCard(userId, nameCard as string);
-    }
-  };
+    this.roomStore.updateUserInfo({ userId, nameCard });
+  }
 
-  private async onAllUserMicrophoneDisableChanged(eventInfo: { roomId: string; isDisable: boolean }) {
+  private async onAllUserMicrophoneDisableChanged(eventInfo: {
+    roomId: string;
+    isDisable: boolean;
+  }) {
     const { isDisable } = eventInfo;
     if (
-      isDisable !== this.roomStore.isMicrophoneDisableForAllUser
-      && this.roomStore.localUser.userRole === TUIRole.kGeneralUser
+      isDisable !== this.roomStore.isMicrophoneDisableForAllUser &&
+      this.roomStore.localUser.userRole === TUIRole.kGeneralUser
     ) {
       this.roomStore.setCanControlSelfAudio(!isDisable);
     }
@@ -299,7 +403,9 @@ export class RoomService implements IRoomService {
   }
 
   private async handleAudioStateChange(isDisableAudio: boolean) {
-    const tipMessage = isDisableAudio ? t('All audios disabled') : t('All audios enabled');
+    const tipMessage = isDisableAudio
+      ? t('All audios disabled')
+      : t('All audios enabled');
     this.emit(EventType.ROOM_NOTICE_MESSAGE, {
       type: 'success',
       message: tipMessage,
@@ -310,11 +416,17 @@ export class RoomService implements IRoomService {
      * if the moderator turns on the full staff mute, users actively turns off the user's microphone
      *
      **/
-    if (isDisableAudio && this.roomStore.localUser.userRole === TUIRole.kGeneralUser) {
+    if (
+      isDisableAudio &&
+      this.roomStore.localUser.userRole === TUIRole.kGeneralUser
+    ) {
       await roomEngine.instance?.muteLocalAudio();
     }
   }
-  private async onScreenShareForAllUserDisableChanged(eventInfo: { roomId: string; isDisable: boolean }) {
+  private async onScreenShareForAllUserDisableChanged(eventInfo: {
+    roomId: string;
+    isDisable: boolean;
+  }) {
     const { isDisable } = eventInfo;
     this.roomStore.setDisableScreenShareForAllUserByAdmin(isDisable);
   }
@@ -326,12 +438,18 @@ export class RoomService implements IRoomService {
 
   private storeInit(option: RoomInitData) {
     this.basicStore.setBasicInfo(option);
-    this.roomStore.setLocalUser(option);
+    this.userManager.setLocalUser(option);
   }
 
   public async initRoomKit(option: RoomInitData) {
     this.storeInit(option);
-    const { sdkAppId, userId, userSig, userName = userId, avatarUrl = '' } = option;
+    const {
+      sdkAppId,
+      userId,
+      userSig,
+      userName = userId,
+      avatarUrl = '',
+    } = option;
     await TUIRoomEngine.login({ sdkAppId, userId, userSig });
     await TUIRoomEngine.setSelfInfo({ userName, avatarUrl });
     this.emit(EventType.ROOM_LOGIN);
@@ -366,11 +484,16 @@ export class RoomService implements IRoomService {
     await this.roomActionManager.dismissRoom();
   }
 
+  public fetchRoomInfo(options?: RoomParamsInfo) {
+    return this.roomActionManager.fetchRoomInfo(options);
+  }
+
   public async handleRoomEngineReady() {
     const storageCurrentTheme = localStorage.getItem('tuiRoom-currentTheme');
     storageCurrentTheme && this.basicStore.setDefaultTheme(storageCurrentTheme);
     // Set the default rendering mode of local video
     const trtcCloud = roomEngine.instance?.getTRTCCloud();
+    // eslint-disable-next-line no-nested-ternary
     const mirrorType = isMobile
       ? TRTCVideoMirrorType.TRTCVideoMirrorType_Auto
       : this.basicStore.isLocalStreamMirror
@@ -388,7 +511,7 @@ export class RoomService implements IRoomService {
     this.resetStore();
   }
 
-  on(eventType: EventType, callback: (data?: any) => any) {
+  on(eventType: EventType, callback: (data?: any) => void) {
     this.emitter.on(eventType, callback);
   }
 
@@ -408,9 +531,9 @@ export class RoomService implements IRoomService {
     return this.componentManager.setComponentConfig(options);
   }
   // Config Manager
-  public setTheme(theme: ThemeOption) {
+  public setTheme(theme: Theme) {
     return this.configManager.setTheme(theme);
-  };
+  }
   public setLanguage(language: LanguageOption) {
     return this.configManager.setLanguage(language);
   }
@@ -422,7 +545,10 @@ export class RoomService implements IRoomService {
   getDisplayName(options: UserInfo) {
     return this.userManager.getDisplayName(options);
   }
-}
 
+  getMediaManager() {
+    return this.mediaManager;
+  }
+}
 
 export const roomService = RoomService.getInstance();