tuikit-atomicx-vue3 3.4.1 → 4.3.0

package/src/types/coGuest.ts

@@ -1,3 +1,21 @@
+import type { LiveUserInfo } from './audience';
+
+export enum HostEvent {
+  onGuestApplicationReceived = 'onGuestApplicationReceived',
+  onGuestApplicationCancelled = 'onGuestApplicationCancelled',
+  onGuestApplicationProcessedByOtherHost = 'onGuestApplicationProcessedByOtherHost',
+  onHostInvitationResponded = 'onHostInvitationResponded',
+  onHostInvitationNoResponse = 'onHostInvitationNoResponse',
+}
+
+export enum GuestEvent {
+  onHostInvitationReceived = 'onHostInvitationReceived',
+  onHostInvitationCancelled = 'onHostInvitationCancelled',
+  onGuestApplicationResponded = 'onGuestApplicationResponded',
+  onGuestApplicationNoResponse = 'onGuestApplicationNoResponse',
+  onKickedOffSeat = 'onKickedOffSeat',
+}
+
 export type CoGuestRequestInfo = {
   timestamp: number;
   requestId: string;
@@ -7,9 +25,73 @@ export type CoGuestRequestInfo = {
   avatarUrl: string;
 };
 
-export enum CoGuestStatus {
-  Connected = 'Connected',
-  Disconnected = 'Disconnected', //  不在连线中
-  AdminInviting = 'AdminInviting', // 主持人/管理员邀请连线中
-  UserApplying = 'UserApplying', // 普通成员申请连线中
+export enum NoResponseReason {
+  timeout = 0,
+  alreadySeated = 1,
+}
+
+interface GuestApplicationReceivedEventInfo {
+  guestUser: LiveUserInfo;
+}
+
+interface GuestApplicationCancelledEventInfo {
+  guestUser: LiveUserInfo;
+}
+
+interface GuestApplicationProcessedByOtherHostEventInfo {
+  guestUser: LiveUserInfo;
+  hostUser: LiveUserInfo;
+}
+
+interface HostInvitationRespondedEventInfo {
+  isAccept: boolean;
+  guestUser: LiveUserInfo;
+}
+
+interface HostInvitationNoResponseEventInfo {
+  guestUser: LiveUserInfo;
+  reason: NoResponseReason;
 }
+
+interface HostInvitationReceivedEventInfo {
+  hostUser: LiveUserInfo;
+}
+interface HostInvitationCancelledEventInfo {
+  hostUser: LiveUserInfo;
+}
+interface GuestApplicationRespondedEventInfo {
+  isAccept: boolean;
+  hostUser: LiveUserInfo;
+}
+interface GuestApplicationNoResponseEventInfo {
+  reason: NoResponseReason;
+}
+
+interface KickedOffSeatEventInfo {
+  seatIndex: number;
+  hostUser: LiveUserInfo;
+}
+
+type HostEventInfoMap = {
+  [HostEvent.onGuestApplicationReceived]: GuestApplicationReceivedEventInfo;
+  [HostEvent.onGuestApplicationCancelled]: GuestApplicationCancelledEventInfo;
+  [HostEvent.onGuestApplicationProcessedByOtherHost]: GuestApplicationProcessedByOtherHostEventInfo;
+  [HostEvent.onHostInvitationResponded]: HostInvitationRespondedEventInfo;
+  [HostEvent.onHostInvitationNoResponse]: HostInvitationNoResponseEventInfo;
+};
+
+type GuestEventInfoMap = {
+  [GuestEvent.onHostInvitationReceived]: HostInvitationReceivedEventInfo;
+  [GuestEvent.onHostInvitationCancelled]: HostInvitationCancelledEventInfo;
+  [GuestEvent.onGuestApplicationResponded]: GuestApplicationRespondedEventInfo;
+  [GuestEvent.onGuestApplicationNoResponse]: GuestApplicationNoResponseEventInfo;
+  [GuestEvent.onKickedOffSeat]: KickedOffSeatEventInfo;
+};
+
+export type CoGuestEventInfoMap = HostEventInfoMap & GuestEventInfoMap;
+
+type CoGuestEventCallbackBase<T extends HostEvent | GuestEvent> = (
+  eventInfo: CoGuestEventInfoMap[T]
+) => void;
+
+export type CoGuestEventCallback = CoGuestEventCallbackBase<HostEvent | GuestEvent>;

package/src/types/device.ts

@@ -1,15 +1,21 @@
 export enum DeviceError {
-  NoError = 'NoError',
-  NoDeviceDetected = 'NoDeviceDetected',
-  NoSystemPermission = 'NoSystemPermission',
-  NotSupportCapture = 'NotSupportCapture',
-  OccupiedError = 'OccupiedError',
-  UnknownError = 'UnknownError',
+  NoError = 0,
+  NoDeviceDetected = 1,
+  NoSystemPermission = 2,
+  NotSupportCapture = 3,
+  OccupiedError = 4,
+  UnknownError = 5,
 }
 
-export enum AudioOutput {
-  Speaker = 'speaker',
-  Earpiece = 'earpiece',
+export enum AudioRoute {
+  Speakerphone = 0,
+  Earpiece = 1,
+}
+
+export enum MirrorType {
+  Auto = 0,
+  Enable = 1,
+  Disable = 2,
 }
 
 export enum DeviceType {
@@ -18,6 +24,13 @@ export enum DeviceType {
   ScreenShare =  'ScreenShare',
 }
 
+export enum VideoQuality {
+  Quality360P = 1,
+  Quality540P = 2,
+  Quality720P = 3,
+  Quality1080P = 4,
+}
+
 export enum DevicePermission {
   PublishAudio = 'PublishAudio',
   PublishVideo = 'PublishVideo',
@@ -46,13 +59,25 @@ export interface AudioSettingProps {
 }
 
 export enum DeviceStatus {
-  On = "On",            // 媒体状态打开
-  Off = "Off",          // 媒体状态关闭
-  AdminInviting = "AdminInviting",   // 关闭状态且正在被主持人/管理员被邀请中
-  UserApplying = "UserApplying", // 关闭状态且用户正在申请打开中
+  Off = 0,
+  On = 1,
 }
 
-export enum DeviceStatusReason {
-  ChangedBySelf = 0,
-  ChangedByAdmin = 1,
+export enum NetworkQuality {
+  Unknown = 0,
+  Excellent = 1,
+  Good = 2,
+  Poor = 3,
+  Bad = 4,
+  VeryBad = 5,
+  Down = 6,
 }
+
+export interface NetworkInfo {
+  userId: string;
+  quality: NetworkQuality;
+  upLoss: number;
+  downLoss: number;
+  delay: number;
+}
+

package/src/types/index.ts

@@ -1,5 +1,5 @@
 // common
-export * from './login';
+export type * from './login';
 // chat
 export * from './message';
 export * from './search';
@@ -15,7 +15,7 @@ export * from './types';
 export * from './live';
 export * from './stream';
 export * from './room';
-export * from './videoMixer';
+export type * from './videoMixer';
 export * from './audience';
 export * from './seat';
 export * from './monitor';

package/src/types/live.ts

@@ -33,14 +33,6 @@ export enum LiveOrientation {
   Portrait = 'portrait',
 }
 
-export enum LiveStatus {
-  IDLE = 'IDLE', // 未进入直播间的状态
-  NotStarted = 'NotStarted', // 进入直播间，直播未开始
-  Live = 'Live', // 进入直播间，直播中
-  Paused = 'Paused', // 进入直播间，直播暂停中，优先级低
-  Ended = 'Ended', // 进入直播间，直播已结束
-}
-
 export interface LayoutItem {
   locationX: number; // 以画面左上角为原点的 x 坐标
   locationY: number; // 以画面左上角为原点的 y 坐标
@@ -75,20 +67,20 @@ export interface LayoutInfo {
 export interface CreateLiveParams {
   liveId: string;
   liveName: string;
-  notice: string;
-  isMessageDisableForAllUser: boolean;
-  isGiftEnabled: boolean;
-  isLikeEnabled: boolean;
-  isPublicVisible: boolean;
-  isSeatEnabled: boolean;
-  keepOwnerOnSeat: boolean;
-  seatLayoutTemplateId: number;
-  maxSeatCount: number;
-  seatMode: TUISeatMode;
-  coverUrl: string;
-  backgroundUrl: string;
-  categoryList: Array<number>;
-  activityStatus: number;
+  notice?: string;
+  isMessageDisableForAllUser?: boolean;
+  isGiftEnabled?: boolean;
+  isLikeEnabled?: boolean;
+  isPublicVisible?: boolean;
+  isSeatEnabled?: boolean;
+  keepOwnerOnSeat?: boolean;
+  seatLayoutTemplateId?: number;
+  maxSeatCount?: number;
+  seatMode?: TUISeatMode;
+  coverUrl?: string;
+  backgroundUrl?: string;
+  categoryList?: Array<number>;
+  activityStatus?: number;
 }
 
 export interface JoinLiveParams {
@@ -104,3 +96,30 @@ export interface UpdateLiveInfoParams {
   isPublicVisible?: boolean;
   layoutTemplate?: number;
 }
+
+export enum LiveListEvent {
+  onLiveEnded = 'onLiveEnded',
+  onKickedOutOfLive = 'onKickedOutOfLive',
+}
+
+export enum LiveEndedReason {
+  endedByHost = 1,
+  endedByServer = 2,
+}
+
+export enum LiveKickedOutReason {
+  byAdmin = 0,
+  byLoggedOnOtherDevice = 1,
+  byServer = 2,
+  forNetworkDisconnected = 3,
+  forJoinRoomStatusInvalidDuringOffline = 4,
+  forCountOfJoinedRoomsExceedLimit = 5,
+}
+
+export interface LiveListEventInfo {
+  liveId: string;
+  reason: LiveEndedReason | LiveKickedOutReason;
+  message: string;
+}
+
+export type LiveListEventCallback = (eventInfo: LiveListEventInfo) => void;

package/src/types/seat.ts

@@ -1,14 +1,21 @@
-import { DeviceStatus, DeviceStatusReason } from './device';
+import { DeviceStatus } from './device';
 
 export type SeatUserInfo = {
-  liveId: string;
   userId: string;
   userName: string;
   avatarUrl: string;
+  // role: Role;  // 暂不支持，等 roomEngine 支持
+  liveId: string;
   microphoneStatus: DeviceStatus;
-  microphoneStatusReason: DeviceStatusReason;
+  allowOpenMicrophone: boolean;
   cameraStatus: DeviceStatus;
-  cameraStatusReason: DeviceStatusReason;
+  allowOpenCamera: boolean;
+}
+
+export enum Role {
+  Owner = 0,
+  Administrator = 1,
+  GeneralUser = 2,
 }
 
 export type RegionInfo = {
@@ -31,3 +38,20 @@ export interface LiveCanvas {
   height: number;
   background: string;
 }
+
+export enum MoveSeatPolicy {
+  AbortWhenOccupied = 0,
+  ForceReplace = 1,
+  SwapPosition = 2,
+}
+
+export enum DeviceControlPolicy {
+  UnlockOnly = 1,
+}
+
+export enum LiveSeatEvent {
+  onLocalCameraOpenedByAdmin = 'onLocalCameraOpenedByAdmin',
+  onLocalCameraClosedByAdmin = 'onLocalCameraClosedByAdmin',
+  onLocalMicrophoneOpenedByAdmin = 'onLocalMicrophoneOpenedByAdmin',
+  onLocalMicrophoneClosedByAdmin = 'onLocalMicrophoneClosedByAdmin',
+}

package/src/utils/eventCenter.ts

@@ -0,0 +1,249 @@
+/**
+ * 事件中心工具类
+ * 提供事件的订阅、取消订阅和触发功能
+ */
+
+// 事件回调函数类型
+export type EventCallback<T = any> = (data?: T) => void;
+
+// 事件监听器信息
+interface EventListener<T = any> {
+  callback: EventCallback<T>;
+  once: boolean;
+  id: string;
+}
+
+// 事件中心类
+export class EventCenter {
+  // 存储所有事件监听器
+  private listeners: Map<string, EventListener[]> = new Map();
+  // 用于生成唯一的监听器ID
+  private listenerIdCounter = 0;
+
+  /**
+   * 订阅事件
+   * @param event 事件名称
+   * @param callback 回调函数
+   * @returns 返回取消订阅的函数
+   */
+  on<T = any>(event: string, callback: EventCallback<T>): () => void {
+    if (!this.isValidEvent(event) || !this.isValidCallback(callback)) {
+      throw new Error('Invalid event name or callback function');
+    }
+
+    const listenerId = this.generateListenerId();
+    const listener: EventListener<T> = {
+      callback,
+      once: false,
+      id: listenerId,
+    };
+
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+
+    this.listeners.get(event)!.push(listener);
+
+    // 返回取消订阅函数
+    return () => this.off(event, listenerId);
+  }
+
+  /**
+   * 订阅事件（只触发一次）
+   * @param event 事件名称
+   * @param callback 回调函数
+   * @returns 返回取消订阅的函数
+   */
+  once<T = any>(event: string, callback: EventCallback<T>): () => void {
+    if (!this.isValidEvent(event) || !this.isValidCallback(callback)) {
+      throw new Error('Invalid event name or callback function');
+    }
+
+    const listenerId = this.generateListenerId();
+    const listener: EventListener<T> = {
+      callback,
+      once: true,
+      id: listenerId,
+    };
+
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+
+    this.listeners.get(event)!.push(listener);
+
+    // 返回取消订阅函数
+    return () => this.off(event, listenerId);
+  }
+
+  /**
+   * 取消订阅事件
+   * @param event 事件名称
+   * @param callbackOrId 回调函数或监听器ID
+   */
+  off(event: string, callbackOrId?: EventCallback | string): void {
+    if (!this.isValidEvent(event)) {
+      return;
+    }
+
+    const listeners = this.listeners.get(event);
+    if (!listeners) {
+      return;
+    }
+
+    // 如果没有提供回调函数或ID，则移除该事件的所有监听器
+    if (callbackOrId === undefined) {
+      this.listeners.delete(event);
+      return;
+    }
+
+    // 根据类型判断是回调函数还是ID
+    const isId = typeof callbackOrId === 'string';
+    const filteredListeners = listeners.filter(listener => {
+      if (isId) {
+        return listener.id !== callbackOrId;
+      } else {
+        return listener.callback !== callbackOrId;
+      }
+    });
+
+    if (filteredListeners.length === 0) {
+      this.listeners.delete(event);
+    } else {
+      this.listeners.set(event, filteredListeners);
+    }
+  }
+
+  /**
+   * 触发事件
+   * @param event 事件名称
+   * @param data 传递给回调函数的数据
+   */
+  emit<T = any>(event: string, data?: T): void {
+    if (!this.isValidEvent(event)) {
+      return;
+    }
+
+    const listeners = this.listeners.get(event);
+    if (!listeners || listeners.length === 0) {
+      return;
+    }
+
+    // 创建监听器副本，避免在执行过程中修改原数组
+    const listenersToExecute = [...listeners];
+    const onceListeners: string[] = [];
+
+    // 执行所有监听器
+    listenersToExecute.forEach(listener => {
+      try {
+        listener.callback(data);
+
+        // 记录需要移除的一次性监听器
+        if (listener.once) {
+          onceListeners.push(listener.id);
+        }
+      } catch (error) {
+        console.error(`Error executing event listener for "${event}":`, error);
+      }
+    });
+
+    // 移除一次性监听器
+    if (onceListeners.length > 0) {
+      onceListeners.forEach(id => this.off(event, id));
+    }
+  }
+
+  /**
+   * 获取指定事件的监听器数量
+   * @param event 事件名称
+   * @returns 监听器数量
+   */
+  getListenerCount(event?: string): number {
+    if (event) {
+      const listeners = this.listeners.get(event);
+      return listeners ? listeners.length : 0;
+    }
+
+    // 如果没有指定事件，返回所有监听器的总数
+    let totalCount = 0;
+    for (const listeners of this.listeners.values()) {
+      totalCount += listeners.length;
+    }
+    return totalCount;
+  }
+
+  /**
+   * 获取所有已注册的事件名称
+   * @returns 事件名称数组
+   */
+  getEventNames(): string[] {
+    return Array.from(this.listeners.keys());
+  }
+
+  /**
+   * 检查是否有指定事件的监听器
+   * @param event 事件名称
+   * @returns 是否有监听器
+   */
+  hasListeners(event: string): boolean {
+    return this.getListenerCount(event) > 0;
+  }
+
+  /**
+   * 清除所有事件监听器
+   */
+  clear(): void {
+    this.listeners.clear();
+  }
+
+  /**
+   * 清除指定事件的所有监听器
+   * @param event 事件名称
+   */
+  clearEvent(event: string): void {
+    if (this.isValidEvent(event)) {
+      this.listeners.delete(event);
+    }
+  }
+
+  /**
+   * 生成唯一的监听器ID
+   * @returns 监听器ID
+   */
+  private generateListenerId(): string {
+    return `listener_${++this.listenerIdCounter}_${Date.now()}`;
+  }
+
+  /**
+   * 验证事件名称是否有效
+   * @param event 事件名称
+   * @returns 是否有效
+   */
+  private isValidEvent(event: string): boolean {
+    return typeof event === 'string' && event.trim().length > 0;
+  }
+
+  /**
+   * 验证回调函数是否有效
+   * @param callback 回调函数
+   * @returns 是否有效
+   */
+  private isValidCallback(callback: EventCallback): boolean {
+    return typeof callback === 'function';
+  }
+}
+
+// 创建默认的全局事件中心实例
+export const eventCenter = new EventCenter();
+
+// 导出便捷方法
+export const on = eventCenter.on.bind(eventCenter);
+export const once = eventCenter.once.bind(eventCenter);
+export const off = eventCenter.off.bind(eventCenter);
+export const emit = eventCenter.emit.bind(eventCenter);
+export const clear = eventCenter.clear.bind(eventCenter);
+export const getListenerCount = eventCenter.getListenerCount.bind(eventCenter);
+export const getEventNames = eventCenter.getEventNames.bind(eventCenter);
+export const hasListeners = eventCenter.hasListeners.bind(eventCenter);
+
+export default eventCenter;