zbzt-live-sdk 0.0.2

package/src/zbzt-av-sdk/talrtc-sdk.js

@@ -0,0 +1,2620 @@
+import dataReport from '../network/dataReport.js';
+import defaultApi from '../default/index.js';
+import NOTICE from '../notice.js';
+import zbztsdk from '../zbzt-live-sdk.js';
+import { deviceListReport } from './device.js';
+import util from '../util/util.js';
+import getRTCInstance from 'omnirtc-web';
+import * as defaultsdk from './default-sdk.js';
+
+// 扩展标识
+const extensionId = 'talrtc_ext';
+// 端提供的 API 入口
+const EM = window.EM;
+// 是否执行过 TALRTC 的 AddListener 的标志
+let hasAddListener = false;
+// 监听id
+let EMListenerId = 0;
+// rtc小班课=0；rtc大班课=1
+const classType = 0;
+// 0: 小组课  1: 小班课  2: 新小班课
+let classMode = 0;
+// 心跳
+let heartBeatDataReportObj = {};
+let isFirstHeartBeatReport = false;
+// 维护的一份拉流的 streamId 与本地预览通道的映射表
+let streamIdToPreviewId = {};
+let previewIdToStreamId = {};
+let heartBeatDataReportTimer = null;
+let streamIdRtcPlayerInfo = {};
+let streamIdRtcPlayerInfo1 = {};
+// 拉流的播放通道初始化从 0 开始依次递增至44(共45路流)，-1 为推流的本地视频预览
+const uiChnIndexs = new Array(100).fill(0).map((a, b) => b).reverse();
+// 维护的一份当前正在使用的音频设备的 deviceId 的列表
+let usingAudioDeviceId = {
+  speaker: '',
+  microphone: ''
+};
+let localStreamId = '';
+let screenStreamId = '';
+let isScreenSharing = false;
+let isSpeakerCapturing = false;
+let sdkVersion = null;
+const streamMuteStatus = {};
+const localStreamMuteStatus = {
+  video: false,
+  audio: false,
+};
+//记录底层推流回调的值
+let dataTalrtcCapture = {};
+let qualityLocalArr = [];
+let qualityRemoteArr = [];
+let localRoomId = null;
+let userId = null;
+let isNoticeMicVolume = false;
+let enableLocalCapture = true; // 本地摄像头采集，默认允许
+let teacherId = null;
+let qualityLocal = 0;
+let qualityRemote = 0;
+
+const BUSI_USER_ROLE = {
+  student: 0,
+  teacher: 1,
+  assistant: 2,
+};
+const ENGINE_TYPE = {
+  talrtc: 7,
+  nertc: 8,
+  volcrtc: 9
+};
+// /**
+//   * 过滤直播云sdk中deviceId前缀
+//   * @param {string} deviceId
+//   * @returns {string}
+//   */
+// const formatDeviceId = (deviceId) => {
+//   return deviceId.replace(/^@device:\w+:/, '');
+// };
+const getStreamMuteStatus = (streamId, type) => {
+  const streamStatus = streamMuteStatus[streamId] || {};
+  return streamStatus[type] || false;
+};
+const setStreamMuteStatus = (streamId, type, status) => {
+  const streamStatus = streamMuteStatus[streamId];
+  if (streamStatus) {
+    streamStatus[type] = status;
+    return;
+  }
+  switch (type) {
+  case 'video':
+    streamMuteStatus[streamId] = {
+      video: status,
+      audio: false,
+    };
+    break;
+  case 'audio':
+    streamMuteStatus[streamId] = {
+      video: false,
+      audio: status,
+    };
+    break;
+  default:break;
+  }
+};
+/**
+ * 判断主流还是辅流
+ * @param {string} streamId 
+ * @returns {boolean} true: 主流 false: 辅流
+ */
+const isMainStream = (streamId) => {
+  return streamId.split('_').length === 4;
+};
+
+const callMethod = (name, args) => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      // let noneCamera = (name === 'SetCameraDevice' && !args.pszDeviceID);
+      // let noneMicrophone = (name === 'SetAudioDevice' && args.deviceType === 0 && !args.pszDeviceID);
+      // let noneSpeaker = (name === 'SetAudioDevice' && args.deviceType === 1 && !args.pszDeviceID);
+      // if (noneCamera || noneMicrophone || noneSpeaker) {
+      //   return resolve();
+      // }
+      EM.CallMethod(
+        extensionId,
+        name,
+        JSON.stringify({ ...args, classType }),
+        (code, msg) => {
+          defaultApi.writeLog(`${name} Code: ${code} Message: ${msg} Params: ${JSON.stringify({ ...args, classType })}`);
+          resolve({
+            code,
+            msg
+          });
+        }
+      );
+    });
+  }
+};
+
+const loadTalrtc = (extensionVersion) => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      removerListener();
+      defaultApi.writeLog(`-> load tal rtc sdk  ${extensionId}, ${extensionVersion}`);
+      EM.Load(
+        extensionId,
+        extensionVersion,
+        false,
+        (code, msg) => {
+          defaultApi.writeLog(`loadTalrtc Code: ${code}\nMessage: ${msg}`);
+          addListener();
+          resolve();
+        }
+      );
+    });
+  }
+};
+
+//卸载监听
+const removerListener = () => {
+  hasAddListener = false;
+  defaultApi.writeLog(`TALRTC::action--removerListener EMListenerId:${EMListenerId}`);
+  EM.RemoverListener(extensionId, EMListenerId, (ec, content) => {
+  });
+  EMListenerId = 0;
+};
+
+//加载监听
+
+/**
+ * @function 添加扩展监听机制
+ * @param userId:Number 用户 id，必选
+ * @param userName:String 用户名，必选
+ * @param roomId:String 频道（房间） id，必选
+ * @param nNetType:Number 网络类型，可选，默认为 1
+ * @return void
+ */
+// const addListener = () => {
+//   // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+//   if (EM && !hasAddListener) {
+//     hasAddListener = true;
+//     EM.AddListener(extensionId, (event, data) => {
+//       if (zbztsdk.openListenerLog) {
+//         console.log(`avsdk TALRTC::Listener:: start event: ${event}, data: ${JSON.stringify(data)}`);
+//       }
+//       if (data && data.indexOf(extensionId) > -1) {
+//         try {
+//           EMListenerId = JSON.parse(data)[extensionId];
+//           defaultApi.writeLog(`TALRTC::addListener-- EMListenerId: ${EMListenerId}`);
+//         } catch (error) {
+//         }
+//       }
+//       if (!event || !data) {
+//         return;
+//       }
+//       let _data = JSON.parse(data);
+//       // defaultApi.writeLog(`TALRTC: event:: ${event} : ${data}`);
+//       switch (event) {
+//       // 推流器出现错误
+//       case 'onLocalError':
+//         defaultApi.writeLog(`TALRTC::addListener-- onLocalError: ${data}`);
+//         NOTICE.pushStreamError({
+//           errorStreamType:_data.streamType,
+//           code: _data.code,
+//           errorMsg: _data
+//         });
+//         dataReport.pushStreamError({
+//           errorStreamType:_data.streamType,
+//           code: _data.code
+//         });
+//         // defaultApi.writeLog(`TALRTC: event:: onLocalError: ${_data}`);
+//         break;
+//         // 直播推流器警告通知
+//       case 'onLocalWarning':
+//         defaultApi.writeLog(`TALRTC::addListener-- onLocalWarning: ${data}`);
+//         NOTICE.pushStreamWarning({
+//           warnStreamType:_data.streamType,
+//           code: _data.code
+//         });
+//         dataReport.pushStreamWarning({
+//           warnStreamType:_data.streamType,
+//           code: _data.code
+//         });
+//         break;
+//         // 首帧音频推送完成的回调通知
+//       case 'onSendLocalFirstAudioFrame':
+//         defaultApi.writeLog(`TALRTC: event:: onSendLocalFirstAudioFrame: ${data}`);
+//         break;
+//       // 采集首帧事件
+//       case 'OnCaptureVideoFirstFrame':
+//         defaultApi.writeLog(`TALRTC: event:: OnCaptureVideoFirstFrame: ${data}`);
+//         NOTICE.pushFlowSuccess({code:0,publish_streamid: _data.pszStreamID});
+//         dataReport.publishResult({
+//           code: '0',
+//         });
+//         break;
+//         // 本地音量
+//       case 'onLocalMicrophoneVolumeUpdate':
+//         // defaultApi.writeLog(`TALRTC: event:: onLocalMicrophoneVolumeUpdate: ${data}`);
+//         if (isNoticeMicVolume) {
+//           NOTICE.captureMicVolumeChanged({
+//             volume: Math.round(_data.volume)
+//           });
+//         }
+//         heartBeatDataReportObj.volume = heartBeatDataReportObj.volume + Math.round(_data.volume) + ',';
+//         break;
+//         // 推流器连接状态回调通知。推流器连接状态 1与服务器断开连接/2 正在连接服务器/3 连接服务器成功/4 重连服务器中  5
+//       case 'onLocalConnectStatusUpdate':
+//         defaultApi.writeLog(`TALRTC: event:: onLocalConnectStatusUpdate: ${data}`);
+//         dataReport.localConnectStatus({
+//           connectStatuStreamType:_data.streamType,
+//           state: _data.state
+//         });
+//         if (_data.state === 2 || _data.state === 1) {
+//           NOTICE.networkError();
+//         } else if (_data.state === 3) {
+//           NOTICE.networkRecovery();
+//         }
+//         break;
+//         // 网络质量的实时统计回调
+//       case 'onLocalNetworkQuality':
+//         // defaultApi.writeLog(`TALRTC: event:: onLocalNetworkQuality: ${data}`);
+//         if(_data.quality == 4 || _data.quality == 5 || _data.quality == 6) {
+//           NOTICE.localNetworkQuality({code: _data.quality});
+//           // dataReport.localNetworkQuality({
+//           //   code:  _data.quality,
+//           // });
+//         }
+//         qualityLocal = _data.quality;
+//         // qualityLocalArr.push(_data.quality);
+//         break;
+
+//         // 远端流错误通知，拉流出现错误时，会回调该通知
+//       case 'onRemoteError':
+//         defaultApi.writeLog(`TALRTC: event:: onRemoteError: ${data}`);
+//         NOTICE.pullStreamError({
+//           strErrorStreamId: _data.streamId,
+//           code:_data.code
+//         });
+//         break;
+//       // 远端流警告通知，拉流出现警告时，会回调该通知
+//       case 'onRemoteWarning':
+//         defaultApi.writeLog(`TALRTC: event:: onRemoteWarning: ${data}`);
+//         NOTICE.pullStreamWarning({
+//           strWarnStreamId: _data.streamId,
+//           code:_data.code
+//         });
+//         break;
+//         // 卡顿事件，用于事件上报
+//       case 'stuckevent':
+//         defaultApi.writeLog(`TALRTC: event:: stuckevent: ${data}`);
+//         break;
+//         // 远端音频首帧
+//       case 'onRecvRemoteAudioFirstFrame':
+//         try{
+//           NOTICE.firstAudioSize({
+//             streamId: _data.streamId,
+//             userId: util.getUidByStreamId(_data.streamId)
+//           });
+//           dataReport.firstAudioSize({
+//             pull_streamid: _data.streamId,
+//             pull_uid: util.getUidByStreamIdDr(_data.streamId),
+//             code:'0'
+//           });
+//         } catch (e) { };
+//         defaultApi.writeLog(`TALRTC: event:: OnRecvRemoteAudioFirstFrame: ${data}`);
+//         break;
+//       // 远端流音量大小
+//       case 'onRemoteAudioVolume':
+//         // defaultApi.writeLog(`TALRTC: event:: onRemoteAudioVolume: ${data}}`);
+//         let cbData = {
+//           streamid: _data.streamId,
+//           streamId: _data.streamId,
+//           userId: util.getUidByStreamId(_data.streamId),
+//           volume: _data.volume
+//         };
+//         NOTICE.playerVolumeChanged(cbData);
+//         NOTICE.volumeChange(cbData);
+//         if(streamIdRtcPlayerInfo[_data.streamId]) {
+//           streamIdRtcPlayerInfo[_data.streamId].volume = streamIdRtcPlayerInfo[_data.streamId].volume + Math.round(_data.volume)+ ',';
+//         }
+//         break;
+//       case 'onUserEnableAudio':
+//         try {
+//           if (
+//             teacherId &&
+//             _data.streamId.match(teacherId) &&
+//             isMainStream(_data.streamId) &&
+//             _data.inuse
+//           ) {
+//             setChiefAudioStream(_data.streamId, util.getUidByStreamIdDr(_data.streamId));
+//           }
+//         } catch (e) {
+//           defaultApi.writeLog(`TALRTC: event:: onUserEnableAudio: ${e}`);
+//         }
+//         defaultApi.writeLog(`TALRTC: event:: onUserEnableAudio: ${data}`);
+//         break;
+//         // 远端视频首帧
+//       case 'onRenderRemoteVideoFirstFrame':
+//         try{
+//           // Test Code: 临时增加
+//           setTimeout(() => {
+//             NOTICE.pullFlowResult({code:0,pull_streamid: _data.streamId});
+//             NOTICE.firstVideoSize({
+//               streamId: _data.streamId,
+//               userId: util.getUidByStreamId(_data.streamId)
+//             });
+//             dataReport.firstVideoSize({
+//               pull_streamid: _data.streamId,
+//               pull_uid: util.getUidByStreamIdDr(_data.streamId),
+//               code:'0'
+//             });
+//           }, 100);
+//         } catch (e) { };
+//         defaultApi.writeLog(`TALRTC: event:: OnRenderRemoteVideoFirstFrame: ${data}`);
+//         break;
+//       // SEI消息
+//       case 'onRecvSEIMsg':
+//         defaultApi.writeLog(`TALRTC: event:: onRecvSEIMsg: ${data}`);
+//         break;
+//       // 网络质量的实时统计回调
+//       case 'onRemoteNetworkQuality':
+//         // defaultApi.writeLog(`TALRTC: event:: onRemoteNetworkQuality: ${data}`);
+//         if(_data.quality == 4 || _data.quality == 5 || _data.quality == 6) {
+//           NOTICE.remoteNetworkQuality({code: _data.quality});
+//           // dataReport.remoteNetworkQuality({
+//           //   code:  _data.quality,
+//           // });
+//         }
+//         qualityRemote = _data.quality;
+//         // qualityRemoteArr.push(_data.quality);
+//         break;
+
+//       // 转推 CDN 上发布音视频流的事件回调
+//       case 'onRtmpStreamingStateChanged':
+//         defaultApi.writeLog(`TALRTC: event:: onRtmpStreamingStateChanged: ${data}`);
+//         break;
+//       // 设备异常
+//       case 'onDeviceError':
+//         defaultApi.writeLog(`TALRTC: event:: OnDeviceError: ${data}`);
+//         break;
+//         // 拉流的结果通知
+//       case 'onPlayStateUpdate':
+//         defaultApi.writeLog(`TALRTC: event:: onPlayStateUpdate: ${data}`);
+//         break;
+//         // 推流的结果通知
+//       case 'onPushStateUpdate':
+//         defaultApi.writeLog(`TALRTC: event:: onPushStateUpdate: ${data}`);
+//         if (_data.state === 3) {
+//           NOTICE.pushFlowSuccess({code:0,publish_streamid: _data.streamId});
+//         }
+//         break;
+//         // 推、拉流的统计数据。
+//       case 'onLocalStatistics':
+//         try {
+//           NOTICE.playLossAndDelay({
+//             userId,
+//             delay:_data.rtt,
+//             lostrate:_data.packetLoss
+//           });
+//         }catch(e){}
+//         heartBeatDataReportCalc('onLocalStatistics', _data);
+//         // defaultApi.writeLog(`TALRTC: event:: onStatisticsUpdate: ${_data}`);
+//         break;
+//         // 本地摄像头设备的通断状态发生变化
+//       case 'onRemoteStatistics':
+//         try {
+//           const _d = JSON.parse(_data.stats);
+//           NOTICE.pullQuality({
+//             video: {
+//               streamId: _d.streamId,
+//               userId: util.getUidByStreamId(_d.streamId),
+//               bitrate: _d.videoBitrate,
+//               fps: _d.fps,
+//             }
+//           });
+//           NOTICE.playLossAndDelay({
+//             userId: util.getUidByStreamId(_d.streamId),
+//             delay:_d.rtt,
+//             lostrate:_d.packetLoss
+//           });
+//         }catch(e){}
+//         heartBeatDataReportCalc('onRemoteStatistics', _data);
+//         // defaultApi.writeLog(`TALRTC: event:: onStatisticsUpdate: ${_data}`);
+//         break;
+//       // 本地摄像头设备的通断状态发生变化
+//       case 'onVideoDeviceChanged':
+//         defaultApi.writeLog(`TALRTC: event:: onVideoDeviceChanged: ${data}`);
+//         setCameraDevice({deviceId: _data.state == 1 ? _data.deviceId : '', operationType: 'hotPlug', deviceState: _data.state == 1 ? 0 : 1, changedDeviceId: _data.deviceId});
+//         break;
+//         /* 本地麦克风设备的通断状态发生变化
+//            *  state：1：使用中   2：被禁用  4：一开始就没有？（我也不懂）  8：设备移除
+//            *  deviceType：-1：未知   0：播放器   1：麦克风  2：视频显示设备  3：摄像头
+//            */
+//       case 'onAudioDeviceChanged':
+//         defaultApi.writeLog(`TALRTC: event:: onAudioDeviceChanged: ${data}`);
+//         if (_data.deviceType === 0) {
+//           setSpeakerDevice({deviceId: _data.state == 1 ? _data.deviceId : '', operationType: 'hotPlug', deviceState: _data.state == 1 ? 0 : 1, changedDeviceId: _data.deviceId});
+//         }
+//         if (_data.deviceType === 1) {
+//           setMicrophoneDevice({deviceId: _data.state == 1 ? _data.deviceId : '', operationType: 'hotPlug', deviceState: _data.state == 1 ? 0 : 1, changedDeviceId: _data.deviceId});
+//         }
+//         break;
+
+//         // mute 视频状态，true：远端开始推流，并拉流收到首帧；false：远端停止推流。
+//       case 'onRemoteVideoStatus':
+//         defaultApi.writeLog(`TALRTC: event:: onRemoteVideoStatus: ${data}`);
+//         break;
+
+//         // mute 音频状态，true：远端开始推流，并拉流收到首帧；false：远端停止推流。
+//       case 'onRemoteAudioStatus':
+//         defaultApi.writeLog(`TALRTC: event:: onRemoteAudioStatus: ${data}`);
+//         break;
+//         // 首帧视频推送完成的回调通知
+//       case 'onSendLocalFirstVideoFrame':
+//         defaultApi.writeLog(`TALRTC: event:: onSendLocalFirstVideoFrame: ${data}`);
+//         break;
+//       case 'updateRet':
+//         defaultApi.writeLog(`TALRTC: event:: updateRet: ${data}`);
+//         break;
+//       default:
+//         console.warn('warning: uncaught listener:', event);
+//       }
+//     });
+//   }
+// };
+
+class Clients extends Map {
+  constructor() {
+    super(arguments);
+  }
+  /**
+   * @param {string} roomId
+   * @param {import('omnirtc-web').IOmniRTCClient} client
+   */
+  set(roomId, client) {
+    return super.set(roomId, client);
+  }
+  /**
+   * 
+   * @param {string} roomId 
+   * @returns {import('omnirtc-web').IOmniRTCClient | null}
+   */
+  get(roomId) {
+    return super.get(roomId);
+  }
+  /**
+   * 
+   * @param {string} roomId 
+   * @returns 
+   */
+  delete(roomId) {
+    const client = super.get(roomId);
+    if (client) {
+      client.leave();
+    }
+    return super.delete(roomId);
+  }
+  clear() {
+    super.forEach((client) => {
+      client.leave();
+    });
+    return super.clear();
+  }
+}
+/**
+ * @type {import('omnirtc-web').IOmniRTC | null}
+ */
+let talrtc = null;
+
+/**
+ * @type {import('omnirtc-web').IMicrophoneAudioTrack | null}
+ */
+let audioTrack = null;
+
+/**
+ * @type {import('omnirtc-web').ICameraVideoTrack | null}
+ */
+let videoTrack = null;
+
+/**
+ * @type {import('omnirtc-web').ILocalVideoTrack | null}
+ */
+let screenTrack = null;
+
+/**
+ * @type {Map<string, import('omnirtc-web').IOmniRTCClient>}
+ */
+const clients = new Clients();
+/**
+ * @type {Map<string, import('omnirtc-web').IRemoteVideoTrack | import('omnirtc-web').IRemoteAudioTrack | true>}
+ */
+const remoteTracks = new Map();
+
+/**
+ * 
+ * @param {import('omnirtc-web').IOmniRTCClient} client 
+ */
+const addListener = (client) => {
+  client.on('user-join', (uid) => {});
+  client.on('user-left', (uid) => {});
+  client.on('user-published', (user, mediaType) => {});
+  client.on('user-unpublished', (user, mediaType) => {});
+  client.on('user-info-updated', (uid, info) => {});
+  client.on('volume-indicator', (result) => {});
+};
+
+// 初始化相关
+const init = async (args) => {
+  defaultApi.writeLog(`avsdk TALRTC::init ${JSON.stringify(args)}`);
+  const usedDevices = window.zbztAVSDK_device_checker_init;
+  const { devices } = args;
+  const sdkType = window.zbztAVSDK_init_sdk_type || 'talrtc';
+  localStreamId = args.streamId;
+  screenStreamId = `${args.institutionId}_${args.roomId}_${args.userId}_${args.live_id}_1`;
+  teacherId = args.teacherId;
+  const _devices = {
+    camera: (devices && devices.camera) || (usedDevices && usedDevices.camera && usedDevices.camera.use) || '',
+    microphone: (devices && devices.microphone) || (usedDevices && usedDevices.microphone && usedDevices.microphone.use) || '',
+    speaker: (devices && devices.speaker) || (usedDevices && usedDevices.speaker && usedDevices.speaker.use) || ''
+  };
+
+  talrtc = getRTCInstance(args.token);
+  const client = talrtc.createClient({codec: 'h264', mode: 'rtc'});
+  await client.join();
+  clients.set(String(args.roomId), client);
+  // await startEngine(args.appId, localRoomId, args.userId, args.usersign || '67890', ENGINE_TYPE[sdkType] || 7, args.live_id, BUSI_USER_ROLE[args.role] || 0);
+
+  // classMode = args.classMode >> 0;
+  // // 0: 小组课  1: 小班课  2: 新小班课
+  // if (classMode === 1 || classMode === 2){
+  //   if(args.role === 'teacher') {
+  //     //小班课 需要加载采集插件的输入数据,为了拼接talrtc头像
+  //     await loadCollectionInputEntry();
+
+  //     //屏幕流通道
+  //     screenStreamId = `${window.zbzt_sdk_init_params.institutionId}_${localRoomId}_${userId}_${args.live_id}_1`;
+  //     await enableExternalVideoSource(true, screenStreamId);
+  //     await setCameraEncodeFps(args.screenSameFps, screenStreamId);
+  //     await setCameraCaptureResolution(args.screenSameResolutionWidth, args.screenSameResolutionHeight, screenStreamId);
+  //     await setCameraEncodeResolution(args.screenSameResolutionWidth, args.screenSameResolutionHeight, screenStreamId);
+  //     await setCameraEncodeBitrate(args.screenSameBitrate, screenStreamId);
+
+  //     //rtc同屏以及高光时刻,都开启音频外部采集,默认传1
+  //     await setAudioAuxSource(1);
+  //     teacherId = undefined;
+  //   }
+
+  //   if(args.noiseSuppressMode == -2) {
+  //     defaultApi.writeLog(`noiseSuppressMode 关闭噪声消除 ${args.noiseSuppressMode}`);
+  //     await setEnableNoiseSuppress(false);
+  //   } else if(args.noiseSuppressMode == -1) {
+  //     defaultApi.writeLog(`noiseSuppressMode 由底层进行配置，js层不进行配置 ${args.noiseSuppressMode}`);
+  //   } else {
+  //     defaultApi.writeLog(`noiseSuppressMode 启动噪音消除,模式为：${args.noiseSuppressMode}`);
+  //     await setEnableNoiseSuppress(true);
+  //     await setNoiseSuppressMode(args.noiseSuppressMode >> 0);
+  //     await enableTransientNoiseSuppress(true);
+  //   };
+  //   //aecMode为-1是关闭回音消除，云控下传
+  //   if(args.aecMode == -2) {
+  //     defaultApi.writeLog(`aecMode 关闭回音消除 ${args.aecMode}`);
+  //     await setEnableAEC(false);
+  //   } else if(args.aecMode == -1) {
+  //     defaultApi.writeLog(`aecMode 由底层进行配置，js层不进行配置 ${args.aecMode}`);
+  //   } else {
+  //     defaultApi.writeLog(`aecMode 启动回音消除,模式为：${args.aecMode}`);
+  //     await setEnableAEC(true);
+  //     await setAECMode(args.aecMode >> 0);
+  //   };
+  // };
+
+  // if((args.role === 'teacher' || args.role === 'assistant') && classMode === 0){
+  //   //坐立模式开启外部采集器，站立关闭外部采集器,只有小组课坐立模式才会调用，通过这个把rtmp数据给到talrtc(头像),开启了外部采集，talrtc不会再本地采集数据
+  //   // V2 不区分坐立站立，老师和辅导老师都启动外部视频源
+  //   await enableExternalVideoSource(true, localStreamId);
+  //   enableLocalCapture = false; // 禁用本地摄像头采集，防止与其他进程抢占摄像头
+  // } else {
+  //   await setDefaultDevice(_devices, 'default');
+  // }
+  // 主通道
+  // await setCameraEncodeFps(args.encodeCaptureFps, localStreamId);
+  // await setCameraCaptureResolution(args.previewResolutionWidth, args.previewResolutionHeight, localStreamId);
+  // await setCameraEncodeResolution(args.encodedResolutionWidth, args.encodedResolutionHeight, localStreamId);
+  // await setCameraEncodeBitrate(args.encodeCaptureBitrate, localStreamId);
+
+  setMicphoneVolumInterval(1000);
+  // await setMediaSideFlags();
+  window.current_sdk_type = sdkType;
+  defaultApi.writeLog('avsdk TALRTC::init finished current_sdk_type: ' + sdkType);
+};
+
+
+/**
+ * @function 初始化引擎
+ * @param {string} appid TalRTC 秘钥，必选
+ * @param {string} userid
+ * @param {string} usersign
+ * @param {1 | 7} type 直播中台SDK底层引擎类型 7: 自研引擎
+ * @param {string} liveID
+ * @param {0 | 1 | 2} businessRole 0: student 1: teacher 2: tutor
+ * @return Promise | void
+ */
+const startEngine = (appid, roomId, userid, usersign, type, liveID, businessRole) => {
+  defaultApi.writeLog(`avsdk TALRTC::StartEngine appid: ${appid} roomId:${roomId} userid: ${userid} usersign: ${usersign}, liveID: ${liveID}, businessRole: ${businessRole}`);
+  return callMethod('StartEngine', {
+    appid,
+    roomId,
+    userid,
+    usersign,
+    type,
+    liveID: '' + liveID,
+    businessRole,
+    institutionId: '' + window.zbzt_sdk_init_params.institutionId,
+  });
+};
+
+//开启消除回声
+export const setEnableAEC = (enable) => {
+  return callMethod('EnableAEC', {enable});
+};
+
+//设置回声消除模式 mode ：激进模式 =0/中等模式 =1/轻度模式 =2
+export const setAECMode = (mode) => {
+  return callMethod('SetAECMode', {mode});
+};
+
+//开启噪音消除
+export const setEnableNoiseSuppress = (enable) => {
+  return callMethod('EnableNoiseSuppress', {enable});
+};
+
+//设置噪音消除模式 mode ：0：低  1：中   2高
+export const setNoiseSuppressMode = (mode) => {
+  return callMethod('SetNoiseSuppressMode', {mode});
+};
+
+//新增瞬时降噪接口 瞬时降噪 可以处理掉 敲键盘、敲桌子、敲门等瞬态噪声。非瞬态噪声，此接口无法处理，比如划桌子等摩擦噪音。
+export const enableTransientNoiseSuppress = (enable) => {
+  return callMethod('EnableTransientNoiseSuppress',{enable});
+};
+
+/**
+   * 加载采集插件的输入数据  //调用后，talrtc 可以向采集插件传送摄像头数据，用于拼接
+   * @return {Promise}
+   */
+export const loadCollectionInputEntry = () => {
+  return callMethod('LoadCollectionInputEntry', {});
+};
+
+/**
+ * 1、设置需要拼接的学生头像流id，按数组顺序拼接
+ * 2、加载截屏插件，获取截屏插件设置拉流头像回调函数
+ * @param {Array} stream_ids  拉流id数组，最大有效数量7个
+ * @returns {Promise}
+ */
+export const loadCollectionInputEntry2 = (stream_ids) => {
+  return callMethod('LoadCollectionInputEntry2', {stream_ids});
+};
+//设置是否发送sei
+const setMediaSideFlags = (start = true, onlyAudioPublish = false, mediaInfoType = 2, seiSendType = 1, idx = 0) => {
+  return callMethod('SetMediaSideFlags',{start,onlyAudioPublish, mediaInfoType, seiSendType, idx});
+};
+
+/**
+ * @function 销毁引擎
+ * @return Promise | void
+ */
+const destroyEngine = () => {
+  defaultApi.writeLog('avsdk TALRTC::destroyEngine');
+  audioTrack && audioTrack.close();
+  videoTrack && videoTrack.close();
+  screenTrack && screenTrack.close();
+  clients.forEach((client) => {
+    client.leave();
+  });
+  clients.clear();
+  audioTrack = null;
+  videoTrack = null;
+  screenTrack = null;
+  remoteTracks.clear();
+};
+
+// 设置采集分辨率
+const setCameraCaptureResolution = (width, height, streamId = localStreamId) => {
+  return callMethod('SetCameraCaptureResolution', { width, height, streamId });
+};
+
+// 设置编码分辨率
+const setCameraEncodeResolution = (width, height, streamId = localStreamId) => {
+  return callMethod('SetCameraEncodeResolution', { width, height, streamId });
+};
+
+// 设置编码帧率
+const setCameraEncodeFps = (fps, streamId = localStreamId) => {
+  return callMethod('SetCameraEncodeFps', { fps, streamId });
+};
+
+// 设置编码码率
+const setCameraEncodeBitrate = (bitrate, streamId = localStreamId) => {
+  return callMethod('SetCameraEncodeBitrate', { bitrate, streamId });
+};
+
+// 获取指定摄像头的支持的分辨率
+const getCameraResolution = async (deviceId) => {
+  const resp = await callMethod('GetCameraResolution', { deviceId });
+  const cameraArr = JSON.parse(resp.msg || '{}').SupportedResolution;
+  return {
+    code: resp.code,
+    msg: JSON.stringify(cameraArr)
+  };
+};
+
+// 获取 rtc_sdk.dll 版本号
+const getSDKVersion = async () => {
+  if (sdkVersion) {
+    return sdkVersion;
+  }
+  return callMethod('GetSDKVersion', {}).then((e) => {
+    sdkVersion = e;
+  });
+};
+
+/**
+ * @function 设置默认的硬件设备，包括摄像头、麦克风以及扬声器
+ * @return Promise
+ */
+export const setDefaultDevice = async (devices, operationType) => {
+  // 设置默认的摄像头
+  if (devices && devices.camera) {
+    if (zbztAVSDK_device_checker_init.camera.list.length == 0) {
+      await getCameraDeviceList();
+    }
+    await setCameraDevice({ deviceId: devices.camera, operationType: `${operationType}_1` });
+  } else {
+    const cameraData = await getCameraDeviceList();
+    if (cameraData.length) {
+      let hasSetCamera = false;
+      for (let item of cameraData) {
+        if (item.isDefault) {
+          await setCameraDevice({ deviceId: item.deviceId, operationType: `${operationType}_2` });
+          hasSetCamera = true;
+          break;
+        }
+      }
+      if (!hasSetCamera) {
+        await setCameraDevice({ deviceId: cameraData[0].deviceId, operationType: `${operationType}_3` });
+      }
+    }
+  }
+  // 设置默认的麦克风
+  if (devices && devices.microphone) {
+    if (zbztAVSDK_device_checker_init.microphone.list.length == 0) {
+      await getMicrophoneDeviceList();
+    }
+    await setMicrophoneDevice({ deviceId: devices.microphone, operationType: `${operationType}_1` });
+  } else {
+    const microPhoneData = await getMicrophoneDeviceList();
+    try {
+      if (microPhoneData.length) {
+        let hasSetMicrophone = false;
+        for (let item of microPhoneData) {
+          if (item.isDefault) {
+            await setMicrophoneDevice({ deviceId: item.deviceId, operationType: `${operationType}_2` });
+            hasSetMicrophone = true;
+            break;
+          }
+        }
+        if (!hasSetMicrophone) {
+          await setMicrophoneDevice({ deviceId: microPhoneData[0].deviceId, operationType: `${operationType}_3` });
+        }
+      }
+    } catch (e) {
+      console.log(e);
+    }
+
+  }
+  // 设置默认的扬声器
+  if (devices && devices.speaker) {
+    await setSpeakerDevice({ deviceId: devices.speaker, operationType: `${operationType}_1` });
+  } else {
+    const speakerData = await getSpeakerDeviceListInternal();
+    if (speakerData.length) {
+      let hasSetSpeaker = false;
+      for (let item of speakerData) {
+        if (item.isDefault) {
+          await setSpeakerDevice({ deviceId: item.deviceId, operationType: `${operationType}_2` });
+          hasSetSpeaker = true;
+          break;
+        }
+      }
+      if (!hasSetSpeaker) {
+        await setSpeakerDevice({ deviceId: speakerData[0].deviceId, operationType: `${operationType}_3` });
+      }
+    }
+  }
+};
+
+// 麦克风相关
+/**
+ * @function 开启麦克风
+ * @param intervalMs: Number
+ * @return Promise | void
+ */
+const startMicrophone = async (intervalMs = 500) => {
+  defaultApi.writeLog('avsdk TALRTC::startMicrophone');
+  isNoticeMicVolume = true;
+  audioTrack = await talrtc.createMicrophoneAudioTrack({
+    microphoneId: window.zbztAVSDK_device_checker_init.microphone.use,
+  });
+
+  audioTrack.on('track-ended', () => {
+    defaultApi.writeLog('avsdk TALRTC::startMicrophone track-ended');
+    audioTrack.removeAllListeners();
+    audioTrack = null;
+  });
+  // return callMethod('StartMicrophone', { intervalMs });
+};
+
+/**
+ * @function 关闭麦克风
+ * @return Promise | void
+ */
+const stopMicrophone = async () => {
+  defaultApi.writeLog('avsdk TALRTC::stopMicrophone');
+  isNoticeMicVolume = false;
+  if (audioTrack) {
+    audioTrack.close();
+  }
+  // return callMethod('StopMicrophone', {});
+};
+
+const openOrCloseMicrophone = async (operation) => {
+  if (operation) {
+    await startMicrophone();
+  } else {
+    await stopMicrophone();
+  }
+};
+
+let micVolTimer;
+/**
+ * @function 设置麦克风音量大小回调周期
+ * @param intervalMs: Number
+ * @return Promise | void
+ */
+const setMicphoneVolumInterval = (intervalMs = 1000) => {
+  if (typeof intervalMs !== 'number' || intervalMs < 0) {
+    defaultApi.writeLog('avsdk TALRTC::setMicphoneVolumInterval intervalMs is not a number or less than 0', null, 'error');
+    throw new Error('[setMicphoneVolumInterval] intervalMs is not a number or less than 0');
+  }
+  micVolTimer = setInterval(async () => {
+    if (audioTrack) {
+      const volume = audioTrack.getVolumeLevel();
+      NOTICE.captureMicVolumeChanged({
+        volume: Math.round(volume)
+      });
+    }
+  }, intervalMs);
+};
+
+/**
+ * @function 获取麦克风设备列表
+ * @return Promise | void
+ */
+const getMicrophoneDeviceListInternal = () => {
+  return callMethod('GetMicrophoneDeviceList', {});
+};
+
+/**
+ * @function 获取麦克风列表
+ * @return Promise | void
+ */
+const getMicrophoneDeviceList = async () => {
+  defaultApi.writeLog('avsdk TALRTC::getMicrophoneDeviceList');
+  return defaultsdk.getMicrophoneDeviceList();
+
+  // const defaultMicrophoneId = JSON.parse((await getDefaultMicrophone()).msg).deviceId;
+  // const resp = await getMicrophoneDeviceListInternal();
+  // let microphoneListArr = JSON.parse(JSON.parse(resp.msg).DeviceList) || [];
+  // let microphoneList = [];
+  // for (let i = 0, len = microphoneListArr.length; i < len; i++) {
+  //   microphoneList.push({
+  //     deviceId: microphoneListArr[i].id,
+  //     deviceName: microphoneListArr[i].name,
+  //     isDefault: defaultMicrophoneId === microphoneListArr[i].id
+  //   });
+  //   deviceListReport.micList[microphoneListArr[i].szDeviceId] = microphoneListArr[i].szDeviceName;
+  // }
+  // if (!window.zbztAVSDK_device_checker_init) {
+  //   window.zbztAVSDK_device_checker_init = {};
+  // }
+  // if (!window.zbztAVSDK_device_checker_init.microphone) {
+  //   window.zbztAVSDK_device_checker_init.microphone = {};
+  // }
+  // window.zbztAVSDK_device_checker_init.microphone.hasTest = true;
+  // window.zbztAVSDK_device_checker_init.microphone.list = microphoneList;
+  // defaultApi.writeLog(`getMicrophoneDeviceList ${JSON.stringify(microphoneList)}`);
+  // return microphoneList;
+};
+
+/**
+ * @function 设置指定音频（当前麦克风）设备
+ * @param deviceId: String 音频设备 id，必选
+ * @return Promise | void
+ */
+const setCurrentMicrophoneDevice = (deviceId) => {
+  window.zbztAVSDK_device_checker_init.microphone.use = deviceId;
+  return callMethod('SetCurrentMicrophoneDevice', {
+    deviceId
+  });
+};
+
+/**
+ * @function 指定麦克风设备
+ * @param deviceId: String 麦克风设备 id，必选
+ * @param operationType: String 操作类型，可选
+ * @return Promise | void
+ */
+const setMicrophoneDevice = async (args) => {
+  defaultApi.writeLog('-> getMicrophoneDeviceList_microphoneListArr_tal_rtc_i');
+  let { deviceId, operationType, deviceState, changedDeviceId } = args;
+  let deviceName = '';
+  let microPhoneData;
+  if (!deviceId) {
+    microPhoneData = await getMicrophoneDeviceList();
+    if (microPhoneData.length) {
+      let hasGetMicrophone = false;
+      for (let item of microPhoneData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetMicrophone = true;
+          break;
+        }
+      }
+      if (!hasGetMicrophone) {
+        deviceId = microPhoneData[0].deviceId;
+        deviceName = microPhoneData[0].deviceName;
+      }
+    } else {
+      deviceId = '';
+    }
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'microphone'
+      });
+    }
+  }
+
+  window.zbztAVSDK_device_checker_init.microphone.use = deviceId;
+  window.zbztAVSDK_device_checker_init.microphone.name = deviceListReport.micList[deviceId];
+
+  try {
+    dataReport.setDevice({
+      device_type: 2,
+      device_id: deviceId,
+      device_name: deviceListReport.micList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? +deviceState + 1 : '-'
+    });
+  } catch (e) {
+  };
+  if (audioTrack) {
+    audioTrack.setDevice(deviceId);
+  }
+  if (operationType == 'hotPlug' || operationType == 'deviceError') {
+    if (!microPhoneData) {
+      microPhoneData = await getMicrophoneDeviceList();
+      deviceName = deviceListReport.micList[deviceId];
+    }
+    NOTICE[operationType]({
+      deviceType: 'microphone',
+      useDeviceId: deviceId,
+      useDeviceName: deviceName,
+      deviceList: microPhoneData,
+      deviceState,
+      changedDeviceId
+    });
+  }
+};
+
+/**
+ * @function 获取当前麦克风的音量
+ * @return Promise | void
+ */
+const getCurrentMicrophoneVolume = () => {
+  return callMethod('GetCurrentMicrophoneVolume', {}).then(ret => {
+    let volume = 0;
+    try {
+      volume = Math.round(JSON.parse(ret.msg).microphoneVolume / 255 * 100);
+    } catch (e) {
+      console.error(`zbzt-live-sdk: getCurrentMicrophoneVolume ret: ${ret}. error: ${e}`);
+    }
+    return volume;
+  });
+};
+
+/**
+ * @function 设置当前麦克风的音量
+ * @param volume: number 音量值
+ * @return Promise | void
+ */
+const setCurrentMicrophoneVolume = (volume) => {
+  return callMethod('SetCurrentMicrophoneVolume', {
+    volume: Math.round(volume / 100 * 255)
+  });
+};
+
+/**
+ * @function 获取当前麦克风ID
+ * @return Promise | void
+ */
+const getCurrentMicrophoneId = (volume) => {
+  return callMethod('GetCurrentMicrophoneId', { volume });
+};
+
+// 摄像头相关
+/**
+ * @function 打开摄像头
+ * @param width: Number
+ * @param height: Number
+ * @return Promise | void
+ */
+const startCamera = async (width, height) => {
+  defaultApi.writeLog('avsdk TALRTC::startCamera');
+  videoTrack = await talrtc.createCameraVideoTrack({
+    cameraId: window.zbztAVSDK_device_checker_init.camera.use,
+  });
+
+  videoTrack.on('track-ended', () => {
+    defaultApi.writeLog('avsdk TALRTC::startCamera track-ended');
+    videoTrack.removeAllListeners();
+    videoTrack = null;
+  });
+  // return callMethod('StartCamera', { width, height, streamId: localStreamId });
+};
+
+/**
+ * @function 关闭摄像头
+ * @return Promise | void
+ */
+const stopCamera = () => {
+  defaultApi.writeLog('avsdk TALRTC::stopCamera');
+  videoTrack && videoTrack.close();
+  // return callMethod('StopCamera', { streamId: localStreamId });
+};
+
+const openOrCloseCamera = async (operation) => {
+  if (operation) {
+    await startCamera();
+  } else {
+    stopCamera();
+  }
+};
+
+/**
+ * @function 获取摄像头列表
+ * @return Promise | void
+ */
+const getCameraDeviceListInternal = () => {
+  return callMethod('GetCameraDeviceList', {});
+};
+
+/**
+ * @function 获取摄像头列表
+ * @return Promise | void
+ */
+export const getCameraDeviceList = async () => {
+  defaultApi.writeLog('avsdk TALRTC::getCameraDeviceList');
+  return defaultsdk.getCameraDeviceList();
+  // const resp = await getCameraDeviceListInternal();
+  // let videoListArr = JSON.parse(JSON.parse(resp.msg).DeviceList) || [];
+  // let videoList = [];
+  // for (let i = 0, len = videoListArr.length; i < len; i++) {
+  //   let nameForChecking = videoListArr[i].name.toLowerCase();
+  //   let checkIfIsDefaultFromName = (nameForChecking.indexOf('built-in') >= 0) ||
+  //     (nameForChecking.indexOf('builtin') >= 0) ||
+  //     (nameForChecking.indexOf('default') >= 0) ||
+  //     (nameForChecking.indexOf('默认') >= 0) ||
+  //     (nameForChecking.indexOf('默認') >= 0);
+  //   videoList.push({
+  //     deviceId: videoListArr[i].id,
+  //     deviceName: videoListArr[i].name,
+  //     isDefault: videoListArr[i].default || checkIfIsDefaultFromName
+  //   });
+  //   deviceListReport.cameraList[videoListArr[i].szDeviceId] = videoListArr[i].szDeviceName;
+  // }
+  // if (!window.zbztAVSDK_device_checker_init) {
+  //   window.zbztAVSDK_device_checker_init = {};
+  // }
+  // if (!window.zbztAVSDK_device_checker_init.camera) {
+  //   window.zbztAVSDK_device_checker_init.camera = {};
+  // }
+  // window.zbztAVSDK_device_checker_init.camera.hasTest = true;
+  // window.zbztAVSDK_device_checker_init.camera.list = videoList;
+  // return videoList;
+};
+
+/**
+ * @function 设置指定视频（当前摄像头）设备
+ * @param deviceId: String 视频设备 id，必选
+ * @return Promise | void
+ */
+const setCurrentCameraDeviceInternal = (deviceId) => {
+  window.zbztAVSDK_device_checker_init.camera.use = deviceId;
+  return callMethod('SetCurrentCameraDevice', {
+    streamId: localStreamId,
+    deviceId
+  });
+};
+
+/**
+ * @function 指定使用的摄像头
+ * @param deviceId: String 摄像头 id，必选
+ * @param operationType: String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置摄像头设备的行为
+ * @return Promise | void
+ */
+const setCameraDevice = async (args) => {
+  defaultApi.writeLog(`setCameraDevice ${JSON.stringify(args)}`);
+  let { deviceId, operationType, deviceState, code, changedDeviceId } = args;
+
+  let deviceName = '';
+  let cameraData;
+  if (!deviceId) {
+    cameraData = await getCameraDeviceList();
+
+    if (cameraData.length) {
+      let hasGetCamare = false;
+      for (let item of cameraData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetCamare = true;
+          break;
+        }
+      }
+      if (!hasGetCamare) {
+        deviceId = cameraData[0].deviceId;
+        deviceName = cameraData[0].deviceName;
+      }
+    } else {
+      deviceId = '';
+    }
+
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'camera'
+      });
+    }
+  }
+  // deviceId = formatDeviceId(deviceId);
+
+  window.zbztAVSDK_device_checker_init.camera.use = deviceId;
+  window.zbztAVSDK_device_checker_init.camera.name = deviceListReport.cameraList[deviceId];
+  try {
+    dataReport.setDevice({
+      device_type: 1,
+      device_id: deviceId,
+      device_name: deviceListReport.cameraList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+  } catch (e) {
+  };
+
+  if (videoTrack) {
+    videoTrack.setDevice(deviceId);
+  }
+
+  if (operationType == 'hotPlug' || operationType == 'deviceError') {
+    if (!cameraData) {
+      cameraData = await getCameraDeviceList();
+      deviceName = deviceListReport.cameraList[deviceId];
+    }
+    NOTICE[operationType]({
+      deviceType: 'camera',
+      useDeviceId: deviceId,
+      useDeviceName: deviceName,
+      deviceList: cameraData,
+      messge: code,
+      deviceState,
+      changedDeviceId
+    });
+  }
+  try {
+    NOTICE.useredCamera({
+      deviceId,
+      deviceName
+    });
+  } catch (e) {
+  };
+};
+
+/**
+ * @function 获取当前摄像头 id
+ * @return Promise | void
+ */
+const GetCurrentCameraId = () => {
+  return callMethod('GetCurrentCameraId', {});
+};
+
+// 扬声器相关
+
+/**
+ * @function 获取扬声器列表
+ * @return Promise | void
+ */
+const getAudioDeviceList = () => {
+  return callMethod('GetAudioDeviceList', {});
+};
+
+/**
+ * @function 获取系统默认的音频设备
+ * @param deviceType: Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @return Promise | void
+ */
+const getDefaultAudioDeviceId = (deviceType) => {
+  return callMethod('GetDefaultAudioDeviceId', {
+    deviceType,
+    // 以下两个参数仅仅是为了向下向后兼容，使用 hardcore 即可
+    deviceId: '',
+    deviceIdLength: 0
+  });
+};
+
+/**
+ * @function 获取系统默认的麦克风设备 id
+ * @return Promise
+ */
+const getDefaultMicrophone = () => {
+  return getDefaultAudioDeviceId(0);
+};
+
+/**
+ * @function 获取系统默认的扬声器设备 id
+ * @return Promise
+ */
+const getDefaultSpeaker = () => {
+  return getDefaultAudioDeviceId(1);
+};
+
+/**
+ * @function 获取扬声器设备列表
+ * @return Promise | void
+ */
+const getSpeakerDeviceListInternal = () => {
+  return callMethod('GetSpeakerDeviceList', {});
+};
+
+/**
+ * @function 获取扬声器列表
+ * @return Promise | void
+ */
+const getSpeakerDeviceList = async () => {
+  defaultApi.writeLog('avsdk TALRTC::getSpeakerDeviceList');
+  return defaultsdk.getSpeakerDeviceList();
+  // const defaultSpeakerId = JSON.parse((await getDefaultSpeaker()).msg).deviceId;
+  // const resp = await getSpeakerDeviceListInternal();
+  // let speakerListArr = JSON.parse(JSON.parse(resp.msg).DeviceList) || [];
+  // let speakerList = [];
+  // for (let i = 0, len = speakerListArr.length; i < len; i++) {
+  //   speakerList.push({
+  //     deviceId: speakerListArr[i].id,
+  //     deviceName: speakerListArr[i].name,
+  //     isDefault: defaultSpeakerId === speakerListArr[i].id
+  //   });
+  //   deviceListReport.speakerList[speakerListArr[i].szDeviceId] = speakerListArr[i].szDeviceName;
+  // }
+  // if (!window.zbztAVSDK_device_checker_init) {
+  //   window.zbztAVSDK_device_checker_init = {};
+  // }
+  // if (!window.zbztAVSDK_device_checker_init.speaker) {
+  //   window.zbztAVSDK_device_checker_init.speaker = {};
+  // }
+  // window.zbztAVSDK_device_checker_init.speaker.hasTest = true;
+  // window.zbztAVSDK_device_checker_init.speaker.list = speakerList;
+  // return speakerList;
+};
+
+/**
+ * @function 设置指定音频（当前扬声器）设备
+ * @param deviceId: String 音频设备 id，必选
+ * @return Promise | void
+ */
+const setCurrentSpeakerDevice = (deviceId) => {
+  window.zbztAVSDK_device_checker_init.speaker.use = deviceId;
+  return callMethod('SetCurrentSpeakerDevice', {
+    deviceId
+  }).then((result) => {
+    if (result.code === 0) {
+      NOTICE.speakerChanged({
+        deviceId
+      });
+    }
+    return result;
+  });
+};
+
+/**
+ * 获取当前扬声器设备id
+ * @return {String} 当前扬声器设备id
+ */
+const getCurrentSpeakerDevice = () => {
+  defaultApi.writeLog(`avsdk TALRTC::getSpeakerDevice ${usingAudioDeviceId.speaker}`);
+  return usingAudioDeviceId.speaker;
+};
+
+/**
+ * @function 指定扬声器
+ * @param deviceId: String 扬声器 id，必选
+ * @param operationType:String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置扬声器设备的行为
+ * @return Promise | void
+ */
+const setSpeakerDevice = async (args) => {
+  defaultApi.writeLog(`${JSON.stringify(args)}----setSpeakerDevice-talrtc----`);
+  let { deviceId, operationType, deviceState, code, changedDeviceId } = args;
+  let deviceName = '';
+  let speakerData;
+  if (!deviceId) {
+    speakerData = await getSpeakerDeviceList();
+    if (speakerData.length) {
+      let hasGetSpeaker = false;
+      for (let item of speakerData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetSpeaker = true;
+          break;
+        }
+      }
+      if (!hasGetSpeaker) {
+        deviceId = speakerData[0].deviceId;
+        deviceName = speakerData[0].deviceName;
+      }
+    } else {
+      deviceId = '';
+    }
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'speaker'
+      });
+    }
+  }
+
+  window.zbztAVSDK_device_checker_init.speaker.use = deviceId;
+  window.zbztAVSDK_device_checker_init.speaker.name = deviceListReport.speakerList[deviceId];
+
+  try {
+    dataReport.setDevice({
+      device_type: 3,
+      device_id: deviceId,
+      device_name: deviceListReport.speakerList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+  } catch (e) {
+    console.log(e);
+  };
+  usingAudioDeviceId.speaker = deviceId;
+  // await setCurrentSpeakerDevice(deviceId);
+  if (operationType == 'hotPlug' || operationType == 'deviceError') {
+    if (!speakerData) {
+      speakerData = await getSpeakerDeviceList();
+      deviceName = deviceListReport.speakerList[deviceId];
+    }
+    NOTICE[operationType]({
+      deviceType: 'speaker',
+      useDeviceId: deviceId,
+      useDeviceName: deviceName,
+      deviceList: speakerData,
+      message: code,
+      deviceState,
+      changedDeviceId
+    });
+  }
+};
+
+/**
+ * @function 获取当前扬声器的音量
+ * @returns {Promise<number>}
+ */
+const getCurrentSpeakerVolume = () => {
+  return callMethod('GetCurrentSpeakerVolume', {}).then(ret => {
+    let volume = 0;
+    try {
+      volume = Math.round(JSON.parse(ret.msg).speakerVolume / 255 * 100);
+    } catch (e) {
+      console.error(`zbzt-live-sdk: getCurrentSpeakerVolume ret: ${ret}. error: ${e}`);
+    }
+    return volume;
+  });
+};
+
+/**
+ * @function 获取当前扬声器ID
+ * @return Promise | void
+ */
+const getCurrentSpeakerId = () => {
+  return callMethod('GetCurrentSpeakerId', {});
+};
+
+/**
+ * @function 是否存在媒体流
+ * @param streamId
+ * @returns {boolean}
+ */
+export const hasStream = streamId => {
+  return Object.keys(streamIdToPreviewId).includes(streamId);
+};
+
+
+/**
+ * @function 获取当前视频流的通道
+ * @param  streamId 流 id
+ * @return channelIndex
+ */
+export const getChannelIndex = (streamId) => {
+  defaultApi.writeLog(`avsdk TALRTC::getChannelIndex streamId: ${streamId} ${JSON.stringify(streamIdToPreviewId)}`);
+  return streamIdToPreviewId[streamId];
+};
+
+/**
+ * @function 获取当前视频流所有的通道
+ * @param  streamId 流 id
+ * @return channelIndex
+ */
+export const getAllChannelIndex = () => {
+  defaultApi.writeLog(`avsdk TALRTC::getAllChannelIndex ${JSON.stringify(streamIdToPreviewId)}`);
+  return streamIdToPreviewId;
+};
+
+
+/**
+ * @function 设置当前扬声器音量
+ * @param volume: number 音量值
+ * @return Promise | void
+ */
+const setCurrentSpeakerVolume = (volume) => {
+  return callMethod('SetCurrentSpeakerVolume', {
+    volume: Math.round(volume / 100 * 255)
+  });
+};
+
+/**
+ * @function 设置扬声器静音
+ * @param mute: Boolean 必选
+ * @return Promise | void
+ */
+const setSpeakerDeviceMute = (mute) => {
+  return callMethod('SetSpeakerDeviceMute', {
+    deviceId: usingAudioDeviceId.speaker,
+    mute
+  });
+};
+
+/**
+ * @function 获取当前应用程序音量
+ * @return Promise | void
+ */
+const getSpeakerSimpleVolume = () => {
+  return callMethod('GetSpeakerSimpleVolume', {
+    deviceId: usingAudioDeviceId.speaker
+  }).then(ret => {
+    let volume = 0;
+    try {
+      volume = Math.round(JSON.parse(ret.msg).speakerVolume / 255 * 100);
+    } catch (e) {
+      console.error(`zbzt-live-sdk: getSpeakerSimpleVolume ret: ${ret}. error: ${e}`);
+    }
+    return volume;
+  });
+};
+
+/**
+ * @function 设置当前应用程序音量
+ * @param volume: Number 应用程序音量，必选
+ * @return Promise | void
+ */
+const setSpeakerSimpleVolume = (volume) => {
+  return callMethod('SetSpeakerSimpleVolume', {
+    deviceId: usingAudioDeviceId.speaker,
+    volume: Math.round(volume / 100 * 255)
+  });
+};
+
+/**
+ * @function 设置当前应用程序静音
+ * @param mute: Boolean 是否静音，必选
+ * @return Promise | void
+ */
+const setSpeakerSimpleMute = (mute) => {
+  return callMethod('SetSpeakerSimpleMute', {
+    deviceId: usingAudioDeviceId.speaker,
+    mute
+  });
+};
+
+const enableAudioSpeakerCapture = (capture) => {
+  setSystemAudioLoopback(capture);
+};
+
+/**
+ * @function 打开系统声音采集
+ * @enable true|false
+ * @return Promise | void
+ */
+const setSystemAudioLoopback = (enable) => {
+  isSpeakerCapturing = enable;
+  if (enable) {
+    return setAudioType(6, localStreamId);
+  } else {
+    return setAudioType(1, localStreamId);
+  }
+  // return callMethod('SetAudioSpeakerCapture', {
+  //   enable,
+  // });
+};
+
+/**
+ * @function 录制转推对外接口
+ * @param type: String start/stop 必选
+ * @param targetUrl: String 转推地址(支持 RTMP) 必选
+ * @return Promise | void
+ */
+const controlCdnStreaming = async (type) => {
+  const targetUrl = 'rtmp://media-push-ali-test.livecloud.eaydu.com/testlive/210926-11?key=75c868672113df0063430e9e47fb2a60&appId=zt10001&bizId=zt10001AI&cdn=1';
+  defaultApi.writeLog(`avsdk TALRTC::controlCdnStreaming targetUrl: ${targetUrl} type: ${type}`);
+  if (type === 'start') {
+    return addPublishRtmpStreamUrl(targetUrl);
+  }
+  if (type === 'stop') {
+    return removePublishStreamUrl(targetUrl);
+  }
+};
+
+/**
+ * @function SEI 消息
+ * @param data: String    数据
+ * @param dataSize: Number    数据长度
+ * @param repeatCount: Number    重试次数
+ * @return Promise | void
+ */
+const sendSEIMsg = (data) => {
+  return callMethod('SendSEIMsg', { data: data, dataSize: data.length, repeatCount: 3 });
+};
+
+/**
+ * @function 开始屏幕采集
+ * @return Promise | void
+ */
+const startScreenCapture = async () => {
+  defaultApi.writeLog('avsdk TALRTC::startScreenCapture');
+  screenTrack = await talrtc.createScreenVideoTrack({
+    screenSourceType: 'application',
+  }, 'disable');
+
+  screenTrack.on('track-ended', () => {
+    defaultApi.writeLog('avsdk TALRTC::startScreenCapture track-ended');
+    screenTrack.removeAllListeners();
+    screenTrack = null;
+  });
+  // return callMethod('StartScreenCapture', {});
+};
+
+/**
+ * @function 停止屏幕采集
+ * @return Promise | void
+ */
+const stopScreenCapture = () => {
+  defaultApi.writeLog('avsdk TALRTC::stopScreenCapture');
+  screenTrack && screenTrack.close();
+  // return callMethod('StopScreenCapture', {});
+};
+
+
+// 推拉流相关
+/**
+ * @function 开启本地或者远程的视频视图
+ * @param isLocal: Boolean 是否是本地的视频预览，必选
+ * @param streamId: String 要拉取的视频流的 id，可选，只有拉取远程的视频流的时候才是必选的
+ * @param domId: String <video> 标签的 id，可选
+ * 如果传了 domId，就把视频绑定到对应的 <video> 标签上
+ * @return Promise 可从 Promise 中获取 src，Promise.then((src) => {})
+ */
+const startLocalOrRemotePreview = async (isLocal, streamId, domId) => {
+  defaultApi.writeLog(`avsdk TALRTC::startLocalOrRemotePreview streamId: ${streamId}, isLocal: ${isLocal}, domId: ${domId}`);
+
+  if (isLocal) {
+    if (streamId === localStreamId) {
+      if (!videoTrack) {
+        defaultApi.writeLog('avsdk TALRTC::startLocalOrRemotePreview - startCamera first', null, 'error');
+        throw new Error('avsdk TALRTC::startLocalOrRemotePreview - startCamera first');
+      }
+  
+      videoTrack.play(domId);
+    }
+
+    if (streamId === screenStreamId) {
+      if (!screenTrack) {
+        await startScreenCapture();
+      }
+
+      screenTrack.play(domId);
+    }
+
+  } else {
+    if (!streamId) {
+      defaultApi.writeLog('avsdk TALRTC::startLocalOrRemotePreview - streamId is required', null, 'error');
+      return;
+    }
+    if (!remoteTracks.has(streamId)) {
+      defaultApi.writeLog(`avsdk TALRTC::startLocalOrRemotePreview - ${streamId} is null, set it to auto play`);
+      remoteTracks.set(streamId, true);
+      return;
+    }
+    remoteTracks.get(streamId).play(domId);
+  }
+};
+
+/**
+ * @function 开始推流
+ * @param streamId: String   流 id
+ * @return Promise | void
+ */
+const startPush = async (streamId) => {
+  if (!streamId) {
+    streamId = localStreamId;
+  }
+  defaultApi.writeLog(`avsdk TALRTC::startPush streamId: ${streamId}`);
+
+  const roomId = util.getRoomIdByStreamId(streamId);
+  const client = clients.get(roomId);
+
+  if (!client) {
+    defaultApi.writeLog('avsdk TALRTC::startPush - init first', null, 'error');
+    throw new Error('avsdk TALRTC::startPush - init first');
+  }
+
+  try {
+    if (!isFirstHeartBeatReport) {
+      isFirstHeartBeatReport = true;
+      heartBeatDataReport('start');
+    }
+  } catch (error) {}
+  const tracks = [];
+
+  if (streamId === screenStreamId && screenTrack) {
+    await startScreenCapture();
+    tracks.push(screenTrack);
+  }
+  if (streamId === localStreamId && audioTrack) {
+    tracks.push(audioTrack);
+  }
+  if (streamId === localStreamId && videoTrack) {
+    tracks.push(videoTrack);
+  }
+  // const muteAudio = localStreamMuteStatus.audio;
+  // const muteVideo = localStreamMuteStatus.video;
+  return client.publish(tracks);
+};
+
+/**
+ * @function 停止推流
+ * @param streamId: String   流 id
+ * @return Promise | void
+ */
+const stopPush = (streamId) => {
+  if (!streamId) {
+    streamId = localStreamId;
+  }
+
+  defaultApi.writeLog(`avsdk TALRTC::stopPush streamId: ${streamId}`);
+
+  const roomId = util.getRoomIdByStreamId(streamId);
+  const client = clients.get(roomId);
+
+  if (!client) {
+    defaultApi.writeLog('avsdk TALRTC::stopPush - init first', null, 'error');
+    throw new Error('avsdk TALRTC::stopPush - init first');
+  }
+
+  const tracks = [];
+  if (streamId === screenStreamId && screenTrack) {
+    screenTrack.close();
+    tracks.push(screenTrack);
+  }
+  if (streamId === localStreamId && audioTrack) {
+    tracks.push(audioTrack);
+  }
+  if (streamId === localStreamId && videoTrack) {
+    tracks.push(videoTrack);
+  }
+  return client.unpublish(tracks);
+  // return callMethod('StopPush', { streamId });
+};
+
+/**
+ * @function 不推/推 音频
+ * @param mute: bool
+ * @return Promise | void
+ */
+const muteLocalAudio = async (mute) => {
+  defaultApi.writeLog(`avsdk TALRTC::muteLocalAudio mute: ${mute}`);
+
+  if (audioTrack) {
+    await audioTrack.setMuted(mute);
+  }
+  localStreamMuteStatus.audio = mute;
+};
+
+/**
+ * @function 不推/推 视频
+ * @param mute: bool
+ * @return Promise | void
+ */
+const muteLocalVideo = async (mute) => {
+  defaultApi.writeLog(`avsdk TALRTC::muteLocalVideo mute: ${mute}`);
+
+  if (videoTrack) {
+    await videoTrack.setMuted(mute);
+  }
+  localStreamMuteStatus.video = mute;
+};
+
+/**
+ * @function 开始转推本地摄像头 TALRTC 流至 RTMP。目前只支持转推 1 路
+ * @return Promise | void
+ */
+const addPublishRtmpStreamUrl = (url) => {
+  defaultApi.writeLog(`avsdk TALRTC::addPublishRtmpStreamUrl url: ${url}`);
+  return callMethod('AddPublishRtmpStreamUrl', { url });
+};
+
+/**
+ * @function 停止转推 RTMP
+ * @return Promise | void
+ */
+const removePublishStreamUrl = (url) => {
+  defaultApi.writeLog(`avsdk TALRTC::removePublishStreamUrl url: ${url}`);
+  return callMethod('RemovePublishStreamUrl', { url });
+};
+
+/**
+ * @function 开始拉流
+ * @param {string} streamId   流 id
+ * @return {Promise} Promise | void
+ */
+const startPlay = (streamId, muteAudio, muteVideo) => {
+  if (typeof muteAudio === 'undefined') {
+    muteAudio = getStreamMuteStatus(streamId, 'audio');
+  }
+
+  if (typeof muteVideo === 'undefined') {
+    muteVideo = getStreamMuteStatus(streamId, 'video');
+  }
+  defaultApi.writeLog(`avsdk TALRTC::startPlay streamId: ${streamId}, muteAudio: ${muteAudio}, muteVideo: ${muteVideo}`);
+  return callMethod('StartPlay', {
+    myStreamId: localStreamId,
+    streamId,
+    muteAudio,
+    muteVideo,
+    muteDefaultAudio: classMode === 1 || classMode === 2,
+    muteDefaultVideo: classMode === 1 || classMode === 2
+  }).then((...args) => {
+    if (args[0].code !== 0 && streamIdToPreviewId[streamId]) {
+      console.log('retry startPlay----', streamId);
+      return startPlay(streamId, muteAudio, muteVideo);
+    }
+    setStreamMuteStatus(streamId, 'audio', muteAudio);
+    setStreamMuteStatus(streamId, 'video', muteVideo);
+    return args;
+  });
+};
+
+/**
+ * @function 初始化拉流
+ * @param streamId:String 从传来的信道消息中获取，必选
+ * @param domId:String <video> 标签的 id，可选
+ * 如果传了就把视频绑定到对应的 <video> 标签上
+ * @param pInfo:String 多媒体流附加信息，可选，默认为 'none'
+ * @return src:String 视频预览地址
+ */
+export const initPullFlow = async (streamId, domId, mute, pInfo, notAutoPlay, audioOnly) => {
+  defaultApi.writeLog(`TALRTC::initPullFlow_start , streamId :${streamId}, notAutoPlay: ${notAutoPlay}, audioOnly: ${audioOnly}`);
+  let playChannel;
+  resetStreamIdRtcPlayerInfo1(streamId);
+  resetStreamIdRtcPlayerInfo(streamId);
+  try {
+    if (!isFirstHeartBeatReport) {
+      isFirstHeartBeatReport = true;
+      heartBeatDataReport('start');
+    }
+  } catch (error) {}
+  if (streamIdToPreviewId[streamId] == undefined) {
+
+    defaultApi.writeLog(`TALRTC::  The streamId queue does not contain this streamId ${uiChnIndexs}`);
+    playChannel = uiChnIndexs.pop();
+    streamIdToPreviewId[streamId] = playChannel;
+    // console.log('streamIdIsNoExited',playChannel,streamIdToPreviewId[streamId],uiChnIndexs);
+  } else {
+    defaultApi.writeLog(`TALRTC::The streamId queue contains this streamId: ${streamId}`);
+    playChannel = streamIdToPreviewId[streamId];
+    // console.log('streamIdIsExited',playChannel,streamIdToPreviewId[streamId],uiChnIndexs);
+    await stopPlay(streamId);
+    resetStreamIdRtcPlayerInfo(streamId);
+  }
+  // 判断是否创建或者获取播放通道成功，不成功就删掉重试
+  if (playChannel == undefined) {
+    delete streamIdToPreviewId[streamId];
+    defaultApi.writeLog('error', 'TALRTC::  uiChnIndex is not exist');
+    return initPullFlow(streamId, domId, mute, pInfo, notAutoPlay, audioOnly);
+  }
+  previewIdToStreamId[playChannel] = streamId;
+  /**
+   * 将 muteRemote 参数耦合进startPlay，减少异步调用，降低黑屏概率
+   */
+  // 是否拉取声音
+  // await muteRemoteAudio(streamId, !!mute);
+  // // 是否拉取画面
+  // await muteRemoteVideo(streamId, !!audioOnly);
+  const videoSrc = await startLocalOrRemotePreview(false, streamId, domId);
+
+  if (!notAutoPlay) {
+    await startPlay(streamId, !!mute, !!audioOnly);
+  }
+  return {
+    videoSrc,
+    playerId: playChannel
+  };
+};
+
+
+
+/**
+ * @function 开始连麦
+ * @param mode: number 采集器默认， 默认0=站立 1=坐立
+ * @return Promise | void
+ */
+export const teacherStartLinkMic = async (mode = 0) => {
+  await startMicrophone();
+  if (mode === 0) {
+    await muteLocalVideo(true, localStreamId);
+    await setMicrophoneDevice({});
+    // await muteStreamAudio(false);
+    await muteLocalAudio(false);
+  } else {
+    // await muteLocalVideo(false, localStreamId);
+    await muteLocalAudio(false);
+  }
+};
+
+
+/**
+ * @function 结束连麦
+ * @param mode:number 采集器默认， 默认0=站立 1=坐立
+ * @return Promise | void
+ */
+export const teacherStopLinkMic = async (mode = 0) => {
+  await stopMicrophone();
+  if (mode === 0) {
+    await muteLocalAudio(true);
+  } else {
+    await setSystemAudioLoopback(false);
+  }
+};
+
+/**
+ * @function 停止拉流
+ * @param streamId: String 流 id
+ * @return Promise | void
+ */
+const stopPlay = (streamId, recovery) => {
+  const id = streamIdToPreviewId[streamId];
+  delete streamIdRtcPlayerInfo[streamId];
+  if (recovery && (id || id === 0) && !uiChnIndexs.includes(id)) {
+    uiChnIndexs.push(id);
+    defaultApi.writeLog(`avsdk TALRTC::stopPlayStream streamId: ${streamId} id: ${id} uiChnIndexs: ${uiChnIndexs}`);
+    delete streamIdToPreviewId[streamId];
+  }
+  return callMethod('StopPlay', { streamId });
+};
+
+
+/**
+ * @function 停止拉所有的流
+ * @return Promise | void
+ */
+const stopPlayAll = () => {
+  return callMethod('StopPlayAll', {});
+};
+
+const playerSnapShot = (streamId) => {
+  switch (streamId) {
+  case localStreamId:
+    return videoTrack.getCurrentFrameData();
+  case screenStreamId:
+    return screenTrack.getCurrentFrameData();
+  case remoteTracks.has(streamId):
+    return remoteTracks.get(streamId).getCurrentFrameData();
+  default:
+    defaultApi.writeLog('avsdk TALRTC::playerSnapShot error', null, 'error');
+    throw new Error('streamId not found');
+  }
+};
+/**
+ * @function 切换播放流
+ * @param streamId: String 需要停止流的 id，必选
+ * @param toStreamId: String 被拉取的流的 id，必选
+ * @param toDomId: String <video> 标签的 id，可选
+ * @return Promise | void
+ */
+const changePullFlow = async (streamId, toStreamId, toDomId) => {
+  await stopPlay(streamId);
+  return initPullFlow(toStreamId, toDomId);
+};
+
+/**
+ * @function 是否拉取音频流--通过播放器id控制
+ * @param mute: Boolean，必选，true -> 不拉取，false -> 拉取，必选
+ * @param playerId: Number，必选，播放器 id
+ * @return Promise | void
+ */
+const pullAudioFlow = (playerId, mute, streamid) => {
+  defaultApi.writeLog(`pullAudioFlow -- playerId ${playerId} operation ${mute} streamId ${streamid}`);
+  if(streamid){
+    if(streamIdToPreviewId[streamid] == undefined) {
+      NOTICE.pullAudioFlowError({streamid});
+      return;
+    }else{
+      playerId = streamIdToPreviewId[streamid];
+      defaultApi.writeLog(`pullAudioFlow-playerId ${playerId}, ${JSON.stringify(streamIdToPreviewId)}`);
+    }
+  }
+  let streamId = previewIdToStreamId[playerId];
+  try {
+    streamIdRtcPlayerInfo1[streamId].audio_type = !mute;
+    defaultApi.writeLog(
+      `pullAudioFlow, ${streamId} ::previewIdToStreamId', ${JSON.stringify(previewIdToStreamId)} ::streamIdRtcPlayerInfo1 ${JSON.stringify(streamIdRtcPlayerInfo1)}`);
+  } catch (e) {
+    defaultApi.writeLog(`pullAudioFlow ::streamIdRtcPlayerInfo1--error ${JSON.stringify(e)}`, null, error);
+  }
+  try {
+    dataReport.setPullVoice({
+      code: +!mute,
+      pull_uid: util.getUidByStreamId(streamId),
+      pull_streamid: streamId,
+      playerId
+      // operator:'client'
+    });
+  } catch (e) { };
+  return muteRemoteAudio(streamId, mute);
+};
+
+/**
+  * @function 设置镜像状态(预览)
+  * @param { 0 | 1 | 2 | 3 } mode 0: 预览启用镜像，推流不启用镜像; 1: 预览启用镜像，推流启用镜像; 2: 预览不启用镜像，推流不启用镜像; 3: 预览不启用镜像，推流启用镜像
+  * @return {Promise}
+  */
+const setMirrorStatus = (mode) => {
+  const realId = mode == 0 ? 2 : 1;
+  defaultApi.writeLog(`avsdk TALRTC::setMirrorStatus, mode: ${mode}, streamId:${localStreamId}, realId:${realId}`);
+  return callMethod('SetMirrorStatus', { mode: realId, streamId: localStreamId });
+};
+
+/**
+  * @function 设置拉流镜像状态
+  * @param { boolean } type true=开启 false=关闭
+  * @return: Promise
+  */
+const setPlayViewMirror = (isMirror, id) => {
+  return callMethod('SetPlayViewMirror', { isMirror, streamId: id });
+};
+
+/**
+ * @function 不拉/拉 音频
+ * @param streamId: string
+ * @param mute: bool
+ * @return Promise | void
+ */
+const muteRemoteAudio = (streamId, mute) => {
+  const stream = remoteTracks.get(streamId);
+  if (stream) {
+    return stream.setMuted(mute);
+  }
+  return callMethod('MuteRemoteAudio', { streamId, mute }).then((...args) => {
+    setStreamMuteStatus(streamId, 'audio', mute);
+    return args;
+  });
+};
+
+/**
+ * @function 不拉/拉 视频
+ * @param streamId: string
+ * @param mute: bool
+ * @return Promise | void
+ */
+const muteRemoteVideo = (streamId, mute) => {
+  return callMethod('MuteRemoteVideo', { streamId, mute }).then((...args) => {
+    setStreamMuteStatus(streamId, 'video', mute);
+    return args;
+  });
+};
+/**
+ * @function 设置外部采集设备模块
+ * @param  enable  是否开启外部采集设备模块
+ * @attention  必须在  InitSDK  前调用，置空必须在UninitSDK之后
+ * @return Promise | void
+ */
+const enableExternalVideoSource = (enable = false, streamId = localStreamId) => {
+  defaultApi.writeLog('info', 'avsdk TALRTC::EnableExternalVideoSource');
+  return callMethod('EnableExternalVideoSource', {enable, streamId});
+};
+
+//设置音频数据来源
+const setAudioAuxSource = (source) => {
+  defaultApi.writeLog('info', 'avsdk TALRTC::setAudioAuxSource');
+  return callMethod('SetAudioAuxSource', {
+    source
+  });
+};
+
+/**
+ * RTC流音频类型
+ * @param {number} type 音频类型  0：静音 / 1:麦克风  / 2：拉流的声音  / 3：1+2 / 4：麦克风+扬声器+2 5: 扬声器 6: 麦克风+扬声器
+ * @param {string} streamId 流
+ * @returns {Promise<void>}
+ */
+const setAudioType = (type, streamId) => {
+  defaultApi.writeLog('info', 'avsdk TALRTC::SetAudioType');
+  if (!streamId) {
+    streamId = screenStreamId;
+  }
+  return callMethod('SetAudioType', {
+    streamId,
+    type
+  });
+};
+
+//开启音频外部采集 参数：channel   参数类型：int 通道(传1使用辅通道)
+const startAudioExCapture = (channel) => {
+  defaultApi.writeLog('info', 'avsdk TALRTC::startAudioExCapture');
+  return callMethod('StartAudioExCapture', {
+    channel
+  });
+};
+/**
+ * @function 加载采集插件的输出数据  //采集屏幕并且拼接了连麦学生头像的数据
+ * @returns {Promise}
+ */
+export const loadCollectionOutputEntry = () => {
+  return callMethod('LoadCollectionOutputEntry', {
+    streamId: localStreamId
+  });
+};
+/**
+ * @function 加载采集插件的输出数据  //只采集屏幕数据
+ * @returns {Promise}
+ */
+const LoadCollectionOutputEntry2 = () => {
+  defaultApi.writeLog('info', 'avsdk TALRTC::LoadCollectionOutputEntry2');
+  return callMethod('LoadCollectionOutputEntry2', {
+    streamId: screenStreamId
+  });
+};
+
+//开启同屏
+const startMultiScreen = async () => {
+  defaultApi.writeLog('info', 'avsdk TALRTC::startMultiScreen');
+  // await enableExternalVideoSource(true,1);
+  await LoadCollectionOutputEntry2();
+};
+
+/**
+ * 音频增强调到最高优先级
+ * @param {string} streamId 
+ * @param {string} uid 
+ * @param {boolean} add 
+ * @returns 
+ */
+const setChiefAudioStream = async (streamId, uid, add = true) => {
+  defaultApi.writeLog('info', 'avsdk TALRTC::SetChiefAudioStream');
+  return callMethod('SetChiefAudioStream', {
+    streamId,
+    uid,
+    add
+  });
+};
+
+/**
+ * talrtc40路拉流混音接口
+ * @param {number} mixMode //混流模式  0=关闭混流  1=开启混流
+ * @param {Array<string>} streamIdArr //表示要突出声音的channel
+ * @returns {Promise}
+ */
+export const setAudioMixMode = async (mixMode, streamIdArr) => {
+  // let channelsArr = [];
+  // if(streamIdArr.length > 0){
+  //   streamIdArr.forEach( item => {
+  //     channelsArr.push(getChannelIndex(item));
+  //   });
+  // }
+  if (!Array.isArray(streamIdArr)) return;
+
+  // if (!streamIdArr.includes(teacherId)) {
+  //   streamIdArr.push(teacherId);
+  // }
+  return callMethod('SetAudioMixMode', {mixMode: mixMode, streamIdArr, num: streamIdArr.length});
+};
+
+
+/**
+ * @function 离开教室
+ * @return Promise | void
+ */
+const leaveRoom = async () => {
+  for (let key in streamIdToPreviewId) {
+    stopPlay(key, true);//huishou
+  }
+
+  if (screenStreamId) {
+    screenStreamId = null;
+  }
+
+  stopPush(localStreamId);
+
+  if (isSpeakerCapturing) {
+    setSystemAudioLoopback(false);
+  }
+  if(window.zbzt_sdk_init_params.role === 'teacher' && window.zbzt_sdk_init_params.mode === 1){
+    //坐立模式关闭外部采集器，站立关闭外部采集器
+    enableExternalVideoSource(false);
+  }
+  localStreamId = null;
+  removerListener();
+  destroyEngine();
+  heartBeatDataReport('stop');
+  // isFirstHeartBeatReport = false;
+  streamIdToPreviewId = {};
+  previewIdToStreamId = {};
+  streamIdRtcPlayerInfo = {};
+  streamIdRtcPlayerInfo1 = {};
+  uiChnIndexs.length = 100;
+  uiChnIndexs.fill(0).forEach((value, index, array) => {
+    array[index] = array.length - (index + 1);
+  });
+};
+
+
+/**
+ * @function 卸载 Talrtc 扩展
+ * @return Promise | void
+ */
+export const unloadTalrtc = () => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      EM.UnLoad(
+        extensionId,
+        (code, msg) => {
+          defaultApi.writeLog(`unloadTalrtc Code: ${code}\nMessage: ${msg}`);
+          resolve();
+        }
+      );
+    });
+  }
+};
+
+/**
+ * @function 本地录制
+ * @param {string | undefined} fileName 
+ * @param {number} fileType 1:flv 2:mp4
+ * @param {number} idx 0:主流 1:辅流 2:RTMP流
+ * @returns {Promise<any>}
+ */
+export const startRecord = async (fileName, fileType, idx) => {
+  const streamId = [localStreamId, screenStreamId, 'rtmp'][idx];
+  defaultApi.writeLog(`avsdk TALRTC::startRecord fileName: ${fileName}, fileType: ${fileType}, idx: ${idx}, streamId: ${streamId}`);
+  if (idx === 1 && !screenStreamId) {
+    defaultApi.writeLog('avsdk TALRTC::startRecord screenStreamId is null', null, 'error');
+    return;
+  }
+  if (!fileName) {
+    fileName = `${streamId}-${util.currentTimeString().replace(/:/g, '-')}`;
+  }
+  dataReport.startRecord({fileName, fileType, idx, streamId});
+  return callMethod('StartRecord', {
+    streamId,
+    recordType: 3, // 1:音频 2:视频 3:音视频
+    fileName,
+    recordFormat: fileType,
+  });
+};
+/**
+ * 结束音视频录制 channelIndex(number) 录制通道  0主推流通道/ 1辅助推流通道/ 2辅助推流通道
+ * @param {number} idx 0 | 1 | 2
+ * @returns 
+ */
+export const stopRecord = async (idx) => {
+  const streamId = [localStreamId, screenStreamId, 'rtmp'][idx];
+  defaultApi.writeLog(`avsdk TALRTC::stopRecord idx: ${idx}, streamId: ${streamId}`);
+
+  dataReport.stopRecord({idx, streamId});
+  return callMethod('StopRecord',{streamId});
+};
+/**
+ * 开启外部音频采集（通知sdk）推流前，调用此接口，publish_channel，number类型，传2代表第三路流
+ * @param {number} idx 0 | 1 | 2
+ * @returns 
+ */
+export const startCapture = async (idx) => {
+  const streamId = [localStreamId, screenStreamId, 'rtmp'][idx];
+  defaultApi.writeLog(`avsdk TALRTC::startCapture idx: ${idx}, streamId: ${streamId}`);
+
+  return callMethod('StartCapture',{streamId});
+};
+/**
+ * 结束外部音频采集（通知sdk）
+ * @param {number} idx 0 | 1 | 2
+ * @returns 
+ */
+export const stopCapture = async (idx) => {
+  const streamId = [localStreamId, screenStreamId, 'rtmp'][idx];
+  defaultApi.writeLog(`avsdk TALRTC::stopCapture idx: ${idx}, streamId: ${streamId}`);
+
+  return callMethod('StopCapture',{streamId});
+};
+
+const heartBeatRealKeys = ['video_fps', 'video_bitrate', 'audio_fps', 'audio_bitrate'];
+
+const _heartBeatDataReport = () => {
+  // let cpuRate = 0;
+  // let memRate = 0;
+  // let rateCount = 0;
+  // let appCpuRate = 0;
+  // let appMemUsed = 0;
+  // let rateTimer = setInterval(async () => {
+  // rateCount++;
+  // let {cpu_rate, mem_rate, gpus, app_cpu_rate, app_mem_used} = (await toolApi.getCurCpuMemInfo()).msg;
+  // cpu_rate = cpu_rate < 0 ? 0 : cpu_rate;
+  // cpuRate += parseFloat(cpu_rate);
+  // memRate += parseFloat(mem_rate);
+  // if (window.zbztAVSDK_init_params.zego.role === 'student') {
+  //   appCpuRate += parseFloat(app_cpu_rate);
+  //   appMemUsed += parseFloat(app_mem_used);
+  // }
+
+  // if (rateCount >= 3) {
+  // heartBeatRealKeys.forEach(realKey => {
+  //   if (heartBeatDataReportObj.hasOwnProperty(realKey) && heartBeatDataReportObj.count > 0) {
+  //     heartBeatDataReportObj[realKey] = util.toFixed(heartBeatDataReportObj[realKey]/heartBeatDataReportObj.count);
+  //   }
+  // });
+  const pullInfo = [];
+  console.log('拉流的类型1',streamIdRtcPlayerInfo);
+  Object.keys(streamIdRtcPlayerInfo).forEach(streamid => {
+    heartBeatRealKeys.forEach(realKey => {
+      if (!streamIdRtcPlayerInfo[streamid].hasOwnProperty(realKey)) {
+        streamIdRtcPlayerInfo[streamid][realKey] = [];
+      }
+      // if (streamIdRtcPlayerInfo[streamid].count > 0) {
+      //   streamIdRtcPlayerInfo[streamid][realKey] = util.toFixed(streamIdRtcPlayerInfo[streamid][realKey]/streamIdRtcPlayerInfo[streamid].count);
+      // }
+    });
+    //获取拉流类型，后期可写为函数提出去
+    if(streamIdRtcPlayerInfo1[streamid].audio_type && streamIdRtcPlayerInfo1[streamid].video_type) {
+      streamIdRtcPlayerInfo1[streamid].stream_type = 'both';
+    } else if(!streamIdRtcPlayerInfo1[streamid].audio_type && streamIdRtcPlayerInfo1[streamid].video_type) {
+      streamIdRtcPlayerInfo1[streamid].stream_type = 'video';
+    } else if(streamIdRtcPlayerInfo1[streamid].audio_type && !streamIdRtcPlayerInfo1[streamid].video_type) {
+      streamIdRtcPlayerInfo1[streamid].stream_type = 'audio';
+    } else {
+      streamIdRtcPlayerInfo1[streamid].stream_type = 'none';
+    }
+    // console.log('hsghsghsg_type_type', streamIdRtcPlayerInfo1[streamid].stream_type);
+
+    pullInfo.push({
+      streamid,
+      // uid: util.getUidByStreamId(streamid),
+      ...streamIdRtcPlayerInfo[streamid],
+      pull_type: streamIdRtcPlayerInfo1[streamid].stream_type,
+      volume: streamIdRtcPlayerInfo[streamid].volume.slice(0,streamIdRtcPlayerInfo[streamid].volume.length-1)
+    });
+    resetStreamIdRtcPlayerInfo(streamid);
+  });
+  if (isFirstHeartBeatReport) {
+    try {
+      //静音推流时过滤掉音频帧率和码率，上报为0；
+      // if (!isNoticeMicVolumeZego) {
+      //   heartBeatDataReportObj['audio_fps'] = [];
+      //   heartBeatDataReportObj['audio_bitrate'] = [];
+      // }
+
+      //获取推流类型，后期可写为函数提出去
+      if(zbztsdk.deviceStatus.camera && zbztsdk.deviceStatus.microphone) {
+        zbztsdk.deviceStatus.stream_type = 'both';
+      } else if(!zbztsdk.deviceStatus.camera && zbztsdk.deviceStatus.microphone) {
+        zbztsdk.deviceStatus.stream_type = 'audio';
+      } else if(zbztsdk.deviceStatus.camera && !zbztsdk.deviceStatus.microphone) {
+        zbztsdk.deviceStatus.stream_type = 'video';
+      } else {
+        zbztsdk.deviceStatus.stream_type = 'none';
+      };
+      // console.log('push_type222',zbztsdk.deviceStatus,zbztsdk.deviceStatus.stream_type);
+      defaultApi.writeLog(`push_type_talrtc,camera: ${zbztsdk.deviceStatus.camera},microphone: ${zbztsdk.deviceStatus.microphone},type: ${zbztsdk.deviceStatus.stream_type},a_fps: ${dataTalrtcCapture.fps}, a_bit: ${dataTalrtcCapture.audioBitrate}, v_fps: ${dataTalrtcCapture.fps}, v_bit: ${dataTalrtcCapture.videoBitrate}`);
+      // if (window.zbztAVSDK_init_params.zego.role === 'teacher') {
+      dataReport.heartbeat({
+        ...{...heartBeatDataReportObj, push_type: zbztsdk.deviceStatus.stream_type, volume: heartBeatDataReportObj.volume.slice(0,heartBeatDataReportObj.volume.length-1)},
+        // pull_info: JSON.stringify(pullInfo),
+        pull_info: pullInfo,
+        // cpu_rate: util.toFixed(cpuRate/rateCount),
+        // mem_rate: util.toFixed(memRate/rateCount),
+      });
+      // } else {
+      //   dataReport.heartbeat({
+      //     ...heartBeatDataReportObj,
+      //     pull_info: JSON.stringify(pullInfo),
+      //     cpu_rate: util.toFixed(cpuRate/rateCount),
+      //     mem_rate: util.toFixed(memRate/rateCount),
+      //     app_cpu: util.toFixed(appCpuRate/rateCount),
+      //     app_mem: util.toFixed(appMemUsed/rateCount),
+      //     video_mem: gpus
+      //   });
+      // }
+      dataReport.localNetworkQuality({
+        code:  qualityLocal,
+      });
+      dataReport.remoteNetworkQuality({
+        code:  qualityRemote,
+      });
+    } catch (e) {
+      console.log(e);
+    }
+  }
+  resetHeartBeatDataReportObj();
+  // cpuRate = 0;
+  // memRate = 0;
+  // appCpuRate = 0;
+  // appMemUsed = 0;
+
+  // clearInterval(rateTimer);
+  // }
+  // }, 10 * 1000);
+};
+
+const heartBeatDataReport = (type) => {
+  try {
+    if (type === 'start' && !heartBeatDataReportTimer) {
+      console.log('start heart beat report');
+      _heartBeatDataReport();
+      heartBeatDataReportTimer = setInterval(() => {
+        _heartBeatDataReport();
+      }, 30 * 1000);
+    }
+    if (type === 'stop') {
+      clearInterval(heartBeatDataReportTimer);
+      heartBeatDataReportTimer = null;
+    }
+  } catch (error) {
+    console.log(error);
+  }
+};
+const lastStreamReportTimestamps = {};
+
+const heartBeatDataReportCalc = (name, _data) => {
+  let _d = JSON.parse(_data.stats);
+
+  if (lastStreamReportTimestamps[_d.streamId] && Date.now() - lastStreamReportTimestamps[_d.streamId] < 4999) {
+    return;
+  } else {
+    lastStreamReportTimestamps[_d.streamId] = Date.now();
+  }
+  // 拉流
+  const pullKeys = ['fps', 'videoBitrate', 'afps', 'audioBitrate'];
+  if (name === 'onRemoteStatistics') {
+    if (streamIdRtcPlayerInfo && streamIdRtcPlayerInfo.hasOwnProperty(_d.streamId)) {
+      let streamid = _d.streamId;
+      let isReport = true;
+      // streamIdRtcPlayerInfo[streamid].count++;
+      heartBeatRealKeys.forEach((realKey, index) => {
+        if (_d.hasOwnProperty(pullKeys[index])) {
+          if (streamIdRtcPlayerInfo[streamid][realKey] === undefined) {
+            streamIdRtcPlayerInfo[streamid][realKey] = [];
+            isReport = false;
+          }
+          // streamIdRtcPlayerInfo[streamid][realKey].push(parseFloat(parseInt(item[pullKeys[index]])));
+        }
+      });
+      if (isReport) {
+        let audio_fps_talrtc_pull = 0;
+        let audio_bitrate_talrtc_pull = 0;
+        let video_fps_talrtc_pull = 0;
+        let video_bitrate_talrtc_pull = 0;
+        if(streamIdRtcPlayerInfo1[streamid].audio_type && streamIdRtcPlayerInfo1[streamid].video_type) {
+          audio_fps_talrtc_pull = parseFloat(parseInt(_d.afps));
+          audio_bitrate_talrtc_pull = parseFloat(parseInt(_d.audioBitrate));
+          video_fps_talrtc_pull = parseFloat(parseInt(_d.fps));
+          video_bitrate_talrtc_pull = parseFloat(parseInt(_d.videoBitrate));
+        } else if(!streamIdRtcPlayerInfo1[streamid].audio_type && streamIdRtcPlayerInfo1[streamid].video_type) {
+          video_fps_talrtc_pull = parseFloat(parseInt(_d.fps));
+          video_bitrate_talrtc_pull = parseFloat(parseInt(_d.videoBitrate));
+        } else if(streamIdRtcPlayerInfo1[streamid].audio_type && !streamIdRtcPlayerInfo1[streamid].video_type) {
+          audio_fps_talrtc_pull = parseFloat(parseInt(_d.afps));
+          audio_bitrate_talrtc_pull = parseFloat(parseInt(_d.audioBitrate));
+        }
+        streamIdRtcPlayerInfo[streamid].audio_fps.push(audio_fps_talrtc_pull);
+        streamIdRtcPlayerInfo[streamid].audio_bitrate.push(audio_bitrate_talrtc_pull);
+        streamIdRtcPlayerInfo[streamid].video_fps.push(video_fps_talrtc_pull);
+        streamIdRtcPlayerInfo[streamid].video_bitrate.push(video_bitrate_talrtc_pull);
+        streamIdRtcPlayerInfo[streamid].pull_loss.push(_d.packetLoss);
+        streamIdRtcPlayerInfo[streamid].pull_delay.push(_d.rtt);
+
+        streamIdRtcPlayerInfo[streamid].ctime.push(Math.round((new Date().getTime()+dataReport.timestamp)/1000));
+        streamIdRtcPlayerInfo[streamid].video_ifg += _d.videoBlockRate;
+        streamIdRtcPlayerInfo[streamid].audio_ifg += _d.audioBlockRate;
+        // console.log('hsg_tpull_keys',JSON.parse(JSON.stringify(streamIdRtcPlayerInfo[streamid])),_d.avTimestampDiff);
+      }
+    }
+  }
+  // 推流
+  const pushKeys = ['fps', 'videoBitrate', 'afps', 'audioBitrate'];
+  if (name === 'onLocalStatistics') {
+    // console.log('hsgmzk',_d);
+    // heartBeatDataReportObj.count++;
+    // heartBeatRealKeys.forEach((realKey, index) => {
+    //   if (heartBeatDataReportObj.hasOwnProperty(realKey) && _d.hasOwnProperty(pushKeys[index])) {
+    //     heartBeatDataReportObj[realKey].push(parseFloat(parseInt(_d[pushKeys[index]])));
+    //   }
+    // });
+    let audio_fps_talrtc_push = 0;
+    let audio_bitrate_talrtc_push = 0;
+    let video_fps_talrtc_push = 0;
+    let video_bitrate_talrtc_push = 0;
+    dataTalrtcCapture =_d;
+
+    if(zbztsdk.deviceStatus.camera && zbztsdk.deviceStatus.microphone) {
+      audio_fps_talrtc_push = parseFloat(parseInt(_d.afps));
+      audio_bitrate_talrtc_push = parseFloat(parseInt(_d.audioBitrate));
+      video_fps_talrtc_push = parseFloat(parseInt(_d.fps));
+      video_bitrate_talrtc_push= parseFloat(parseInt(_d.videoBitrate));
+    } else if(!zbztsdk.deviceStatus.camera && zbztsdk.deviceStatus.microphone) {
+      audio_fps_talrtc_push = parseFloat(parseInt(_d.afps));
+      audio_bitrate_talrtc_push = parseFloat(parseInt(_d.audioBitrate));
+    } else if(zbztsdk.deviceStatus.camera && !zbztsdk.deviceStatus.microphone) {
+      video_fps_talrtc_push = parseFloat(parseInt(_d.fps));
+      video_bitrate_talrtc_push = parseFloat(parseInt(_d.videoBitrate));
+    }
+    heartBeatDataReportObj.audio_fps.push(audio_fps_talrtc_push);
+    heartBeatDataReportObj.audio_bitrate.push(audio_bitrate_talrtc_push);
+    heartBeatDataReportObj.video_fps.push(video_fps_talrtc_push);
+    heartBeatDataReportObj.video_bitrate.push(video_bitrate_talrtc_push);
+    heartBeatDataReportObj.push_loss.push(_d.packetLoss);
+    heartBeatDataReportObj.push_delay.push(_d.rtt);
+    heartBeatDataReportObj.ctime.push(Math.round((new Date().getTime()+dataReport.timestamp)/1000));
+  }
+};
+
+//推流字段
+const resetHeartBeatDataReportObj = () => {
+  console.log('resetHeartBeatDataReportObj重置');
+  heartBeatDataReportObj = {
+    ctime: [],
+    push_type: 'none',
+    video_fps: [],
+    video_bitrate: [],
+    audio_fps: [],
+    audio_bitrate: [],
+    push_loss: [],
+    push_delay: [],
+    volume: ''
+  };
+};
+
+resetHeartBeatDataReportObj();
+//记录拉流类型，用作数据上报
+const resetStreamIdRtcPlayerInfo1 = (streamId) => {
+  streamIdRtcPlayerInfo1[streamId] = {
+    audio_type: false,
+    video_type: false,
+    stream_type: 'none'
+  };
+  // console.log('hsgshgs_heartbeat',streamIdRtcPlayerInfo1);
+};
+//拉流字段
+const resetStreamIdRtcPlayerInfo = (streamId) => {
+  console.log('reset stream info ----------', streamId);
+  streamIdRtcPlayerInfo[streamId] = {
+    pull_uid: util.getUidByStreamId(streamId),
+    streamid: streamId,
+    ctime: [],
+    pull_type: streamIdRtcPlayerInfo1[streamId].stream_type,
+    volume: '',
+    // 平均值
+    // count: 0,
+    // video_fps: 0,
+    // video_bitrate: 0,
+    // audio_fps: 0,
+    // audio_bitrate: 0,
+    video_fps: [],
+    video_bitrate: [],
+    audio_fps: [],
+    audio_bitrate: [],
+    pull_loss: [],
+    pull_delay: [],
+    //音画不同步字段
+    avtimestampdiff: [],
+    // 累加
+    audio_ifg: 0,
+    video_ifg: 0
+  };
+
+  console.log('reset stream info ----------', streamId, streamIdRtcPlayerInfo[streamId]);
+};
+
+export default {
+  init,
+  setCameraCaptureResolution,
+  setCameraEncodeResolution,
+  setCameraEncodeFps, // 未实现调用
+  setCameraEncodeBitrate,
+  getCameraResolution,
+  getMicrophoneDeviceList,
+  setMicrophoneDevice,
+  openOrCloseMicrophone,
+  getCurrentMicrophoneVolume,
+  setCurrentMicrophoneVolume,
+  getCameraDeviceList,
+  setCameraDevice,
+  openOrCloseCamera,
+  getSpeakerDeviceList,
+  setSpeakerDevice,
+  getCurrentSpeakerDevice,
+  getCurrentSpeakerVolume,
+  setCurrentSpeakerVolume,
+  setSpeakerDeviceMute,
+  muteRemoteAudio,
+  muteRemoteVideo,
+  getSpeakerSimpleVolume,
+  setSpeakerSimpleVolume,
+  setSpeakerSimpleMute,
+  startLocalOrRemotePreview,
+  enableAudioSpeakerCapture,
+  startPush,
+  stopPush,
+  startPlay,
+  stopPlay,
+  initPullFlow,
+  stopPlayAll,
+  playerSnapShot,
+  changePullFlow,
+  sendSEIMsg,
+  loadCollectionInputEntry2,
+  controlCdnStreaming, // addPublishRtmpStreamUrl or removePublishStreamUrl
+  leaveRoom,
+  destroyEngine,
+  unloadTalrtc,
+  muteLocalVideo,
+  muteLocalAudio,
+  pullAudioFlow,
+  hasStream,
+  teacherStartLinkMic,
+  teacherStopLinkMic,
+  setMirrorStatus,
+  setPlayViewMirror,
+  setAudioAuxSource,
+  setAudioType,
+  startAudioExCapture,
+  startMultiScreen,
+  setAudioMixMode,
+  startRecord,
+  stopRecord,
+  startCapture,
+  stopCapture,
+  getChannelIndex,
+  getSDKVersion
+};