@tencentcloud/trtc-cloud-wx 1.0.7 → 1.0.9-beta.0

package/src/index.ts

@@ -0,0 +1,1184 @@
+import EventEmitter from 'eventemitter3'
+import TRTC from 'trtc-wx-sdk'
+import {
+  TRTCParams,
+  TRTCAppScene,
+  TRTCRoleType,
+  TRTCVideoStreamType,
+  TRTCVideoEncParam,
+  TRTCRenderParams,
+  TRTCAudioQuality,
+  TRTCVolumeInfo,
+  TRTCBeautyStyle,
+  AudioMusicParam,
+  TRTCAudioRoute,
+} from './interface'
+import {
+  setHandle, Handletype, TaskQueueEvent, taskMachine
+} from './TaskMachine'
+import {
+  translateTRTCAppScene,
+  translateTRTCStreamId,
+  translateTRTCVideoMirrorType,
+  translateTRTCVideoResolution,
+  translateTRTCVideoRotation,
+  translateVideoFillMod,
+  translateTRTCAudioRoute,
+  uniqueFunc,
+  isNumber,
+  safelyParse,
+  translateBeautyStyle
+} from './utils'
+
+import {logger} from './log/logger'
+
+import packageJson from '../package.json' // 假设 package.json 文件在项目根目录下
+
+export * from './interface'
+export * from './utils/translate'
+
+/**
+ * TRTCCloud
+ * @interface
+ */
+export class TRTCCloud {
+  static instance;
+
+  public version = packageJson.version;
+
+  // 内部使用，用于调用接口时UI测监听，完成剩余逻辑
+  public InterfaceEventEmitter = new EventEmitter();
+
+  // 外部使用，用户监听回调事件
+  private EventEmitter = new EventEmitter();
+
+  public trtc;
+
+  public TRTC_EVENT;
+
+  private role = TRTCRoleType.TRTCRoleAnchor;
+
+  private scene: TRTCAppScene;
+
+  public userId = '';
+
+  private isEnterRoom = false;
+
+  private isVideoMuted = false;
+
+  private isOpenCamera = false;
+
+  private currentSoundMode = TRTCAudioRoute.TRTC_AUDIO_ROUTE_SPEAKER;
+
+  private audioVolumeEvaluation = 0;
+
+  private encsmall = 0;
+
+  private enableinfiniteanchor = 0;
+
+  private allTimer: Record<string, NodeJS.Timer> = {};
+
+  private renderMap = new Map();
+
+  private pusherIsReady = false;
+
+  public logger = logger;
+
+  // private handleAudioVolumeUpdate: (userVolumes: Array<TRTCVolumeInfo>) => void;
+
+  constructor() {
+    this.init()
+  }
+
+  /**
+   * 获取 TRTCCloud 实例（单例模式）
+   * @category Base
+   */
+  static getTRTCShareInstance(): TRTCCloud {
+    if (!TRTCCloud.instance) {
+      TRTCCloud.instance = new TRTCCloud()
+    }
+    return TRTCCloud.instance
+  }
+
+  /**
+   * 销毁 TRTCCloud 实例（单例模式）
+   * @category Base
+   */
+  static destroyTRTCShareInstance(): void {
+    if (!TRTCCloud.instance) return
+    TRTCCloud.instance.destroy()
+    TRTCCloud.instance = null
+  }
+
+  public createSubCloud(): TRTCCloud {
+    return TRTCCloud.getTRTCShareInstance()
+  }
+
+  getSDKVersion(): string {
+    return this.version
+  }
+
+  private destroy(): void {
+    this.offTRTCEvent()
+    this.EventEmitter.removeAllListeners()
+    this.InterfaceEventEmitter.removeAllListeners()
+    this.trtc.exitRoom()
+  }
+
+  private init(): void {
+    this.trtc = new TRTC(this)
+    this.trtc.setLogLevel(3)
+    this.TRTC_EVENT = this.trtc.EVENT
+    this.bindTRTCEvent()
+    this.bindComponentEvent()
+    this.handleNetworkQuality = this.getHandleNetworkQuality(2000)
+  }
+
+  private reset(): void {
+    this.role = TRTCRoleType.TRTCRoleAnchor
+    this.userId = ''
+    this.isEnterRoom = false
+    this.isVideoMuted = false
+    this.isOpenCamera = false
+    this.currentSoundMode = TRTCAudioRoute.TRTC_AUDIO_ROUTE_SPEAKER
+    this.encsmall = 0
+    this.enableinfiniteanchor = 0
+    taskMachine.reset()
+    Object.keys(this.allTimer).forEach((key) => {
+      clearInterval(this.allTimer[key])
+      this.allTimer[key] = null
+    })
+  }
+
+  private bindComponentEvent(): void {
+    this.InterfaceEventEmitter.on('pusherDomReady', (isReady: boolean) => {
+      this.pusherIsReady = isReady
+      taskMachine.setPusherDomReady(isReady)
+      if (isReady) {
+        this.trtc.createPusher({})
+        taskMachine.send(TaskQueueEvent.SETPROCESS)
+      } else {
+        if (this.isEnterRoom) {
+          this.exitRoom()
+        }
+        taskMachine.send(TaskQueueEvent.SETDONE)
+      }
+    })
+
+    this.InterfaceEventEmitter.on('playerDomReady', ({isReady, view}) => {
+      taskMachine.setPlayerDomReady(view, isReady)
+      if (isReady) {
+        taskMachine.send(TaskQueueEvent.SETPROCESS, view)
+      } else {
+        taskMachine.send(TaskQueueEvent.SETDONE, view)
+      }
+    })
+  }
+
+  private bindTRTCEvent(): void {
+    this.trtc.on(this.TRTC_EVENT.LOCAL_LEAVE, (event) => {
+      // todo 第二个参数为进房耗时 此处调用start的时候处理
+      // this.emit('onEnterRoom', 0)
+    })
+    this.trtc.on(this.TRTC_EVENT.PLAYER_WARNING, (event) => {
+      const {code, message} = event.data
+      this.emit('onWarnning', code, message)
+    })
+    this.trtc.on(this.TRTC_EVENT.ERROR, (event) => {
+      const {code, message} = event.data
+      this.emit('onError', code, message)
+    })
+    this.trtc.on(this.TRTC_EVENT.REMOTE_USER_JOIN, (event) => {
+      const {userID} = event.data
+      this.emit('onRemoteUserEnterRoom', userID)
+    })
+    // 远端用户退出
+    this.trtc.on(this.TRTC_EVENT.REMOTE_USER_LEAVE, (event) => {
+      const {userID, playerList} = event.data
+      this.InterfaceEventEmitter.emit('onRemoteUserLeaveRoom', userID, 0)
+      this.emit('onUserVideoAvailable', userID, 0)
+      this.emit('onUserSubStreamAvailable', userID, 0)
+      this.emit('onRemoteUserLeaveRoom', userID, 0)
+    })
+    // 远端用户推送视频
+    this.trtc.on(this.TRTC_EVENT.REMOTE_VIDEO_ADD, (event) => {
+      const {player} = event.data
+      this.emit(player.streamType === 'aux' ? 'onUserSubStreamAvailable' : 'onUserVideoAvailable', player.userID, 1)
+    })
+    // 远端用户取消推送视频
+    this.trtc.on(this.TRTC_EVENT.REMOTE_VIDEO_REMOVE, (event) => {
+      const {player} = event.data
+      this.emit(player.streamType === 'aux' ? 'onUserSubStreamAvailable' : 'onUserVideoAvailable', player.userID, 0)
+    })
+    // 远端用户推送音频
+    this.trtc.on(this.TRTC_EVENT.REMOTE_AUDIO_ADD, (event) => {
+      const {player} = event.data
+      this.emit('onUserAudioAvailable', player.userID, 1)
+    })
+    // 远端用户取消推送音频
+    this.trtc.on(this.TRTC_EVENT.REMOTE_AUDIO_REMOVE, (event) => {
+      const {player} = event.data
+      this.emit('onUserAudioAvailable', player.userID, 0)
+    })
+    this.trtc.on(this.TRTC_EVENT.REMOTE_AUDIO_VOLUME_UPDATE, (event) => {
+      const {playerList} = event.data
+      const userVolumes = playerList.map((player) => ({
+        userId: player.userID,
+        volume: player.volume,
+      }))
+      this.handleAudioVolumeUpdate(userVolumes)
+    })
+    this.trtc.on(this.TRTC_EVENT.LOCAL_AUDIO_VOLUME_UPDATE, (event) => {
+      const {pusher} = event.data
+      const userVolumes = [
+        {
+          userId: pusher.userID,
+          volume: pusher.volume,
+        },
+      ]
+      this.handleAudioVolumeUpdate(userVolumes)
+    })
+    this.trtc.on(this.TRTC_EVENT.LOCAL_NET_STATE_UPDATE, (event) => {
+      const {pusher} = event.data
+      this.handleNetworkQuality({pusher})
+    })
+    this.trtc.on(this.TRTC_EVENT.REMOTE_NET_STATE_UPDATE, (event) => {
+      const {playerList} = event.data
+      this.handleNetworkQuality({playerList})
+    })
+  }
+
+  private offTRTCEvent(): void {
+    this.trtc.off(this.TRTC_EVENT.LOCAL_LEAVE)
+    this.trtc.off(this.TRTC_EVENT.ERROR)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_USER_JOIN)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_USER_LEAVE)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_VIDEO_ADD)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_VIDEO_REMOVE)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_AUDIO_ADD)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_AUDIO_REMOVE)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_AUDIO_VOLUME_UPDATE)
+    this.trtc.off(this.TRTC_EVENT.REMOTE_NET_STATE_UPDATE)
+  }
+
+  private getHandleAudioVolumeUpdate(
+    interval: number
+  ): (userVolumes: Array<TRTCVolumeInfo>) => void {
+    if (this.allTimer?.AudioVolume) {
+      clearInterval(this.allTimer.AudioVolume)
+      this.allTimer.AudioVolume = null
+    }
+    if (interval === 0) return (): void => { }
+    let tempUserVolumes = []
+    const filterUselessItem = function (userId: string): void {
+      tempUserVolumes = tempUserVolumes.filter(userVolume => userVolume.userId !== userId)
+    }
+    this.InterfaceEventEmitter.off('onRemoteUserLeaveRoom') // 防止重复监听
+    this.InterfaceEventEmitter.on('onRemoteUserLeaveRoom', filterUselessItem, this.getHandleAudioVolumeUpdate)
+    return (userVolumes: Array<TRTCVolumeInfo>): void => {
+      tempUserVolumes = uniqueFunc(
+        [...userVolumes, ...tempUserVolumes],
+        'userId'
+      )
+      if (this.allTimer.AudioVolume) return
+      const timer = setInterval(() => {
+        this.emit(
+          'onUserVoiceVolume',
+          tempUserVolumes,
+          tempUserVolumes.length,
+          0 // todo 此参数无用，暂时废弃
+        )
+      }, interval)
+      this.allTimer.AudioVolume = timer
+    }
+  }
+
+  private handleAudioVolumeUpdate(userVolumes: Array<TRTCVolumeInfo>): void { }
+
+  private getHandleNetworkQuality(
+    interval: number
+  ): (data: {
+    pusher?: Record<string, unknown>;
+    playerList?: Array<Record<string, unknown>>;
+  }) => void {
+    if (this.allTimer?.networkQuality) {
+      clearInterval(this.allTimer.networkQuality)
+      this.allTimer.networkQuality = null
+    }
+    if (interval === 0) return (): void => { }
+    const resultQuality = {localQuality: null, remoteQuality: []}
+    this.on('onRemoteUserLeaveRoom', (userId) => {
+      resultQuality.remoteQuality = resultQuality.remoteQuality.filter(quality => quality.userId !== userId)
+    }, this)
+
+    return (data): void => {
+      const {pusher, playerList} = data
+      if (pusher) resultQuality.localQuality = {userId: pusher.userID, quality: pusher.netStatus}
+      if (playerList) {
+        resultQuality.remoteQuality = playerList.map(player => ({
+          userId: player.userID,
+          quality: player.netStatus
+        }))
+      }
+      if (this.allTimer.networkQuality) return
+      const timer = setInterval(() => {
+        this.emit('onNetworkQuality', resultQuality.localQuality, resultQuality.remoteQuality)
+      }, interval)
+      this.allTimer.networkQuality = timer
+    }
+  }
+
+  private handleNetworkQuality(quality: {
+    pusher?: Record<string, unknown>;
+    playerList?: Array<Record<string, unknown>>;
+  }): void { }
+
+  /**
+   * @category Base
+   */
+  on(eventName, handler, context): void {
+    this.EventEmitter.on(eventName, handler, context)
+  }
+
+  /**
+   * @category Base
+   */
+  off(eventName, handler, context): void {
+    this.EventEmitter.off(eventName, handler, context)
+  }
+
+  /**
+   * @category Base
+   */
+  emit(eventName, ...args): void {
+    this.EventEmitter.emit(eventName, ...args)
+  }
+
+  /**
+   * @category 房间
+   */
+  async enterRoom(params: TRTCParams, scene: TRTCAppScene): Promise<void> {
+    if (this.isEnterRoom) {
+      logger.warn('You are already in the room, please exit the current room first.')
+      return
+    }
+    this.trtc.createPusher({})
+    const startTime = new Date().getTime()
+    const {
+      sdkAppId,
+      userId,
+      userSig,
+      roomId,
+      strRoomId,
+      role,
+      privateMapKey,
+    } = params
+    logger.setInfo({sdkAppId, userId, roomId: strRoomId})
+    logger.info('enterRoom with options: ', JSON.stringify(params), scene)
+    this.userId = userId
+    this.isEnterRoom = true
+    try {
+      await this.setAttributes({
+        params: {
+          sdkAppID: sdkAppId, // 您的腾讯云账号
+          userID: userId, // 当前进房用户的userID
+          userSig, // 您服务端生成的userSig
+          roomID: roomId, // 您进房的房间号，
+          strRoomID: strRoomId,
+          role,
+          privateMapKey,
+          scene: translateTRTCAppScene(scene),
+          enableMic: false, // 进房默认开启音频上行
+          enableCamera: false, // 进房默认开启视频上行
+          videoPreview: false,
+          encsmall: this.encsmall,
+          enableinfiniteanchor: this.enableinfiniteanchor, // 是否开启无限主播
+          recvMode: this.enableinfiniteanchor ? 2 : 1, // 1 自动接收音视频 2 仅自动接收音频
+        }
+      }, 'enterRoom')
+    } catch (error) {
+      this.isEnterRoom = false
+      logger.info('enterRoom fail')
+      this.emit('onEnterRoom', -1)
+    }
+    this.trtc.getPusherInstance().start({
+      success: async () => {
+        logger.info('enterRoom success')
+        this.scene = scene
+        const endTime = new Date().getTime()
+        this.emit('onEnterRoom', endTime - startTime)
+        if (this.trtc.getPusherAttributes().videoPreview === true) {
+          // 如果进房前有打开摄像头，需要开启视频上行，并抛出 onSendFirstLocalVideoFrame 事件
+          await this.setAttributes(
+            {
+              params: {
+                videoPreview: false,
+                enableCamera: true,
+              }
+            },
+            'other'
+          )
+          this.emit(
+            'onSendFirstLocalVideoFrame',
+            TRTCVideoStreamType.TRTCVideoStreamTypeBig,
+          )
+        }
+      },
+      fail: () => {
+        this.isEnterRoom = false
+        logger.info('enterRoom fail')
+        this.emit('onEnterRoom', -1)
+      },
+    })
+  }
+
+  /**
+   * @category 房间
+   */
+  exitRoom(): void {
+    logger.info('exitRoom')
+    const {pusher} = this.trtc.exitRoom()
+    this.reset()
+    if (!this.pusherIsReady) {
+      logger.info('exitRoom success')
+      this.emit('onExitRoom', 0)
+    } else {
+      this.InterfaceEventEmitter.emit('pusherAttributesChange', {
+        pusher,
+        callback: () => {
+          logger.info('exitRoom success')
+          this.emit('onExitRoom', 0)
+        },
+      })
+    }
+  }
+
+  /**
+   * @category 房间
+   */
+  switchRoom(): void { }
+
+  /**
+   * 切换角色，仅适用于直播场景（TRTCAppSceneLIVE 和 TRTCAppSceneVoiceChatRoom）
+   * @category 房间
+   */
+  async switchRole(role: TRTCRoleType): Promise<void> {
+    logger.info('switchRole with options: ', role)
+    const tempRole = this.role
+    this.role = role
+    if (tempRole === role || role === TRTCRoleType.TRTCRoleAnchor) {
+      logger.info('switchRole success')
+      this.emit('onSwitchRole', 0, '')
+      return
+    }
+    await this.setAttributes({params: {enableCamera: false, enableMic: false}}, 'switchRole')
+    logger.info('switchRole success')
+    this.emit('onSwitchRole', 0, '')
+  }
+
+  connectOtherRoom(): void { }
+
+  disconnectOtherRoom(): void { }
+
+  setDefaultStreamRecvMode(): void { }
+
+  useVirtualBackground(): void { }
+
+  /**
+   * 启动本地摄像头采集和预览
+   * @category 视频
+   */
+  async startLocalPreview(frontCamera = true): Promise<void> {
+    logger.info('startLocalPreview with options: ', frontCamera)
+    if (this.role !== TRTCRoleType.TRTCRoleAnchor) {
+      return
+    }
+    const pusher = await this.setAttributes({
+      params: () => ({
+        videoPreview: this.isEnterRoom ? this.isVideoMuted : true,
+        enableCamera: this.isEnterRoom ? !this.isVideoMuted : false,
+        frontCamera: frontCamera ? 'front' : 'back',
+      })
+    }, 'startLocalPreview')
+    logger.info('startLocalPreview success')
+    this.emit('onCameraDidReady')
+    this.emit(
+      'onFirstVideoFrame',
+      '',
+      TRTCVideoStreamType.TRTCVideoStreamTypeBig,
+      pusher.videoWidth,
+      pusher.videoHeight
+    )
+    if (this.isEnterRoom) {
+      this.emit(
+        'onSendFirstLocalVideoFrame',
+        TRTCVideoStreamType.TRTCVideoStreamTypeBig,
+      )
+    }
+    this.isOpenCamera = true
+  }
+
+  /**
+   * 停止本地摄像头采集和预览
+   * @category 视频
+   */
+  async stopLocalPreview(): Promise<void> {
+    logger.info('stopLocalPreview')
+    await this.setAttributes({
+      params: {
+        videoPreview: false,
+        enableCamera: false,
+      }
+    }, 'stopLocalPreview')
+    logger.info('stopLocalPreview success')
+    this.isOpenCamera = false
+    this.emit('onUserVideoAvailable', this.userId, 0)
+  }
+
+  /**
+   * 修改本地摄像头预览的 HTML 元素，小程序不支持
+   * @category 视频
+   */
+  updateLocalView(view: string | null): void {
+    logger.info('updateLocalView with options: ', view)
+    if (view !== null) {
+      this.startLocalPreview()
+      return
+    }
+    this.stopLocalPreview()
+  }
+
+  /**
+   * 暂停/恢复发布本地的视频流
+   * @category 视频
+   * @param  {boolean} mute true：屏蔽；false：开启，默认值：false
+   * @param {TRTCVideoStreamType} streamType 要暂停/恢复的视频流类型, 仅支持 TRTCVideoStreamTypeBig 和 TRTCVideoStreamTypeSub
+   */
+  async muteLocalVideo(
+    mute: boolean,
+    streamType: TRTCVideoStreamType
+  ): Promise<void> {
+    logger.info('muteLocalVideo called with options: ', mute, streamType)
+    if (!this.isOpenCamera) {
+      logger.info('muteLocalVideo early exit: isOpenCamera is false')
+      return
+    }
+    switch (streamType) {
+      case TRTCVideoStreamType.TRTCVideoStreamTypeBig:
+      case TRTCVideoStreamType.TRTCVideoStreamTypeSub:
+        this.isVideoMuted = mute
+        logger.info('muteLocalVideo: isVideoMuted set to ', mute)
+        try {
+          await this.setAttributes({
+            params: {
+              videoPreview: mute,
+              enableCamera: !mute,
+            }
+          }, 'muteLocalVideo')
+          logger.info('muteLocalVideo: setAttributes success')
+        } catch (error) {
+          logger.error('muteLocalVideo: setAttributes failed with error ', error)
+        }
+        logger.info('muteLocalVideo success')
+        break
+      default:
+        logger.info('muteLocalVideo: streamType not supported ', streamType)
+    }
+  }
+
+  /**
+   * 开始显示远端视频画面
+   * @category 视频
+   * @param userId 对方的用户标识
+   * @param view 此参数无效，小程序不支持
+   * @param streamType 视频流类型
+   */
+  async startRemoteView(
+    userId: string,
+    view: string,
+    streamType: TRTCVideoStreamType
+  ): Promise<void> {
+    logger.info('startRemoteView with options: ', userId, view, streamType)
+    const streamId = translateTRTCStreamId(userId, streamType) // trtc
+    this.renderMap.set(streamId, view)
+    await this.setAttributes({
+      params: {
+        muteVideo: false,
+        stopVideo: false,
+      },
+      streamId,
+      view
+    }, 'startRemoteView')
+    this.updateAudioRoute()
+    logger.info('startRemoteView success')
+    this.emit('onFirstVideoFrame', userId, streamType, 0, 0)
+  }
+
+  /**
+   * 停止显示远端视频画面，同时不再拉取该远端用户的视频数据流
+   * @param userId 对方的用户标识
+   * @param streamType 视频流类型
+   */
+  async stopRemoteView(userId: string, streamType: TRTCVideoStreamType): Promise<void> {
+    logger.info('stopRemoteView with options: ', userId, streamType)
+    const streamId = translateTRTCStreamId(userId, streamType)
+    await this.setAttributes({
+      params: {
+        muteVideo: true,
+        stopVideo: true,
+      },
+      streamId,
+      view: this.renderMap.get(streamId),
+    }, 'stopRemoteView')
+    logger.info('stopRemoteView success')
+  }
+
+  /**
+   * 修改远端视频渲染的 HTML 元素，小程序不支持
+   * @param userId 远端视频流的用户 ID
+   * @param view
+   * 接受远端视频流渲染的 HTML 元素，传入 null 结束远端视频的渲染
+   * - 传入的 HTML 元素必须时块元素，例如：div
+   * @param streamType
+   * @returns
+   */
+  async updateRemoteView(
+    userId: string,
+    view: string,
+    streamType: TRTCVideoStreamType
+  ): Promise<void> {
+    logger.info('updateRemoteView with options: ', userId, view, streamType)
+    if (view !== null) {
+      await this.startRemoteView(userId, view, streamType)
+      return
+    }
+    await this.stopRemoteView(userId, streamType)
+  }
+
+
+  // 停止显示所有远端视频画面，同时不再拉取该远端用户的视频数据流
+  async stopAllRemoteView(): Promise<void> {
+    logger.info('stopAllRemoteView')
+    const playerList = this.trtc.getPlayerList()
+    playerList.forEach(async (player) => {
+      const streamId = player.streamID
+      await this.setAttributes({
+        params: {
+          muteVideo: true,
+          stopVideo: true,
+        },
+        streamId,
+        view: this.renderMap.get(streamId),
+      }, 'stopAllRemoteView')
+    })
+    logger.info('stopAllRemoteView success')
+  }
+
+  // 暂停接收指定的远端视频流
+  // 该接口仅停止接收远程用户的视频流，但并不释放显示资源，所以视频画面会冻屏在 mute 前的最后一帧。
+  async muteRemoteVideoStream(
+    userId: string,
+    mute: boolean,
+    streamType: TRTCVideoStreamType
+  ): Promise<void> {
+    logger.info('muteRemoteVideoStream')
+    const streamId = translateTRTCStreamId(userId, streamType)
+    await this.setAttributes({
+      params: {muteVideo: mute},
+      streamId,
+      view: this.renderMap.get(streamId),
+    }, 'muteRemoteVideoStream')
+    logger.info('muteRemoteVideoStream success')
+  }
+
+  async muteAllRemoteVideoStreams(mute: boolean): Promise<void> {
+    logger.info('muteAllRemoteVideoStreams with options: ', mute)
+    const playerList = this.trtc.getPlayerList()
+    playerList.forEach(async (player) => {
+      const streamId = player.streamID
+      await this.setAttributes({
+        params: {muteVideo: mute},
+        streamId,
+        view: this.renderMap.get(streamId),
+      }, 'muteAllRemoteVideoStreams')
+    })
+    logger.info('muteAllRemoteVideoStreams success')
+  }
+
+  private setTRTCPlayerAttributes(streamId, options): object {
+    logger.info('setTRTCPlayerAttributes with options: ', streamId, options)
+    this.trtc.setPlayerAttributes(streamId, options)
+    return this.trtc.getPlayerInstance(streamId)?.playerAttributes || {}
+  }
+
+  async setVideoEncoderParam(params: TRTCVideoEncParam): Promise<void> {
+    logger.info('setVideoEncoderParam with options: ', JSON.stringify(params))
+    const {
+      videoResolution,
+      resMode,
+      videoFps,
+      videoBitrate,
+      minVideoBitrate,
+    } = params
+    const {videoWidth, videoHeight} =
+      translateTRTCVideoResolution(videoResolution)
+    await this.setAttributes({
+      params: {
+        videoWidth,
+        videoHeight,
+        // videoOrientation,
+        fps: videoFps,
+        minBitrate: minVideoBitrate,
+      }
+    }, 'setVideoEncoderParam')
+    logger.info('setVideoEncoderParam success')
+  }
+
+  async setLocalRenderParams(params: TRTCRenderParams): Promise<void> {
+    logger.info('setLocalRenderParams with options: ', JSON.stringify(params))
+    const {rotation, fillMode, mirrorType} = params
+    const videoOrientation = translateTRTCVideoRotation(rotation)
+    const localMirror = translateTRTCVideoMirrorType(mirrorType)
+    await this.setAttributes({
+      params: {
+        videoOrientation,
+        localMirror,
+      }
+    }, 'setLocalRenderParams')
+    logger.info('setLocalRenderParams success')
+  }
+
+  /**
+   * 设置远端图像的渲染模式
+   * @param {string} userId
+   * @param {TRTCVideoStreamType} streamType
+   * @param {TRTCRenderParams} params
+   */
+  async setRemoteRenderParams(
+    userId: string, streamType: TRTCVideoStreamType, params: TRTCRenderParams
+  ): Promise<void> {
+    logger.info('setRemoteRenderParams with options: ', userId, streamType, JSON.stringify(params))
+    const {fillMode, rotation, mirrorType} = params
+    const streamId = translateTRTCStreamId(userId, streamType) // 音频默认都是主流
+    await this.setAttributes({
+      params: {
+        objectFit: translateVideoFillMod(fillMode),
+        orientation: translateTRTCVideoRotation(rotation)
+      },
+      streamId,
+      view: this.renderMap.get(streamId),
+    }, 'setRemoteRenderParams')
+    logger.info('setRemoteRenderParams success')
+  }
+
+  async startLocalAudio(quality: TRTCAudioQuality): Promise<void> {
+    logger.info('startLocalAudio with options: ', quality)
+    if (this.role !== TRTCRoleType.TRTCRoleAnchor) {
+      throw new Error('Current role is audience, unable to access mic. Call switchRole to become a host.')
+    }
+    const getAudioQuality = (quality: TRTCAudioQuality) => {
+      if (quality === TRTCAudioQuality.TRTCAudioQualitySpeech) {
+        return 'low'
+      }
+      return 'high'
+    }
+
+    await this.setAttributes({params: {enableMic: true, audioQuality: getAudioQuality(quality)}}, 'startLocalAudio')
+    logger.info('startLocalAudio success')
+    this.emit('onMicDidReady')
+    if (this.enterRoom) {
+      this.emit('onSendFirstLocalAudioFrame')
+    }
+  }
+
+  async stopLocalAudio(): Promise<void> {
+    logger.info('stopLocalAudio')
+    await this.setAttributes({params: {enableMic: false}}, 'stopLocalAudio')
+    logger.info('stopLocalAudio success')
+  }
+
+  async muteLocalAudio(mute: boolean): Promise<void> {
+    logger.info('muteLocalAudio called with options: ', mute)
+
+    try {
+      await this.setAttributes({params: {muted: mute}}, 'muteLocalAudio')
+      logger.info('setAttributes executed successfully')
+    } catch (error) {
+      logger.error('Error in setAttributes: ', error)
+      throw error
+    }
+
+    try {
+      this.emit('onUserAudioAvailable', this.userId, mute === true ? 0 : 1)
+      logger.info('onUserAudioAvailable event emitted successfully')
+    } catch (error) {
+      logger.error('Error in emitting onUserAudioAvailable event: ', error)
+      throw error
+    }
+
+    logger.info('muteLocalAudio execution finished')
+  }
+
+  async setAudioRoute(route: TRTCAudioRoute): Promise<void> {
+    logger.info('setAudioRoute with options: ', route)
+    this.currentSoundMode = route
+    const soundMode = translateTRTCAudioRoute(route)
+    try {
+      await this.playerAudioRouteChange({
+        soundMode,
+      })
+      logger.info('setAudioRoute success')
+    } catch (error) {
+      logger.error('Error in setAttributes: ', error)
+      throw error
+    }
+  }
+
+  private async updateAudioRoute(): Promise<void> {
+    logger.info('updateAudioRoute with options: ', this.currentSoundMode)
+    const soundMode = translateTRTCAudioRoute(this.currentSoundMode)
+    try {
+      await this.playerAudioRouteChange({
+        soundMode,
+      })
+    } catch (error) {
+      logger.error('Error in setAttributes: ', error)
+      throw error
+    }
+  }
+
+  async muteRemoteAudio(userId: string, mute: boolean): Promise<void> {
+    logger.info('muteRemoteAudio with options: ', userId, mute)
+    const streamId = translateTRTCStreamId(
+      userId,
+      TRTCVideoStreamType.TRTCVideoStreamTypeBig
+    ) // 音频默认都是主流
+    await this.setAttributes({
+      params: {
+        muteAudio: mute,
+      },
+      streamId,
+      view: this.renderMap.get(streamId),
+    }, 'muteRemoteAudio')
+    logger.info('muteRemoteAudio success')
+  }
+
+  async muteAllRemoteAudio(mute: boolean): Promise<void> {
+    logger.info('muteAllRemoteAudio with options: ', mute)
+    const playerList = this.trtc.getPlayerList()
+    playerList.forEach(async (player) => {
+      const streamId = player.streamID
+      await this.setAttributes({
+        params: {
+          muteAudio: mute,
+        },
+        streamId,
+        view: this.renderMap.get(streamId),
+      }, 'muteRemoteAudio')
+    })
+    logger.info('muteAllRemoteAudio success')
+  }
+
+  enableAudioVolumeEvaluation(interval: number): void {
+    logger.info('enableAudioVolumeEvaluation with options: ', interval)
+    this.handleAudioVolumeUpdate = this.getHandleAudioVolumeUpdate(interval)
+  }
+
+  /**
+   * 切换前后摄像头
+   */
+  switchCamera(frontCamera: boolean): Promise<any> {
+    logger.info('switchCamera with options: ', frontCamera)
+    const pusher = this.trtc.getPusherInstance()
+    if (frontCamera === (pusher.pusherAttributes.frontCamera === 'front')) return Promise.resolve()
+    return new Promise((resolve, reject) => {
+      wx.createLivePusherContext().switchCamera({
+        success: async (event) => {
+          await this.setAttributes(
+            {params: {frontCamera: frontCamera ? 'front' : 'back'}},
+            'switchCamera'
+          )
+          logger.info('switchCamera success')
+          resolve(event)
+        },
+        fail: (error) => {
+          logger.info('switchCamera fail')
+          reject(error)
+        },
+      })
+    })
+  }
+
+  async setBeautyStyle(
+    style: TRTCBeautyStyle,
+    beauty: number,
+    white: number,
+    ruddiness: number
+  ): Promise<void> {
+    logger.info('setBeautyStyle with options: ', style, beauty, white, ruddiness)
+    await this.setAttributes({
+      params: {
+        beautyStyle: translateBeautyStyle(style),
+        beautyLevel: beauty,
+        whitenessLevel: white,
+      }
+    }, 'setBeautyStyle')
+    logger.info('setBeautyStyle success')
+  }
+
+  sendSEIMsg(msg: string, repeatCount = 1): Promise<any> {
+    logger.info('sendSEIMsg with options: ', msg, repeatCount)
+    return new Promise((resolve, reject) => {
+      wx.createLivePusherContext().sendMessage({
+        msg,
+        success: (event) => {
+          logger.info('sendSEIMsg success')
+          resolve(event)
+        },
+        fail: (error) => {
+          logger.info('sendSEIMsg fail')
+          reject(error)
+        },
+      })
+    })
+  }
+
+  startPlayMusic(
+    musicParam: AudioMusicParam,
+    callbackMap: Record<'onStart' | 'onPlayProgress' | 'onComplete', () => void>
+  ): Promise<any> {
+    logger.info('startPlayMusic with options: ', JSON.stringify(musicParam))
+    return new Promise((resolve, reject) => {
+      const {path, startTimeMS = 0, endTimeMS = 0} = musicParam
+      wx.createLivePusherContext().playBGM({
+        url: path,
+        startTimeMs: startTimeMS,
+        endTimeMs: endTimeMS,
+        success: (event) => {
+          logger.info('startPlayMusic success')
+          resolve(event)
+        },
+        fail: (error) => {
+          logger.info('startPlayMusic fail')
+          reject(error)
+        },
+      })
+    })
+  }
+
+  stopPlayMusic(): Promise<any> {
+    logger.info('stopPlayMusic')
+    return new Promise((resolve, reject) => {
+      wx.createLivePusherContext().stopBGM({
+        success: (event) => {
+          logger.info('stopPlayMusic success')
+          resolve(event)
+        },
+        fail: (error) => {
+          logger.info('stopPlayMusic fail')
+          reject(error)
+        },
+      })
+    })
+  }
+
+  pausePlayMusic(): Promise<any> {
+    logger.info('pausePlayMusic')
+    return new Promise((resolve, reject) => {
+      wx.createLivePusherContext().pauseBGM({
+        success: (event) => {
+          logger.info('pausePlayMusic success')
+          resolve(event)
+        },
+        fail: (error) => {
+          logger.info('pausePlayMusic fail')
+          reject(error)
+        },
+      })
+    })
+  }
+
+  resumePlayMusic(): Promise<any> {
+    logger.info('resumePlayMusic')
+    return new Promise((resolve, reject) => {
+      wx.createLivePusherContext().resumeBGM({
+        success: (event) => {
+          logger.info('resumePlayMusic success')
+          resolve(event)
+        },
+        fail: (error) => {
+          logger.info('resumePlayMusic fail')
+          reject(error)
+        },
+      })
+    })
+  }
+
+  // 设置背景音乐的音量大小，播放背景音乐混音时使用，用来控制背景音音量大小
+  setAllMusicVolume(volume: number): Promise<any> {
+    logger.info('setAllMusicVolume with options: ', volume)
+    return new Promise((resolve, reject) => {
+      const volumeStr = (volume / 200).toString()
+      wx.createLivePusherContext().setBGMVolume({
+        volume: volumeStr,
+        success: (event) => {
+          logger.info('setAllMusicVolume success')
+          resolve(event)
+        },
+        fail: (error) => {
+          logger.info('setAllMusicVolume fail')
+          reject(error)
+        },
+      })
+    })
+  }
+
+  // 开启大小画面双路编码模式
+  enableSmallVideoStream(enable: boolean, params: TRTCVideoEncParam) {
+    logger.info('enableSmallVideoStream with options: ', enable, JSON.stringify(params))
+    this.encsmall = enable ? 1 : 0
+  }
+
+  /**
+   * 调用实验性 API 接口
+   *
+   * 注意：该接口用于调用一些实验性功能, 目前 web 端空实现
+   *
+   * @param {String} jsonStr - 接口及参数描述的 JSON 字符串
+   */
+  callExperimentalAPI(jsonStr: string): void {
+    logger.info('callExperimentalAPI with options: ', jsonStr)
+    const jsonObj = safelyParse(jsonStr)
+    if (jsonObj === jsonStr) {
+      return
+    }
+    const {api, params} = jsonObj
+    if (!api || !params) {
+      return
+    }
+    switch (api) {
+      case 'setFramework':
+        this.handleSetFrameWork(params)
+        break
+      case 'enableInfiniteAnchor':
+        this.enableinfiniteanchor = params?.enable ? 1 : 0
+        break
+      default:
+        break
+    }
+  }
+
+  private handleSetFrameWork(params: any): void {
+    const {component} = params
+    if (isNumber(component)) {
+      try {
+        if (wx) {
+          wx.TUIScene = component
+          wx.setStorageSync('TUIScene', String(component))
+        }
+      } catch (err) {
+        throw err
+      }
+    }
+  }
+
+  private pusherAttributesChange(pusher: any): Promise<any> {
+    return new Promise((resolve) => {
+      this.InterfaceEventEmitter.emit(
+        'pusherAttributesChange',
+        {
+          pusher,
+          callback: () => {
+            resolve(pusher)
+          },
+        }
+      )
+    })
+  }
+
+  private playerAttributesChange(params: any): Promise<any> {
+    const {streamId, playerAttributes} = params
+    return new Promise((resolve) => {
+      this.InterfaceEventEmitter.emit(
+        'playerAttributesChange',
+        {
+          streamId,
+          view: this.renderMap.get(streamId),
+          playerAttributes,
+          callback: () => {
+            resolve(playerAttributes)
+          }
+        }
+      )
+    })
+  }
+
+  private playerAudioRouteChange(params: any): Promise<any> {
+    const {soundMode} = params
+    return new Promise((resolve) => {
+      this.InterfaceEventEmitter.emit(
+        'playerAudioRouteChange',
+        {
+          soundMode,
+          callback: () => {
+            resolve(soundMode)
+          }
+        }
+      )
+    })
+  }
+
+  @setHandle
+  private async setAttributes(options: any, funName: string, handleType?: Handletype): Promise<any> {
+    const {params, streamId} = options
+    const handleMap = {
+      [Handletype.setPlayer]: async () => {
+        const playerAttributes = await this.playerAttributesChange({
+          playerAttributes: this.setTRTCPlayerAttributes(streamId, params),
+          streamId
+        })
+        return playerAttributes
+      },
+      [Handletype.setPusher]: async () => {
+        if (funName === 'enterRoom') {
+          const pusher = await this.pusherAttributesChange(this.trtc.enterRoom(params))
+          return pusher
+        }
+        const pusher = await this.pusherAttributesChange(this.trtc.setPusherAttributes(params))
+        return pusher
+      }
+    }
+    // 定义一个超时时间（以毫秒为单位）
+    const timeoutDuration = 2000
+    // 定义超时重试次数
+    const retriesNumber = 3
+    return this.retryWithTimeout(
+      () => (handleMap[handleType]
+        ? handleMap[handleType]()
+        : Promise.reject(Object.assign(new Error('setAttributes fail'), {errorCode: -1}))),
+      timeoutDuration,
+      retriesNumber
+    )
+  }
+
+  private async retryWithTimeout<T>(fn: () => Promise<T>, timeout: number, retries: number): Promise<T> {
+    let lastError = null
+    for (let i = 0; i < retries; i++) {
+      try {
+        logger.info(`setAttributes ${i + 1}st retry`)
+        const result = await Promise.race([
+          fn(),
+          new Promise<T>((resolve, reject) => setTimeout(() => reject(new Error('setAttributes timed out')), timeout)),
+        ])
+        return result
+      } catch (error) {
+        if (error?.errorCode === -1) return error
+        lastError = error
+      }
+    }
+    throw lastError
+  }
+}
+
+export default TRTCCloud