@tencentcloud/roomkit-electron-vue3 2.4.2 → 2.6.0

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

@@ -4,6 +4,10 @@ import {
   TUIRoomInfo,
   TUIRoomType,
   TUISeatMode,
+  TUIMediaDeviceType,
+  TUISeatInfo,
+  TUIVideoStreamType,
+  TUIUserInfo,
 } from '@tencentcloud/tuiroom-engine-electron';
 import { EventType, IRoomService, RoomParam } from '../types';
 import { isMobile, isWeChat } from '../../utils/environment';
@@ -30,9 +34,14 @@ export interface StartParams extends DeviceParams {
 }
 
 export interface JoinParams extends DeviceParams {
-  // You can add additional properties for JoinParams here if needed
+  password?: string;
 }
 
+export type RoomParamsInfo = {
+  roomId: string;
+  roomType: TUIRoomType;
+};
+
 export class RoomActionManager {
   private service: IRoomService;
 
@@ -83,6 +92,7 @@ export class RoomActionManager {
       defaultCameraId,
       defaultMicrophoneId,
       defaultSpeakerId,
+      password,
     } = params;
     await this.enterRoom({
       roomId,
@@ -92,6 +102,7 @@ export class RoomActionManager {
         defaultCameraId,
         defaultMicrophoneId,
         defaultSpeakerId,
+        password,
       },
     });
     this.service.emit(EventType.ROOM_JOIN);
@@ -136,23 +147,15 @@ export class RoomActionManager {
         roomType: TUIRoomType.kConference,
         isSeatEnabled: roomMode !== 'FreeToSpeak',
         seatMode:
-        roomMode === 'SpeakAfterTakingSeat'
-          ? TUISeatMode.kApplyToTake
-          : undefined,
+          roomMode === 'SpeakAfterTakingSeat'
+            ? TUISeatMode.kApplyToTake
+            : undefined,
       };
 
       await this.handleRoomCreation(roomParams, options);
     } catch (error) {
       logger.error(`${logPrefix}createRoom error:`, error);
-      this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
-        title: this.service.t('Note'),
-        message: this.service.t('Failed to initiate meeting'),
-        confirmButtonText: this.service.t('Sure'),
-        callback: async () => {
-          this.service.emit(EventType.ROOM_ERROR, error);
-          this.service.resetStore();
-        },
-      });
+      this.service.errorHandler.handleError(error, 'createRoom');
       throw error;
     }
   }
@@ -170,60 +173,163 @@ export class RoomActionManager {
   public async enterRoom(options: { roomId: string; roomParam?: RoomParam }) {
     try {
       const { roomId, roomParam } = options;
-
-      const roomParams = {
+      const roomInfo = await this.doEnterRoom({
         roomId,
         roomType: TUIRoomType.kConference,
-      };
-
-      const roomInfo = await this.doEnterRoom(roomParams);
+        password: roomParam?.password || '',
+      });
 
       this.service.roomStore.setRoomInfo(roomInfo);
       await this.getUserList();
-
+      await this.syncUserInfo(this.service.basicStore.userId);
+      await this.fetchAttendeeList(roomId);
+      await this.getInvitationList(roomId);
       if (roomInfo.isSeatEnabled) {
         await this.getSeatList();
-        this.service.roomStore.isMaster
-        && (await this.service.roomEngine.instance?.takeSeat({
-          seatIndex: -1,
-          timeout: 0,
-        }));
+        this.service.roomStore.isMaster &&
+          (await this.service.roomEngine.instance?.takeSeat({
+            seatIndex: -1,
+            timeout: 0,
+          }));
       }
-
-      this.service.roomStore.setRoomParam(roomParam);
+      this.setRoomParams(roomParam);
     } catch (error) {
       logger.error(`${logPrefix}enterRoom error:`, error);
-      this.service.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
-        title: this.service.t('Note'),
-        message: this.service.t('Failed to enter the meeting'),
-        confirmButtonText: this.service.t('Sure'),
-        callback: async () => {
-          this.service.emit(EventType.ROOM_ERROR, error);
-          this.service.roomStore.reset();
-        },
-      });
+      this.service.errorHandler.handleError(error, 'enterRoom');
       throw error;
     }
   }
 
-  private async doEnterRoom(options: {
+  private async setRoomParams(roomParam?: RoomParam) {
+    if (!roomParam) {
+      return;
+    }
+    const {
+      isOpenCamera,
+      isOpenMicrophone,
+      defaultCameraId,
+      defaultMicrophoneId,
+      defaultSpeakerId,
+    } = roomParam;
+    if (defaultCameraId) {
+      this.service.roomStore.setCurrentCameraId(defaultCameraId);
+      this.service.roomEngine.instance?.setCurrentCameraDevice({
+        deviceId: defaultCameraId,
+      });
+    }
+    if (defaultMicrophoneId) {
+      this.service.roomStore.setCurrentMicrophoneId(defaultMicrophoneId);
+      this.service.roomEngine.instance?.setCurrentMicDevice({
+        deviceId: defaultMicrophoneId,
+      });
+    }
+    if (defaultSpeakerId) {
+      this.service.roomStore.setCurrentSpeakerId(defaultSpeakerId);
+      this.service.roomEngine.instance?.setCurrentSpeakerDevice({
+        deviceId: defaultSpeakerId,
+      });
+    }
+
+    const {
+      isMaster,
+      isMicrophoneDisableForAllUser,
+      isCameraDisableForAllUser,
+      isFreeSpeakMode,
+    } = this.service.roomStore;
+    // 是否可以自动打开麦克风
+    const isCanOpenMicrophone =
+      isMaster || (!isMicrophoneDisableForAllUser && isFreeSpeakMode);
+    if (isCanOpenMicrophone) {
+      if (isOpenMicrophone) {
+        await this.service.roomEngine.instance?.unmuteLocalAudio();
+        if (!this.service.basicStore.isOpenMic) {
+          this.service.roomEngine.instance?.openLocalMicrophone();
+          this.service.basicStore.setIsOpenMic(true);
+        }
+        if (!isWeChat && !isMobile) {
+          const microphoneList =
+            await this.service.roomEngine.instance?.getMicDevicesList();
+          const speakerList =
+            await this.service.roomEngine.instance?.getSpeakerDevicesList();
+          if (microphoneList?.length === 0 || speakerList?.length === 0) return;
+          if (
+            !this.service.roomStore.currentMicrophoneId &&
+            microphoneList.length > 0
+          ) {
+            this.service.roomStore.setCurrentMicrophoneId(
+              microphoneList[0].deviceId
+            );
+          }
+          if (
+            !this.service.roomStore.currentSpeakerId &&
+            speakerList.length > 0
+          ) {
+            this.service.roomStore.setCurrentSpeakerId(speakerList[0].deviceId);
+          }
+          await this.service.roomEngine.instance?.setCurrentMicDevice({
+            deviceId: this.service.roomStore.currentMicrophoneId,
+          });
+        }
+      } else {
+        await this.service.roomEngine.instance?.muteLocalAudio();
+      }
+    }
+
+    // 是否可以自动打开摄像头
+    const isCanOpenCamera =
+      isMaster || (!isCameraDisableForAllUser && isFreeSpeakMode);
+    if (isCanOpenCamera && isOpenCamera) {
+      if (isMobile) {
+        await this.service.roomEngine.instance?.openLocalCamera({
+          isFrontCamera: this.service.basicStore.isFrontCamera,
+        });
+        return;
+      }
+      const deviceManager =
+        this.service.roomEngine.instance?.getMediaDeviceManager();
+      if (!this.service.roomStore.currentCameraId) {
+        const cameraList = await deviceManager.getDevicesList({
+          type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera,
+        });
+        if (cameraList && cameraList.length > 0) {
+          this.service.roomStore.setCurrentCameraId(cameraList[0].deviceId);
+        }
+      }
+      await deviceManager.setCurrentDevice({
+        type: TUIMediaDeviceType.kMediaDeviceTypeVideoCamera,
+        deviceId: this.service.roomStore.currentCameraId,
+      });
+      /**
+       * Turn on the local camera
+       *
+       **/
+      await this.service.roomEngine.instance?.openLocalCamera();
+    }
+  }
+
+  private async doEnterRoom(params: {
     roomId: string;
     roomType: TUIRoomType;
+    password: string;
   }) {
     const { roomEngine } = this.service;
-    const { roomId, roomType } = options;
+    const { roomId, roomType, password } = params;
     this.service.basicStore.setRoomId(roomId);
 
     const isH5 = isMobile && !isWeChat;
     const trtcCloud = roomEngine.instance?.getTRTCCloud();
     trtcCloud?.setDefaultStreamRecvMode(true, false);
-    trtcCloud?.enableSmallVideoStream(!isH5, smallParam);
 
     const roomInfo = (await roomEngine.instance?.enterRoom({
       roomId,
       roomType,
+      options: {
+        password,
+      },
     })) as TUIRoomInfo;
 
+    // roomEngine enabled small stream by default in enterRoom api
+    trtcCloud?.enableSmallVideoStream(!isH5, smallParam);
     roomEngine.instance?.muteLocalAudio();
 
     if (!roomInfo.isSeatEnabled) {
@@ -242,7 +348,17 @@ export class RoomActionManager {
         const result = (await roomEngine.instance?.getUserList({
           nextSequence,
         })) as any;
-        this.service.roomStore.updateUserList(result.userInfoList);
+        result.userInfoList.forEach((user: TUIUserInfo) => {
+          this.service.roomStore.addUserInfo(
+            Object.assign(user, { isInRoom: true })
+          );
+          if (this.service.roomStore.isFreeSpeakMode) {
+            this.service.roomStore.addStreamInfo(
+              user.userId,
+              TUIVideoStreamType.kCameraStream
+            );
+          }
+        });
         nextSequence = result.nextSequence;
       } while (nextSequence !== 0);
     } catch (error: any) {
@@ -250,11 +366,87 @@ export class RoomActionManager {
     }
   }
 
+  private async getInvitationList(
+    roomId: string,
+    cursor = '',
+    result: any[] = []
+  ) {
+    const res =
+      await this.service.conferenceInvitationManager.getInvitationList({
+        roomId,
+        cursor,
+        count: 20,
+      });
+    if (!res?.invitationList) return [];
+    // eslint-disable-next-line no-unsafe-optional-chaining
+    result.push(...res?.invitationList);
+    if (res.cursor !== '') {
+      await this.getInvitationList(roomId, res.cursor, result);
+    }
+    const list = result.map(({ invitee, status }) => ({
+      ...invitee,
+      status,
+    }));
+    this.service.roomStore.updateInviteeList(list as any);
+  }
+
+  private async fetchAttendeeList(
+    roomId: string,
+    cursor = '',
+    result: any[] = []
+  ) {
+    const res = await this.service.scheduleConferenceManager.fetchAttendeeList({
+      roomId,
+      cursor,
+      count: 20,
+    });
+    if (!res?.attendeeList) return [];
+    // eslint-disable-next-line no-unsafe-optional-chaining
+    result.push(...res?.attendeeList);
+    if (res.cursor !== '') {
+      await this.fetchAttendeeList(roomId, res.cursor, result);
+    }
+    const inviteeList = result.filter(user => {
+      return !this.service.roomStore.userList.some(
+        item => item.userId === user.userId
+      );
+    });
+    this.service.roomStore.updateInviteeList(inviteeList);
+  }
+
+  private async syncUserInfo(userId: string) {
+    const { roomEngine } = this.service;
+    const userInfo = (await roomEngine.instance?.getUserInfo({
+      userId,
+    })) as any;
+    const { isMessageDisabled } = userInfo;
+    this.service.chatStore.setSendMessageDisableChanged(isMessageDisabled);
+  }
+
   private async getSeatList() {
     const { roomEngine } = this.service;
     try {
       const seatList = (await roomEngine.instance?.getSeatList()) as any;
-      this.service.roomStore.setSeatList(seatList);
+      seatList.forEach((seat: TUISeatInfo) => {
+        const { userId } = seat;
+        if (!userId) {
+          return;
+        }
+        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
+        );
+      });
     } catch (error: any) {
       logger.error('TUIRoomEngine.getSeatList', error.code, error.message);
     }
@@ -269,4 +461,8 @@ export class RoomActionManager {
       roomEngine.instance?.closeLocalCamera();
     }
   }
+
+  public async fetchRoomInfo(options?: RoomParamsInfo) {
+    return await this.service.roomEngine.instance?.fetchRoomInfo(options);
+  }
 }

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

@@ -0,0 +1,301 @@
+import {
+  TUIConferenceCancelReason,
+  TUIConferenceInfo,
+  TUIConferenceListManagerEvents,
+  TUIRoomType,
+  TUISeatMode,
+  TUIUserInfo,
+  TUIConferenceStatus,
+  TUIConferenceModifyInfo,
+} from '@tencentcloud/tuiroom-engine-electron';
+import { EventType, IRoomService } from '../types';
+import mitt from 'mitt';
+export * from '@tencentcloud/tuiroom-engine-electron';
+interface IScheduleConferenceManager {
+  on(
+    eventType: TUIConferenceListManagerEvents,
+    callback: (data?: any) => any
+  ): void;
+  off(
+    eventType: TUIConferenceListManagerEvents,
+    callback: (data?: any) => void
+  ): void;
+  dispose(): void;
+  scheduleConference(conferenceInfo: IScheduleConferenceOptions): Promise<void>;
+  cancelConference(options: { roomId: string }): Promise<void>;
+  updateConferenceInfo(options: {
+    roomId: string;
+    roomName?: string;
+    scheduleStartTime?: number;
+    scheduleEndTime?: number;
+  }): Promise<void>;
+  fetchScheduledConferenceList(options: {
+    statusArray?: TUIConferenceStatus[];
+    cursor: string;
+    count: number;
+  }): Promise<Array<TUIConferenceInfo>>;
+  fetchAttendeeList(options: {
+    roomId: string;
+    cursor: string;
+    count: number;
+  }): Promise<Array<TUIUserInfo>>;
+  addAttendeesByAdmin(options: {
+    roomId: string;
+    userIdList: string[];
+  }): Promise<void>;
+  removeAttendeesByAdmin(options: {
+    roomId: string;
+    userIdList: string[];
+  }): Promise<void>;
+
+  fetchFriendList(): Promise<void>;
+  replaceFriendList(
+    userList: Array<{
+      userID: string;
+      avatar: string;
+      nick: string;
+    }>
+  ): void;
+}
+
+export interface IScheduleConferenceOptions {
+  scheduleStartTime: number;
+  scheduleEndTime: number;
+  scheduleAttendees?: string[];
+  reminderSecondsBeforeStart?: number;
+  roomId: string;
+  roomName?: string;
+  roomType?: TUIRoomType;
+  isSeatEnabled?: boolean;
+  seatMode?: TUISeatMode;
+  isMicrophoneDisableForAllUser?: boolean;
+  isScreenShareDisableForAllUser?: boolean;
+  isCameraDisableForAllUser?: boolean;
+  isMessageDisableForAllUser?: boolean;
+  maxSeatCount?: number;
+  password?: string;
+}
+
+export class ScheduleConferenceManager implements IScheduleConferenceManager {
+  private service: IRoomService;
+  private customFriendList?: Array<any>;
+  private emitter = mitt();
+
+  constructor(service: IRoomService) {
+    this.service = service;
+    this.bindEventContext();
+    this.service.on(EventType.SERVICE_READY, () => {
+      this.bindEvent();
+    });
+  }
+
+  public dispose() {
+    this.unbindEvent();
+  }
+
+  public on(
+    eventType: TUIConferenceListManagerEvents,
+    callback: (data?: any) => any
+  ) {
+    this.emitter.on(eventType, callback);
+  }
+
+  public off(
+    eventType: TUIConferenceListManagerEvents,
+    callback: (data?: any) => void
+  ) {
+    this.emitter.off(eventType, callback);
+  }
+
+  private emit(eventType: TUIConferenceListManagerEvents, data?: any) {
+    this.emitter.emit(eventType, data);
+  }
+
+  private bindEventContext() {
+    this.onConferenceScheduled = this.onConferenceScheduled.bind(this);
+    this.onConferenceWillStart = this.onConferenceWillStart.bind(this);
+    this.onConferenceCancelled = this.onConferenceCancelled.bind(this);
+    this.onConferenceInfoChanged = this.onConferenceInfoChanged.bind(this);
+    this.onScheduleAttendeesChanged =
+      this.onScheduleAttendeesChanged.bind(this);
+    this.onConferenceStatusChanged = this.onConferenceStatusChanged.bind(this);
+  }
+
+  private bindEvent() {
+    const conferenceListManager =
+      this.service.roomEngine?.instance.getConferenceListManager();
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onConferenceScheduled,
+      this.onConferenceScheduled
+    );
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onConferenceWillStart,
+      this.onConferenceWillStart
+    );
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onConferenceCancelled,
+      this.onConferenceCancelled
+    );
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onConferenceInfoChanged,
+      this.onConferenceInfoChanged
+    );
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onScheduleAttendeesChanged,
+      this.onScheduleAttendeesChanged
+    );
+    conferenceListManager.on(
+      TUIConferenceListManagerEvents.onConferenceStatusChanged,
+      this.onConferenceStatusChanged
+    );
+  }
+
+  private unbindEvent() {
+    const conferenceListManager =
+      this.service.roomEngine?.instance.getConferenceListManager();
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onConferenceScheduled,
+      this.onConferenceScheduled
+    );
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onConferenceWillStart,
+      this.onConferenceWillStart
+    );
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onConferenceCancelled,
+      this.onConferenceCancelled
+    );
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onConferenceInfoChanged,
+      this.onConferenceInfoChanged
+    );
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onScheduleAttendeesChanged,
+      this.onScheduleAttendeesChanged
+    );
+    conferenceListManager.off(
+      TUIConferenceListManagerEvents.onConferenceStatusChanged,
+      this.onConferenceStatusChanged
+    );
+  }
+
+  private onConferenceScheduled(data: { conferenceInfo: TUIConferenceInfo }) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceScheduled, data);
+  }
+
+  private onConferenceWillStart(data: { conferenceInfo: TUIConferenceInfo }) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceWillStart, data);
+  }
+
+  private onConferenceCancelled(data: {
+    roomId: string;
+    reason: TUIConferenceCancelReason;
+    operateUser: TUIUserInfo;
+  }) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceCancelled, data);
+  }
+
+  private onConferenceInfoChanged(data: {
+    conferenceModifyInfo: TUIConferenceModifyInfo;
+  }) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceInfoChanged, data);
+    const { roomId, roomName } = data.conferenceModifyInfo.basicRoomInfo;
+    const isCurrentRoom = this.service.basicStore.roomId === roomId;
+    if (!isCurrentRoom) return;
+    roomName !== undefined &&
+      roomName !== null &&
+      this.service.roomStore.setRoomInfo({
+        roomName,
+      });
+  }
+
+  private onScheduleAttendeesChanged(data: {
+    roomId: string;
+    leftUsers: TUIUserInfo;
+    joinedUsers: TUIUserInfo;
+  }) {
+    this.emit(TUIConferenceListManagerEvents.onScheduleAttendeesChanged, data);
+  }
+
+  private onConferenceStatusChanged(data: {
+    roomId: string;
+    status: TUIConferenceStatus;
+  }) {
+    this.emit(TUIConferenceListManagerEvents.onConferenceStatusChanged, data);
+  }
+
+  async fetchFriendList() {
+    if (this.customFriendList) return this.customFriendList;
+    const tim = this.service.roomEngine.instance?.getTIM();
+    const { data } = await tim.getFriendList();
+    return data;
+  }
+
+  replaceFriendList(
+    userList: Array<{
+      userID: string;
+      avatar: string;
+      nick: string;
+    }>
+  ) {
+    this.customFriendList = userList;
+  }
+
+  async scheduleConference(options: IScheduleConferenceOptions) {
+    return await this.service.roomEngine.instance
+      ?.getConferenceListManager()
+      .scheduleConference(options);
+  }
+
+  async cancelConference(options: { roomId: string }) {
+    return await this.service.roomEngine.instance
+      ?.getConferenceListManager()
+      .cancelConference(options);
+  }
+
+  async updateConferenceInfo(options: {
+    roomId: string;
+    roomName?: string;
+    scheduleStartTime?: number;
+    scheduleEndTime?: number;
+  }) {
+    return await this.service.roomEngine.instance
+      ?.getConferenceListManager()
+      .updateConferenceInfo(options);
+  }
+
+  async fetchScheduledConferenceList(options: {
+    statusArray?: TUIConferenceStatus[];
+    cursor: string;
+    count: number;
+  }) {
+    return await this.service.roomEngine.instance
+      ?.getConferenceListManager()
+      .fetchScheduledConferenceList(options);
+  }
+
+  async fetchAttendeeList(options: {
+    roomId: string;
+    cursor: string;
+    count: number;
+  }) {
+    return await this.service.roomEngine.instance
+      ?.getConferenceListManager()
+      .fetchAttendeeList(options);
+  }
+
+  async addAttendeesByAdmin(options: { roomId: string; userIdList: string[] }) {
+    return await this.service.roomEngine.instance
+      ?.getConferenceListManager()
+      .addAttendeesByAdmin(options);
+  }
+
+  async removeAttendeesByAdmin(options: {
+    roomId: string;
+    userIdList: string[];
+  }) {
+    return await this.service.roomEngine.instance
+      ?.getConferenceListManager()
+      .removeAttendeesByAdmin(options);
+  }
+}