tuikit-atomicx-vue3 4.4.0 → 4.5.0

package/src/subEntry/room/server.ts

@@ -0,0 +1,123 @@
+import type { Ref } from 'vue';
+import { ref } from 'vue';
+import TUIChatEngine from '@tencentcloud/chat-uikit-engine';
+import TUICore, { TUILogin, TUIConstants } from '@tencentcloud/tui-core';
+import TUIRoomEngine from '@tencentcloud/tuiroom-engine-js';
+import { dataReport, MetricsKey } from '../../report';
+import { useLoginState } from '../../states/LoginState';
+import { isMobile } from '../../utils';
+
+export default class RTCLoginServer {
+  private static instance: RTCLoginServer;
+  private isReady = false;
+  private isEngineLoggingIn = false;
+  public isLogin: Ref<boolean> = ref(false);
+  private resolveList: any[] = [];
+  private rejectList: any[] = [];
+
+  constructor() {
+    this.init();
+  }
+
+  static getInstance() {
+    if (!RTCLoginServer.instance) {
+      RTCLoginServer.instance = new RTCLoginServer();
+    }
+    return RTCLoginServer.instance;
+  }
+
+  public init() {
+    if (!this.isReady) {
+      this.isReady = true;
+      TUICore.registerEvent(
+        TUIConstants.TUILogin.EVENT.LOGIN_STATE_CHANGED,
+        TUIConstants.TUILogin.EVENT_SUB_KEY.USER_LOGIN_SUCCESS,
+        this,
+      );
+    }
+  }
+
+  /**
+   * @param { TUIInitParam } params
+   */
+  public onNotifyEvent(eventName: string, subKey: string) {
+    if (eventName === TUIConstants.TUILogin.EVENT.LOGIN_STATE_CHANGED) {
+      switch (subKey) {
+        case TUIConstants.TUILogin.EVENT_SUB_KEY.USER_LOGIN_SUCCESS:
+          this.login();
+          break;
+        case TUIConstants.TUILogin.EVENT_SUB_KEY.USER_LOGOUT_SUCCESS:
+          this.logout();
+          break;
+        default:
+          break;
+      }
+    }
+  }
+
+  public async login() {
+    const {
+      chat,
+      SDKAppID,
+      userID,
+      userSig,
+    } = TUILogin.getContext();
+    if (this.isEngineLoggingIn) {
+      return new Promise((resolve, reject) => {
+        this.resolveList.push(resolve);
+        this.rejectList.push(reject);
+      });
+    }
+
+    try {
+      this.isEngineLoggingIn = true;
+      const metricsKey = !isMobile ? MetricsKey.T_METRICS_STATE_API_LOGIN_COUNT : MetricsKey.T_METRICS_STATE_API_LOGIN_MOBILE_COUNT;
+      dataReport.reportCount(metricsKey);
+      await TUIChatEngine.login({
+        chat,
+        SDKAppID,
+        userID,
+        userSig,
+      });
+      const res = await TUIRoomEngine.login({
+        sdkAppId: SDKAppID,
+        userId: userID,
+        userSig,
+        tim: chat,
+      });
+      this.isLogin.value = true;
+      this.resolveList.forEach((resolve) => {
+        resolve();
+      });
+      this.rejectList = [];
+      this.resolveList = [];
+      const { loginUserInfo } = useLoginState();
+      const result = await chat.getUserProfile({ userIDList: [userID] });
+      const localUserInfo = result.data[0];
+      if (!localUserInfo.value) {
+        loginUserInfo.value = {
+          userId: localUserInfo.userID,
+          userName: localUserInfo.nick,
+          avatarUrl: localUserInfo.avatar,
+          customInfo: localUserInfo.profileCustomField,
+        };
+      }
+      return res;
+    } catch (error) {
+      this.rejectList.forEach((reject) => {
+        reject(error);
+      });
+      this.rejectList = [];
+      this.resolveList = [];
+      throw error;
+    } finally {
+      this.isEngineLoggingIn = false;
+    }
+  }
+
+  public logout() {
+    TUIRoomEngine.logout();
+    this.isLogin.value = false;
+    this.isEngineLoggingIn = false;
+  }
+}

package/src/types/asr.ts

@@ -0,0 +1,31 @@
+export interface TranscriptRawData {
+  type: number;
+  sender: string;
+  start_ms_ts: number;
+  end_ms_ts: number;
+  payload: {
+    end: boolean;
+    end_time: string;
+    end_time_ms: string;
+    roundid: string;
+    start_time: string;
+    start_time_ms: string;
+    taskid: string;
+    text: string;
+  };
+}
+
+export interface Transcript {
+  userId: string;
+  userName: string;
+  avatarUrl: string;
+  text: string;
+  startTime: number;
+  endTime: number;
+  end: boolean;
+  rawData: TranscriptRawData;
+}
+
+export enum ASREvent {
+  TRANSCRIPT_RECEIVED = 'transcript_received',
+}

package/src/types/barrage.ts

@@ -0,0 +1,86 @@
+/**
+ * 弹幕消息类型枚举
+ * @memberof module:BarrageState
+ * @description 定义弹幕消息的类型，包括文本消息和自定义消息
+ * @enum {number}
+ * @example
+ * ```typescript
+ * import { BarrageType } from '@/states/BarrageState';
+ *
+ * // 判断消息类型
+ * if (message.messageType === BarrageType.text) {
+ *   console.log('这是文本消息:', message.textContent);
+ * } else if (message.messageType === BarrageType.custom) {
+ *   console.log('这是自定义消息:', message.data);
+ * }
+ * ```
+ */
+export enum BarrageType {
+  /** 文本消息 */
+  text = 0,
+  /** 自定义消息 */
+  custom = 1,
+}
+
+/**
+   * 基础消息信息接口
+   * @memberof module:BarrageState
+   * @description 定义所有弹幕消息的基础属性
+   * @interface BaseMessageInfo
+   * @property {string} liveId - 直播间ID
+   * @property {TUIUserInfo} sender - 发送者用户信息
+   * @property {number} sequence - 消息序列号
+   * @property {number} timestampInSecond - 消息时间戳(秒)
+   */
+interface BaseMessageInfo {
+  liveId: string;
+  sender: TUIUserInfo;
+  sequence: number;
+  timestampInSecond: number;
+}
+
+/**
+   * 弹幕消息接口
+   * @memberof module:BarrageState
+   * @description 定义完整的弹幕消息结构，继承基础消息信息并扩展特定属性
+   * @interface Barrage
+   * @extends BaseMessageInfo
+   * @property {BarrageType} messageType - 消息类型
+   * @property {string} [textContent] - 文本内容(文本消息时使用)
+   * @property {Record<string, string>} [extensionInfo] - 扩展信息(文本消息时使用)
+   * @property {string} [businessId] - 业务ID(自定义消息时使用)
+   * @property {string} [data] - 自定义数据(自定义消息时使用)
+   * @example
+   * ```typescript
+   * // 文本消息示例
+   * const textBarrage: Barrage = {
+   *   liveId: 'live123',
+   *   sender: userInfo,
+   *   sequence: 1,
+   *   timestampInSecond: 1640995200,
+   *   messageType: BarrageType.text,
+   *   textContent: '大家好！',
+   *   extensionInfo: { color: 'red' }
+   * };
+   *
+   * // 自定义消息示例
+   * const customBarrage: Barrage = {
+   *   liveId: 'live123',
+   *   sender: userInfo,
+   *   sequence: 2,
+   *   timestampInSecond: 1640995201,
+   *   messageType: BarrageType.custom,
+   *   businessId: 'gift',
+   *   data: JSON.stringify({ giftId: 1, count: 5 })
+   * };
+   * ```
+   */
+export interface Barrage extends BaseMessageInfo {
+  messageType: BarrageType;
+
+  textContent?: string;
+  extensionInfo?: Record<string, string> | null;
+
+  businessId?: string;
+  data?: string;
+}

package/src/types/beauty.ts

@@ -0,0 +1,10 @@
+export type FreeBeautyConfig = {
+  beautyLevel: number;
+  whitenessLevel: number;
+  ruddinessLevel: number;
+};
+
+export enum TRTCBeautyStyle {
+  TRTCBeautyStyleSmooth = 0,
+  TRTCBeautyStyleNature = 1,
+}

package/src/types/device.ts

@@ -19,9 +19,9 @@ export enum MirrorType {
 }
 
 export enum DeviceType {
-  Microphone =  'Microphone',
-  Camera =  'Camera',
-  ScreenShare =  'ScreenShare',
+  Microphone = 'Microphone',
+  Camera = 'Camera',
+  ScreenShare = 'ScreenShare',
 }
 
 export enum VideoQuality {
@@ -74,10 +74,8 @@ export enum NetworkQuality {
 }
 
 export interface NetworkInfo {
-  userId: string;
   quality: NetworkQuality;
   upLoss: number;
   downLoss: number;
   delay: number;
 }
-

package/src/types/index.ts

@@ -1,5 +1,6 @@
 // common
 export type * from './login';
+export * from './device';
 // chat
 export * from './message';
 export * from './search';
@@ -9,12 +10,9 @@ export * from './contact';
 export * from './call';
 export * from './chatSetting';
 // live
-export * from './device';
-export * from './user';
 export * from './types';
 export * from './live';
 export * from './stream';
-export * from './room';
 export type * from './videoMixer';
 export * from './audience';
 export * from './seat';
@@ -22,3 +20,11 @@ export * from './monitor';
 export * from './coGuest';
 export * from './coHost';
 export * from './battle';
+export * from './barrage';
+// room
+export * from './room';
+export * from './participant';
+export * from './beauty';
+export * from './virtualBackground';
+// @deprecated 请使用最新 participant.ts 文件
+export * from './user';

package/src/types/participant.ts

@@ -0,0 +1,155 @@
+import type { Ref } from 'vue';
+import type { DeviceType, DeviceStatus, NetworkInfo } from './device';
+import type { RoomUser } from './room';
+
+export enum RoomParticipantRole {
+  Owner = 0,
+  Admin = 1,
+  GeneralUser = 2,
+}
+
+export enum RoomParticipantStatus {
+  None = 'None', // 未定义
+  Scheduled = 'Scheduled',
+  InCalling = 'InCalling',
+  CallTimeout = 'CallTimeout',
+  CallRejected = 'CallRejected',
+  InRoom = 'InRoom',
+}
+
+export interface RoomParticipant extends RoomUser {
+  nameCard: string;
+  role: RoomParticipantRole;
+  roomStatus: RoomParticipantStatus;
+  microphoneStatus: DeviceStatus;
+  cameraStatus: DeviceStatus;
+  screenShareStatus: DeviceStatus;
+  isMessageDisabled: boolean;
+  metaData: Record<string, string>;
+}
+
+export enum KickedOutOfRoomReason {
+  KickedByAdmin = 'KickedByAdmin',
+  ReplacedByAnotherDevice = 'ReplacedByAnotherDevice',
+  KickedByServer = 'KickedByServer',
+  ConnectionTimeout = 'ConnectionTimeout',
+  InvalidStatusOnReconnect = 'InvalidStatusOnReconnect',
+  RoomLimitExceeded = 'RoomLimitExceeded',
+}
+
+export interface DeviceRequestInfo {
+  timestamp: number;
+  senderUserId: string;
+  senderUserName: string;
+  senderNameCard: string;
+  senderAvatarUrl: string;
+  content: string;
+  deviceType: DeviceType;
+}
+
+export enum VideoStreamType {
+  Screen = 'screen',
+  Camera = 'camera',
+}
+
+export enum FillMode {
+  Fill = 'fill', // 图像铺满屏幕
+  Fit = 'fit', // 图像长边填满屏幕，短边区域会被填充黑色
+}
+
+export enum RoomLayoutTemplate {
+  GridLayout = 'gridLayout',
+  CinemaLayout = 'cinemaLayout', // 顶部栏
+  SidebarLayout = 'sidebarLayout', // 侧边栏
+}
+
+export interface IRoomParticipantState {
+  // data:
+  participantList: Ref<RoomParticipant[]>;
+  participantListCursor: Ref<string>;
+  participantListWithVideo: Ref<RoomParticipant[]>;
+  participantWithScreen: Ref<RoomParticipant | null>;
+  pendingDeviceApplications: Ref<DeviceRequestInfo[]>;
+  pendingDeviceInvitations: Ref<DeviceRequestInfo[]>;
+  speakingUsers: Ref<Map<string, number>>;
+  networkQualities: Ref<Map<string, NetworkInfo>>;
+  pendingParticipantList: Ref<RoomParticipant[]>;
+
+  readonly localParticipant: Ref<RoomParticipant | null>;
+
+  // functions:
+  getParticipantList(options: { cursor?: string }): Promise<{ participantList: RoomParticipant[]; cursor: string }>;
+
+  transferOwner(options: { userId: string }): Promise<void>;
+  setAdmin(options: { userId: string }): Promise<void>;
+  revokeAdmin(options: { userId: string }): Promise<void>;
+  kickParticipant(options: { userId: string }): Promise<void>;
+  updateParticipantNameCard(options: { userId: string; nameCard: string }): Promise<void>;
+  updateParticipantMetaData(options: { userId: string; metaData: Record<string, string> }): Promise<void>;
+
+  closeParticipantDevice(options: { userId: string; deviceType: DeviceType }): Promise<void>;
+  muteParticipantMessage(options: { userId: string; mute: boolean }): Promise<void>;
+  disableAllDevices(options: { deviceType: DeviceType; disable: boolean }): Promise<void>;
+  disableAllMessages(options: { disable: boolean }): Promise<void>;
+
+  requestToOpenDevice(options: { device: DeviceType; timeout?: number }): Promise<void>;
+  cancelOpenDeviceRequest(options: { device: DeviceType }): Promise<void>;
+  approveOpenDeviceRequest(options: { device: DeviceType; userId: string }): Promise<void>;
+  rejectOpenDeviceRequest(options: { device: DeviceType; userId: string }): Promise<void>;
+
+  inviteToOpenDevice(options: { userId: string; device: DeviceType; timeout?: number }): Promise<void>;
+  cancelOpenDeviceInvitation(options: { userId: string; device: DeviceType }): Promise<void>;
+  acceptOpenDeviceInvitation(options: { userId: string; device: DeviceType }): Promise<void>;
+  declineOpenDeviceInvitation(options: { userId: string; device: DeviceType }): Promise<void>;
+
+  subscribeEvent(event: RoomParticipantEvent, callback: RoomParticipantEventPayloads[keyof RoomParticipantEventPayloads]): void;
+  unsubscribeEvent(event: RoomParticipantEvent, callback: RoomParticipantEventPayloads[keyof RoomParticipantEventPayloads]): void;
+}
+
+export enum RoomParticipantEvent {
+  onParticipantJoined = 'onParticipantJoined',
+  onParticipantLeft = 'onParticipantLeft',
+  onOwnerChanged = 'onOwnerChanged',
+  onAdminSet = 'onAdminSet',
+  onAdminRevoked = 'onAdminRevoked',
+  onKickedFromRoom = 'onKickedFromRoom',
+  onParticipantDeviceClosed = 'onParticipantDeviceClosed',
+  onParticipantMessageMuted = 'onParticipantMessageMuted',
+  onAllDevicesDisabled = 'onAllDevicesDisabled',
+  onAllMessagesDisabled = 'onAllMessagesDisabled',
+  onDeviceRequestReceived = 'onDeviceRequestReceived',
+  onDeviceRequestCancelled = 'onDeviceRequestCancelled',
+  onDeviceRequestTimeout = 'onDeviceRequestTimeout',
+  onDeviceRequestApproved = 'onDeviceRequestApproved',
+  onDeviceRequestRejected = 'onDeviceRequestRejected',
+  onDeviceRequestProcessed = 'onDeviceRequestProcessed',
+  onDeviceInvitationReceived = 'onDeviceInvitationReceived',
+  onDeviceInvitationCancelled = 'onDeviceInvitationCancelled',
+  onDeviceInvitationTimeout = 'onDeviceInvitationTimeout',
+  onDeviceInvitationAccepted = 'onDeviceInvitationAccepted',
+  onDeviceInvitationDeclined = 'onDeviceInvitationDeclined',
+}
+
+export interface RoomParticipantEventPayloads {
+  onParticipantJoined: (options: { userInfo: RoomUser }) => void;
+  onParticipantLeft: (options: { userInfo: RoomUser }) => void;
+  onOwnerChanged: (options: { newOwner: RoomUser }) => void;
+  onAdminSet: (options: { userInfo: RoomUser }) => void;
+  onAdminRevoked: (options: { userInfo: RoomUser }) => void;
+  onKickedFromRoom: (options: { reason: KickedOutOfRoomReason; message: string }) => void;
+  onParticipantDeviceClosed: (options: { device: DeviceType; operator: RoomUser }) => void;
+  onParticipantMessageMuted: (options: { muted: boolean; operator: RoomUser }) => void;
+  onAllDevicesDisabled: (options: { device: DeviceType; disable: boolean; operator: RoomUser }) => void;
+  onAllMessagesDisabled: (options: { disable: boolean; operator: RoomUser }) => void;
+  onDeviceRequestReceived: (options: { request: DeviceRequestInfo }) => void;
+  onDeviceRequestCancelled: (options: { request: DeviceRequestInfo }) => void;
+  onDeviceRequestTimeout: (options: { request: DeviceRequestInfo }) => void;
+  onDeviceRequestApproved: (options: { request: DeviceRequestInfo; operator: RoomUser }) => void;
+  onDeviceRequestRejected: (options: { request: DeviceRequestInfo; operator: RoomUser }) => void;
+  onDeviceRequestProcessed: (options: { request: DeviceRequestInfo; operator: RoomUser }) => void;
+  onDeviceInvitationReceived: (options: { invitation: DeviceRequestInfo }) => void;
+  onDeviceInvitationCancelled: (options: { invitation: DeviceRequestInfo }) => void;
+  onDeviceInvitationTimeout: (options: { invitation: DeviceRequestInfo }) => void;
+  onDeviceInvitationAccepted: (options: { invitation: DeviceRequestInfo; operator: RoomUser }) => void;
+  onDeviceInvitationDeclined: (options: { invitation: DeviceRequestInfo; operator: RoomUser }) => void;
+}

package/src/types/room.ts

@@ -1,73 +1,138 @@
-// Import from local types
-import { TUIConferenceStatus, TUIUserInfo } from '@tencentcloud/tuiroom-engine-js';
-import { TUIRoomType, TUISeatMode } from './types';
-import type { TUILoginUserInfo } from './types';
+import type { Ref } from 'vue';
 
-export type RoomInfo = {
-  roomId: string;              // readonly
-  roomName: string;
-  roomOwner: TUILoginUserInfo; // readonly
-  memberCount: number;         // readonly
-  createTime: number;          // readonly
-  roomStatus: TUIConferenceStatus;
-  scheduleStartTime: number;
-  scheduleEndTime: number;
-  reminderSecondsBeforeStart: number;
-  scheduleAttendees: TUIUserInfo[];
-  password: string;
-  isSeatEnabled: boolean;     // readonly
-  seatMode: TUISeatMode;
-  maxSeatCount: number;
-  isMicrophoneDisableForAllUser: boolean;
-  isScreenShareDisableForAllUser: boolean;
-  isCameraDisableForAllUser: boolean;
-  isMessageDisableForAllUser: boolean;
-  customInfo: Record<string, any>;
-};
+export enum RoomStatus {
+  Scheduled = 1,
+  Running = 2,
+}
 
-export interface StartRoomParams {
-  roomId: string;
-  roomName?: string;
-  seatMode?: TUISeatMode;
-  maxSeatCount?: number;
-  isMicrophoneDisableForAllUser?: boolean;
-  isScreenShareDisableForAllUser?: boolean;
-  isCameraDisableForAllUser?: boolean;
-  isMessageDisableForAllUser?: boolean;
+export interface RoomUser {
+  userId: string;
+  userName: string;
+  avatarUrl: string;
 }
 
-export interface EnterRoomParams {
-  roomId: string;
+export interface RoomInfo {
+  readonly roomId: string;
+  roomName: string;
+  roomOwner: RoomUser;
+  readonly participantCount?: number;
+  readonly createTime?: number;
+  readonly roomStatus?: RoomStatus;
+  scheduledStartTime?: number;
+  scheduledEndTime?: number;
+  startReminderInSeconds?: number;
+  scheduleAttendees?: RoomUser[];
+  password?: string;
+  isAllMicrophoneDisabled?: boolean;
+  isAllCameraDisabled?: boolean;
+  isAllScreenShareDisabled?: boolean;
+  isAllMessageDisabled?: boolean;
 }
 
-export interface ScheduleRoomParams {
+export type ScheduleRoomOptions = {
+  roomName?: string;
+  password?: string;
   scheduleStartTime: number;
   scheduleEndTime: number;
-  scheduleAttendees?: string[];
   reminderSecondsBeforeStart?: number;
-  roomId: string;
+  scheduleAttendees?: string[];
+  isAllMicrophoneDisabled?: boolean;
+  isAllCameraDisabled?: boolean;
+  isAllScreenShareDisabled?: boolean;
+  isAllMessageDisabled?: boolean;
+};
+
+export type CreateRoomOptions = {
+  roomName?: string;
+  password?: string;
+  isAllMicrophoneDisabled?: boolean;
+  isAllCameraDisabled?: boolean;
+  isAllScreenShareDisabled?: boolean;
+  isAllMessageDisabled?: boolean;
+};
+
+export type UpdateRoomOptions = {
   roomName?: string;
-  roomType?: TUIRoomType;
-  isSeatEnabled?: boolean;
-  seatMode?: TUISeatMode;
-  isMicrophoneDisableForAllUser?: boolean;
-  isScreenShareDisableForAllUser?: boolean;
-  isCameraDisableForAllUser?: boolean;
-  isMessageDisableForAllUser?: boolean;
-  maxSeatCount?: number;
   password?: string;
+};
+
+export enum RoomCallStatus {
+  None = 0,
+  Calling = 1,
+  Timeout = 2,
+  Rejected = 3,
+}
+
+export enum RoomCallResult {
+  Success = 0,
+  AlreadyInCalling = 1,
+  AlreadyInRoom = 2,
+}
+
+export interface RoomCall {
+  caller: RoomUser;
+  callee: RoomUser;
+  status?: RoomCallStatus;
 }
 
-export enum RoomAction {
-  AudioAction = 'RoomAudioAction',
-  VideoAction = 'RoomVideoAction',
-  ScreenAction = 'RoomScreenAction',
+export interface IRoomState {
+  scheduledRoomList: Ref<RoomInfo[]>;
+  scheduledRoomListCursor: Ref<string>;
+  currentRoom: Ref<RoomInfo | null>;
+
+  getScheduledRoomList(options: { cursor: string }): Promise<{ scheduledRoomList: RoomInfo[]; cursor: string }>;
+  getScheduledAttendees(options: { roomId: string; cursor: string }): Promise<{ attendees: RoomUser[]; cursor: string; totalAttendeesCount: number }>;
+
+  scheduleRoom(options: { roomId: string; options: ScheduleRoomOptions }): Promise<void>;
+  updateScheduledRoom(options: { roomId: string; options: ScheduleRoomOptions }): Promise<void>;
+  addScheduledAttendees(options: { roomId: string; userIdList: string[] }): Promise<void>;
+  removeScheduledAttendees(options: { roomId: string; userIdList: string[] }): Promise<void>;
+  cancelScheduledRoom(options: { roomId: string }): Promise<void>;
+
+  createAndJoinRoom(options: { roomId: string; options: CreateRoomOptions }): Promise<void>;
+  joinRoom(options: { roomId: string; password?: string }): Promise<void>;
+  leaveRoom(): Promise<void>;
+  endRoom(): Promise<void>;
+  updateRoomInfo(options: { roomId: string; options: UpdateRoomOptions }): Promise<void>;
+  getRoomInfo(options: { roomId: string }): Promise<RoomInfo>;
+
+  getPendingCalls(options: { roomId: string; cursor: string }): Promise<{ calls: RoomCall[]; cursor: string }>;
+  callUserToRoom(options: { roomId: string; userIdList: string[]; timeout?: number; extensionInfo?: string }): Promise<Map<string, RoomCallResult>>;
+  cancelCall(options: { roomId: string; userIdList: string[] }): Promise<void>;
+  acceptCall(options: { roomId: string }): Promise<void>;
+  rejectCall(options: { roomId: string; extensionInfo?: string }): Promise<void>;
+
+  subscribeEvent<T extends RoomEvent>(event: T | `${T}`, handler: RoomEventHandlers[T]): void;
+  unsubscribeEvent<T extends RoomEvent>(event: T | `${T}`, handler: RoomEventHandlers[T]): void;
+}
+
+export enum RoomEvent {
+  onAddedToScheduledRoom = 'onAddedToScheduledRoom',
+  onRemovedFromScheduledRoom = 'onRemovedFromScheduledRoom',
+  onScheduledRoomCancelled = 'onScheduledRoomCancelled',
+  onScheduledRoomStartingSoon = 'onScheduledRoomStartingSoon',
+  onRoomEnded = 'onRoomEnded',
+  onCallReceived = 'onCallReceived',
+  onCallCancelled = 'onCallCancelled',
+  onCallTimeout = 'onCallTimeout',
+  onCallAccepted = 'onCallAccepted',
+  onCallRejected = 'onCallRejected',
+  onCallHandledByOtherDevice = 'onCallHandledByOtherDevice',
+  onCallRevokedByAdmin = 'onCallRevokedByAdmin',
 }
 
-export enum LocalRoomStatus {
-  IDLE = "IDLE",               // 未加入会议
-  JOINING = "JOINING",         // 正在加入会议
-  JOINED = "JOINED",           // 已加入会议
-  EXITING = "EXITING",         // 正在退出会议
-  EXITED = "EXITED",           // 已退出会议
+export interface RoomEventHandlers {
+  onAddedToScheduledRoom: (options: { roomInfo: RoomInfo }) => void;
+  onRemovedFromScheduledRoom: (options: { roomInfo: RoomInfo; operator: RoomUser }) => void;
+  onScheduledRoomCancelled: (options: { roomInfo: RoomInfo; operator: RoomUser }) => void;
+  onScheduledRoomStartingSoon: (options: { roomInfo: RoomInfo }) => void;
+  onRoomEnded: (options: { roomInfo: RoomInfo }) => void;
+
+  onCallReceived: (options: { roomInfo: RoomInfo; call: RoomCall; extensionInfo: string }) => void;
+  onCallCancelled: (options: { roomInfo: RoomInfo; call: RoomCall }) => void;
+  onCallTimeout: (options: { roomInfo: RoomInfo; call: RoomCall }) => void;
+  onCallAccepted: (options: { roomInfo: RoomInfo; call: RoomCall }) => void;
+  onCallRejected: (options: { roomInfo: RoomInfo; call: RoomCall; extensionInfo: string }) => void;
+  onCallHandledByOtherDevice: (options: { roomInfo: RoomInfo; isAccepted: boolean }) => void;
+  onCallRevokedByAdmin: (options: { roomInfo: RoomInfo; call: RoomCall; operator: RoomUser }) => void;
 }

package/src/types/user.ts

@@ -1,3 +1,5 @@
+// @deprecated 请使用最新 participant.ts 文件
+
 import { defineComponent } from 'vue';
 import { PropType } from 'vue';
 import { TUIRole, TUINetworkQuality } from './types';

package/src/types/virtualBackground.ts

@@ -0,0 +1,17 @@
+export interface VirtualBackgroundConfig {
+  enable?: boolean;
+  type?: VirtualBackgroundType;
+  blurLevel?: number;
+  imagePath?: string;
+}
+
+export enum VirtualBackgroundType {
+  blur = 'blur',
+  image = 'image',
+}
+
+export enum VirtualBackgroundEvent {
+  onAbort = 'onAbort', // 运行过程中发生错误
+}
+
+export type VirtualBackgroundEventCallback = () => void;