zbzt-live-sdk 0.0.2

package/src/zbzt-av-sdk/zego-sdk.js.bak

@@ -0,0 +1,3133 @@
+/**
+ * @File: Zego 音视频 SDK
+ * @Author: xuyuanrui
+ * @Email: raywhbxyr@163.com
+ * @Date: 2018-08-08 10:14:41
+ **/
+import { dabanDataReport } from '../network/api.js';
+import dataReport from '../network/dataReport.js';
+import {
+  getS,
+  setS,
+  compareS
+} from '../util/sessionStorage.js';
+import defaultApi from '../default/index.js';
+import util from '../util/util.js';
+import NOTICE from '../notice.js';
+import toolApi from '../tool/index.js';
+import { deviceListReport } from './device.js';
+import zbztsdk from '../zbzt-live-sdk.js';
+
+// 扩展标识
+const extensionId = 'zego_ext';
+// 端提供的 API 入口
+const EM = window.EM;
+// 维护的一份当前正在使用的音频设备的 deviceId 的列表
+let usingAudioDeviceId = {
+  speaker: '',
+  microphone: ''
+};
+// 维护的一份拉流的 streamId 与本地预览通道的映射表
+let streamIdToPreviewId = {};
+let previewIdToStreamId = {};
+// const streamIdToBlobUrl = {};
+// 拉流的播放通道初始化从 0 开始依次递增至44(共45路流)，-1 为推流的本地视频预览
+// const uiChnIndexs = new Array(50).fill(0).map((a, b) => b + 1).reverse();
+const uiChnIndexs = new Array(48).fill(0).map((a, b) => b).reverse();
+// 初始化是否完成的标志，0 为未完成，1 为完成
+let isInitFinished = 0;
+// 设备检测初始化是否完成的标志，0 为未完成，1 为完成
+let isDeviceCheckInitFinished = 0;
+// 进入房间是否成功
+let hasLoginChannel = 0;
+// 是否已经推流
+let hasPushFlow = 0;
+// 是否logoutChannel成功
+let isAVEngineStopped = 0;
+// 上层透传的回调函数缓存
+// let zegoCallback = null;
+// 是否执行过 Zego 的 AddListener 的标志
+let hasAddListener = false;
+// 是否处于网络错误状态中的标志
+let hasNetWrong = false;
+// rtc小班课=0；rtc大班课=1
+const classType = 0;
+// 监听id
+let EMListenerId = 0;
+
+//静音推流时，音量值是否上抛上层标志 false=没有声音不往上层通知/true=有声音有上层通知
+let isNoticeMicVolumeZego = false;
+
+// 心跳
+let heartBeatDataReportObj = {};
+let heartBeatDataReportTimer = null;
+let isFirstHeartBeatReport = false;
+let streamIdRtcPlayerInfo = {};
+let streamIdRtcPlayerInfo1 = {};
+let currStreamIdRtcPlayerInfo;
+
+//记录底层推流回调的值
+let dataZegoCapture = {};
+
+//记录当前角色
+let currentRole = '';
+//记录当前课态类型：小组课=0/小班课=1
+let currentClassMode = null;
+//记录当前rtmp推流sdk类型
+let currentGroupSdkType = '';
+//主流ID
+let localStreamId = '';
+//屏幕流ID
+let screenStreamId = '';
+/**
+ * @function 调用端提供的回调方法
+ * @param name:String 回调方法名
+ * @param args 回调参数
+ * @return Promise | void
+ */
+const callMethod = (name, args) => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      let noneCamera = (name === 'SetVideoDevice' && !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
+          });
+        }
+      );
+    });
+  }
+};
+
+/**
+ * @function 加载 Zego 扩展
+ * @param extensionVersion:String 扩展版本号，必选
+ * @return Promise | void
+ */
+export const loadZego = (extensionVersion) => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      if (getS('zegoVersion')) {
+        if (compareS('zegoVersion', extensionVersion)) {
+          return resolve();
+        }
+      }
+      EM.Load(
+        extensionId,
+        extensionVersion,
+        false,
+        (code, msg) => {
+          defaultApi.writeLog(`loadZego Code: ${code}\nMessage: ${msg}`);
+          if (code === 0) {
+            setS('zegoVersion', extensionVersion);
+          }
+          resolve();
+        }
+      );
+    });
+  }
+};
+
+/**
+ * @function 卸载 Zego 扩展
+ * @return Promise | void
+ */
+export const unloadZego = () => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      EM.UnLoad(
+        extensionId,
+        (code, msg) => {
+          defaultApi.writeLog(`unloadZego Code: ${code}\nMessage: ${msg}`);
+          resolve();
+        }
+      );
+    });
+  }
+};
+
+/**
+ * @function 添加扩展监听机制
+ * @param userId:Number 用户 id，必选
+ * @param userName:String 用户名，必选
+ * @param roomId:String 频道（房间） id，必选
+ * @param nNetType:Number 网络类型，可选，默认为 1
+ * @return void
+ */
+const addListener = (userId, userName, confId, nNetType, devices, role) => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM && !hasAddListener) {
+    hasAddListener = true;
+    EM.AddListener(extensionId, (event, data) => {
+      if (data && data.indexOf(extensionId) > -1) {
+        try {
+          EMListenerId = JSON.parse(data)[extensionId];
+          defaultApi.writeLog(`ZEGO::addListener-- EMListenerId: ${EMListenerId}`);
+        } catch (error) { }
+      }
+      if (!event || !data) {
+        return;
+      }
+      let _data = JSON.parse(data);
+      // if (_data && _data.classType === 1) {
+      //   return false;
+      // }
+      switch (event) {
+      case 'OnInitSDK':
+        // 只有 OnInitSDK 事件成功返回后才可以执行后续操作，比如 loginChannel
+        var status = JSON.parse(data).nError;
+        var nclassType = JSON.parse(data).nClassType;
+        defaultApi.writeLog(`ZEGO::addListener-- OnInitSDK: ${status}--${nclassType}`);
+        if (status === 0 && nclassType == 0) {
+          if (userId === 'deviceCheckerInit') {
+            deviceCheckerInitSDK();
+          } else {
+            afterInitSDK(userId, userName, confId, nNetType, devices, role);
+          }
+        }
+        break;
+      case 'OnLoginChannel':
+        var status = JSON.parse(data).uiErrorCode;
+        defaultApi.writeLog(`ZEGO::addListener-- OnLoginChannel: ${status}`);
+        if (status === 0) {
+          hasLoginChannel = 1;
+        }
+        break;
+      case 'OnPublishStateUpdate':
+        let res = JSON.parse(data);
+        let keys = Object.keys(res);
+        if (keys.indexOf('eState') > -1) {
+          switch (res.eState) {
+            case 0:
+              hasPushFlow = 1;
+              window.zegoHasPushFlow = 1;
+              try {
+                let ReportArgs = {};
+                if (_data.pszStreamID.split('_').length == 5) {
+                  ReportArgs.publish_rtc_streamid = _data.pszStreamID;
+                }
+                dataReport.publishResult({
+                  code: '0',
+                  ...ReportArgs
+                  // publish_streamid: window.zbztAVSDK_init_params.zego.streamId,
+                });
+                NOTICE.pushFlowSuccess({ code: 0, publish_streamid: _data.pszStreamID });
+              } catch (e) { };
+              if (window.zbztAVSDK_init_params.zego.isTurnPush) {
+                singleRecord('start');
+              }
+              break;
+            case 1:
+              hasPushFlow = 0;
+              window.zegoHasPushFlow = 0;
+              break;
+            // 推流重试
+            case 6:
+            case 7:
+            case 105:
+              // pushFlowExceptionHandler();
+              try {
+                dataReport.publishResult({
+                  code: res.eState,
+                  // publish_streamid: window.zbztAVSDK_init_params.zego.streamId,
+                });
+              } catch (e) { };
+              break;
+            case 10:
+              if (!hasNetWrong) {
+                hasNetWrong = true;
+                defaultApi.writeLog('error', 'Network error');
+                NOTICE.networkError({
+                  message: 'Network error'
+                });
+              }
+              try {
+                dataReport.publishResult({
+                  code: res.eState,
+                  // publish_streamid: window.zbztAVSDK_init_params.zego.streamId,
+                });
+              } catch (e) { };
+              // pushFlowExceptionHandler();
+              break;
+            default:
+              try {
+                dataReport.publishResult({
+                  code: res.eState,
+                  // publish_streamid: window.zbztAVSDK_init_params.zego.streamId,
+                });
+              } catch (e) { };
+              break;
+          }
+        }
+        break;
+      case 'OnPublishQualityUpdate':
+        if (_data.hasOwnProperty('pq') && (_data.pszStreamID).split('_').length != 5) {
+          // 主辅两路质量回调,丢包延时只上抛一次，过滤掉辅路数据
+          _data.opt = 'quality';
+          _data.type = 'mediaupqos';
+          if (typeof _data.pq.kbps === 'number' && typeof _data.pq.fps === 'number') {
+            NOTICE.pushQuality({
+              video: {
+                bitrate: Math.round(_data.pq.kbps),
+                fps: Math.round(_data.pq.fps)
+              }
+            });
+          }
+          // console.log('推流延迟丢包zego',_data);
+          NOTICE.pushLossAndDelay({
+            userId: util.getUidByStreamId(_data.pszStreamID),
+            delay: _data.pq.rtt,
+            lostrate: _data.pq.pktLostRate
+          });
+          heartBeatDataReportCalc(event, _data.pq, _data.pszStreamID);
+        }
+        break;
+      case 'OnCaptureSoundLevelUpdate':
+        if (isNoticeMicVolumeZego) {
+          NOTICE.captureMicVolumeChanged({
+            volume: Math.round(_data.pCaptureSoundLevel[0].soundLevel)
+          });
+        }
+        // heartBeatDataReportObj.volume.push(Math.round(_data.pCaptureSoundLevel[0].soundLevel));
+        heartBeatDataReportObj.volume = heartBeatDataReportObj.volume + Math.round(_data.pCaptureSoundLevel[0].soundLevel) + ',';
+        break;
+      case 'OnSoundLevelUpdate':
+        _data.pSoundLevelList.forEach(item => {
+          const cbData = {
+            streamid: item.szStreamID,
+            userId: util.getUidByStreamId(item.szStreamID),
+            volume: Math.round(item.soundLevel)
+          };
+          NOTICE.playerVolumeChanged(cbData);
+          NOTICE.volumeChange(cbData);
+          // currStreamIdRtcPlayerInfo && currStreamIdRtcPlayerInfo.volume.push(Math.round(item.soundLevel));
+          // streamIdRtcPlayerInfo[item.szStreamID] && streamIdRtcPlayerInfo[item.szStreamID].volume.push(Math.round(item.soundLevel));
+          if (streamIdRtcPlayerInfo[item.szStreamID]) {
+            streamIdRtcPlayerInfo[item.szStreamID].volume = streamIdRtcPlayerInfo[item.szStreamID].volume + Math.round(item.soundLevel) + ',';
+          }
+        });
+        break;
+      case 'OnPlayStateUpdate':
+        if (_data.hasOwnProperty('eState')) {
+          let code = _data.eState;
+          if (code === 3) {
+            defaultApi.writeLog('error', `ZEGO::  OnPlayStateUpdate  eState: ${code}`);
+          }
+          let normalCode = [0, 1, 3, 1011];
+          if (code === 10 && !hasNetWrong) {
+            hasNetWrong = true;
+            defaultApi.writeLog('error', 'Network error');
+            NOTICE.networkError({
+              message: 'Network error'
+            });
+            dabanDataReport({
+              action: 'zbzt_live_sdk_player_network_error',
+              uid: window.zbztAVSDK_init_params.zego.userId,
+              streamid: _data.pszStreamID,
+              teacherId: window.zbztAVSDK_init_params.zego.teacherId,
+              errorcode: code,
+              sdktype: 'zego'
+            });
+          }
+          // 拉流重试
+          if (normalCode.indexOf(code) === -1) {
+            setTimeout(() => {
+              // pullFlowExceptionHandler(_data.pszStreamID);
+              NOTICE.playError({
+                userId: util.getUidByStreamId(_data.pszStreamID),
+                message: 'play error'
+              });
+
+              dabanDataReport({
+                action: 'zbzt_live_sdk_player_play_error',
+                uid: window.zbztAVSDK_init_params.zego.userId,
+                streamid: _data.pszStreamID,
+                teacherId: window.zbztAVSDK_init_params.zego.teacherId,
+                errorcode: code,
+                sdktype: 'zego'
+              });
+            }, 1000);
+          };
+          try {
+            if (_data.pszStreamID.indexOf('ai') < 0) {
+              dataReport.pullResult({
+                code: code,
+                // pull_uid: _data.pszStreamID.split('_').length == 5 ? _data.pszStreamID : util.getUidByStreamId(_data.pszStreamID),
+                pull_uid: util.getUidByStreamId(_data.pszStreamID),
+                pull_streamid: _data.pszStreamID
+              });
+              NOTICE.pullFlowResult({ code: code, pull_streamid: _data.pszStreamID });
+            }
+            // dataReport.pullResult({
+            //   code: code,
+            //   pull_uid: util.getUidByStreamId(_data.pszStreamID),
+            //   pull_streamid: _data.pszStreamID
+            // });
+          } catch (e) { };
+        }
+        break;
+      case 'OnPlayQulityUpdate': // 拉流
+        if (_data.hasOwnProperty('pq')) {
+          // console.log('拉流回调',`${new Date().getMinutes()}:${new Date().getSeconds()}`,_data);
+          _data.opt = 'quality';
+          _data.type = 'mediadownqos';
+          NOTICE.pullQuality({
+            video: {
+              streamId: _data.pszStreamID,
+              userId: util.getUidByStreamId(_data.pszStreamID),
+              bitrate: _data.pq.kbps,
+              fps: _data.pq.fps,
+            }
+          });
+          // console.log('拉流延迟丢包zego',_data);
+          NOTICE.playLossAndDelay({
+            userId: util.getUidByStreamId(_data.pszStreamID),
+            delay: _data.pq.rtt,
+            lostrate: _data.pq.pktLostRate
+          });
+          currStreamIdRtcPlayerInfo = streamIdRtcPlayerInfo[_data.pszStreamID];
+          heartBeatDataReportCalc(event, _data.pq, _data.pszStreamID);
+        }
+        break;
+      case 'OnVideoDeviceStateChanged': // 视频设备状态变更
+        // _data.state 0=添加设备 1=移除设备
+        // console.log('hsghsghsg摄像头热插拔',_data);
+        setVideoDevice({ deviceId: _data.state == 1 ? '' : _data.deviceInfo.szDeviceId, idx: 0, operationType: 'hotPlug', deviceState: _data.state, changedDeviceId: _data.deviceInfo.szDeviceId });
+        // try {
+        //   dataReport.deviceTest({
+        //     device: '1',
+        //     fore_state: _data.state == 0 ? 1 : 2 ,
+        //     camera_name: _data.deviceInfo && _data.deviceInfo.szDeviceName,
+        //   });
+        // } catch (e){};
+        break;
+      case 'OnAudioDeviceStateChanged': // 音频设备状态变更
+        // console.log('hsghsghsg扬声器热插拔1',_data);
+        if (_data.deviceType === 0) {
+          // _data.state 0=添加设备 1=移除设备
+          setMicrophoneDevice({ deviceId: _data.state == 1 ? '' : _data.deviceInfo.szDeviceId, operationType: 'hotPlug', deviceState: _data.state, changedDeviceId: _data.deviceInfo.szDeviceId });
+        }
+        if (_data.deviceType === 1) {
+          // console.log('hsghsghsg扬声器热插拔',_data);
+          setSpeakerDevice({ deviceId: _data.state == 1 ? '' : _data.deviceInfo.szDeviceId, operationType: 'hotPlug', deviceState: _data.state, changedDeviceId: _data.deviceInfo.szDeviceId });
+        }
+        // try {
+        //   dataReport.deviceTest({
+        //     device: _data.deviceType === 0 ? '2' : '3',
+        //     fore_state: _data.state == 0 ? 1 : 2 ,
+        //     microphone_name: _data.deviceInfo && _data.deviceInfo.szDeviceName,
+        //     speaker_name: _data.deviceInfo && _data.deviceInfo.szDeviceName
+        //   });
+        // } catch (e){};
+        break;
+      case 'OnDeviceError':
+        //errorCode 无效设备ID (-2), 没有权限	(-3), 采集帧率为0	(-4), 设备被占用 (-5), 设备未插入	(-6), 需要重启系统 (-7), 媒体服务无法恢复	(-8), 设备被SIRI占用 (-9)
+        let codemsg = {
+          '-2': '无效设备ID',
+          '-3': '没有权限',
+          '-4': '采集帧率为0',
+          '-5': '设备被占用',
+          '-6': '设备未插入',
+          '-7': '需要重启系统',
+          '-8': '媒体服务无法恢复',
+          '-9': '设备被SIRI占用'
+        };
+        defaultApi.writeLog(`avsdk ZEGO:: OnDeviceError ${_data.deviceName} ${_data.errorCode}`);
+        dataReport.deviceError({ deviceName: _data.deviceName, errorCode: _data.errorCode });
+        // _data.deviceName === 'camera' ? setVideoDevice({deviceId: '', idx: 0, operationType: 'deviceError', deviceState: '', code: codemsg[_data.errorCode]}) : setMicrophoneDevice({deviceId: '', operationType: 'deviceError', deviceState: '', code: codemsg[_data.errorCode]});
+        break;
+      case 'OnAVKitEvent':
+        // defaultApi.writeLog('avsdk ZEGO:: OnAVKitEvent');
+        if (_data.event === 4 && hasNetWrong) {
+          hasNetWrong = false;
+          NOTICE.networkRecovery({
+            message: 'Network recovery'
+          });
+        }
+        break;
+      case 'OnAVEngineStop':
+        isAVEngineStopped = 1;
+        defaultApi.writeLog('avsdk ZEGO:: listened AVEngineStop');
+        break;
+      case 'OnMixStream':
+        defaultApi.writeLog('avsdk ZEGO:: listened mix_stream_response');
+        break;
+      case 'OnRenderRemoteVideoFirstFrame':
+        // 大班数据上报
+        if (window.zbztAVSDK_init_params.zego.role === 'student') {
+          dabanDataReport({
+            action: 'interact_play',
+            teammate_streamid: _data.pszStreamID,
+            uid: window.zbztAVSDK_init_params.zego.userId
+          });
+        }
+        try {
+          NOTICE.firstVideoSize({
+            streamId: _data.pszStreamID,
+            // userId: _data.pszStreamID.split('_').length == 5 ? _data.pszStreamID : util.getUidByStreamId(_data.pszStreamID)
+            userId: util.getUidByStreamId(_data.pszStreamID)
+          });
+          dataReport.firstVideoSize({
+            pull_streamid: _data.pszStreamID,
+            pull_uid: util.getUidByStreamIdDr(_data.pszStreamID),
+            code: '0'
+          });
+        } catch (e) { };
+        defaultApi.writeLog(`ZEGO: pullStream success & haveFirstVideoSize  streamId: ${_data.pszStreamID}`);
+        // try {
+        //   dataReport.pullResult({
+        //     status: 0,
+        //     pull_uid: util.getUidByStreamId(_data.pszStreamID),
+        //     pull_streamid: _data.pszStreamID
+        //   });
+        // } catch (e) {};
+        break;
+      case 'OnRecvRemoteAudioFirstFrame':
+        try {
+          NOTICE.firstAudioSize({
+            streamId: _data.pszStreamID,
+            userId: util.getUidByStreamId(_data.pszStreamID)
+          });
+          dataReport.firstAudioSize({
+            pull_streamid: _data.pszStreamID,
+            pull_uid: util.getUidByStreamIdDr(_data.pszStreamID),
+            code: '0'
+          });
+        } catch (e) { };
+        break;
+      // 转推回调 0=转推停止 1=正在转推 2=正在重试
+      case 'onRecvMediaSideInfo':
+        defaultApi.writeLog(`avsdk ZEGO:: onRecvMediaSideInfo, ${JSON.stringify(_data)}`);
+        NOTICE.seiReceived({ data: _data });
+        break;
+      case 'zego_recovery_start':
+        defaultApi.writeLog(`avsdk ZEGO:: zego_recovery_start ${JSON.stringify(_data)}`);
+        NOTICE.zegoRecoveryStart();
+        break;
+      case 'OnRelayCDNStateUpdate':
+        if (_data.statesInfo && _data.statesInfo[0] && _data.statesInfo[0].state === 1) {
+          NOTICE.recordResponse({
+            streamId: _data.streamID,
+            userId: util.getUidByStreamId(_data.streamID)
+          });
+        }
+        //   try {
+        //     dataReport.turnPushResult({
+        //       errorcode:_data.statesInfo[0].state,
+        //       case: 'turn push',
+        //       streamid: _data.streamID
+        //     })
+        // } catch (e) {};
+        break;
+      case 'OnCaptureVideoFirstFrame':
+        // 大班数据上报
+        dabanDataReport({
+          action: 'open_camera',
+          camera_status: 1,
+          uid: window.zbztAVSDK_init_params.zego.userId
+        });
+        break;
+      case 'OnKaDunEvent':
+        if (_data.event === 8) {
+          currStreamIdRtcPlayerInfo && (currStreamIdRtcPlayerInfo.video_ifg += _data.kaDunTime);
+        }
+        if (_data.event === 10) {
+          currStreamIdRtcPlayerInfo && (currStreamIdRtcPlayerInfo.audio_ifg += _data.kaDunTime);
+        }
+        break;
+      }
+      if (zbztsdk.openListenerLog) {
+        defaultApi.writeLog(`Zego::Listener:: event: ${event}, data: ${JSON.stringify(data)}`);
+      }
+    });
+  }
+};
+
+/**
+ * @function 添加扩展监听机制
+ * @return void
+ */
+const removerListener = () => {
+  hasAddListener = false;
+  defaultApi.writeLog(`ZEGO::action--removerListener EMListenerId:${EMListenerId}`);
+  EM.RemoverListener(extensionId, EMListenerId, (ec, content) => { });
+  EMListenerId = 0;
+};
+
+/**
+ * @function 推流异常恢复
+ */
+export const pushFlowExceptionHandler = async () => {
+  await new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve();
+    }, 1000);
+  });
+  defaultApi.writeLog('断网重推');
+  defaultApi.writeLog('avsdk ZEGO::try to pushFlow again');
+  await stopPublish();
+  await startPublish2();
+};
+
+/**
+ * @function 拉流异常恢复
+ */
+export const pullFlowExceptionHandler = async (streamId) => {
+  await new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve();
+    }, 1000);
+  });
+  defaultApi.writeLog('断网重拉');
+  defaultApi.writeLog(`avsdk ZEGO::try to pullFlow again ，streamId : ${streamId}`);
+  await stopPlayStream(streamId);
+  await playStream(streamId);
+};
+
+/**
+ * @function 初始化 Engine
+ * @param appId:String Zego 秘钥，必选
+ * @param appSignature:String 签名，必选
+ * @param businessType:Number 业务类型，可选，默认为 0
+ * @param videoRenderType:Number zego视频渲染类型，默认为2(只外部渲染),zego小组课需要设置为5（同时支持内部+外部渲染）
+ * @return Promise | void
+ */
+export const startEngine = (appId, appSignature, businessType, videoRenderType=2) => {
+  if (typeof businessType === 'undefined') {
+    businessType = 0;
+  }
+  defaultApi.writeLog('avsdk ZEGO::StartEngine');
+  return callMethod('StartEngine', {
+    appId,
+    appSignature,
+    businessType,
+    videoRenderType
+  });
+};
+
+//开启消除回声
+export const setEnableAEC = (bEnable) => {
+  return callMethod('EnableAEC', { bEnable });
+};
+
+//设置回声消除模式 mode ：激进模式 =0/中等模式 =1/轻度模式 =2
+export const setAECMode = (mode) => {
+  return callMethod('SetAECMode', { mode });
+};
+
+//开启噪音消除
+export const setEnableNoiseSuppress = (bEnable) => {
+  return callMethod('EnableNoiseSuppress', { bEnable });
+};
+
+//设置噪音消除模式 mode ：0：低  1：中   2高
+export const setNoiseSuppressMode = (level) => {
+  return callMethod('SetNoiseSuppressMode', { level });
+};
+
+//新增瞬时降噪接口 瞬时降噪 可以处理掉 敲键盘、敲桌子、敲门等瞬态噪声。非瞬态噪声，此接口无法处理，比如划桌子等摩擦噪音。
+export const enableTransientNoiseSuppress = (enable) => {
+  return callMethod('EnableTransientNoiseSuppress', { enable })
+}
+
+/**
+   * @function 加载采集插件的输入数据  //调用后，zego 可以向采集插件传送摄像头数据，用于拼接
+   * @return: Promise
+   */
+export const loadCollectionInputEntry = () => {
+  return callMethod('LoadCollectionInputEntry', {});
+};
+
+/**
+ * @function 加载采集插件的输出数据  //调用后，zego 可以向采集插件传送学生流数据(加载截屏插件，获取截屏插件设置拉流头像回调函数)
+ * @param stream_ids array 设置需要拼接的学生头像流id，按数组顺序拼接
+ * @return: Promise
+ */
+export const loadCollectionInputEntry2 = (stream_ids) => {
+  return callMethod('LoadCollectionInputEntry2', { stream_ids });
+};
+
+/**
+ * @function 加载采集插件的输出数据  //调用后，zego 可以从采集插件获取拼接数据
+ * @return: Promise
+ */
+export const loadCollectionOutputEntry = () => {
+  return callMethod('LoadCollectionOutputEntry', {});
+};
+/**
+ * @function 设置直推url  //调用后，zego 可以从采集插件获取拼接数据
+ * @param pRtmpUrl:String 直推地址
+ * @param idx:Number 使用外部采集的通道idx，与StartEngine中channel_idx保持一致
+ * @return: Promise
+ */
+export const setCDNPublishTarget = (pRtmpUrl, idx) => {
+  return callMethod('SetCDNPublishTarget', { pRtmpUrl, idx });
+};
+/**
+ * @function 销毁引擎
+ * @return Promise | void
+ */
+export const destroyEngine = () => {
+  return callMethod('DestroyEngine', {});
+};
+
+/**
+ * @function 加入频道
+ * @param userId:Number 用户 id，必选
+ * @param userName:String 用户名，必选
+ * @param channelId:String 频道 id，必选
+ * @param nNetType:Number 网络类型，可选，默认为 1
+ * @return Promise | void
+ */
+export const loginChannel = (userId, userName, channelId, nNetType) => {
+  if (typeof nNetType === 'undefined') {
+    nNetType = 1;
+  }
+  return callMethod('LoginChannel', {
+    pszUserID: userId + '',
+    pszUserName: userName,
+    pszChannelID: channelId,
+    nNetType
+  });
+};
+
+/**
+ * @function 退出直播频道
+ * @return Promise | void
+ */
+export const logoutChannel = () => {
+  defaultApi.writeLog('avsdk ZEGO:: CallMethod : LogoutChannel');
+  return callMethod('LogoutChannel', {});
+};
+
+/**
+ * @function 云控时退出房间
+ * @return Promise
+ */
+export const leaveRoomWithChangeSDK = async () => {
+  defaultApi.writeLog(`leaveRoomWithChangeSDK--currentClassMode--currentGroupSdkType ${currentClassMode}, ${currentGroupSdkType}`);
+  let needDestroyZegoEngine = true; //云控从zego切到其他sdk时，默认释放zego引擎。但是如果zego在推拉RTMP流，则不能释放
+  if (currentGroupSdkType == 'zego' || window.zbzt_isM1Type) {
+    switch (currentClassMode) {
+      case 0: // 小组
+      case 2: // 组合小班
+        needDestroyZegoEngine = false;
+        break;
+      case 1: // 小班
+        if (window.zbzt_sdk_init_params.role === 'teacher' || window.zbzt_sdk_init_params.role === 'assistant') {
+          needDestroyZegoEngine = false;
+        }
+        break;
+    }
+  }
+  await stopSoundLevelMonitor();
+  for (let key in streamIdToPreviewId) {
+    await stopPlayStream(key, true);
+  }
+  if ((isZegoGroupClass() && (currentRole === 'teacher' || currentRole === 'assistant')) || (isZegoCombinationClass() && currentRole === 'assistant')) {
+    // zego小组课，切RTC流云控后，授课端不能停止预览
+    console.log('zego小组课不可停止预览，会影响rtmp')
+  }
+  else {
+    await stopPreview();
+  }
+  await stopPublish();
+  removerListener();
+
+  if (needDestroyZegoEngine === true) {
+    await destroyEngine();
+  }
+  if ((window.zbzt_sdk_init_params.role === 'teacher')  && window.zbzt_sdk_init_params.mode === 1) {
+    //坐立模式关闭外部采集器，站立关闭外部采集器
+    await setVideoCaptureFactory(false);
+  }
+  heartBeatDataReport('stop');
+  isFirstHeartBeatReport = false;
+  streamIdToPreviewId = {};
+  previewIdToStreamId = {};
+  streamIdRtcPlayerInfo = {};
+  streamIdRtcPlayerInfo1 = {};
+  // heartBeatDataReportObj = {};
+  hasLoginChannel = 0;
+  hasPushFlow = 0;
+  isAVEngineStopped = 0;
+  window.zegoHasPushFlow = 0;
+};
+
+/**
+ * @function 退出房间
+ * @return Promise
+ */
+export const leaveRoom = async (type) => {
+    await stopSoundLevelMonitor();
+    for (let key in streamIdToPreviewId) {
+      await stopPlayStream(key, true);
+    }
+    await stopPublish();
+    removerListener();
+    // await logoutChannel();
+    // await new Promise((resolve, reject) => {
+    //   let timer = setInterval(() => {
+    //     if (isAVEngineStopped) {
+    //       clearInterval(timer);
+    //       resolve();
+    //     }
+    //   }, 300);
+    // });
+    if (type == 'reload') {
+      defaultApi.writeLog('leaveroom -- reload --小组课刷新不可销毁zego引擎')
+    } else {
+      await stopPreview();
+      await destroyEngine();
+    }
+    if ((window.zbzt_sdk_init_params.role === 'teacher') && window.zbzt_sdk_init_params.mode === 1) {
+      //坐立模式关闭外部采集器，站立关闭外部采集器
+      await setVideoCaptureFactory(false);
+    }
+    heartBeatDataReport('stop');
+    isFirstHeartBeatReport = false;
+    streamIdToPreviewId = {};
+    previewIdToStreamId = {};
+    streamIdRtcPlayerInfo = {};
+    streamIdRtcPlayerInfo1 = {};
+    // heartBeatDataReportObj = {};
+    hasLoginChannel = 0;
+    hasPushFlow = 0;
+    isAVEngineStopped = 0;
+    window.zegoHasPushFlow = 0;
+};
+
+export const stopCheckDevice = async () => {
+  removerListener();
+  await stopSoundLevelMonitor();
+  await stopPreview();
+  defaultApi.writeLog('rtc stopCheckDevice and removerListener and captureDestroy');
+  return callMethod('DestroyEngine', {});
+};
+
+/**
+ * @function 获取系统默认的音频设备
+ * @param deviceType:Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @return Promise | void
+ */
+export const getDefaultAudioDeviceId = (deviceType) => {
+  return callMethod('GetDefaultAudioDeviceId', {
+    deviceType,
+    // 以下两个参数仅仅是为了向下向后兼容，使用 hardcore 即可
+    deviceId: '',
+    deviceIdLength: 0
+  });
+};
+
+/**
+ * @function 获取系统默认的麦克风设备 id
+ * @return Promise
+ */
+export const getDefaultMicrophone = () => {
+  return getDefaultAudioDeviceId(0);
+};
+
+/**
+ * @function 获取系统默认的扬声器设备 id
+ * @return Promise
+ */
+export const getDefaultSpeaker = () => {
+  return getDefaultAudioDeviceId(1);
+};
+
+/**
+ * @function 获取摄像头列表
+ * @return Promise | void
+ */
+export const getVideoDeviceList = async () => {
+  let videoListArr = JSON.parse((await callMethod('GetVideoDeviceList', {
+    // 这个参数是 C++ 要使用的引用参数，随便传个整型就行
+    device_count: 1
+  })).msg).ret;
+  let videoList = [];
+  for (let i = 0, len = videoListArr.length; i < len; i++) {
+    videoList.push({
+      deviceId: videoListArr[i].szDeviceId,
+      deviceName: videoListArr[i].szDeviceName,
+      isDefault: i === 0
+    });
+    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，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @param operationType:String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置摄像头设备的行为
+ * @return Promise | void
+ */
+export const setVideoDevice = async (args) => {
+  defaultApi.writeLog(`${JSON.stringify(args)}----setVideoDevice-zego----`);
+  let { deviceId, idx, operationType, deviceState, code, changedDeviceId } = args;
+  let deviceName = '';
+  let cameraData;
+  if (!deviceId) {
+    cameraData = await getVideoDeviceList();
+    // console.log('hsghsghsg0',cameraData);
+    if (cameraData.length) {
+      let hasGetCamare = false;
+      // console.log('hsghsghsg1',hasGetSpeaker);
+      for (let item of cameraData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetCamare = true;
+          break;
+        }
+      }
+      // console.log('hsghsghsg2',hasGetSpeaker);
+      if (!hasGetCamare) {
+        deviceId = cameraData[0].deviceId;
+        deviceName = cameraData[0].deviceName;
+        // console.log('hsghsghsg91',deviceId);
+      }
+    } else {
+      deviceId = '';
+    }
+    // console.log('hsghsghsg1',deviceId);
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'camera'
+      });
+    }
+  }
+  window.zbztAVSDK_device_checker_init.camera.use = deviceId;
+  window.zbztAVSDK_device_checker_init.camera.name = deviceListReport.cameraList[deviceId];
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  try {
+    dataReport.setDevice({
+      device_type: 1,
+      device_id: deviceId,
+      device_name: deviceListReport.cameraList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+  } catch (e) { };
+  await callMethod('SetVideoDevice', {
+    pszDeviceID: deviceId,
+    idx
+  });
+  if (operationType == 'hotPlug' || operationType == 'deviceError') {
+    if (!cameraData) {
+      cameraData = await getVideoDeviceList();
+      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 开/关摄像头
+ * @param enable:Boolean false -> 关闭，true -> 打开，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const enableCamera = (enable, idx = 0) => {
+  // try {
+  //   dataReport.deviceChange({
+  //     device: 1,
+  //     device_state: enable? 1 : 0
+  //   });
+  // } catch (e){};
+  return callMethod('EnableCamera', {
+    bEnable: enable,
+    idx
+  });
+};
+
+/**
+ * @function 开/关麦克风
+ * @param bEnable:Boolean false -> 关闭，true -> 打开，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const enableMic = async (bEnable, idx) => {
+  defaultApi.writeLog('enableMic --start');
+  isNoticeMicVolumeZego = bEnable;
+  // if (bEnable) {
+  //   await setMicDeviceMute(false);
+  //   defaultApi.writeLog('openMic and muteFalse');
+  // }
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  // try {
+  //   dataReport.deviceChange({
+  //     device: 2,
+  //     device_state: bEnable ? 1 : 0
+  //   });
+  // } catch (e){};
+  return callMethod('EnableMic', {
+    bEnable,
+    idx
+  });
+};
+
+/**
+ * @function 是否推声音
+ * @param mute:Boolean true/不推声音，false/推声音,必选
+ * @return Promise | void
+ */
+export const setMuteStreamAudio = (mute) => {
+  return callMethod('MuteStreamAudio', { mute });
+};
+
+/**
+ * @function 是否推画面
+ * @param mute:Boolean true/不推画面，false/推画面,必选
+ * @return Promise | void
+ */
+export const setMuteStreamVideo = (mute) => {
+  return callMethod('MuteStreamVideo', { mute });
+};
+
+/**
+ * @function 获取音频设备
+ * @param deviceType:Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @return Promise | void
+ */
+export const getAudioDeviceList = (deviceType) => {
+  return callMethod('GetAudioDeviceList', {
+    deviceType,
+    // 这个参数是 C++ 要使用的引用参数，随便传个整型就行
+    device_count: 0
+  });
+};
+
+/**
+ * @function 指定音频设备
+ * @param deviceType:Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @param deviceId:String 音频设备 id，必选
+ * @return Promise | void
+ */
+export const setAudioDevice = (deviceType, deviceId) => {
+  if (deviceType == 0) {
+    window.zbztAVSDK_device_checker_init.microphone.use = deviceId;
+  } else {
+    window.zbztAVSDK_device_checker_init.speaker.use = deviceId;
+  }
+  return callMethod('SetAudioDevice', {
+    deviceType,
+    pszDeviceID: deviceId
+  }).then((result) => {
+    if (deviceType == 1 && result.code === 0) {
+      NOTICE.speakerChanged({
+        deviceId
+      });
+    }
+    return result;
+  });
+};
+
+/**
+ * 获取当前扬声器设备id
+ * @return {String} 当前扬声器设备id
+ */
+const getCurrentSpeakerDevice = () => {
+  defaultApi.writeLog(`avsdk ZEGO::getSpeakerDevice ${usingAudioDeviceId.speaker}`);
+  return usingAudioDeviceId.speaker;
+};
+
+/**
+ * @function 获取扬声器列表
+ * @return Promise | void
+ */
+export const getSpeakerDeviceList = async () => {
+  const defaultSpeakerId = JSON.parse((await getDefaultSpeaker()).msg).ret.deviceId;
+  let speakerListArr = JSON.parse((await getAudioDeviceList(1)).msg).ret;
+  let speakerList = [];
+  for (let i = 0, len = speakerListArr.length; i < len; i++) {
+    speakerList.push({
+      deviceId: speakerListArr[i].szDeviceId,
+      deviceName: speakerListArr[i].szDeviceName,
+      isDefault: defaultSpeakerId === speakerListArr[i].szDeviceId
+    });
+    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，必选
+ * @param operationType:String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置扬声器设备的行为
+ * @return Promise | void
+ */
+export const setSpeakerDevice = async (args) => {
+  defaultApi.writeLog(`${JSON.stringify(args)}----setSpeakerDevice-zego----`);
+  // console.log('hsghsghsg999',args);
+  let { deviceId, operationType, deviceState, code, changedDeviceId } = args;
+  let deviceName = '';
+  let speakerData;
+  if (!deviceId) {
+    speakerData = await getSpeakerDeviceList();
+    // console.log('hsghsghsg0',speakerData.length);
+    if (speakerData.length) {
+      let hasGetSpeaker = false;
+      // console.log('hsghsghsg1',hasGetSpeaker);
+      for (let item of speakerData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetSpeaker = true;
+          break;
+        }
+      }
+      // console.log('hsghsghsg2',hasGetSpeaker);
+      if (!hasGetSpeaker) {
+        deviceId = speakerData[0].deviceId;
+        deviceName = speakerData[0].deviceName;
+        // console.log('hsghsghsg91',deviceId);
+      }
+    } else {
+      deviceId = '';
+    }
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'speaker'
+      });
+    }
+  }
+  // console.log('hsghsghsg999',deviceId);
+  try {
+    dataReport.setDevice({
+      device_type: 3,
+      device_id: deviceId,
+      device_name: deviceListReport.speakerList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+    window.zbztAVSDK_device_checker_init.speaker.name = deviceListReport.speakerList[deviceId];
+  } catch (e) { };
+  usingAudioDeviceId.speaker = deviceId;
+  await setAudioDevice(1, 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 获取扬声器音量
+ * @return Promise | void
+ */
+export const getSpeakerDeviceVolume = () => {
+  return callMethod('GetSpeakerDeviceVolume', {
+    deviceId: usingAudioDeviceId.speaker
+  });
+};
+
+/**
+ * @function 设置扬声器音量
+ * @param volume:Number 扬声器音量，必选
+ * @return Promise | void
+ */
+export const setSpeakerDeviceVolume = (volume) => {
+  return callMethod('SetSpeakerDeviceVolume', {
+    deviceId: usingAudioDeviceId.speaker,
+    volume
+  });
+};
+
+/**
+ * @function 设置扬声器静音
+ * @param mute:Boolean 必选
+ * @return Promise | void
+ */
+export const setSpeakerDeviceMute = (mute) => {
+  // try {
+  //   dataReport.deviceChange({
+  //     device: 3,
+  //     device_state: mute ? 0 :1
+  //   });
+  // } catch (e){};
+  return callMethod('SetSpeakerDeviceMute', {
+    deviceId: usingAudioDeviceId.speaker,
+    mute
+  });
+};
+
+/**
+ * @function 获取麦克风列表
+ * @return Promise | void
+ */
+export const getMicrophoneDeviceList = async () => {
+  const defaultMicrophoneId = JSON.parse((await getDefaultMicrophone()).msg).ret.deviceId;
+  let microphoneListArr = JSON.parse((await getAudioDeviceList(0)).msg).ret;
+  let microphoneList = [];
+  for (let i = 0, len = microphoneListArr.length; i < len; i++) {
+    microphoneList.push({
+      deviceId: microphoneListArr[i].szDeviceId,
+      deviceName: microphoneListArr[i].szDeviceName,
+      isDefault: defaultMicrophoneId === microphoneListArr[i].szDeviceId
+    });
+    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;
+  return microphoneList;
+};
+
+/**
+ * @function 指定麦克风
+ * @param deviceId:String 麦克风 id，必选
+ * @param operationType:String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置麦克风设备的行为
+ * @return Promise | void
+ */
+export const setMicrophoneDevice = async (args) => {
+  defaultApi.writeLog(`${JSON.stringify(args)}----setMicrophoneDevice-zego----`);
+  let { deviceId, operationType, deviceState, code, 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'
+      });
+    }
+  }
+  try {
+    dataReport.setDevice({
+      device_type: 2,
+      device_id: deviceId,
+      device_name: deviceListReport.micList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+    window.zbztAVSDK_device_checker_init.microphone.name = deviceListReport.micList[deviceId];
+  } catch (e) { };
+  usingAudioDeviceId.microphone = deviceId;
+  await setAudioDevice(0, deviceId);
+  await setAudioVolumeNotify(0, 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,
+      message: code,
+      deviceState,
+      changedDeviceId
+    });
+  }
+};
+
+/**
+ * @function 获取麦克风音量
+ * @return Promise | void
+ */
+export const getMicDeviceVolume = () => {
+  return callMethod('GetMicDeviceVolume', {
+    deviceId: usingAudioDeviceId.microphone
+  });
+};
+
+/**
+ * @function 设置麦克风音量
+ * @param volume:Number 麦克风音量，必选
+ * @return Promise | void
+ */
+export const setMicDeviceVolume = (volume) => {
+  return callMethod('SetMicDeviceVolume', {
+    deviceId: usingAudioDeviceId.microphone,
+    volume
+  });
+};
+
+/**
+ * @function 设置麦克风静音
+ * @param mute:Boolean 必选
+ * @return Promise | void
+ */
+export const setMicDeviceMute = (mute) => {
+  return callMethod('SetMicDeviceMute', {
+    deviceId: usingAudioDeviceId.microphone,
+    mute
+  });
+};
+
+//设置采集扬声器声音
+export const setAudioSpeakerCapture = async (bEnable) => {
+  return callMethod('EnableMixSystemPlayout', {
+    bEnable,
+  });
+};
+
+// //采集扬声器
+// export const setAudioSpeakerCapture2 = async (bEnable) => {
+//   return callMethod('MixEnginePlayout', {
+//     bEnable,
+//   });
+// };
+
+/**
+ * @function 获取当前应用程序音量
+ * @return Promise | void
+ */
+export const getSpeakerSimpleVolume = () => {
+  return callMethod('GetSpeakerSimpleVolume', {
+    deviceId: usingAudioDeviceId.speaker
+  });
+};
+
+/**
+ * @function 设置视频预览载体 view
+ * @param idx:Number 直播通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setPreviewView = (idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('SetPreviewView', {
+    idx
+  });
+};
+
+/**
+ * @function 设置本地预览视频视图的模式
+ * @param mode:Number 模式，必选，0 | 1 | 2
+ * 0：等比缩放，可能有黑边
+ * 1：等比缩放填充整View，可能有部分被裁减
+ * 2：填充整个View
+ * @param idx:Number 直播通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setPreviewViewMode = (mode, idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('SetPreviewViewMode', {
+    mode,
+    idx
+  });
+};
+
+/**
+ * @function 开启预览
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const startPreview = (idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('StartPreview', {
+    idx
+  });
+};
+
+/**
+ * @function 停止预览
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const stopPreview = (idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('StopPreview', {
+    idx
+  });
+};
+
+/**
+ * @function 设置当前应用程序音量
+ * @param volume:Number 应用程序音量，必选
+ * @return Promise | void
+ */
+export const setSpeakerSimpleVolume = (volume) => {
+  return callMethod('SetSpeakerSimpleVolume', {
+    deviceId: usingAudioDeviceId.speaker,
+    volume
+  });
+};
+
+/**
+ * @function 设置当前应用程序静音
+ * @param mute:Boolean 是否静音，必选
+ * @return Promise | void
+ */
+export const setSpeakerSimpleMute = (mute) => {
+  return callMethod('SetSpeakerSimpleMute', {
+    deviceId: usingAudioDeviceId.speaker,
+    mute
+  });
+};
+
+/**
+ * @function 开启本地或者远程的视频视图
+ * @param isLocal:Boolean 是否是本地的视频预览，必选
+ * @param streamId:String 要拉取的视频流的 id，可选，只有拉取远程的视频流的时候才是必选的
+ * @param domId:String <video> 标签的 id，可选
+ * 如果传了 domId，就把视频绑定到对应的 <video> 标签上
+ * @return Promise 可从 Promise 中获取 src，Promise.then((src) => {})
+ */
+export const startLocalOrRemotePreview = async (isLocal, streamId, domId, isTeacherNewWindowPreview) => {
+  defaultApi.writeLog(`${streamId}----streamId-zego----`);
+  let playChannel = null;
+  let isUpdateChromeVersion = await util.getChromeVersion();
+  // zego 的本地视频预览必须使用 -1 通道，为了与远程的视频预览兼容使用，此处需要判断是否是本地预览
+  if (isLocal) {
+    playChannel = -1;
+  } else {
+    playChannel = streamIdToPreviewId[streamId];
+  }
+  const externalConstraints = {
+    audio: false,
+    video: {
+      mandatory: {
+        chromeMediaSource: 'external',
+        chromeMediaSourceId: `ems://zego/${isLocal || isTeacherNewWindowPreview ? -1 : streamId}`
+      }
+    }
+  };
+  defaultApi.writeLog(`avsdk ZEGO::startLocalOrRemotePreview streamId: ${streamId} uiChnIndex: ${playChannel}`);
+
+  return new Promise((resolve, reject) => {
+    const handleExternalSuccess = (stream) => {
+      defaultApi.writeLog(`${stream}----stream-zego----`);
+      stream.oninactive = () => {
+        defaultApi.writeLog('Stream inactive');
+      };
+      const src = isUpdateChromeVersion ? stream : window.URL.createObjectURL(stream);
+      if (domId && document.querySelector(domId)) {
+        if (isUpdateChromeVersion) {
+          document.querySelector(domId).srcObject = src;
+        } else {
+          document.querySelector(domId).src = src;
+        }
+      }
+      defaultApi.writeLog(`setVidoeSrc, streamId:${streamId}, domId: ${domId}, src: ${src}`);
+      resolve(src);
+    };
+
+    const handleExternalError = (error) => {
+      if (error.name === 'ConstraintNotSatisfiedError') {
+        console.error('ConstraintNotSatisfiedError');
+      } else if (error.name === 'PermissionDeniedError') {
+        console.error(
+          'Permissions have not been granted to use your camera and ' +
+          'microphone, you need to allow the page access to your devices in ' +
+          'order for the demo to work.'
+        );
+      }
+      console.error(`getUserMedia error: ${error.name}`, error);
+      if (domId) {
+        document.querySelector(domId).src = '';
+      }
+      reject('');
+    };
+
+    if (navigator.webkitGetUserMedia) {
+      navigator.webkitGetUserMedia(
+        externalConstraints,
+        handleExternalSuccess,
+        handleExternalError
+      );
+    }
+  });
+};
+
+/**
+ * @function 设置本地预览以及推流的视频帧率
+ * @param nFps:Number 帧率，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setVideoFPS = (nFps, idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('SetVideoFPS', {
+    nFps,
+    idx
+  });
+};
+
+/**
+ * @function 设置本地预览以及推流的视频码率
+ * @param nBitrate:Number 码率，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setVideoBitrate = (nBitrate, idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('SetVideoBitrate', {
+    nBitrate,
+    idx
+  });
+};
+
+/**
+ * @function 设置本地预览以及推流的音频码率
+ * @param bitrate:Number 码率，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setAudioBitrate = (bitrate, idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('SetAudioBitrate', {
+    bitrate,
+    idx
+  });
+};
+
+/**
+ * @function 设置本地预览的视频分辨率
+ * @param nWidth:Number 分辨率宽，必选
+ * @param nHeight:Numnber 分辨率高，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setCameraParam = async (nWidth, nHeight, idx) => {
+  defaultApi.writeLog(`avsdk ZEGO::setCameraParam ${nWidth}--${nHeight}`);
+  await enableCamera(false);
+  await setVideoCaptureResolution(nWidth, nHeight, idx);
+  return enableCamera(true);
+};
+
+/**
+ * @function 设置本地预览的视频分辨率
+ * @param nWidth:Number 分辨率宽，必选
+ * @param nHeight:Numnber 分辨率高，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setVideoCaptureResolution = async (nWidth, nHeight, idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  await setCapturePipelineScaleMode();
+  return callMethod('SetVideoCaptureResolution', {
+    nWidth,
+    nHeight,
+    idx
+  });
+};
+
+export const setCapturePipelineScaleMode = () => {
+  return callMethod('SetCapturePipelineScaleMode', {
+    scaleMode: 1
+  });
+};
+
+/**
+ * @function 设置推流的视频分辨率
+ * @param nWidth:Number 分辨率宽，必选
+ * @param nHeight:Numnber 分辨率高，必选
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const setVideoEncodeResolution = (nWidth, nHeight, idx) => {
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  return callMethod('SetVideoEncodeResolution', {
+    nWidth,
+    nHeight,
+    idx
+  });
+};
+
+/**
+ * @function 初始化
+ * @param args:Object
+ * {
+ *   extensionVersion,    // String，扩展版本号，必选
+ *   appId,               // String，Zego 秘钥，必选
+ *   appSignature,        // String，签名，必选
+ *   businessType,        // Number，业务类型，必选
+ *   userId,              // Number，用户 id，必选
+ *   userName,            // String，用户名，必选
+ *   roomId,              // String，频道（房间） id，必选
+ *   nNetType             // Number，网络类型，可选，默认为 1
+ * }
+ * classMode  0:小组课及其他   1：小班课  2：组合小班课
+ * @return Promise
+ */
+export const init = async (args) => {
+  defaultApi.writeLog(`avsdk ZEGO::init ${JSON.stringify(args)}`);
+  currentRole = args.role;
+  currentClassMode = args.classMode;
+  currentGroupSdkType = args.sdkTypeGroup;
+  localStreamId = args.streamId;
+  await loadZego(args.extensionVersion);
+  if (args.role === 'teacher' && args.mode === 1) {
+    //坐立模式开启外部采集器，站立关闭外部采集器,只有小组课坐立模式才会调用，通过这个把rtmp数据给到zego或者rtc(头像),开启了外部采集，zego不会再本地采集数据
+    await setVideoCaptureFactory(true);
+  }
+  // if (args.classMode === 1 || args.classMode === 2){
+  //   //如果是小班课保证关闭外部采集器，小组课上一步打开
+  //   await setVideoCaptureFactory(false);
+  // };
+  // 注册回调
+  addListener(args.userId, args.userName, args.confId, args.nNetType, args.devices, args.role);
+  //rtc同屏以及高光时刻,都开启音频外部采集,默认传1
+  if (args.role === 'teacher') {
+    defaultApi.writeLog('avsdk ZEGO::init_ open setAudioAuxSource');
+    if (args.classMode === 1 || args.classMode === 2) {
+      await setAudioAuxSource(1);
+    }
+  }
+
+  if (args.mode === 1 && ((isZegoGroupClass() && (args.role === 'teacher' || args.role === 'assistant')) || (isZegoCombinationClass() && args.role === 'assistant'))) {
+    //zego推拉RTMP小组课，授课端坐立模式、辅导端坐立模式 或 zego推拉RTMP组合小班辅导端坐立模式，需要将摄像头渲染模式设置为 内部渲染+外部渲染
+    await startEngine(args.appId, args.appSignature, args.businessType, 5); //5为摄像头内部渲染+外部渲染
+  } else {
+    await startEngine(args.appId, args.appSignature, args.businessType); //默认为摄像头外部渲染
+  }
+  
+  //小班课 需要加载采集插件的输入数据,为了拼接zego头像
+  if ((args.classMode === 1 || args.classMode === 2) && args.role === 'teacher') {
+    screenStreamId = `${window.zbzt_sdk_init_params.institutionId}_${args.roomId}_${args.userId}_${args.live_id}_1`;
+    loadCollectionInputEntry();
+  };
+  if (args.noiseSuppressMode == -2) {
+    defaultApi.writeLog(`noiseSuppressMode 关闭噪声消除 ${args.noiseSuppressMod}`);
+    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);
+    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);
+  };
+  await setVideoBitrate(args.encodeCaptureBitrate);
+  await setAudioBitrate(args.encodeCaptureBitrate);
+  await setVideoFPS(args.encodeCaptureFps);
+  await setVideoCaptureResolution(args.previewResolutionWidth, args.previewResolutionHeight);
+  await setVideoEncodeResolution(args.encodedResolutionWidth, args.encodedResolutionHeight);
+
+  if ((isZegoGroupClass() && (args.role === 'teacher' || args.role === 'assistant')) || (isZegoCombinationClass() && args.role === 'assistant')) {
+    defaultApi.writeLog('zego小组课或辅导端组合小班课,用第二路推RTMP流,在pyzx初始化采集参数');
+  } else {
+    await setVideoBitrate(args.screenSameBitrate,1);
+    await setVideoFPS(args.screenSameFps, 1);
+    await setVideoCaptureResolution(args.screenSameResolutionWidth, args.screenSameResolutionHeight, 1);
+    await setVideoEncodeResolution(args.screenSameResolutionWidth, args.screenSameResolutionHeight, 1);
+  }
+
+  // await setVideoBitrate(500000);
+  // await setAudioBitrate(500000);
+  // await setVideoFPS(15);
+  // await setVideoCaptureResolution(1280, 720);
+  // await setVideoEncodeResolution(1280, 720);
+  await setSoundLevelMonitorCycle(500);
+  if (isInitFinished) {
+    defaultApi.writeLog(`avsdk ZEGO::init_isInitFinished ${isInitFinished}`);
+    // await afterInitSDK(args.userId, args.userName, args.roomId, args.nNetType, JSON.parse(JSON.stringify(args.devices)));
+    isInitFinished = 0;
+    window.current_sdk_type = 'zego';
+    defaultApi.writeLog('zego init finished current_sdk_type : zego');
+  } else {
+    await new Promise((resolve, reject) => {
+      let timer = null;
+      timer = setInterval(() => {
+        if (isInitFinished) {
+          isInitFinished = 0;
+          clearInterval(timer);
+          resolve();
+        }
+      }, 30);
+    });
+    window.current_sdk_type = 'zego';
+    defaultApi.writeLog('zego init finished current_sdk_type : zego');
+  }
+};
+
+/**
+ * @function 在OnInitSDK事件之后调用的初始化方法
+ * @param userId:Number 用户 id，必选
+ * @param userName:String 用户名，必选
+ * @param roomId:String 频道（房间） id，必选
+ * @param nNetType:Number 网络类型，可选，默认为 1
+ * @return Promise
+ */
+const afterInitSDK = async (userId, userName, confId, nNetType, devices, role, classMode) => {
+  // 指定默认设备
+  const usedDevices = window.zbztAVSDK_device_checker_init;
+  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) || ''
+  };
+  defaultApi.writeLog('avsdk ZEGO::afterInitSDK');
+  await setDefaultDevice(_devices, 'default');
+  await loginChannel(userId, userName, confId, nNetType);
+  //设置拉流质量监控周期
+  await setPlayQualityMoniterCycle(5000);
+  await setPublishQualityMoniterCycle(5000);
+  await setMediaSideFlags();
+  defaultApi.writeLog(`test: isZegoGroupClass, ${isZegoGroupClass()}`);
+  if ((isZegoGroupClass() && (role === 'teacher' || role === 'assistant')) || (isZegoCombinationClass() && role === 'assistant')) {
+    defaultApi.writeLog(`avsdk ZEGO::afterInitSDK zegoRtmp, classMode: ${classMode} role: ${role}`);
+  } else {
+    // 初始化的时候不打开摄像头
+    await enableCamera(false);
+    // 只有调用了这个方法之后才开启关闭摄像头才有效
+    await startPreview();
+  }
+  // 置为 1 表示初始化完成
+  isInitFinished = 1;
+};
+
+const deviceCheckerInitSDK = async () => {
+  defaultApi.writeLog('avsdk ZEGO::deviceCheckerInitSDK');
+  await enableCamera(false);
+  await startPreview();
+  isDeviceCheckInitFinished = 1;
+};
+
+const getDeviceCheckInitStatus = () => {
+  return isDeviceCheckInitFinished;
+};
+
+const setDeviceCheckInitStatus = () => {
+  isDeviceCheckInitFinished = 0;
+}
+
+//设置是否发送sei
+const setMediaSideFlags = (bStart = true, bOnlyAudioPublish = false, mediaInfoType = 2, seiSendType = 1, idx = 0) => {
+  return callMethod('SetMediaSideFlags', { bStart, bOnlyAudioPublish, mediaInfoType, seiSendType, idx });
+};
+//设置拉流质量监控周期
+const setPlayQualityMoniterCycle = (timeInMS) => {
+  return callMethod('SetPlayQualityMoniterCycle', { timeInMS });
+};
+
+//设置推流质量监控周期
+const setPublishQualityMoniterCycle = (timeInMS) => {
+  return callMethod('SetPublishQualityMoniterCycle', { timeInMS });
+};
+
+/**
+ * @function 设置默认的硬件设备，包括摄像头、麦克风以及扬声器
+ * @return Promise
+ */
+export const setDefaultDevice = async (devices, operationType) => {
+  // 设置默认的摄像头
+  if (devices && devices.camera) {
+    if (zbztAVSDK_device_checker_init.camera.list.length == 0) {
+      await getVideoDeviceList();
+    }
+    await setVideoDevice({ deviceId: devices.camera, operationType: `${operationType}_1` });
+  } else {
+    const cameraData = await getVideoDeviceList();
+    if (cameraData.length) {
+      let hasSetCamera = false;
+      for (let item of cameraData) {
+        if (item.isDefault) {
+          await setVideoDevice({ deviceId: item.deviceId, operationType: `${operationType}_2` });
+          hasSetCamera = true;
+          break;
+        }
+      }
+      if (!hasSetCamera) {
+        await setVideoDevice({ 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();
+    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` });
+      }
+    }
+  }
+  // 设置默认的扬声器
+  if (devices && devices.speaker) {
+    await setSpeakerDevice({ deviceId: devices.speaker, operationType: `${operationType}_1` });
+  } else {
+    const speakerData = await getSpeakerDeviceList();
+    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 title:String 直播的名称，可选，默认为 ''
+ * @param flag:Number 直播属性，可选，默认为 0
+ * @param seq:Number 请求序号，可选，默认为 0
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const startPublish2 = async (streamid, idx, title, flag, seq) => {
+  const streamId = streamid || window.zbztAVSDK_init_params.zego.streamId;
+  if (typeof title === 'undefined') {
+    title = 'none';
+  }
+  if (typeof flag === 'undefined') {
+    flag = 0;
+  }
+  if (typeof seq === 'undefined') {
+    seq = 0;
+  }
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  await new Promise((resolve, reject) => {
+    let timer = setInterval(() => {
+      if (hasLoginChannel) {
+        clearInterval(timer);
+        resolve();
+      }
+    }, 30);
+  });
+  let res = await callMethod('StartPublish2', {
+    pszStreamID: streamId,
+    pszTitle: title,
+    seq,
+    idx,
+    flag
+  });
+  await startSoundLevelMonitor();
+  await new Promise((resolve, reject) => {
+    let timer = setInterval(() => {
+      if (hasPushFlow) {
+        clearInterval(timer);
+        resolve();
+      }
+    }, 300);
+  });
+  // 心跳开始
+  if (!isFirstHeartBeatReport) {
+    isFirstHeartBeatReport = true;
+    heartBeatDataReport('start');
+  }
+  return res;
+};
+
+/**
+ * @function 结束推流
+ * @param msg:String 自定义信息，server 对接流结束回调包含此字段内容，可选，默认为 'none'
+ * @param flag:Number 直播属性，可选，默认为 0
+ * @param idx:Number 推流通道，可选，默认为 0
+ * @return Promise | void
+ */
+export const stopPublish = (idx, msg, flag) => {
+  if (typeof msg === 'undefined') {
+    msg = 'none';
+  }
+  if (typeof flag === 'undefined') {
+    flag = 0;
+  }
+  if (typeof idx === 'undefined') {
+    idx = 0;
+  }
+  // try {
+  //   dataReport.stopPublish({publish_streamid:window.zbztAVSDK_init_params.zego.streamId});
+  // } catch (error) {}
+  return callMethod('StopPublish', {
+    pszMsg: msg,
+    flag,
+    idx
+  });
+};
+
+/**
+ * @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(`ZEGO:: initPullFlow_start ,streamId :${streamId}`);
+  let playChannel;
+  resetStreamIdRtcPlayerInfo1(streamId);
+  resetStreamIdRtcPlayerInfo(streamId);
+  try {
+    if (!isFirstHeartBeatReport) {
+      isFirstHeartBeatReport = true;
+      heartBeatDataReport('start');
+    }
+  } catch (error) { }
+  if (streamIdToPreviewId[streamId] == undefined) {
+    // if (typeof zegoCallback === 'function' && uiChnIndexs.length === 0) {
+    //   zegoCallback({
+    //     type: 'over_max_connect',
+    //     data: {
+    //       message: 'ZEGO:: all uiChnIndexs are used'
+    //     }
+    //   });
+    // }
+    defaultApi.writeLog(`ZEGO::  The streamId queue does not contain this streamId ${uiChnIndexs}`);
+    if (uiChnIndexs.length === 0) {
+      NOTICE.overMaxConnect();
+      defaultApi.writeLog('error', `ZEGO:: all uiChnIndexs are used ${uiChnIndexs}`);
+      return {
+        videoSrc: '',
+        playerId: -2
+      };
+    }
+    playChannel = uiChnIndexs.pop();
+    streamIdToPreviewId[streamId] = playChannel;
+    defaultApi.writeLog(`streamIdIsNoExited ${playChannel} ${uiChnIndexs}`);
+  } else {
+    playChannel = streamIdToPreviewId[streamId];
+    defaultApi.writeLog(`ZEGO::  The streamId queue contains this streamId ${playChannel} ${uiChnIndexs}`);
+    await stopPlayStream(streamId);
+    resetStreamIdRtcPlayerInfo(streamId);
+  }
+  // 判断是否创建或者获取播放通道成功，不成功就删掉重试
+  if (playChannel == undefined) {
+    delete streamIdToPreviewId[streamId];
+    defaultApi.writeLog('error', 'ZEGO::  uiChnIndex is not exist');
+    // delete streamIdToBlobUrl[streamId];
+    return initPullFlow(streamId, domId, mute, pInfo, notAutoPlay, audioOnly);
+  }
+  previewIdToStreamId[playChannel] = streamId;
+  //是否拉取声音
+  activateAudioPlayStream(streamId, !!!mute);
+  //是否拉取画面
+  activateVideoPlayStream(streamId, !!!audioOnly);
+  if (!notAutoPlay) {
+    await playStream(streamId, playChannel, pInfo);
+  }
+  const videoSrc = await startLocalOrRemotePreview(false, streamId, domId);
+  return {
+    videoSrc,
+    playerId: playChannel
+  };
+};
+
+/**
+ * @function 恢复拉指定的流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param uiChnIndex:Number 播放通道，可选
+ * @param pInfo:String 多媒体流附加信息，可选，默认为 'none'
+ * @return Promise | void
+ */
+export const playStream = (streamId, uiChnIndex, pInfo) => {
+  if (typeof uiChnIndex === 'undefined') {
+    uiChnIndex = streamIdToPreviewId[streamId];
+  }
+  if (typeof pInfo === 'undefined') {
+    pInfo = 'none';
+  }
+  defaultApi.writeLog(`avsdk ZEGO::PlayStream streamId: ${streamId} uiChnIndex: ${uiChnIndex}`);
+  return callMethod('PlayStream', {
+    pszStreamID: streamId,
+    uiChnIndex,
+    pInfo
+  });
+};
+
+/**
+ * @function 停止拉指定的流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param recovery:Boolean 是否回收播放器， 可选
+ * @return Promise | void
+ */
+export const stopPlayStream = async (streamId, recovery) => {
+  const id = streamIdToPreviewId[streamId];
+  delete streamIdRtcPlayerInfo[streamId];
+  if (recovery && id && !uiChnIndexs.includes(id)) {
+    uiChnIndexs.push(id);
+    defaultApi.writeLog(`avsdk ZEGO::stopPlayStream streamId: ${streamId} id: ${id} uiChnIndexs: ${uiChnIndexs}`);
+    delete streamIdToPreviewId[streamId];
+    // delete streamIdToBlobUrl[streamId];
+  }
+  return callMethod('StopPlayStream', {
+    pszStreamID: streamId
+  });
+};
+
+/**
+ * @function 停止并回收所有拉流
+ * @return Promise | void
+ */
+export const stopAllPlayStream = () => {
+  const toRecoveryArr = [];
+  for (let streamId in streamIdToPreviewId) {
+    if (streamIdToPreviewId.hasOwnProperty(streamId)) {
+      const id = streamIdToPreviewId[streamId];
+      if (id && !uiChnIndexs.includes(id)) {
+        uiChnIndexs.push(id);
+        toRecoveryArr.push(callMethod('StopPlayStream', {
+          pszStreamID: streamId
+        }));
+      }
+    }
+  }
+  defaultApi.writeLog(`avsdk ZEGO::stopAllPlayStream uiChnIndexs: ${uiChnIndexs}`);
+  streamIdToPreviewId = {};
+  return Promise.all(toRecoveryArr);
+};
+
+/**
+ * @function 切换播放流
+ * @param streamId:String 需要停止流的 id，必选
+ * @param toStreamId:String 被拉取的流的 id，必选
+ * @param toDomId:String <video> 标签的 id，可选
+ * @return Promise | void
+ */
+export const changePullFlow = async (streamId, toStreamId, toDomId) => {
+  await stopPlayStream(streamId, true);
+  return initPullFlow(toStreamId, toDomId);
+};
+
+/**
+ * @function 转推，录课
+ * @param type:String 必选，'start' | 'stop'
+ * @param seq:Number 可选，默认为 1
+ * @return Promise | void
+ */
+export const mixStream = (type, args, seq) => {
+  if (!args) {
+    const zego = window.zbztAVSDK_init_params.zego;
+    const streamId = zego.streamId;
+    const sid = zego.sid;
+    let pInputStreamList;
+    let nInputStreamCount;
+    if (type === 'start') {
+      pInputStreamList = [{
+        szStreamID: streamId,
+        layout: {
+          top: 0,
+          right: zego.previewResolutionWidth,
+          bottom: zego.previewResolutionHeight,
+          left: 0
+        },
+        uSoundLevelID: 0,
+        nContentControl: 0
+      }];
+      nInputStreamCount = 1;
+    }
+    if (type === 'stop') {
+      pInputStreamList = [];
+      nInputStreamCount = 0;
+    }
+    if (typeof seq === 'undefined') {
+      seq = 1;
+    }
+
+    return callMethod('MixStream', {
+      config: {
+        szOutputStream: zego.recordUrl + '/' + sid,
+        bOutputIsUrl: true,
+        nOutputFps: zego.previewCaptureFps,
+        nOutputBitrate: zego.previewCaptureBitrate,
+        nOutputAudioBitrate: zego.previewCaptureBitrate,
+        nOutputWidth: zego.previewResolutionWidth,
+        nOutputHeight: zego.previewResolutionHeight,
+        nOutputAudioConfig: 1,
+        pInputStreamList,
+        nInputStreamCount,
+        pUserData: '',
+        nLenOfUserData: 0,
+        nChannels: 0,
+        nOutputBackgroundColor: 0,
+        pOutputBackgroundImage: '',
+        bWithSoundLevel: false
+      },
+      seq
+    });
+  } else {
+    return callMethod('MixStream', args);
+  }
+
+};
+
+/**
+ * @function 是否拉取音频流--通过流id控制
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param bActive:Boolean true -> 拉取，false -> 不拉取，必选
+ * @return Promise | void
+ */
+export const activateAudioPlayStream = (streamId, bActive) => {
+  streamIdRtcPlayerInfo1[streamId].audio_type = bActive;
+  return callMethod('ActivateAudioPlayStream', {
+    nChannelIdx: streamIdToPreviewId[streamId],
+    bActive
+  });
+};
+
+/**
+ * @function 是否拉取音频流--通过播放器id控制
+ * @param operation:Boolean，必选，true -> 拉取，false -> 不拉取，必选
+ * @param playerId:Number，必选，播放器id
+ * @return Promise | void
+ */
+export const pullAudioFlow = (playerId, operation, streamid) => {
+  defaultApi.writeLog(`pullAudioFlow -- playerId ${playerId} operation ${operation} streamId ${streamid}`);
+  if (streamid) {
+    if (streamIdToPreviewId[streamid] == undefined) {
+      NOTICE.pullAudioFlowError({ streamid })
+      return;
+    } else {
+      playerId = streamIdToPreviewId[streamid]
+      defaultApi.writeLog(`pullAudioFlow-playerId ${playerId}`);
+    }
+  }
+  let streamId = previewIdToStreamId[playerId];
+  try {
+    streamIdRtcPlayerInfo1[streamId].audio_type = operation;
+    defaultApi.writeLog(`pullAudioFlow ${streamId}`);
+  } catch (e) {
+    defaultApi.writeLog(`pullAudioFlow ${streamId} --error ${JSON.stringify(e)}`, null, 'error');
+  }
+  try {
+    dataReport.setPullVoice({
+      code: +operation,
+      pull_uid: util.getUidByStreamId(streamId),
+      pull_streamid: streamId,
+      playerId
+      // operator:'client'
+    });
+  } catch (e) { };
+  return callMethod('ActivateAudioPlayStream', {
+    bActive: operation,
+    nChannelIdx: playerId
+  });
+};
+
+/**
+ * @function 是否拉取画面流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param bActive:Boolean true -> 拉取，false -> 不拉取，必选
+ * @return Promise | void
+ */
+export const activateVideoPlayStream = (streamId, bActive) => {
+  try {
+    streamIdRtcPlayerInfo1[streamId].video_type = bActive;
+    defaultApi.writeLog(`'activateVideoPlayStream ${streamId}`);
+  } catch (e) {
+    defaultApi.writeLog(`activateVideoPlayStream ${streamId} --error ${JSON.stringify(e)}`, null, 'error');
+  }
+  return callMethod('ActivateVideoPlayStream', {
+    nChannelIdx: streamIdToPreviewId[streamId],
+    bActive
+  });
+};
+
+/**
+ * @function 开启/关闭麦克风音量回调
+ * @param open:Boolean true -> 开启，false -> 关闭，必选
+ * @return void
+ */
+export const openMicVolumeCb = (open) => {
+  // if (open) {
+  //   runMicVolumeCb = true;
+  // } else {
+  //   runMicVolumeCb = false;
+  // }
+};
+
+/**
+ * @function 监听设备的音量变化
+ * @param deviceType:Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @param deviceId:String 音频设备 id，必选
+ * @return Promise | void
+ */
+export const setAudioVolumeNotify = (deviceType, deviceId) => {
+  return callMethod('SetAudioVolumeNotify', {
+    deviceType,
+    deviceId
+  });
+};
+
+/**
+ * @function 关闭监听设备的音量变化
+ * @param deviceType:Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @param deviceId:String 音频设备 id，必选
+ * @return Promise | void
+ */
+export const stopAudioVolumeNotify = (deviceType, deviceId) => {
+  return callMethod('StopAudioVolumeNotify', {
+    deviceType,
+    deviceId
+  });
+};
+
+/**
+ * @function 启动 soundLevel 监听
+ * StartSoundLevelMonitor 后一定要 StopSoundLevelMonitor
+ * @return Promise | void
+ */
+export const startSoundLevelMonitor = () => {
+  return callMethod('StartSoundLevelMonitor', {});
+};
+
+/**
+ * @function 停止 soundLevel 监听
+ * @return Promise | void
+ */
+export const stopSoundLevelMonitor = () => {
+  return callMethod('StopSoundLevelMonitor', {});
+};
+
+/**
+ * @function 设置 soundLevel 的监控周期
+ * @param timeInMS:Number 时间周期，单位为毫秒，取值范围 [100, 3000]，必选
+ * @return Promise | void
+ */
+export const setSoundLevelMonitorCycle = (timeInMS) => {
+  return callMethod('SetSoundLevelMonitorCycle', {
+    timeInMS
+  });
+};
+
+/**
+ * @function 单路录制
+ * @param type:String start/stop,必选
+ * @param szOutputStream:转推地址（支持rtmp/avertp）,必选
+ * @param szStreamID:推流ID,必选
+ * @return Promise | void
+ */
+/*export const singleRecord = async (type, szOutputStream, szStreamID, seq = 1) => {
+  defaultApi.writeLog(`avsdk ZEGO::singleRecord szStreamID: ${szStreamID} szOutputStream: ${szOutputStream} type: ${type}`);
+  const zego = window.zbztAVSDK_init_params.zego;
+  let pInputStreamList = [];
+  let nInputStreamCount = 0;
+  if (type === 'start') {
+    pInputStreamList = [{
+      szStreamID,
+      layout: {
+        top: 0,
+        right: zego.previewResolutionWidth,
+        bottom: zego.previewResolutionHeight,
+        left: 0
+      },
+      uSoundLevelID: 0,
+      nContentControl: 0
+    }];
+    nInputStreamCount = 1;
+  }
+  return callMethod('MixStream', {
+    config: {
+      szOutputStream,
+      bOutputIsUrl: true,
+      nOutputFps: zego.previewCaptureFps,
+      nOutputBitrate: zego.previewCaptureBitrate,
+      nOutputAudioBitrate: zego.previewCaptureBitrate,
+      nOutputWidth: zego.previewResolutionWidth,
+      nOutputHeight: zego.previewResolutionHeight,
+      nOutputAudioConfig: 1,
+      pInputStreamList,
+      nInputStreamCount,
+      pUserData: '',
+      nLenOfUserData: 0,
+      nChannels: 0,
+      nOutputBackgroundColor: 0,
+      pOutputBackgroundImage: '',
+      bWithSoundLevel: false
+    },
+    seq
+  });
+};
+*/
+export const hasStream = streamId => {
+  return Object.keys(streamIdToPreviewId).includes(streamId);
+};
+
+/**
+ * @function 获取当前视频流的通道
+ * @param  streamId 流 id
+ * @return channelIndex
+ */
+export const getChannelIndex = (streamId) => {
+  defaultApi.writeLog(`ZEGO : getChannelIndex  streamId: ${streamId} ${JSON.stringify(streamIdToPreviewId)}`);
+  return streamIdToPreviewId[streamId];
+};
+
+/**
+ * @function 获取当前视频流所有的通道
+ * @param  streamId 流 id
+ * @return channelIndex
+ */
+export const getAllChannelIndex = () => {
+  defaultApi.writeLog(`ZEGO : getAllChannelIndex ${JSON.stringify(streamIdToPreviewId)}`);
+  return streamIdToPreviewId;
+};
+
+
+/**
+ * @function 录制转推对外接口
+ * @param type:String start/stop,必选
+ * @param szOutputStream:转推地址（支持rtmp/avertp）,必选
+ * @param szStreamID:推流ID,必选
+ * @return Promise | void
+ */
+export const singleRecord = async (type, szOutputStream, szStreamID) => {
+  defaultApi.writeLog(`avsdk ZEGO::recordPublishTarget szStreamID: ${szStreamID} szOutputStream: ${szOutputStream} type: ${type}`);
+  const zego = window.zbztAVSDK_init_params.zego;
+  if (!szOutputStream) {
+    const sid = zego.sid;
+    // 拼接转推地址
+    szOutputStream = zego.recordUrl + '/' + sid;
+  }
+  if (!szStreamID) {
+    szStreamID = window.zbztAVSDK_init_params.zego.streamId;
+  }
+  if (type === 'start') {
+    return addPublishTarget(szOutputStream, szStreamID);
+  }
+  if (type === 'stop') {
+    return deletePublishTarget(szOutputStream, szStreamID);
+  }
+};
+
+/**
+ * @function 开始转推
+ * @param szTarget:转推地址（支持rtmp/avertp）,必选
+ * @param szStreamID:推流ID,必选
+ * @return Promise | void
+ */
+export const addPublishTarget = async (szTarget, szStreamID) => {
+  defaultApi.writeLog(`avsdk ZEGO::addPublishTarget szStreamID: ${szStreamID} szTarget: ${szTarget}`);
+  let res = await callMethod('AddPublishTarget', {
+    strTarget: szTarget,
+    pszStreamID: szStreamID,
+  });
+  try {
+    dataReport.turnPushResult({
+      errorcode: res == 0 ? 0 : 1,
+      case: 'turn push',
+      streamid: szStreamID
+    });
+  } catch (e) { };
+  return res;
+};
+
+/**
+ * @function 结束转推
+ * @param szTarget:转推地址（支持rtmp/avertp）,必选
+ * @param szStreamID:推流ID,必选
+ * @param seqNum
+ * @return Promise | void
+ */
+export const deletePublishTarget = async (szTarget, szStreamID) => {
+  defaultApi.writeLog(`avsdk ZEGO::deletePublishTarget szStreamID: ${szStreamID} szTarget: ${szTarget}`);
+  return callMethod('DeletePublishTarget', {
+    strTarget: szTarget,
+    pszStreamID: szStreamID
+  });
+};
+
+/**
+ * @function 开始本地视频录制
+ * @param enableRecord 开始/结束
+ * @param storagePath 录制路径
+ * @return Promise | void
+ */
+export const localRecordVideo = async (enableRecord, storagePath) => {
+  defaultApi.writeLog(`avsdk ZEGO::localRecordVideo enableRecord: ${enableRecord}, storagePath: ${storagePath}`);
+  if (enableRecord) {
+    return callMethod('StartRecord', {
+      channelIndex: 0,
+      recordType: 3,
+      enableStatusCallback: true,
+      interval: 3000,
+      recordFormat: 2,
+      isFragment: false,
+      storagePath
+    });
+  } else {
+    return callMethod('StopRecord', {
+      channelIndex: 0
+    });
+  }
+};
+
+/**
+ * @function 本地音频录制
+ * @param enableRecord 开始/结束
+ * @param storagePath 录制路径
+ * @return Promise | void
+ */
+export const localRecordAudio = async (enableRecord, storagePath) => {
+  defaultApi.writeLog(`avsdk ZEGO::localRecordAudio enableRecord: ${enableRecord}, storagePath: ${storagePath}`);
+  return callMethod('EnableSelectedAudioRecord', {
+    uMask: 1,
+    nSampleRate: 16000,
+    nChannels: 1,
+    enableRecord,
+    storagePath,
+  });
+};
+/**
+ * @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) => {
+  defaultApi.writeLog(`avsdk ZEGO::startRecord fileName: ${fileName}, fileType: ${fileType}, idx: ${idx}`);
+  if (idx === 1 && !screenStreamId) {
+    defaultApi.writeLog('avsdk ZEGO::startRecord screenStreamId is null', null, 'error');
+    return;
+  }
+  if (!fileName) {
+    const fileNameMap = [localStreamId, screenStreamId, 'rtmp'];
+    fileName = `${fileNameMap[idx]}-${util.currentTimeString().replace(/:/g, '-')}`;
+  }
+  dataReport.startRecord({fileName, fileType, idx});
+  return callMethod('StartRecord', {
+    idx,
+    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) => {
+  defaultApi.writeLog(`avsdk ZEGO::stopRecord idx: ${idx}`);
+  dataReport.stopRecord({idx});
+  return callMethod('StopRecord',{idx});
+};
+/**
+ * 开启外部音频采集（通知sdk）推流前，调用此接口，publish_channel，number类型，传2代表第三路流
+ * @param {number} idx 0 | 1 | 2
+ * @returns 
+ */
+export const startCapture = async (idx) => {
+  defaultApi.writeLog(`avsdk ZEGO::startCapture idx: ${idx}`);
+  return callMethod('StartCapture',{publish_channel:idx});
+};
+/**
+ * 结束外部音频采集（通知sdk）
+ * @param {number} idx 0 | 1 | 2
+ * @returns 
+ */
+export const stopCapture = async (idx) => {
+  defaultApi.writeLog(`avsdk ZEGO::stopCapture idx: ${idx}`);
+  return callMethod('StopCapture',{publish_channel:idx});
+};
+
+/**
+ * @function 设置外部采集设备模块
+ * @param  bUseVideoCapture  是否开启外部采集设备模块
+ * @attention  必须在  InitSDK  前调用，置空必须在UninitSDK之后
+ * @return Promise | void
+ */
+const setVideoCaptureFactory = (bUseVideoCapture = false, streamChannel) => {
+  defaultApi.writeLog('info', 'avsdk ZEGO::setVideoCaptureFactory');
+  return callMethod('SetVideoCaptureFactory', {
+    bUseVideoCapture,
+    streamChannel
+  });
+};
+
+//设置音频数据来源
+const setAudioAuxSource = (source) => {
+  defaultApi.writeLog('info', 'avsdk ZEGO::setAudioAuxSource');
+  return callMethod('SetAudioAuxSource', {
+    source
+  });
+};
+
+//RTC同屏 辅助通道音频类型  0：静音 / 1:麦克风  / 2：拉流的声音  / 3：1+2 / 4：麦克风+扬声器 / 5：扬声器(不含拉流)
+const setAUXAudioType = (type) => {
+  defaultApi.writeLog('info', 'avsdk ZEGO::SetAUXAudioType');
+  return callMethod('SetAUXAudioType', {
+    type
+  });
+};
+
+//录制通道音频类型  0：静音 / 1:麦克风  / 2：拉流的声音  / 4：1+2 / 8：麦克风+扬声器（不含拉流）
+const setThirdAudioType = (type) => {
+  defaultApi.writeLog('info', 'avsdk ZEGO::SetThirdAudioType');
+  return callMethod('SetThirdAudioType', {
+    type
+  });
+};
+
+//开启音频外部采集 参数：channel   参数类型：int 通道(传1使用辅通道)
+const startAudioExCapture = (channel) => {
+  defaultApi.writeLog('info', 'avsdk ZEGO::startAudioExCapture');
+  return callMethod('StartAudioExCapture', {
+    channel
+  });
+};
+
+//加载截屏插件
+const LoadCollectionOutputEntry2 = () => {
+  defaultApi.writeLog('info', 'avsdk ZEGO::LoadCollectionOutputEntry2');
+  return callMethod('LoadCollectionOutputEntry2', {});
+};
+
+//native调用开启同屏, Web端屏幕共享
+const startMultiScreen = async () => {
+  defaultApi.writeLog('info', 'avsdk ZEGO::startMultiScreen');
+  // await setVideoCaptureFactory(true,1);
+  await LoadCollectionOutputEntry2();
+};
+
+
+/**
+ * @function 设置推流时是否发送视频数据
+ * @param  mute  true不发送（仅预览），false  发送
+ * @param  idx  推流通道索引  0表示主推流通道，默认；1表示第二路流推流通道，无法推出声音
+ * @return Promise | void (0代表设置成功，否则设置失败)
+ */
+const muteVideoPublish = (mute = true, idx = 0) => {
+  return callMethod('MuteVideoPublish', {
+    mute,
+    idx
+  });
+};
+
+/**
+ * @function 开始连麦
+ * @param mode:number 采集器默认， 默认0=站立 1=坐立
+ * @return Promise | void
+ */
+export const teacherStartLinkMic = async (mode = 0) => {
+  if (mode === 0) {
+    await muteVideoPublish(true, 0);
+    await setMicrophoneDevice({});
+    await enableMic(true);
+  } else {
+    //开始连麦后，需要打开摄像头（开启外部采集器后，不会争抢摄像头），否则学生拉到的小班流会没有画面
+    await enableCamera(true);
+    await enableMic(true);
+  }
+};
+
+/**
+ * @function 结束连麦
+ * @param mode:number 采集器默认， 默认0=站立 1=坐立
+ * @return Promise | void
+ */
+export const teacherStopLinkMic = async (mode = 0) => {
+  // if (mode === 0) {
+  //   await muteVideoPublish(false,0);
+  // } else {
+  //   await setVideoCaptureFactory(false);
+  // }
+};
+
+/**
+  * @function 设置镜像状态(预览)
+  * @param { boolean } type true=开启 false=关闭
+  * @return: Promise
+  */
+export const setMirrorStatus = (isMirror) => {
+  // return callMethod('SetPreViewMirror', { isMirror });
+  return setVideoMirrorMode(isMirror >> 0);
+};
+
+/**
+  * @function 设置拉流镜像状态
+  * @param { boolean } type true=开启 false=关闭
+  * @return: Promise
+  */
+export const setPlayViewMirror = (isMirror) => {
+  return callMethod('SetPlayViewMirror', { isMirror });
+};
+
+/**
+  * @function 设置推流镜像状态
+  * @param { boolean } id 采集器Id
+  * @param { 0 | 1 | 2 | 3 } mode 0: 预览启用镜像，推流不启用镜像; 1: 预览启用镜像，推流启用镜像; 2: 预览不启用镜像，推流不启用镜像; 3: 预览不启用镜像，推流启用镜像
+  * @return: Promise
+  */
+export const setVideoMirrorMode = (mode, idx = 0) => {
+  let realId = mode == 0 ? 2 : 1;
+  defaultApi.writeLog(`ZEGO: setVideoMirrorMode, mode: ${mode}, idx:${idx}, realId:${realId}`);
+  return callMethod('SetVideoMirrorMode', { idx, mode: realId });
+};
+
+//美颜相关
+/**
+  * @function 开启美颜
+  * @return: Promise
+*/
+export const startSenseMe = async () => {
+  return callMethod('StartSenseMe', {});
+};
+/**
+  * @function 设置美颜参数
+  * * @param { number } type  //美颜类型，1、红润强度，3、磨皮强度，4、美白强度，5、大眼，6、瘦脸，7、小脸，8、对比度强度，9、饱和度强度
+  * * @param { number } value //美颜数值，有效值范围0~100
+  * @return: Promise
+*/
+export const setBeautifyParam = async (type, value) => {
+  return callMethod('SetBeautifyParam', { type, value });
+};
+/**
+  * @function 关闭美颜
+  * @return: Promise
+*/
+export const endSenseMe = async () => {
+  return callMethod('EndSenseMe', {});
+};
+
+/**
+  * @function zego40路拉流混音接口
+  * * @param { number } mixMode //混流模式  0=关闭混流  1=开启混流
+  * * @param { array } streamIdArr //表示要突出声音的channel
+  * * @param { number } mixNum //表示要突出channel的个数， 需要与参数'channels'的数组大小相同
+  * @return: Promise
+*/
+export const setAudioMixMode = async (mixMode, streamIdArr) => {
+  let channelsArr = [];
+  if (streamIdArr.length > 0) {
+    streamIdArr.forEach(item => {
+      channelsArr.push(getChannelIndex(item));
+    });
+  }
+  return callMethod('SetAudioMixMode', { mixMode: mixMode, channels: channelsArr, num: channelsArr.length });
+};
+
+// 获取TalMedia.dll版本号
+export const getSDKVersion = async () => {
+  return callMethod('GetSDKVersion', {});
+};
+
+/**
+ * @function 获取摄像头所支持的分辨率
+ * @param deviceId:String 设备id
+ * @return Promise | void
+ */
+export const getCameraSupportedRes = (deviceId) => {
+  return callMethod('GetCameraSupportedResolution', {
+    deviceId
+  });
+};
+
+/**
+ * @function 发送SEI
+ * @param inData: String  需要传输的音视频次要信息数据，外部输入。
+ * @param dataLen: Number     数据长度，不能超过 4096 bytes
+ * @param bPacket: Bool   是否采用外部打包好的包头，填写 false。
+ * @param idx:Number 推流通道 index
+ * 调用频率不能超过帧率，假设推流采用默认帧率15 fps，即调用频率不能超过 1000/15=66.7 ms/次。
+ */
+export const sendMediaSideInfo = (info) => {
+  defaultApi.writeLog(`SendMediaSideInfo --info${info}`);
+  return callMethod('SendMediaSideInfo', {
+    inData: info,
+    dataLen: info.length,
+    bPacket: false,
+    idx: 0
+  });
+};
+
+//判断当前课型是否为zego推拉RTMP小组课
+export const isZegoGroupClass = () => {
+  defaultApi.writeLog(`test: isZegoGroupClass--currentClassMode--currentGroupSdkType', ${currentClassMode}, ${currentGroupSdkType}`);
+  return currentClassMode == 0 && currentGroupSdkType == 'zego'/*rtmp流为zego*/;
+};
+//判断当前课型是否为zego推拉RTMP组合小班课
+export const isZegoCombinationClass = () => {
+  console.log('test: isZegoCombinationClass--currentClassMode--currentGroupSdkType', currentClassMode, currentGroupSdkType);
+  return currentClassMode == 2 && currentGroupSdkType == 'zego'/*rtmp流为zego*/;
+};
+//判断推流类型是否为音频流
+export const isStreamAudioMuted = () => {
+  return callMethod('IsStreamAudioMuted', {});
+};
+//判断推流类型是否为视频流
+export const isStreamVideoMuted = () => {
+  return callMethod('IsStreamVideoMuted', {});
+};
+export const getStreamType = async () => {
+  try {
+    const pushAudio = JSON.parse((await isStreamAudioMuted()).msg).ret;
+    const pushVideo = JSON.parse((await isStreamVideoMuted()).msg).ret;
+    let stream_type = 'both';
+    if (pushAudio && !pushVideo) {
+      stream_type = 'video';
+    }
+    if (!pushAudio && pushVideo) {
+      stream_type = 'audio';
+    }
+    if (pushAudio && pushVideo) {
+      stream_type = 'none';
+    }
+    return stream_type;
+  } catch (e) {
+    let stream_type = 'none';
+    return stream_type;
+  }
+};
+
+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 = [];
+      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);
+
+        // delete streamIdRtcPlayerInfo[streamid].count;
+        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);
+      });
+      // delete heartBeatDataReportObj.count;
+      if (isFirstHeartBeatReport && rateCount > 0) {
+        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_zego,camera: ${zbztsdk.deviceStatus.camera},microphone: ${zbztsdk.deviceStatus.microphone},type: ${zbztsdk.deviceStatus.stream_type},a_fps: ${dataZegoCapture.afps}, a_bit: ${dataZegoCapture.akbps}, v_fps: ${dataZegoCapture.fps}, v_bit: ${dataZegoCapture.kbps}`);
+          // 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
+          //   });
+          // }
+        } catch (e) {
+          console.log(e);
+        }
+      }
+      resetHeartBeatDataReportObj();
+      rateCount = 0;
+      // cpuRate = 0;
+      // memRate = 0;
+      // appCpuRate = 0;
+      // appMemUsed = 0;
+
+      clearInterval(rateTimer);
+    }
+  }, 10 * 1000);
+};
+
+const heartBeatDataReport = (type) => {
+  try {
+    if (type === 'start' && !heartBeatDataReportTimer) {
+      _heartBeatDataReport();
+      heartBeatDataReportTimer = setInterval(() => {
+        _heartBeatDataReport();
+      }, 30 * 1000);
+    }
+    if (type === 'stop') {
+      clearInterval(heartBeatDataReportTimer);
+      heartBeatDataReportTimer = null;
+    }
+  } catch (error) {
+    console.log(error);
+  }
+};
+
+const heartBeatDataReportCalc = (name, _d, streamid) => {
+  // 拉流
+  const pullKeys = ['fps', 'kbps', 'afps', 'akbps'];
+  if (name === 'OnPlayQulityUpdate') {
+    if (streamIdRtcPlayerInfo && streamIdRtcPlayerInfo.hasOwnProperty(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(_d[pullKeys[index]])));
+        }
+      });
+      if (isReport) {
+        let audio_fps_zego_pull = 0;
+        let audio_bitrate_zego_pull = 0;
+        let video_fps_zego_pull = 0;
+        let video_bitrate_zego_pull = 0;
+
+        if (streamIdRtcPlayerInfo1[streamid].audio_type && streamIdRtcPlayerInfo1[streamid].video_type) {
+          audio_fps_zego_pull = parseFloat(parseInt(_d.afps));
+          audio_bitrate_zego_pull = parseFloat(parseInt(_d.akbps));
+          video_fps_zego_pull = parseFloat(parseInt(_d.fps));
+          video_bitrate_zego_pull = parseFloat(parseInt(_d.kbps));
+        } else if (!streamIdRtcPlayerInfo1[streamid].audio_type && streamIdRtcPlayerInfo1[streamid].video_type) {
+          video_fps_zego_pull = parseFloat(parseInt(_d.fps));
+          video_bitrate_zego_pull = parseFloat(parseInt(_d.kbps));
+        } else if (streamIdRtcPlayerInfo1[streamid].audio_type && !streamIdRtcPlayerInfo1[streamid].video_type) {
+          audio_fps_zego_pull = parseFloat(parseInt(_d.afps));
+          audio_bitrate_zego_pull = parseFloat(parseInt(_d.akbps));
+        }
+        streamIdRtcPlayerInfo[streamid].audio_fps.push(audio_fps_zego_pull);
+        streamIdRtcPlayerInfo[streamid].audio_bitrate.push(audio_bitrate_zego_pull);
+        streamIdRtcPlayerInfo[streamid].video_fps.push(video_fps_zego_pull);
+        streamIdRtcPlayerInfo[streamid].video_bitrate.push(video_bitrate_zego_pull);
+
+        streamIdRtcPlayerInfo[streamid].ctime.push(Math.round((new Date().getTime() + dataReport.timestamp) / 1000));
+        streamIdRtcPlayerInfo[streamid].avtimestampdiff.push(_d.avTimestampDiff);
+        streamIdRtcPlayerInfo[streamid].pull_loss.push(_d.pktLostRate);
+        streamIdRtcPlayerInfo[streamid].pull_delay.push(_d.rtt);
+      }
+    }
+  }
+  // 推流
+  const pushKeys = ['fps', 'kbps', 'afps', 'akbps'];
+  if (name === 'OnPublishQualityUpdate') {
+    // 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_zego_push = 0;
+    let audio_bitrate_zego_push = 0;
+    let video_fps_zego_push = 0;
+    let video_bitrate_zego_push = 0;
+    dataZegoCapture = _d;
+
+    if (zbztsdk.deviceStatus.camera && zbztsdk.deviceStatus.microphone) {
+      audio_fps_zego_push = parseFloat(parseInt(_d.afps));
+      audio_bitrate_zego_push = parseFloat(parseInt(_d.akbps));
+      video_fps_zego_push = parseFloat(parseInt(_d.fps));
+      video_bitrate_zego_push = parseFloat(parseInt(_d.kbps));
+    } else if (!zbztsdk.deviceStatus.camera && zbztsdk.deviceStatus.microphone) {
+      audio_fps_zego_push = parseFloat(parseInt(_d.afps));
+      audio_bitrate_zego_push = parseFloat(parseInt(_d.akbps));
+    } else if (zbztsdk.deviceStatus.camera && !zbztsdk.deviceStatus.microphone) {
+      video_fps_zego_push = parseFloat(parseInt(_d.fps));
+      video_bitrate_zego_push = parseFloat(parseInt(_d.kbps));
+    }
+    heartBeatDataReportObj.audio_fps.push(audio_fps_zego_push);
+    heartBeatDataReportObj.audio_bitrate.push(audio_bitrate_zego_push);
+    heartBeatDataReportObj.video_fps.push(video_fps_zego_push);
+    heartBeatDataReportObj.video_bitrate.push(video_bitrate_zego_push);
+
+    heartBeatDataReportObj.push_loss.push(_d.pktLostRate);
+    heartBeatDataReportObj.push_delay.push(_d.rtt);
+    heartBeatDataReportObj.ctime.push(Math.round((new Date().getTime() + dataReport.timestamp) / 1000));
+  }
+};
+//推流字段
+const resetHeartBeatDataReportObj = () => {
+  heartBeatDataReportObj = {
+    ctime: [],
+    push_type: 'none',
+    // video_fps: 0,
+    // video_bitrate: 0,
+    // audio_fps: 0,
+    // audio_bitrate: 0,
+    video_fps: [],
+    video_bitrate: [],
+    audio_fps: [],
+    audio_bitrate: [],
+    push_loss: [],
+    push_delay: [],
+    // count: 0,
+    volume: ''
+  };
+};
+
+//记录拉流类型，用作数据上报
+const resetStreamIdRtcPlayerInfo1 = (streamId) => {
+  streamIdRtcPlayerInfo1[streamId] = {
+    audio_type: false,
+    video_type: false,
+    stream_type: 'none'
+  };
+};
+
+resetHeartBeatDataReportObj();
+
+//拉流字段
+const resetStreamIdRtcPlayerInfo = (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
+  };
+};
+
+export default {
+  startEngine,
+  destroyEngine,
+  setDefaultDevice,
+  getVideoDeviceList,
+  setVideoDevice,
+  enableCamera,
+  enableMic,
+  setAudioSpeakerCapture,
+  getAudioDeviceList,
+  setAudioDevice,
+  getSpeakerDeviceList,
+  setSpeakerDevice,
+  getCurrentSpeakerDevice,
+  getSpeakerDeviceVolume,
+  setSpeakerDeviceVolume,
+  setSpeakerDeviceMute,
+  getMicrophoneDeviceList,
+  setMicrophoneDevice,
+  getMicDeviceVolume,
+  setMicDeviceVolume,
+  setMicDeviceMute,
+  getSpeakerSimpleVolume,
+  setSpeakerSimpleVolume,
+  setSpeakerSimpleMute,
+  setPreviewView,
+  startPreview,
+  startLocalOrRemotePreview,
+  setVideoFPS,
+  setVideoBitrate,
+  setAudioBitrate,
+  setVideoCaptureResolution,
+  setCameraParam,
+  setVideoEncodeResolution,
+  init,
+  startPublish2,
+  stopPublish,
+  initPullFlow,
+  playStream,
+  stopPlayStream,
+  stopAllPlayStream,
+  leaveRoom,
+  activateAudioPlayStream,
+  pullAudioFlow,
+  activateVideoPlayStream,
+  setAudioVolumeNotify,
+  stopAudioVolumeNotify,
+  openMicVolumeCb,
+  startSoundLevelMonitor,
+  stopSoundLevelMonitor,
+  setSoundLevelMonitorCycle,
+  setMirrorStatus,
+  getStreamType,
+  setPlayViewMirror,
+  setMuteStreamAudio,
+  setMuteStreamVideo,
+  teacherStartLinkMic,
+  teacherStopLinkMic,
+  getSDKVersion,
+  getCameraSupportedRes,
+  setVideoMirrorMode,
+  startMultiScreen,
+  addListener,
+};