@tencentcloud/roomkit-electron-vue3 2.4.1 → 2.5.0

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

@@ -0,0 +1,263 @@
+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);
+  }
+}

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

@@ -1,5 +1,6 @@
 import TUIRoomEngine from '@tencentcloud/tuiroom-engine-electron';
 import { IRoomService } from '../types';
+import { UserInfo } from '../../stores/room';
 
 interface IUserManager {
   setSelfInfo(options: SelfInfoOptions): Promise<void>;
@@ -37,4 +38,9 @@ export class UserManager implements IUserManager {
     const roomEngine = this.service.roomEngine.instance;
     return roomEngine?.setCustomInfoForUser(options);
   }
+
+  public getDisplayName(options: UserInfo) {
+    const { nameCard, userName, userId} = options
+    return nameCard || userName || userId
+  }
 }

package/src/TUIRoom/services/roomService.ts

@@ -10,7 +10,7 @@ import TUIRoomEngine, {
   TUIRoomEvents,
 } from '@tencentcloud/tuiroom-engine-electron';
 import { useBasicStore } from '../stores/basic';
-import { useRoomStore } from '../stores/room';
+import { UserInfo, useRoomStore } from '../stores/room';
 import { useChatStore } from '../stores/chat';
 import useDeviceManager from '../hooks/useDeviceManager';
 import logger from '../utils/common/logger';
@@ -24,6 +24,9 @@ import { LifeCycleManager } from './manager/lifeCycleManager';
 import { JoinParams, RoomActionManager, StartParams } from './manager/roomActionManager';
 import { WaterMark } from './function/waterMark';
 import { VirtualBackground } from './function/virtualBackground';
+import { ScheduleConferenceManager } from './manager/scheduleConferenceManager';
+import { ErrorHandler } from './function/errorHandler';
+
 const { t } = i18n.global;
 
 const logPrefix = '[RoomService]';
@@ -35,9 +38,11 @@ export class RoomService implements IRoomService {
   public configManager = new ConfigManager(this);
   public userManager = new UserManager(this);
   public lifeCycleManager: LifeCycleManager = new LifeCycleManager(this);
-  public roomActionManager = new RoomActionManager(this);
+  public roomActionManager: RoomActionManager = new RoomActionManager(this);
   public waterMark = new WaterMark(this);
   public virtualBackground = new VirtualBackground(this);
+  public scheduleConferenceManager: ScheduleConferenceManager = new ScheduleConferenceManager(this);
+  public errorHandler: ErrorHandler = new ErrorHandler(this);
 
   public roomEngine = roomEngine;
   public t = t;
@@ -60,6 +65,7 @@ export class RoomService implements IRoomService {
     TUIRoomEngine.once('ready', () => {
       this.bindRoomEngineEvents();
       this.handleRoomEngineReady();
+      this.emit(EventType.SERVICE_READY);
     });
   }
 
@@ -74,6 +80,8 @@ export class RoomService implements IRoomService {
     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.onUserInfoChanged = this.onUserInfoChanged.bind(this);
   }
 
   static getInstance(): RoomService {
@@ -89,6 +97,7 @@ export class RoomService implements IRoomService {
     RoomService.instance.unBindRoomEngineEvents();
     RoomService.instance.waterMark.dispose();
     RoomService.instance.virtualBackground.dispose();
+    RoomService.instance.scheduleConference.dispose();
     RoomService.instance = undefined;
   }
 
@@ -118,6 +127,11 @@ export class RoomService implements IRoomService {
     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,
+    );
+    roomEngine.instance?.on(TUIRoomEvents.onUserInfoChanged, this.onUserInfoChanged);
   }
 
   public unBindRoomEngineEvents() {
@@ -131,20 +145,16 @@ export class RoomService implements IRoomService {
     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,
+    );
+    roomEngine.instance?.off(TUIRoomEvents.onUserInfoChanged, this.onUserInfoChanged);
   }
 
   private onError(error: any) {
     logger.error('roomEngine.onError: ', error);
-    if (error.message === 'enter trtc room failed , error code : -1') {
-      this.emit(EventType.ROOM_NOTICE_MESSAGE_BOX, {
-        type: 'warning',
-        message: t('Failed to enter the meeting'),
-        callback: () => {
-          this.emit(EventType.ROOM_ERROR);
-          this.resetStore();
-        },
-      });
-    }
+    this.errorHandler.handleError(error, 'onError');
   }
 
   private onRoomDismissed(eventInfo: { roomId: string }) {
@@ -266,6 +276,16 @@ export class RoomService implements IRoomService {
     }
   }
 
+  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);
+    }
+  };
+
   private async onAllUserMicrophoneDisableChanged(eventInfo: { roomId: string; isDisable: boolean }) {
     const { isDisable } = eventInfo;
     if (
@@ -294,7 +314,10 @@ export class RoomService implements IRoomService {
       await roomEngine.instance?.muteLocalAudio();
     }
   }
-
+  private async onScreenShareForAllUserDisableChanged(eventInfo: { roomId: string; isDisable: boolean }) {
+    const { isDisable } = eventInfo;
+    this.roomStore.setDisableScreenShareForAllUserByAdmin(isDisable);
+  }
   public resetStore() {
     this.basicStore.reset();
     this.chatStore.reset();
@@ -311,6 +334,7 @@ export class RoomService implements IRoomService {
     const { sdkAppId, userId, userSig, userName = userId, avatarUrl = '' } = option;
     await TUIRoomEngine.login({ sdkAppId, userId, userSig });
     await TUIRoomEngine.setSelfInfo({ userName, avatarUrl });
+    this.emit(EventType.ROOM_LOGIN);
   }
 
   public async start(roomId: string, params?: StartParams) {
@@ -394,6 +418,10 @@ export class RoomService implements IRoomService {
   setSelfInfo(options: SelfInfoOptions) {
     return this.userManager.setSelfInfo(options);
   }
+
+  getDisplayName(options: UserInfo) {
+    return this.userManager.getDisplayName(options);
+  }
 }
 
 

package/src/TUIRoom/services/types.ts

@@ -3,7 +3,9 @@ import { useBasicStore } from '../stores/basic';
 import { useRoomStore } from '../stores/room';
 import { useChatStore } from '../stores/chat';
 import { LifeCycleManager } from './manager/lifeCycleManager';
-
+import { ScheduleConferenceManager } from './manager/scheduleConferenceManager';
+import { RoomActionManager } from './manager/roomActionManager';
+import { ErrorHandler } from './function/errorHandler';
 export interface IRoomService {
   t: any;
   roomEngine: Record<string, any>;
@@ -11,6 +13,9 @@ export interface IRoomService {
   roomStore: ReturnType<typeof useRoomStore>;
   chatStore: ReturnType<typeof useChatStore>;
   lifeCycleManager: LifeCycleManager;
+  roomActionManager?: RoomActionManager;
+  scheduleConferenceManager: ScheduleConferenceManager;
+  errorHandler: ErrorHandler;
   on: (eventType: EventType, callback: (data?: any) => any) => void;
   off: (eventType: EventType, callback: (data?: any) => void) => void;
   emit: (eventType: EventType, data?: any) => void;
@@ -40,6 +45,8 @@ export interface RoomParam {
 }
 
 export enum EventType {
+  SERVICE_READY = 'ServiceReady',
+  ROOM_LOGIN = 'RoomLogin',
   ROOM_CONTAINER_RESIZE = 'RoomContainerResize',
   ROOM_NOTICE_MESSAGE = 'RoomNoticeMessage',
   ROOM_NOTICE_MESSAGE_BOX = 'RoomNoticeMessageBox',

package/src/TUIRoom/stores/basic.ts

@@ -8,6 +8,13 @@ import { TUINetwork } from '@tencentcloud/tuiroom-engine-electron';
 type SideBarType = 'chat' | 'invite' | 'manage-member' | 'more' | 'transfer-leave' | 'apply' | '';
 type SceneType = 'chat' | 'default';
 
+function getDefaultLayout() {
+  if (isMobile) {
+    return isWeChat ? LAYOUT.SIX_EQUAL_POINTS : LAYOUT.LARGE_SMALL_WINDOW;
+  }
+  return LAYOUT.NINE_EQUAL_POINTS;
+}
+
 interface BasicState {
   sdkAppId: number,
   userId: string,
@@ -69,7 +76,7 @@ export const useBasicStore = defineStore('basic', {
     roomId: '',
     roomMode: 'FreeSpeech',
     isSidebarOpen: false,
-    layout: isWeChat ? LAYOUT.SIX_EQUAL_POINTS :  LAYOUT.NINE_EQUAL_POINTS,
+    layout: getDefaultLayout(),
     showSettingDialog: false,
     showApplyUserList: false,
     activeSettingTab: 'audio',
@@ -212,7 +219,7 @@ export const useBasicStore = defineStore('basic', {
     },
     reset() {
       this.isSidebarOpen = false;
-      this.layout = isWeChat ? LAYOUT.SIX_EQUAL_POINTS :  LAYOUT.NINE_EQUAL_POINTS;
+      this.layout = getDefaultLayout();
       this.showSettingDialog = false;
       this.activeSettingTab = 'audio';
       this.isLocalStreamMirror = true;