trtc-cloud-js-sdk 1.0.13 → 2.0.0

package/src/index.ts

@@ -0,0 +1,1672 @@
+import { EventEmitter } from 'events';
+import {
+  TRTCAppScene,
+  TRTCVideoEncParam,
+  TRTCRenderParams,
+  TRTCVideoMirrorType,
+  TRTCVideoFillMode,
+  TRTCVideoStreamType,
+  TRTCRoleType,
+  TRTCDeviceInfo,
+  TRTCVideoResolution,
+  TRTCAudioQuality,
+  TRTCDeviceType,
+  TRTCDeviceState,
+  TRTCQualityInfo,
+  TRTCQuality,
+  TRTCVideoRotation,
+} from './common/trtc-define';
+import { EnterRoomFailure, RoleMap, SceneMap, NAME, audioQualityMap } from './common/constants';
+import { MixinsClass, performanceNow, isUndefined, debounce } from './utils/utils';
+import { VideoFillMode, ITRTCCloudConfig, IEnterRoomParams, IVideoProfile, IVideoPlayOption } from './common/ITRTCCloud';
+import { IError } from './common/IError';
+import { NotSupportError, jsExecuteError, ParametersError } from './common/trtc-code';
+import { version } from '../package.json';
+import TRTC from 'trtc-sdk-v5';
+export * from './common/trtc-define';
+let trtcCloudInstance: TRTC_Cloud | null = null;
+const LOG_PREFIX = '【TRTCCloud】';
+
+TRTC._loggerManager.info(`TRTCCloud Version: ${version}`);
+
+class TRTC_Cloud extends MixinsClass(EventEmitter) {
+  private _version: string = '';
+  // frameWorkType: https://doc.weixin.qq.com/sheet/e3_AHIAowbJACcZN50GGNIQYSRacTgpe?scode=AJEAIQdfAAoWyUZ6CdAHIAowbJACc
+  public _frameWorkType: number = 30;
+  public _component: number = 0;
+  private _log: any;
+  public _trtc: any;
+  private _testTrtc: any;
+  private _localView: HTMLElement | string | null = null; // 用来记录本地预览的 view, updateLocalVideo 时传入全量数据
+  private _localTestView: HTMLElement | string | null = null; // 用来记录本地测试的 view, updateLocalVideo 时传入全量数据
+  private _isVideoPublish: boolean = true; // 默认是推流（call 需要在预览时不推流） TODO: 应该可以删掉
+  private _localRenderParams = {
+    rotation: TRTCVideoRotation.TRTCVideoRotation0,
+    fillMode: TRTCVideoFillMode.TRTCVideoFillMode_Fill,
+    mirrorType: TRTCVideoMirrorType.TRTCVideoMirrorType_Auto,
+  };
+  private _videoProfile: IVideoProfile = {};
+  private _videoPlayOption: IVideoPlayOption = {};
+  private _isAudioPublish: boolean = true;
+  private _audioProfile: string = Object.keys(audioQualityMap)[0];
+  private _isSharingScreen: boolean = false;
+  private _remoteStreamConfig: Record<string, any> = new Map();
+  private _remoteStreamMap: Record<string, any> = new Map();
+  private _cameraList: Array<any> = [];
+  private _microphoneList: Array<any> = [];
+  private _speakerList: Array<any> = [];
+  private _currentCamera: Record<string, any> = {};
+  private _currentMicrophone: Record<string, any> = {};
+  private _currentSpeaker: Record<string, any> = {};
+  private _currentCameraId: string = '';
+  private _currentMicrophoneId: string = '';
+  private _currentSpeakerId: string = '';
+  private _screenShareParams: any = { option: {} };
+  // 根据 startLocalPreview 传入的参数记录是否为移动端
+  private _isMobile: boolean = false;
+  // 该属性仅对移动端有效
+  private _isFrontCamera: boolean = false;
+  private _defaultVideoProfile = {
+    width: 640,
+    height: 480,
+    frameRate: 15,
+    bitrate: 900,
+  };
+  // 这里兼容旧版 trtcCloud，设置默认屏幕分享分辨率，帧率，码率
+  private _defaultScreenProfile = {
+    width: 1920,
+    height: 1080,
+    frameRate: 15,
+    bitrate: 1500,
+  };
+  constructor(config: ITRTCCloudConfig = {}) {
+    super();
+    this._version = version;
+    // frameWorkType:https://doc.weixin.qq.com/sheet/e3_AHIAowbJACcZN50GGNIQYSRacTgpe?scode=AJEAIQdfAAoWyUZ6CdAHIAowbJACc
+    const { frameWorkType = 30, component = 0 } = config;
+    // @ts-ignore
+    this._trtc = TRTC.create({ frameWorkType, component });
+    // 用于本地设备测试的实例
+    this._testTrtc = TRTC.create();
+    // @ts-ignore
+    this._log = TRTC._loggerManager; // TODO: 日志上报模块儿
+    this._addTRTCEvents();
+
+    this.handleDeviceChange = this.handleDeviceChange.bind(this);
+
+    if (navigator && navigator.mediaDevices) {
+      navigator.mediaDevices.addEventListener('devicechange', debounce(this.handleDeviceChange, 30));
+    }
+  }
+  /**
+   * 创建 TRTCCloud 对象单例
+   * @param {ITRTCCloudConfig} config 构造函数初始化
+   * @memberof TRTCCloud
+   * @returns {TRTC_Cloud}
+   * @example
+   * import TRTCCloud from 'trtc-cloud-js-sdk';
+   * const trtcCloud = TRTCCloud.getTRTCShareInstance(); // 创建 TRTCCloud 对象单例
+   */
+  static getTRTCShareInstance(config: ITRTCCloudConfig) {
+    if (!trtcCloudInstance) {
+      trtcCloudInstance = new TRTC_Cloud(config);
+    }
+    return trtcCloudInstance;
+  }
+  /**
+   * 释放 TRTCCloud 对象并清理资源
+   * @memberof TRTCCloud
+   * @example
+   * import TRTCCloud from 'trtc-cloud-js-sdk';
+   * TRTCCloud.destroyTRTCShareInstance(); // 释放 TRTCCloud 对象并清理资源
+   */
+  public destroyTRTCShareInstance(): void {
+    if (trtcCloudInstance) {
+      this._removeTRTCEvents();
+      trtcCloudInstance._destroy();
+      trtcCloudInstance = null;
+    }
+  }
+  /**
+   * 获取 SDK 版本信息
+   * @memberof TRTCCloud
+   * @returns {String}
+   */
+  public getSDKVersion(): string {
+    return this._version || '';
+  }
+  /**
+   * 绑定事件<br>
+   * @param {String} event 事件名称
+   * @param {Function} callback 事件回调
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.on('onEnterRoom', callback);
+   */
+  // public on(event: string, callback: Function = () => { }): void {}
+  /**
+   * 取消事件绑定<br>
+   * @param {String} event 事件名称，传入通配符 '*' 会解除所有事件绑定。
+   * @param {Function} callback 事件回调
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.off('onEnterRoom', callback);
+   * trtcCloud.off('*'); // 取消所有绑定的事件
+   */
+  public off(event: string, callback: Function = () => { }): void {
+    try {
+      if (event === '*') {
+        this.removeAllListeners();
+      } else {
+        this.removeListener(event, callback);
+      }
+    } catch (error: any) {
+      console.log('off error ', error); // TODO:
+    }
+  }
+  /**
+   * 进房<br>
+   * 调用接口后，您会收到来自 [TRTCCallback](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html) 中的 [onEnterRoom](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onEnterRoom) 回调
+   * - 如果加入成功，result 会是一个正数（result > 0），表示加入房间所消耗的时间，单位是毫秒（ms）
+   * - 如果加入失败，result 会是一个负数（result < 0），表示进房失败的错误码
+   *
+   * 参数 scene 的枚举值如下：
+   * - {@link TRTCAppSceneVideoCall}：<br>
+   *          视频通话场景，支持720P、1080P高清画质，单个房间最多支持300人同时在线，最高支持50人同时发言。<br>
+   *          适合：[1对1视频通话]、[300人视频会议]、[在线问诊]、[视频聊天]、[远程面试]等。<br>
+   * - {@link TRTCAppSceneAudioCall}：<br>
+   *          语音通话场景，支持 48kHz，支持双声道。单个房间最多支持300人同时在线，最高支持50人同时发言。<br>
+   *          适合：[1对1语音通话]、[300人语音会议]、[语音聊天]、[语音会议]、[在线狼人杀]等。<br>
+   * - {@link TRTCAppSceneLIVE}：<br>
+   *          视频互动直播，支持平滑上下麦，切换过程无需等待，主播延时小于300ms；支持十万级别观众同时播放，播放延时低至1000ms。<br>
+   *          适合：[视频低延时直播]、[十万人互动课堂]、[视频直播 PK]、[视频相亲房]、[互动课堂]、[远程培训]、[超大型会议]等。<br>
+   * - {@link TRTCAppSceneVoiceChatRoom}：<br>
+   *          语音互动直播，支持平滑上下麦，切换过程无需等待，主播延时小于300ms；支持十万级别观众同时播放，播放延时低至1000ms。<br>
+   *          适合：[语音低延时直播]、[语音直播连麦]、[语聊房]、[K 歌房]、[FM 电台]等。<br>
+   *
+   * **Note:**
+   * 1. 当 scene 选择为 TRTCAppSceneLIVE 或 TRTCAppSceneVoiceChatRoom 时，您必须通过 TRTCParams 中的 role 字段指定当前用户的角色。
+   * 2. 不管进房是否成功，{@link TRTCCloud#enterRoom enterRoom()} 都必须与 {@link TRTCCloud#exitRoom exitRoom()} 配对使用。
+   *    在调用 {@link TRTCCloud#exitRoom exitRoom()} 前再次调用 {@link TRTCCloud#enterRoom enterRoom()} 函数会导致不可预期的错误问题。
+   *
+   * @param {TRTCParams} params - 进房参数
+   * @param {Number} params.sdkAppId      - 应用标识（必填）
+   * @param {String} params.userId        - 用户标识（必填）
+   * @param {String} params.userSig       - 用户签名（必填）
+   * @param {Number} params.roomId        - 房间号码, roomId 和 strRoomId 必须填一个, 若您选用 strRoomId，则 roomId 需要填写为0。
+   * @param {String} params.strRoomId     - 字符串房间号码 [选填]，在同一个房间内的用户可以看到彼此并进行视频通话,
+   * roomId 和 strRoomId 必须填一个。若两者都填，则优先选择 roomId
+   * @param {TRTCRoleType} params.role    - 直播场景下的角色，默认值：主播
+   * - TRTCRoleAnchor: 主播，可以上行视频和音频，一个房间里最多支持50个主播同时上行音视频。
+   * - TRTCRoleAudience: 观众，只能观看，不能上行视频和音频，一个房间里的观众人数没有上限。
+   * @param {String=} params.privateMapKey - 房间签名（非必填）
+   * @param {String=} params.streamId      - 自定义 CDN 播放地址（非必填）
+   * @param {String=} params.userDefineRecordId - 设置云端录制完成后的回调消息中的 "userdefinerecordid" 字段内容，便于您更方便的识别录制回调（非必填）
+   * @param {TRTCAppScene} scene 应用场景，目前支持视频通话（TRTCAppSceneVideoCall）、语音通话（TRTCAppSceneAudioCall）、
+   * 在线直播（TRTCAppSceneLIVE）、语音聊天室（VTRTCAppSceneVoiceChatRoom）四种场景，详见 [TrtcDefines] 中 TRTCAppScene 参数定义
+   * @memberof TRTCCloud
+   * @example
+   * import TRTCCloud from 'trtc-cloud-js-sdk';
+   * const trtcCloud = TRTCCloud.getTRTCShareInstance(); // 创建实例，只需创建一次
+   * const params = {
+   *   sdkAppId: 0,
+   *   userId: 'denny',
+   *   roomId: 12345,
+   *   userSig: 'xxx'
+   * };
+   * trtcCloud.enterRoom(params, TRTCAppScene.TRTCAppSceneVideoCall);
+   */
+  public async enterRoom(params: any, scene: TRTCAppScene): Promise<void> {
+    const {
+      sdkAppId,
+      userId,
+      userSig,
+      roomId,
+      strRoomId,
+      role,
+      privateMapKey,
+      businessInfo,
+      enableAutoPlayDialog,
+      proxy,
+      streamId,
+      userDefineRecordId,
+    } = params;
+    if (sdkAppId && userId && userSig) {
+      // 字符串房间号码 [选填]，在同一个房间内的用户可以看到彼此并进行视频通话, roomId 和 strRoomId 必须填一个。若两者都填，则优先选择 roomId
+      try {
+        let clientConfig: IEnterRoomParams = {
+          sdkAppId,
+          userId,
+          userSig,
+          roomId: roomId || strRoomId,
+          role: RoleMap[role],
+          scene: SceneMap[scene],
+          frameWorkType: this._frameWorkType,
+          component: this._component,
+        };
+        clientConfig = privateMapKey ? { ...clientConfig, privateMapKey } : clientConfig;
+        clientConfig = businessInfo ? { ...clientConfig, businessInfo } : clientConfig;
+        clientConfig = enableAutoPlayDialog ? { ...clientConfig, enableAutoPlayDialog } : clientConfig;
+        clientConfig = proxy ? { ...clientConfig, proxy } : clientConfig;
+        clientConfig = streamId ? { ...clientConfig, streamId } : clientConfig;
+        clientConfig = userDefineRecordId ? { ...clientConfig, userDefineRecordId } : clientConfig;
+        const startJoinTimestamp: number = performanceNow();
+        await this._trtc.enterRoom(clientConfig);
+        const delta: number = performanceNow() - startJoinTimestamp;
+        this.emit('onEnterRoom', delta);
+      } catch (error: any) {
+        this.emit('onEnterRoom', EnterRoomFailure);
+        this._callFunctionErrorManage(error, 'enterRoom');
+      }
+    } else {
+      this._emitError(ParametersError);
+      // this._log.error(`(enterRoom) failed - ${ParametersError.message}: ${JSON.stringify(params)}`);
+    }
+  }
+  /**
+   * 退房<br>
+   * 执行退出房间的相关逻辑释放资源后，SDK 会通过 [onExitRoom](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onExitRoom) 回调通知到您
+   * **Note:**
+   * 1. 如果您要再次调用 {@link TRTCCloud#enterRoom enterRoom()} 或者切换到其它的音视频 SDK，请等待 [onExitRoom()](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onExitRoom) 回调到来后再执行相关操作，否则可能会遇到如摄像头、麦克风设备被强占等各种异常问题。
+   * @memberof TRTCCloud
+   * @example
+   * await trtcCloud.exitRoom();
+   */
+  public async exitRoom(): Promise<void> {
+    try {
+      console.warn(`${LOG_PREFIX} exitRoom`);
+      if (this._isSharingScreen) {
+        await this.stopScreenShare();
+      }
+      await this._trtc.exitRoom();
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'exitRoom');
+    }
+  }
+  /**
+   * 切换角色，**仅适用于直播场景（TRTCAppSceneLIVE 和 TRTCAppSceneVoiceChatRoom）**<br>
+   * 在直播场景下，一个用户可能需要在“观众”和“主播”之间来回切换。
+   * 您可以在进房前通过 TRTCParams 中的 role 指定角色，也可以通过 {@link TRTCCloud#switchRole switchRole()} 在进房后切换角色。<br>
+   * @param {TRTCRoleType} role - 目标角色，默认为主播
+   * - TRTCRoleAnchor: 主播，可以上行视频和音频，一个房间里最多支持50个主播同时上行音视频
+   * - TRTCRoleAudience: 观众，只能观看，不能上行视频和音频，一个房间里的观众人数没有上限
+   * @memberof TRTCCloud
+   * @example
+   * import TRTCCloud, { TRTCRoleType } from 'trtc-cloud-js-sdk';
+   * const trtcCloud = TRTCCloud.getTRTCShareInstance();
+   * await trtcCloud.switchRole(TRTCRoleType.TRTCRoleAudience);
+   */
+  public async switchRole(role: TRTCRoleType) {
+    try {
+      await this._trtc.switchRole(RoleMap[role]);
+      this.emit('onSwitchRole', 0, `switch role success, role = ${role}, ${RoleMap[role]}`);
+    } catch (error: any) {
+      this.emit('onSwitchRole', error?.getCode(), error.message);
+    }
+  }
+  // ==============================【 Video 】=============================
+
+  /**
+   * 更新本地视频配置
+   */
+  private async _updateLocalVideo() {
+    try {
+      await this._trtc.updateLocalVideo(this._generateLocalVideoData());
+    } catch (error: any) {
+      if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 更新本地测试视频配置
+   */
+  private async _updateLocalTestVideo() {
+    try {
+      await this._testTrtc.updateLocalVideo(this._generateLocalTestVideoData());
+    } catch (error: any) {
+      // 当没有 startLocalVideo 的时候，调用 updateLocalVideo 会报错，此时忽略该错误不做处理
+      if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 更新远端流视频配置
+   * @param {string} userId 远端用户名
+   * @param {TRTCVideoStreamType} streamType 远端流类型
+   */
+  private async _updateRemoteVideo(userId, streamType) {
+    try {
+      await this._trtc.updateRemoteVideo(this._generateRemoteVideoData(userId, streamType));
+    } catch (error: any) {
+      if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 开启本地视频的预览画面<br>
+   * 这个接口会启动默认的摄像头，可以通过 [setCurrentCameraDevice](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCloud.html#setCurrentCameraDevice) 接口选用其它摄像头<br>
+   * @param {HTMLElement} view - 承载预览画面的 DOM
+   * @memberof TRTCCloud
+   * @example
+   * // 桌面端预览本地画面
+   * const view = document.getElementById('local-view');
+   * trtcCloud.startLocalPreview(view);
+   *
+   * // 移动端预览本地画面
+   * const view = document.getElementById('local-view');
+   * // 移动端使用前置摄像头预览本地画面
+   * await trtcCloud.startLocalPreview(true, view);
+   * // 移动端使用前置摄像头预览本地画面
+   * await trtcCloud.startLocalPreview(false, view);
+   */
+  public async startLocalPreview(...args): Promise<void> {
+    this._log.info(`(startLocalPreview) start - start local preview with params: [${args}]`);
+    let isFrontCamera;
+    let view;
+    if ([...args].length === 1) {
+      [view] = [...args];
+    } else if ([...args].length === 2) {
+      [isFrontCamera, view] = [...args];
+    }
+
+    if (!isUndefined(isFrontCamera)) {
+      this._setIsMobile(true);
+      this._setIsFrontCamera(isFrontCamera);
+    }
+    this._setLocalView(view);
+
+    try {
+      try {
+        await this._trtc.startLocalVideo(this._generateLocalVideoData());
+      } catch (error: any) {
+        if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+          // 重复调用 startLocalVideo 报错时需要更新 view
+          await this._updateLocalVideo();
+          return;
+        }
+        throw error;
+      }
+      this.emit('onCameraDidReady');
+      this.emit('onFirstVideoFrame', {
+        userId: '',
+        streamType: TRTCVideoStreamType.TRTCVideoStreamTypeBig,
+        width: this._getVideoProfile().width,
+        height: this._getVideoProfile().height,
+      });
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'startLocalPreview');
+    }
+  }
+
+  /**
+   * 修改本地摄像头预览的 HTML 元素
+   * @memberof TRTCCloud
+   * @param {HTMLElement | string | null} view 接收本地摄像头采集视频渲染的 HTML 元素
+   * @example
+   * await trtcCloud.startLocalPreview('preview');
+   * await trtcCloud.updateLocalView('newView');
+   */
+  async updateLocalView(view: HTMLElement | string | null) {
+    this._setLocalView(view);
+    await this._updateLocalVideo();
+  }
+
+  /**
+   * 停止本地摄像头采集和预览<br>
+   * 首先停止播放，然后关闭本地流（关闭摄像头和麦克风访问权限）
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.stopLocalPreview();
+   */
+  public async stopLocalPreview() {
+    try {
+      this._setLocalView(null);
+      await this._trtc.stopLocalVideo();
+    } catch (error: any) {
+      console.warn(`${LOG_PREFIX} stopLocalPreview error: ${error}`);
+      this._callFunctionErrorManage(error, 'stopLocalPreview');
+    }
+  }
+  /**
+   * 暂停/恢复发布本地的视频流<br>
+   * 当屏蔽本地视频后，房间里的其它成员将会收到 [onUserVideoAvailable](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onUserVideoAvailable) 回调通知
+   * @param {Boolean} mute - true：屏蔽；false：开启，默认值：false
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.muteLocalVideo(true);
+   */
+  public async muteLocalVideo(mute: boolean = false) {
+    try {
+      this._setIsVideoPublish(!mute);
+      await this._updateLocalVideo();
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'muteLocalVideo');
+    }
+  }
+  /**
+   * 显示远端视频或辅流<br>
+   * 在收到 SDK 的 [onUserVideoAvailable](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onUserVideoAvailable) 通知时，可以获知该远程用户开启了视频，
+   * 此后调用 [startRemoteView](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCloud.html#startRemoteView) 接口加载该用户的远程画面时，可以用 loading 动画优化加载过程中的等待体验。
+   * @param {String}      userId - 对方的用户标识
+   * @param {HTMLElement} view   - 承载预览画面的 DOM
+   * @param {TRTCVideoStreamType} streamType   - 视频流类型
+   * - 高清大画面：TRTCVideoStreamType.TRTCVideoStreamTypeBig
+   * - 低清小画面：TRTCVideoStreamType.TRTCVideoStreamTypeSmall
+   * - 辅流（屏幕分享）：TRTCVideoStreamType.TRTCVideoStreamTypeSub
+   * @memberof TRTCCloud
+   * @example
+   * import { TRTCVideoStreamType } from 'trtc-cloud-js-sdk';
+   * const view = document.getElementById('remote-view');
+   * await trtcCloud.startRemoteView('denny', view, TRTCVideoStreamType.TRTCVideoStreamTypeBig);
+   */
+  public async startRemoteView(userId: string, view: HTMLElement, streamType: TRTCVideoStreamType) {
+    try {
+      this._setRemoteStreamConfig(userId, streamType, { view });
+      if (!this._remoteStreamMap.get(`${userId}_${this._getTRTCStreamType(streamType)}`)) {
+        return;
+      }
+      try {
+        await this._trtc.startRemoteVideo(this._generateRemoteVideoData(userId, streamType));
+      } catch (error: any) {
+        // 连续调用两次 startRemoteVideo 失败时应该执行 updateRemoteVideo
+        if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+          await this._updateRemoteVideo(userId, streamType);
+          return;
+        }
+        throw error;
+      }
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'startRemoteView');
+    }
+  }
+
+  /**
+   * 修改远端视频渲染的 HTML 元素
+   * @param {string} userId 远端视频流的用户 ID
+   * @param {HTMLElement | string} view 接受远端视频流渲染的 HTML 元素
+   * @param {TRTCVideoStreamType} streamType 视频流类型
+   */
+  async updateRemoteView(userId: string, view: HTMLElement | string, streamType: TRTCVideoStreamType) {
+    this._setRemoteStreamConfig(userId, streamType, { view });
+    await this._updateRemoteVideo(userId, streamType);
+  }
+
+  /**
+   * 停止显示远端视频画面，同时不再拉取该远端用户的视频数据流<br>
+   * 指定要停止观看的 userId 的视频流类型<br>
+   * @param {String} userId - userId 指定的远端用户 ID
+   * @param {TRTCVideoStreamType} streamType - 视频流类型
+   * - 高清大画面：TRTCVideoStreamType.TRTCVideoStreamTypeBig
+   * - 低清小画面：TRTCVideoStreamType.TRTCVideoStreamTypeSmall
+   * - 辅流（屏幕分享）：TRTCVideoStreamType.TRTCVideoStreamTypeSub
+   * @memberof TRTCCloud
+   * @example
+   * import { TRTCVideoStreamType } from 'trtc-cloud-js-sdk';
+   * await trtcCloud.stopRemoteView('denny', TRTCVideoStreamType.TRTCVideoStreamTypeBig);
+   */
+  public async stopRemoteView(userId: string, streamType: TRTCVideoStreamType) {
+    try {
+      await this._trtc.stopRemoteVideo({
+        userId,
+        streamType: this._getTRTCStreamType(streamType),
+      });
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'stopRemoteView');
+    }
+  }
+  /**
+   * 停止显示所有的远端视频画面<br>
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.stopAllRemoteView();
+   */
+  public async stopAllRemoteView() {
+    try {
+      await this._trtc.stopRemoteVideo({ userId: '*' });
+    } catch (error) {
+      this._callFunctionErrorManage(error, 'stopAllRemoteView');
+    }
+  }
+  /**
+   * 设置视频编码器相关参数<br>
+   * 该设置决定了远端用户看到的画面质量（同时也是云端录制出的视频文件的画面质量）<br>
+   * @param {TRTCVideoEncParam} params - 视频编码参数
+   * @param {TRTCVideoResolution} params.videoResolution - 视频分辨率
+   * @param {Number} params.videoFps     - 视频采集帧率
+   * @param {Number} params.videoBitrate - 视频上行码率
+   * @memberof TRTCCloud
+   * import { TRTCVideoResolution } from 'trtc-cloud-js-sdk';
+   * const params = {
+   *  videoResolution: TRTCVideoResolution.TRTCVideoResolution_640_480,
+   *  videoFps: 15,
+   *  videoBitrate: 900,
+   * };
+   * trtcCloud.setVideoEncoderParam(params);
+   */
+  public async setVideoEncoderParam(params: TRTCVideoEncParam) {
+    try {
+      const videoProfile: IVideoProfile = this._getTRTCVideoProfile('video', params);
+      this._setVideoProfile(videoProfile);
+      await this._updateLocalVideo();
+      await this._updateLocalTestVideo();
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setVideoEncoderParam');
+    }
+  }
+  /**
+   * 设置本地流渲染参数
+   * @param {TRTCRenderParams} params 本地流渲染参数
+   * @param {TRTCVideoRotation} rotation 旋转角度
+   * @param {TRTCVideoFillMode} fillMode 填充模式
+   * @param {TRTCVideoMirrorType} mirrorType 画面渲染镜像
+   * @examples
+   * import { TRTCVideoRotation, TRTCVideoFillMode, TRTCVideoMirrorType } from 'trtc-cloud-js-sdk';
+   * const params = {
+   *  rotation: TRTCVideoRotation.TRTCVideoRotation_0,
+   *  fillMode: TRTCVideoFillMode.TRTCVideoFillMode_Fill,
+   *  mirrorType: TRTCVideoMirrorType.TRTCVideoMirrorType_Enable,
+   * };
+   * trtcCloud.setRemoteRenderParams(params);
+   */
+  public async setLocalRenderParams(params: TRTCRenderParams) {
+    Object.assign(this._localRenderParams, params);
+    try {
+      const videoPlayOption: IVideoPlayOption = {};
+      if (params.mirrorType) {
+        videoPlayOption.mirror = this._getTRTCMirror(params.mirrorType);
+      }
+      if (params.fillMode) {
+        videoPlayOption.fillMode = this._getTRTCFillMode(params.fillMode);
+      }
+      this._setVideoPlayOption(videoPlayOption);
+      await this._updateLocalVideo();
+      await this._updateLocalTestVideo();
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setLocalRenderParams');
+    }
+  }
+  /**
+   * 设置远端流渲染参数
+   * @param {String} userId 流 userId
+   * @param {TRTCVideoStreamType} streamType 流类型
+   * - 高清大画面：TRTCVideoStreamType.TRTCVideoStreamTypeBig
+   * - 低清小画面：TRTCVideoStreamType.TRTCVideoStreamTypeSmall
+   * - 辅流（屏幕分享）：TRTCVideoStreamType.TRTCVideoStreamTypeSub
+   * @param {TRTCRenderParams} params 远端流渲染参数
+   * @param {TRTCVideoFillMode} params.fillMode 填充模式
+   * @param {TRTCVideoMirrorType} params.mirrorType 画面渲染镜像
+   * @memberof TRTCCloud
+   * @examples
+   * import { TRTCVideoStreamType, TRTCVideoFillMode, TRTCVideoMirrorType } from 'trtc-cloud-js-sdk';
+   * const params = {
+   *  fillMode: TRTCVideoFillMode.TRTCVideoFillMode_Fill,
+   *  mirrorType: TRTCVideoMirrorType.TRTCVideoMirrorType_Enable,
+   * };
+   * await trtcCloud.setRemoteRenderParams('denny', TRTCVideoStreamType.TRTCVideoStreamTypeBig, params)
+   */
+  public async setRemoteRenderParams(userId: string, streamType: TRTCVideoStreamType, params: TRTCRenderParams) {
+    try {
+      this._setRemoteStreamConfig(userId, streamType, params);
+
+      await this._updateRemoteVideo(userId, streamType);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setRemoteRenderParams');
+    }
+  }
+  // ==============================【 Audio 】=============================
+
+  private async _updateLocalAudio() {
+    try {
+      await this._trtc.updateLocalAudio(this._generateLocalAudioData());
+    } catch (error: any) {
+      // 当没有 startLocalAudio 的时候，调用 updateLocalAudio 会报错，此时忽略该错误不做处理
+      if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+        return;
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 开启本地音频的采集和上行, 并设置音频质量<br>
+   * 该函数会启动麦克风采集，并将音频数据传输给房间里的其他用户。 SDK 不会默认开启本地音频采集和上行，您需要调用该函数开启，否则房间里的其他用户将无法听到您的声音<br>
+   * 主播端的音质越高，观众端的听感越好，但传输所依赖的带宽也就越高，在带宽有限的场景下也更容易出现卡顿<br>
+   * **Note:**
+   * 1. 音质参数 TRTCAudioQuality 不同于 [Electron startLocalAudio](https://web.sdk.qcloud.com/trtc/electron/doc/zh-cn/trtc_electron_sdk/TRTCCloud.html#startLocalAudio)
+   * @param {TRTCAudioQuality} quality 声音音质
+   * - TRTCAudioQualityDefault, 样率：48k；单声道；码率：40kbps，默认使用 TRTCAudioQualityDefault
+   * - TRTCAudioQualitySpeech, 采样率：48k；单声道；码率：128kbps
+   * - TRTCAudioQualityMusic, 采样率：48k；双声道；码率：192kbps
+   * @memberof TRTCCloud
+   * @example
+   * import { TRTCAudioQuality } from 'trtc-cloud-js-sdk';
+   * trtcCloud.startLocalAudio(TRTCAudioQuality.TRTCAudioQualityDefault);
+   */
+  public async startLocalAudio(quality: TRTCAudioQuality = TRTCAudioQuality.TRTCAudioQualityDefault) {
+    try {
+      this._setAudioProfile(audioQualityMap[quality]);
+      try {
+        await this._trtc.startLocalAudio(this._generateLocalAudioData());
+      } catch (error: any) {
+        if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+          // 当重复 start 的时候报错，此时执行 update
+          await this._updateLocalAudio();
+          return;
+        }
+        throw error;
+      }
+      // 抛出 onMicDidReady 事件，ref: https://tapd.woa.com/TerWebG/prong/stories/view/1020396022877875239
+      this.emit('onMicDidReady');
+    } catch (error: any) {
+      console.warn(`${LOG_PREFIX} startLocalAudio error: ${error}`);
+      this._callFunctionErrorManage(error, 'startLocalAudio');
+    }
+  }
+  /**
+   * 关闭本地音频的采集和上行<br>
+   * 当关闭本地音频的采集和上行，房间里的其它成员会收到 [onUserAudioAvailable](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onUserAudioAvailable) 回调通知。<br>
+   * @memberof TRTCCloud
+   * @example
+   * await trtcCloud.stopLocalAudio();
+   */
+  public async stopLocalAudio() {
+    try {
+      await this._trtc.stopLocalAudio();
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'stopLocalAudio');
+    }
+  }
+  /**
+   * 静音本地的音频<br>
+   * 当静音本地音频后，房间里的其它成员会收到 [onUserAudioAvailable](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onUserAudioAvailable) 回调通知。
+   * 与 [stopLocalAudio](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCloud.html#stopLocalAudio) 不同之处在于，[muteLocalAudio](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCloud.html#muteLocalAudio)
+   * 并不会停止发送音视频数据，而是会继续发送码率极低的静音包。
+   * 在对录制质量要求很高的场景中，选择 [muteLocalAudio](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCloud.html#muteLocalAudio) 是更好的选择，能录制出兼容性更好的 MP4 文件。
+   * 这是由于 MP4 等视频文件格式，对于音频的连续性是要求很高的，简单粗暴地 [stopLocalAudio](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCloud.html#stopLocalAudio) 会导致录制出的 MP4 不易播放。<br>
+   * @param {Boolean} mute - true：屏蔽；false：开启，默认值：false
+   * @memberof TRTCCloud
+   * @example
+   * await trtcCloud.muteLocalAudio(true);
+   */
+  public async muteLocalAudio(mute: boolean = false) {
+    try {
+      this._setIsAudioPublish(!mute);
+      await this._updateLocalAudio();
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'muteLocalAudio');
+    }
+  }
+  /**
+   * 静音掉某个用户的声音，同时不再拉取该远端用户的音频数据流<br>
+   * @param {String} userId - 用户 ID
+   * @param {Boolean} mute - true：静音；false：非静音
+   * @memberof TRTCCloud
+   * @example
+   * await trtcCloud.muteRemoteAudio('denny', true);
+   */
+  public async muteRemoteAudio(userId: string, mute: boolean = false) {
+    try {
+      if (!userId) {
+        this._emitError(ParametersError);
+        // this._log.error(`(muteRemoteVideoStream) failed - ${ParametersError.message}: userId = ${userId}`);
+        return;
+      }
+      await this._trtc.muteRemoteAudio(userId, mute);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'muteRemoteAudio');
+    }
+  }
+  /**
+   * 静音掉远端所有用户的声音，同时不再拉取远端用户的音频数据流<br>
+   * @param {Boolean} mute - true：静音；false：非静音
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.muteAllRemoteAudio(true);
+   */
+  public muteAllRemoteAudio(mute: boolean): void {
+    try {
+      this._trtc.muteRemoteAudio('*', mute);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'muteAllRemoteAudio');
+    }
+  }
+  /**
+   * 设置某个远程用户的播放音量<br>
+   * @param {String} userId 远程用户 ID
+   * @param {Number} volume 音量大小，100为原始音量，范围是：[0 ~ 100]，默认值为100
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.setRemoteAudioVolume('denny', 80);
+   */
+  public setRemoteAudioVolume(userId: string, volume: number) {
+    try {
+      this._trtc.setRemoteAudioVolume(userId, volume);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setRemoteAudioVolume');
+    }
+  }
+  /**
+   * 开启或关闭音量大小回调<br>
+   * 开启此功能后，SDK 会在 [onUserVoiceVolume](https://web.sdk.qcloud.com/trtc/webrtc/trtcCloud/doc/TRTCCallback.html#event:onUserVoiceVolume) 中反馈对每一路声音音量大小值的评估。<br>
+   * **Note:**
+   * - 如需打开此功能，请在 {@link TRTCCloud#startLocalAudio startLocalAudio()} 之前调用才可以生效。
+   * @param {Number} interval - 设置 onUserVoiceVolume 回调的触发间隔，单位为ms，最小间隔为100ms，如果小于等于0则会关闭回调，建议设置为300ms
+   * @memberof TRTCCloud
+   * @example
+   * trtcCloud.enableAudioVolumeEvaluation(300);
+   */
+  enableAudioVolumeEvaluation(interval: number): void {
+    try {
+      this._trtc.enableAudioVolumeEvaluation(interval);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'enableAudioVolumeEvaluation');
+    }
+  }
+  // ==============================【屏幕分享】==============================
+  /**
+   * 开始屏幕分享<br>
+   * @param {HTMLElement | null} view - 承载预览画面的 DOM
+   * **Note:**
+   * - 如果不想本地预览，需要传入 null
+   * - 本地预览自己的屏幕分享时，不能全屏
+   * @param {TRTCVideoStreamType} type 屏幕分享使用的线路，默认使用辅路。
+   * @param {Object} params 屏幕分享参数
+   * @param {TRTCVideoResolution} params.videoResolution 屏幕分享分辨率
+   * @param {Number} params.videoFps 帧率
+   * @param {Number} params.videoBitrate 码率
+   * @param {Boolean=} params.screenAudio 屏幕分享是否采集系统音频, 默认 false 不采集
+   * **Note:**
+   * - 采集系统声音只支持 Chrome M74+ ，在 Windows 和 Chrome OS 上，可以捕获整个系统的音频
+   * 在 Linux 和 Mac 上，只能捕获选项卡的音频。其它 Chrome 版本、其它系统、其它浏览器均不支持。
+   * @returns {Promise}
+   * @memberof TRTCCloud
+   * @example
+   *  const view = document.getElementById('local-share-view');
+   *  const params = {
+   *    screenAudio: true,
+   *  };
+   *  await trtcCloud.startScreenShare(view, TRTCVideoStreamType.TRTCVideoStreamTypeSub, params);
+   */
+  public async startScreenShare(view: HTMLElement | null, type, params) {
+    try {
+      // 仅支持辅流推屏幕分享
+      const { screenAudio = false } = params || {};
+
+      const screenShareVideoProfile: IVideoProfile = this._getTRTCVideoProfile('screen', params);
+
+      this._setScreenShareParams({
+        view,
+        profile: screenShareVideoProfile,
+        systemAudio: screenAudio,
+      });
+      await this._trtc.startScreenShare(this._getScreenShareParams());
+      this._isSharingScreen = true;
+      this.emit('onFirstVideoFrame', {
+        userId: '',
+        streamType: TRTCVideoStreamType.TRTCVideoStreamTypeSub,
+        width: screenShareVideoProfile.width,
+        height: screenShareVideoProfile.height,
+      });
+    } catch (error: any) {
+      if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+        return;
+      }
+      console.error('Start share screen error:', error, error.code, error.name, error.message);
+      throw error;
+    }
+  }
+  /**
+   * 设置屏幕分享的视频编码参数<br>
+   * **Note:**
+   * - setSubStreamEncoderParam 需在调用 {@link TRTCCloud#startScreenShare startScreenShare()} 进行屏幕分享之前调用
+   * - 默认分辨率：1920*1080，视频采集帧率：15fps，视频码率：1500kps
+   * @memberof TRTCCloud
+   * @param {TRTCVideoEncParam} params 屏幕分享视频编码参数
+   * @param {TRTCVideoResolution} params.videoResolution 视频分辨率
+   * @param {Number} params.videoFps 视频采集帧率
+   * @param {Number} params.videoBitrate 视频码率
+   * @example
+   *  import { TRTCVideoResolution } from 'trtc-cloud-js-sdk';
+   *  const params = {
+   *    videoResolution: TRTCVideoResolution.TRTCVideoResolution_640_480,
+   *    videoFps: 15,
+   *    videoBitrate: 1500,
+   *  };
+   *  await trtcCloud.setSubStreamEncoderParam(params);
+   */
+  public async setSubStreamEncoderParam(params: TRTCVideoEncParam) {
+    try {
+      const screenShareVideoProfile: IVideoProfile = this._getTRTCVideoProfile('screen', params);
+      this._setScreenShareParams({
+        profile: screenShareVideoProfile,
+      });
+      await this._trtc.updateScreenShare(this._getScreenShareParams());
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setSubStreamEncoderParam');
+    }
+  }
+  /**
+   * 停止屏幕分享
+   * @memberof TRTCCloud
+   * @example
+   *  await trtcCloud.stopScreenShare();
+   */
+  public async stopScreenShare(): Promise<void> {
+    try {
+      await this._trtc.stopScreenShare();
+      this._isSharingScreen = false;
+      this.emit('onScreenCaptureStopped', { reason: 0 });
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'stopScreenShare');
+    }
+  }
+
+  // ============ TUIRoom 访问时需返回 NotSupportError, 需保留 =========
+  startScreenCapture() {
+    this.emitError(NotSupportError);
+  }
+  pauseScreenCapture() {
+    this.emitError(NotSupportError);
+  }
+  resumeScreenCapture() {
+    this.emitError(NotSupportError);
+  }
+  getScreenCaptureSources() {
+    this.emitError(NotSupportError);
+  }
+  selectScreenCaptureTarget() {
+    this.emitError(NotSupportError);
+  }
+  // ==============================【摄像头设备】==============================
+  /**
+   * 获取摄像头设备列表<br>
+   * @returns {Promise<TRTCDeviceInfo[]>} 摄像头管理器列表
+   * @memberof TRTCCloud
+   * @example
+   * var cameralist = await trtcCloud.getCameraDevicesList();
+   * for (i = 0; i < cameralist.length; i++) {
+   *    var camera = cameralist[i];
+   *    console.info("camera deviceName: " + camera.deviceName + " deviceId:" + camera.deviceId);
+   * }
+   */
+  public async getCameraDevicesList(): Promise<TRTCDeviceInfo[]> {
+    try {
+      let cameraList = await TRTC.getCameraList();
+      cameraList = cameraList.map(item => ({
+        ...item,
+        deviceName: item.label, // 就是 deviceName
+      }));
+      this._cameraList = cameraList;
+      this._currentCamera = this.getDefaultDeviceInfo(cameraList);
+      this._currentCameraId = this._currentCamera.deviceId;
+      return Promise.resolve(cameraList);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'getCameraDevicesList');
+      return Promise.resolve([]);
+    }
+  }
+  /**
+   * 设置要使用的摄像头<br>
+   * @param {String} deviceId - 从 getCameraDevicesList 中得到的设备 ID
+   * @returns {Promise}
+   * @memberof TRTCCloud
+   */
+  public async setCurrentCameraDevice(deviceId: string): Promise<boolean> {
+    try {
+      if (!deviceId) return false;
+      this._currentCameraId = deviceId;
+      this._currentCamera = this._cameraList.filter(item => item.deviceId === deviceId);
+      await this._updateLocalVideo();
+      await this._updateLocalTestVideo();
+      return true;
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setCurrentCameraDevice');
+      return false;
+    }
+  }
+  /**
+   * 获取当前使用的摄像头<br>
+   * @memberof TRTCCloud
+   * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
+   */
+  public getCurrentCameraDevice(): TRTCDeviceInfo { // TODO: 待确认
+    // return (this.cameraList || []).filter((obj: any) => obj.deviceId === this.currentCameraId)[0] || {};
+    return new TRTCDeviceInfo();
+  }
+
+  /**
+   * 判断是否为前置摄像头（仅适用于移动端）
+   * @returns {boolean}
+   */
+  public isFrontCamera() {
+    return this._getIsFrontCamera();
+  }
+
+  /**
+   * 切换前置或者后置摄像头（仅适用于移动端）
+   * @param { boolean } isFrontCamera 是否为前置摄像头
+   *
+   * @example
+   * // 移动端使用前置摄像头预览本地画面
+   * await trtcCloud.startLocalPreview(true, view);
+   * // 切换使用后置摄像头预览本地画面
+   * await trtcCloud.switchCamera(false);
+   */
+  public async switchCamera(isFrontCamera: boolean) {
+    this._setIsFrontCamera(isFrontCamera);
+
+    const videoPlayOption = this._getVideoPlayOption();
+    videoPlayOption.mirror = this._getTRTCMirror(this._localRenderParams.mirrorType);
+    this._setVideoPlayOption(videoPlayOption);
+
+    await this._updateLocalVideo();
+  }
+
+  // ==============================【麦克风设备】==============================
+  /**
+   * 获取麦克风设备列表<br>
+   * @returns {Promise<TRTCDeviceInfo[]>} 麦克风管理器列表
+   * @memberof TRTCCloud
+   * @example
+   *   var micList = await trtcCloud.getMicDevicesList();
+   *   for (i = 0; i < micList.length; i++) {
+   *     var mic = micList[i];
+   *     console.info("mic deviceName: " + mic.deviceName + " deviceId:" + mic.deviceId);
+   *   }
+   */
+  public async getMicDevicesList(): Promise<TRTCDeviceInfo[]> {
+    try {
+      let micList = await TRTC.getMicrophoneList();
+      micList = micList.map(item => ({
+        ...item,
+        deviceName: item.label, // 就是 deviceName
+      }));
+      this._microphoneList = micList;
+      this._currentMicrophone = this.getDefaultDeviceInfo(micList);
+      this._currentMicrophoneId = this._currentMicrophone.deviceId;
+      return Promise.resolve(micList);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'getMicDevicesList');
+      return Promise.resolve([]);
+    }
+  }
+  /**
+   * 设置要使用的麦克风<br>
+   * 选择指定的麦克风作为录音设备，不调用该接口时，默认选择索引为 0 的麦克风<br>
+   * @param {String} micId - 从 getMicDevicesList 中得到的设备 ID
+   * @memberof TRTCCloud
+   * @returns {Promise}
+   */
+  public async setCurrentMicDevice(micId: string): Promise<boolean> {
+    try {
+      if (!micId) return false;
+      this._setCurrentMicrophoneId(micId);
+      this._currentMicrophone = this._microphoneList.filter(item => item.deviceId === micId);
+      await this._trtc.updateLocalAudio(this._generateLocalAudioData());
+      return true;
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setCurrentMicDevice');
+      return false;
+    }
+  }
+  /**
+   * 获取当前选择的麦克风<br>
+   * @memberof TRTCCloud
+   * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
+   */
+  public getCurrentMicDevice(): TRTCDeviceInfo {
+    return new TRTCDeviceInfo();
+  }
+  // ==============================【麦克风设备】==============================
+  /**
+   * 获取扬声器设备列表<br>
+   * - 出于安全的考虑，在用户未授权摄像头或麦克风访问权限前，deviceId 字段可能都是空的。因此建议在用户授权访问后 再调用该接口获取设备详情
+   * - 移动端不支持获取扬声器列表
+   * @returns {Promise<TRTCDeviceInfo[]>} 扬声器管理器列表
+   * @memberof TRTCCloud
+   * @example
+   *   var speakerList = await trtcCloud.getSpeakerDevicesList();
+   *   for (i = 0; i < speakerList.length; i++) {
+   *     var speaker = speakerList[i];
+   *     console.info("mic deviceName: " + speaker.deviceName + " deviceId:" + speaker.deviceId);
+   *   }
+   */
+  public async getSpeakerDevicesList(): Promise<TRTCDeviceInfo[]> {
+    try {
+      let speakerList = await TRTC.getSpeakerList();
+      speakerList = speakerList.map((item: TRTCDeviceInfo) => ({
+        ...item,
+        deviceName: item.label, // 就是 deviceName
+      }));
+      this._speakerList = speakerList;
+      this._currentSpeaker = this.getDefaultDeviceInfo(speakerList);
+      this._currentSpeakerId = this._currentSpeaker.deviceId;
+      return Promise.resolve(speakerList);
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'getSpeakerDevicesList');
+      return Promise.resolve([]);
+    }
+  }
+  /**
+   * 设置要使用的扬声器<br>
+   * - 移动端不支持设置扬声器。
+   * @param {String} speakerId - 从 getSpeakerDevicesList 中得到的设备 ID
+   * @returns {Promise}
+   * @memberof TRTCCloud
+   */
+  public async setCurrentSpeakerDevice(speakerId: string): Promise<boolean> {
+    try {
+      if (!speakerId) return false;
+      this._setCurrentSpeakerId(speakerId);
+      this._currentSpeaker = this._speakerList.filter(item => item.deviceId === speakerId);
+      await TRTC.setCurrentSpeaker(speakerId);
+      return true;
+    } catch (error: any) {
+      this._callFunctionErrorManage(error, 'setCurrentSpeakerDevice');
+      return false;
+    }
+  }
+  /**
+   * 获取当前的扬声器设备<br>
+   * @memberof TRTCCloud
+   * @returns {TRTCDeviceInfo} 设备信息，能获取设备 ID 和设备名称
+   */
+  public getCurrentSpeakerDevice(): TRTCDeviceInfo {
+    return new TRTCDeviceInfo();
+  }
+
+  /**
+   * 摄像头测试接口
+   * @param {HTMLElement} view 测试接口播放区域
+   */
+  async startCameraDeviceTest(view: HTMLElement) {
+    this._log.info('(startCameraDeviceTest) start - start test camera Device', view);
+    if (!view) {
+      return;
+    }
+    this._setLocalTestView(view);
+    await this._testTrtc.startLocalVideo(this._generateLocalTestVideoData());
+  }
+
+  /**
+   * 停止摄像头测试接口
+   */
+  async stopCameraDeviceTest() {
+    this._setLocalTestView(null);
+    await this._testTrtc.stopLocalVideo();
+  }
+
+  /**
+   * 麦克风测试接口
+   * @param {number} interval 麦克风音量回调间隔
+   */
+  async startMicDeviceTest(interval: number) {
+    this._log.info('(startMicDeviceTest) start - start test mic Device', interval);
+
+    await this._testTrtc.startLocalAudio({
+      publish: false,
+      option: {
+        microphoneId: this._currentMicrophoneId,
+        profile: audioQualityMap[TRTCAudioQuality.TRTCAudioQualityDefault],
+      },
+    });
+
+    this._testTrtc.on(TRTC.EVENT.AUDIO_VOLUME, (event: any) => {
+      event?.result.forEach(({ userId, volume }) => {
+        const isMe = userId === '';
+        if (isMe) {
+          this.emit('onTestMicVolume', volume);
+        }
+      });
+    });
+
+    await this._testTrtc.enableAudioVolumeEvaluation(interval);
+  }
+
+  stopMicDeviceTest() {
+    this._log.info('(stopMicDeviceTest) stop - stop test mic Device');
+
+    this._testTrtc.stopLocalAudio();
+  }
+
+  // ///////////////////////////////////////////////////////////////////////////////
+  //
+  //                      内部方法
+  //
+  // ///////////////////////////////////////////////////////////////////////////////
+  // 解除所有事件绑定
+  private _unbindEvents() {
+  }
+  // 解绑 client 事件, 释放 client 资源
+  private _destroy() {
+    this._unbindEvents();
+  }
+  // 抛出 onError, 上层应用监听该事件
+  private _emitError(error: IError): void {
+    if (!error || !this.emit) {
+      return;
+    }
+    this.emit(NAME.ON_ERROR, error.code, error.message);
+  }
+  /**
+   * 调用方法失败处理
+   * @param {Any} error Error 实例或 trtc-js-sdk 中定义的 RtcError 实例
+   * @param {Function} functionName 函数名称, 调用函数的名称用以记录出错的位置
+   */
+  private _callFunctionErrorManage(error: any, functionName: string): void {
+    if (error && error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+      return;
+    }
+    if (error && error.getCode && error.getCode()) {
+      this.emit(NAME.ON_ERROR, error.getCode(), error.message);
+      this._log.error(`(${functionName}) failed - ${error.message}`);
+    } else {
+      this.emit(NAME.ON_ERROR, jsExecuteError.code, error.message);
+      this._log.error(`(${functionName}) failed - ${error.message}`);
+    }
+  }
+  /**
+   * 解析 TRTCVideoResolution 将其转成 width、height。例如：TRTCVideoResolution_120_120 得到 { width: 120, height: 120 }
+   * @param {TRTCVideoResolution} videoResolution 分辨率
+   * @returns {Object} 返回值
+   */
+  private _getTRTCResolution(videoResolution: TRTCVideoResolution): { width, height } {
+    const TRTCVideoResolutionString = TRTCVideoResolution[videoResolution];
+    const videoResolutionList = (TRTCVideoResolutionString || '').split('_');
+    const width = videoResolutionList.length > 1 && videoResolutionList[1];
+    const height = videoResolutionList.length > 2 && videoResolutionList[2];
+    return { width: +width, height: +height };
+  }
+
+  // 根据用户传入的参数获取 TRTC videoProfile 和 screenProfile
+  private _getTRTCVideoProfile(type: 'video' | 'screen', params): IVideoProfile {
+    const { videoResolution, videoFps, videoBitrate } = params;
+    const videoProfile: IVideoProfile = type === 'screen' ? this._defaultScreenProfile : this._defaultVideoProfile;
+    if (videoResolution) {
+      const resolution = this._getTRTCResolution(videoResolution);
+      videoProfile.width = resolution.width;
+      videoProfile.height = resolution.height;
+    }
+    if (videoFps) {
+      videoProfile.frameRate = videoFps;
+    }
+    if (videoBitrate) {
+      videoProfile.bitrate = videoBitrate;
+    }
+    return videoProfile;
+  }
+
+  // 根据传入的 streamType 获取对应的 TRTC streamType
+  private _getTRTCStreamType(streamType: TRTCVideoStreamType) {
+    const relationObj = {
+      [TRTCVideoStreamType.TRTCVideoStreamTypeBig]: TRTC.TYPE.STREAM_TYPE_MAIN,
+      [TRTCVideoStreamType.TRTCVideoStreamTypeSmall]: TRTC.TYPE.STREAM_TYPE_MAIN,
+      [TRTCVideoStreamType.TRTCVideoStreamTypeSub]: TRTC.TYPE.STREAM_TYPE_SUB,
+    };
+    return relationObj[streamType];
+  }
+  // 根据传入的 filleMode 获取对应的 TRTC fillMode
+  private _getTRTCFillMode(fillMode: TRTCVideoFillMode) {
+    const relationObj = {
+      [TRTCVideoFillMode.TRTCVideoFillMode_Fill]: VideoFillMode.COVER,
+      [TRTCVideoFillMode.TRTCVideoFillMode_Fit]: VideoFillMode.CONTAIN,
+    };
+    return relationObj[fillMode];
+  }
+  // 根据传入的 mirror 获取对应的 TRTC mirror
+  private _getTRTCMirror(mirror: TRTCVideoMirrorType) {
+    if (mirror === TRTCVideoMirrorType.TRTCVideoMirrorType_Auto) {
+      if (this._getIsMobile()) {
+        return this._getIsFrontCamera();
+      }
+      return true;
+    }
+    const relationObj = {
+      [TRTCVideoMirrorType.TRTCVideoMirrorType_Enable]: true,
+      [TRTCVideoMirrorType.TRTCVideoMirrorType_Disable]: false,
+    };
+    return relationObj[mirror];
+  }
+  private _getTRTCCloudDeviceType(mediaType: 'camera' | 'microphone' | 'speaker') {
+    const deviceTypeRelationObj = {
+      camera: TRTCDeviceType.TRTCDeviceTypeCamera,
+      microphone: TRTCDeviceType.TRTCDeviceTypeMic,
+      speaker: TRTCDeviceType.TRTCDeviceTypeSpeaker,
+    };
+    return deviceTypeRelationObj[mediaType];
+  }
+  private _getTRTCCloudDeviceState(state: 'add' | 'remove' | 'active') {
+    const deviceStateRelationObj = {
+      add: TRTCDeviceState.TRTCDeviceStateAdd,
+      remove: TRTCDeviceState.TRTCDeviceStateRemove,
+      active: TRTCDeviceState.TRTCDeviceStateActive,
+    };
+    return deviceStateRelationObj[state];
+  }
+  // 返回调用 trtc.updateLocalVideo() 方法所需的数据
+  private _generateLocalVideoData() {
+    const localVideoData = {
+      view: this._getLocalView(),
+      publish: this._getIsVideoPublish(),
+      option: {
+        profile: this._getVideoProfile(),
+        ...this._getVideoPlayOption(),
+      },
+    };
+    if (this._getIsMobile()) {
+      localVideoData && Object.assign(localVideoData.option, { useFrontCamera: this._getIsFrontCamera() });
+    } else {
+      localVideoData && Object.assign(localVideoData.option, { cameraId: this._getCurrentCameraId() });
+    }
+    return localVideoData;
+  }
+  // 返回测试 trtc 更新本地流所需的数据
+  private _generateLocalTestVideoData() {
+    return {
+      view: this._getLocalTestView(),
+      publish: false,
+      option: {
+        cameraId: this._getCurrentCameraId(),
+        profile: this._getVideoProfile(),
+        ...this._getVideoPlayOption(),
+      },
+    };
+  }
+  // 返回调用 trtc.updateLocalAudio() 方法所需的数据
+  private _generateLocalAudioData() {
+    return {
+      publish: this._getIsAudioPublish(),
+      option: {
+        microphoneId: this._getCurrentMicrophoneId(),
+        profile: this._getAudioProfile(),
+      },
+    };
+  }
+  // 返回远端流的配置数据
+  private _generateRemoteVideoData(userId: string, streamType: TRTCVideoStreamType) {
+    return this._remoteStreamConfig.get(`${userId}_${this._getTRTCStreamType(streamType)}`);
+  }
+
+  // 添加 webRTC 事件监听
+  private _addTRTCEvents() {
+    this._trtc.on(TRTC.EVENT.ERROR, (error: any) => {
+      error && this.emit('onError', error?.getCode?.getCode(), error.message);
+    });
+    this._trtc.on(TRTC.EVENT.REMOTE_USER_ENTER, (event: any) => {
+      event?.userId && this.emit('onRemoteUserEnterRoom', event.userId);
+    });
+    this._trtc.on(TRTC.EVENT.REMOTE_USER_EXIT, (event: any) => {
+      event?.userId && this.emit('onRemoteUserLeaveRoom', event.userId);
+    });
+    this._trtc.on(TRTC.EVENT.REMOTE_AUDIO_AVAILABLE, (event: any) => {
+      event?.userId && this.emit('onUserAudioAvailable', event.userId, true);
+    });
+    this._trtc.on(TRTC.EVENT.REMOTE_AUDIO_UNAVAILABLE, (event: any) => {
+      event?.userId && this.emit('onUserAudioAvailable', event.userId, false);
+    });
+    this._trtc.on(TRTC.EVENT.REMOTE_VIDEO_AVAILABLE, (event: any) => {
+      this._emitVideoAvailable(event, true);
+    });
+    this._trtc.on(TRTC.EVENT.REMOTE_VIDEO_UNAVAILABLE, (event: any) => {
+      this._emitVideoAvailable(event, false);
+    });
+    this._trtc.on(TRTC.EVENT.AUDIO_VOLUME, (event: any) => {
+      event?.result && this.emit('onUserVoiceVolume', event?.result, (event?.result || []).length);
+    });
+    this._trtc.on(TRTC.EVENT.NETWORK_QUALITY, (event: any) => {
+      const { uplinkNetworkQuality, downlinkNetworkQuality } = event;
+      const userId = this.client ? this.client.getUserId() : '';
+      const TRTCQualityRelation = [
+        TRTCQuality.TRTCQuality_Unknown,
+        TRTCQuality.TRTCQuality_Excellent,
+        TRTCQuality.TRTCQuality_Good,
+        TRTCQuality.TRTCQuality_Poor,
+        TRTCQuality.TRTCQuality_Bad,
+        TRTCQuality.TRTCQuality_Vbad,
+        TRTCQuality.TRTCQuality_Down,
+      ];
+      const localQuality = new TRTCQualityInfo(userId, TRTCQualityRelation[uplinkNetworkQuality]);
+      const remoteQuality = new TRTCQualityInfo('remote', TRTCQualityRelation[downlinkNetworkQuality]);
+      this.emit('onNetworkQuality', localQuality, [remoteQuality]);
+    });
+    this._trtc.on(TRTC.EVENT.SCREEN_SHARE_STOPPED, () => {
+      this.emit('onScreenCaptureStopped', { reason: 0 });
+      this._isSharingScreen = false;
+    });
+    this._trtc.on(TRTC.EVENT.PUBLISH_STATE_CHANGED, (event) => {
+      const { mediaType, state } = event;
+      if (state === 'started') {
+        if (mediaType === 'audio') {
+          this.emit('onSendFirstLocalAudioFrame');
+        } else if (mediaType === 'video') {
+          this.emit('onSendFirstLocalVideoFrame', { streamType: TRTCVideoStreamType.TRTCVideoStreamTypeBig });
+        } else if (mediaType === 'screen') {
+          this.emit('onSendFirstLocalVideoFrame', { streamType: TRTCVideoStreamType.TRTCVideoStreamTypeSub });
+        }
+      }
+    });
+  }
+  private _removeTRTCEvents(): void {
+    this._trtc.off('*');
+  }
+  private _emitVideoAvailable(event: any, isVideoAvailable: boolean): void {
+    const { userId, streamType } = event;
+    if (isVideoAvailable) {
+      this._remoteStreamMap.set(`${userId}_${streamType}`, true);
+    } else {
+      this._remoteStreamMap.delete(`${userId}_${streamType}`);
+    }
+    if (streamType === TRTC.TYPE.STREAM_TYPE_SUB) {
+      userId && this.emit('onUserSubStreamAvailable', userId, isVideoAvailable);
+    } else {
+      userId && this.emit('onUserVideoAvailable', userId, isVideoAvailable);
+    }
+  }
+  // --------------------------------- 变量获取、设置 ---------------------------------
+  private _setLocalView(view: HTMLElement | string | null) {
+    this._localView = view;
+  }
+  private _getLocalView(): HTMLElement | string | null {
+    return this._localView;
+  }
+  private _setIsMobile(value: boolean) {
+    this._isMobile = value;
+  }
+  private _getIsMobile(): boolean {
+    return this._isMobile;
+  }
+  private _setIsFrontCamera(value: boolean) {
+    this._isFrontCamera = value;
+  }
+  private _getIsFrontCamera() {
+    return this._isFrontCamera;
+  }
+  private _setIsVideoPublish(value: boolean) {
+    this._isVideoPublish = value;
+  }
+  private _getIsVideoPublish(): boolean {
+    return this._isVideoPublish;
+  }
+  private _setVideoProfile(videoProfile: IVideoProfile) {
+    this._videoProfile = videoProfile;
+  }
+  private _getVideoProfile(): IVideoProfile {
+    return this._videoProfile;
+  }
+  private _setVideoPlayOption(videoPlayOption: IVideoPlayOption) {
+    this._videoPlayOption = videoPlayOption;
+  }
+  private _getVideoPlayOption(): IVideoPlayOption {
+    return this._videoPlayOption;
+  }
+  private _setLocalTestView(view: HTMLElement | string | null) {
+    this._localTestView = view;
+  }
+  private _getLocalTestView(): HTMLElement | string | null {
+    return this._localTestView;
+  }
+  private _setScreenShareParams(params: {
+    view?: HTMLElement | string | null,
+    systemAudio?: boolean,
+    fillMode?: VideoFillMode,
+    profile?,
+  }) {
+    const { view, systemAudio, fillMode, profile } = params;
+    if (!isUndefined(view)) {
+      this._screenShareParams.view = view;
+    }
+    if (!isUndefined(systemAudio)) {
+      this._screenShareParams.option.systemAudio = systemAudio;
+    }
+    if (!isUndefined(fillMode)) {
+      this._screenShareParams.option.fillMode = fillMode;
+    }
+    if (!isUndefined(profile)) {
+      this._screenShareParams.option.profile = profile;
+    }
+  }
+  private _getScreenShareParams() {
+    return this._screenShareParams;
+  }
+  private _setIsAudioPublish(value: boolean) {
+    this._isAudioPublish = value;
+  }
+  private _getIsAudioPublish(): boolean {
+    return this._isAudioPublish;
+  }
+  private _setAudioProfile(audioProfile: string) {
+    this._audioProfile = audioProfile;
+  }
+  private _getAudioProfile(): string {
+    return this._audioProfile;
+  }
+  private _setCurrentCameraId(deviceId: string) {
+    this._currentCameraId = deviceId;
+  }
+  private _getCurrentCameraId(): string {
+    return this._currentCameraId;
+  }
+  private _setCurrentMicrophoneId(deviceId: string) {
+    this._currentMicrophoneId = deviceId;
+  }
+  private _getCurrentMicrophoneId(): string {
+    return this._currentMicrophoneId;
+  }
+  private _setCurrentSpeakerId(deviceId: string) {
+    this._currentSpeakerId = deviceId;
+  }
+  private _getCurrentSpeakerId(): string {
+    return this._currentSpeakerId;
+  }
+  private _setRemoteStreamConfig(userId: string, streamType: TRTCVideoStreamType, data: {
+    view?: HTMLElement | string,
+    mirrorType?: TRTCVideoMirrorType,
+    fillMode?: TRTCVideoFillMode,
+  }) {
+    const config: Record<string, any> = {
+      userId,
+      streamType: this._getTRTCStreamType(streamType),
+      option: {},
+    };
+    const { view, mirrorType, fillMode } = data;
+    if (!isUndefined(view)) {
+      config.view = view;
+    }
+    if (!isUndefined(mirrorType)) {
+      config.option.mirror = this._getTRTCMirror(mirrorType as TRTCVideoMirrorType);
+    }
+    if (!isUndefined(fillMode)) {
+      config.option.fillMode = this._getTRTCFillMode(fillMode as TRTCVideoFillMode);
+    }
+    this._remoteStreamConfig.set(`${userId}_${this._getTRTCStreamType(streamType)}`, config);
+  }
+
+  // ------------ 处理设备监听 -----------
+  /**
+   * 内部方法：设备插拔事件处理
+   */
+  async handleDeviceChange() {
+    // 重新获取 camera 设备列表
+    TRTC.getCameraList().then(async (list) => {
+      if (this._cameraList.length === list.length) return;
+      await this.deviceChangeManage(this._cameraList, list, TRTCDeviceType.TRTCDeviceTypeCamera);
+      this._cameraList = list;
+    });
+    // 重新获取 mic 设备列表
+    TRTC.getMicrophoneList().then(async (list) => {
+      await this.deviceChangeManage(this._microphoneList, list, TRTCDeviceType.TRTCDeviceTypeMic);
+      this._microphoneList = list;
+    });
+    // 重新获取 speaker 设备列表
+    TRTC.getSpeakerList().then(async (list) => {
+      await this.deviceChangeManage(this._speakerList, list, TRTCDeviceType.TRTCDeviceTypeSpeaker);
+      this._speakerList = list;
+    });
+  }
+
+  private isSameDevice(currentDevice, device) {
+    const isNormalCurrentDevice = currentDevice && currentDevice.deviceId && currentDevice.groupId && currentDevice.label;
+    const isNormalDevice = device && device.deviceId && device.groupId && device.label;
+    if (isNormalCurrentDevice && isNormalDevice) {
+      return currentDevice.deviceId === device.deviceId && currentDevice.groupId === device.groupId && currentDevice.label === device.label;
+    }
+    return false;
+  }
+
+  /**
+   * 内部方法：设备插拔数据处理<br>
+   * @param {Array<TRTCDeviceInfo>} currentDeviceList 原来设备列表
+   * @param {Array<TRTCDeviceInfo>} list 当前获取的设备列表
+   * @param {TRTCDeviceType} type 设备类型
+   */
+  // eslint-disable-next-line max-len
+  async deviceChangeManage(currentDeviceList: Array<TRTCDeviceInfo>, list, type: TRTCDeviceType) {
+    // 先处理设备插拔
+    let state: TRTCDeviceState | undefined = undefined;
+    if (currentDeviceList.length !== list.length) {
+      let deviceIdList: Array<String> = (list || []).map(obj => obj.deviceId);
+      let deviceInfo: TRTCDeviceInfo = new TRTCDeviceInfo();
+      // 拔出设备
+      if (currentDeviceList.length > list.length) {
+        deviceInfo = currentDeviceList.filter(obj => !deviceIdList.includes(obj.deviceId))[0] || {};
+        state = TRTCDeviceState.TRTCDeviceStateRemove;
+      } else {
+        // 插入设备
+        deviceIdList = (currentDeviceList || []).map(obj => obj.deviceId);
+        deviceInfo = list.filter(obj => !deviceIdList.includes(obj.deviceId))[0] || {};
+        state = TRTCDeviceState.TRTCDeviceStateAdd;
+      }
+      const { deviceId: changedDeviceId } = deviceInfo;
+      this.emitOnDeviceChange(changedDeviceId, type, state);
+    }
+
+    const defaultDeviceInfo: TRTCDeviceInfo = this.getDefaultDeviceInfo(list);
+
+    // 拔出 camera，底层 SDK 会进行切换，抛出 active 事件
+    if (type === TRTCDeviceType.TRTCDeviceTypeCamera && state === TRTCDeviceState.TRTCDeviceStateRemove) {
+      if (this.isSameDevice(this._currentCamera, defaultDeviceInfo)) {
+        return;
+      }
+      defaultDeviceInfo.deviceId && await this.autoChangeDevice(type, defaultDeviceInfo);
+    }
+
+    // 新增麦克风或者拔出麦克风，导致麦克风 default 发生改变时，处理 active 事件
+    if (type === TRTCDeviceType.TRTCDeviceTypeMic) {
+      if (this.isSameDevice(this._currentMicrophone, defaultDeviceInfo)) {
+        return;
+      }
+      defaultDeviceInfo.deviceId && await this.autoChangeDevice(type, defaultDeviceInfo);
+    }
+
+    // 新增扬声器或者拔出扬声器，导致扬声器 default 发生改变时，处理 active 事件
+    if (type === TRTCDeviceType.TRTCDeviceTypeSpeaker) {
+      if (this.isSameDevice(this._currentSpeaker, defaultDeviceInfo)) {
+        return;
+      }
+      defaultDeviceInfo.deviceId && await this.autoChangeDevice(type, defaultDeviceInfo);
+    }
+  }
+
+  /**
+   * 获取默认的设备信息：TRTC 获取设备列表时，里面会包含 deviceId = 'default' 的设备
+   * - 设备列表中，含有 deviceId = 'default' 的设备，通过 groupId 获取该设备的信息
+   * - 设备列表中，不含有 deviceId = 'default' 的设备，返回设备列表的第一个设备信息
+   * @param {Array<TRTCDeviceInfo>} deviceList 传入的设备列表
+   * @private
+   * @returns {TRTCDeviceInfo} defaultInfo
+   */
+  private getDefaultDeviceInfo(deviceList): TRTCDeviceInfo {
+    let defaultDeviceInfo: TRTCDeviceInfo = new TRTCDeviceInfo();
+    if (deviceList.length === 0) return defaultDeviceInfo;
+
+    const list = deviceList.filter(obj => obj.deviceId === 'default');
+    if (list.length > 0) {
+      [defaultDeviceInfo] = list;
+    } else {
+      [defaultDeviceInfo] = deviceList;
+    }
+    return defaultDeviceInfo;
+  }
+
+  /**
+   * 内部方法：设备插拔后，自动切换设备<br>
+   * @param {TRTCDeviceType} type 设备类型
+   * @param {DeviceInfo} deviceInfo 设备信息
+   */
+  private async autoChangeDevice(type: TRTCDeviceType, deviceInfo) {
+    const { deviceId } = deviceInfo;
+    // 拔出摄像头，切换当前摄像头，返回当前活跃的摄像头
+    if (type === TRTCDeviceType.TRTCDeviceTypeCamera) {
+      try {
+        await this._trtc.updateLocalVideo({ option: { cameraId: deviceId } });
+      } catch (error: any) {
+        console.log('error', JSON.stringify(error));
+        if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+          // ignore
+        }
+      }
+      try {
+        await this._testTrtc.updateLocalVideo({ option: { cameraId: deviceId } });
+      } catch (error: any) {
+        console.log('testTRTC error', JSON.stringify(error));
+        if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+          // ignore
+        }
+      }
+      this._currentCameraId = deviceId;
+      this._currentCamera = deviceInfo;
+      this.emitOnDeviceChange(deviceId, type, TRTCDeviceState.TRTCDeviceStateActive);
+    }
+    // 插入、拔出麦克风，自动切换至插入的麦克风；如果当前 mic 不是插入的 mic，则不进行切换也不抛出事件
+    if (type === TRTCDeviceType.TRTCDeviceTypeMic) {
+      try {
+        await this._trtc.updateLocalAudio({ option: { microphoneId: deviceId } });
+      } catch (error: any) {
+        console.log('error', JSON.stringify(error));
+        if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+          // ignore
+        }
+      }
+      try {
+        await this._testTrtc.updateLocalAudio({ option: { microphoneId: deviceId } });
+      } catch (error: any) {
+        console.log('testTRTC error', JSON.stringify(error));
+        if (error.code === TRTC.ERROR_CODE.OPERATION_ABORT) {
+          // ignore
+        }
+      }
+      this._currentMicId = deviceId;
+      this._currentMicrophone = deviceInfo;
+      this.emitOnDeviceChange(deviceId, type, TRTCDeviceState.TRTCDeviceStateActive);
+    }
+    // 插入、拔出 speaker，自动切换至插入的 speaker
+    if (type === TRTCDeviceType.TRTCDeviceTypeSpeaker) {
+      await TRTC.setCurrentSpeaker(deviceId);
+      this._currentSpeakerId = deviceId;
+      this._currentSpeaker = deviceInfo;
+      this.emitOnDeviceChange(deviceId, type, TRTCDeviceState.TRTCDeviceStateActive);
+    }
+  }
+
+  /**
+   * 设备插拔事件<br>
+   * @param {String} deviceId 设备 ID
+   * @param {TRTCDeviceType} type 设备类型
+   * @param {TRTCDeviceState} state 设备状态
+   * @event TRTCCallback#onDeviceChange
+   */
+  emitOnDeviceChange(deviceId: string, type: TRTCDeviceType, state: TRTCDeviceState) {
+    this.emit('onDeviceChange', deviceId, type, state);
+  }
+}
+
+export default TRTC_Cloud;