zbzt-live-sdk 0.0.2

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

@@ -0,0 +1,2854 @@
+/**
+ * @File: Rtc 音视频 SDK
+ * @Author: xuyuanrui
+ * @Email: raywhbxyr@163.com
+ * @Date: 2018-08-10 10:22:47
+ **/
+import dataReport from '../network/dataReport.js';
+import {dabanDataReport} from '../network/api.js';
+import util from '../util/util.js';
+import defaultApi from '../default/index.js';
+import toolApi from '../tool/index.js';
+import NOTICE from '../notice.js';
+import { deviceListReport } from './device.js';
+import zbztsdk from '../zbzt-live-sdk.js';
+// 扩展标识
+const extensionId = 'live';
+// 端提供的 API 入口
+const EM = window.EM;
+// 维护的一份播放器的 rtcPlayerId 与 streamId 的映射
+let streamIdToRtcPlayerId = {};
+// let streamIdToBlobUrl = {};
+let rtcPlayerIdToStreamId = {};
+// 已经停止的播放器
+let stopedRtcPlayers = [];
+// 播放器 id 缓存
+let rtcPlayerIds = [];
+// rtc 当前正在使用的摄像头的设备 id
+let rtcNowUseCamera = '';
+// 是否执行麦克风音量回调的标记
+let runMicVolumeCb = false;
+// 是否创建了用于设备检测的采集器的标记
+let deviceCheckerCaptureInit = false;
+// 是否执行过 Rtc 的 AddListener 的标志
+let hasAddListener = false;
+// 是否在课中的标志
+let isInRoom = false;
+// 是否处于网络错误状态中的标志
+let hasNetWrong = false;
+// 是否加入/离开 rtc room 成功
+let hasJoinRtcRoom = false;
+let hasLeaveRtcRoom = false;
+// rtc 底层流媒体数据上报地址配置
+
+let _confId = null;
+// rtc小班课=0；rtc大班课=1
+const classType = 0;
+// 监听id
+let EMListenerId = 0;
+
+//静音推流时，音量值是否上抛上层标志 false=没有声音不往上层通知/true=有声音有上层通知
+let isNoticeMicVolumeRtc = false;
+let isNoticeCarVolumeRtc = false;
+
+/*
+  1001--网络错误
+  1002--播放器内部错误
+  1003--调度服务器错误
+  1004--转发服务器错误
+  1005--无可用转发服务器
+  2003--对端尚未进入教室
+  2013–网络断开
+*/
+const rtcPlayerErrorCodes = ['1001', '1002', '1003', '1004', '1005', '2003', '2013', '2008', '1006'];
+
+/*
+2001-- 网络错误,通知业务层检查网络设置和推流地址, 对于直播, id与AddPushUrl返回值对应
+2002-- 网络恢复, 对于直播, id与AddPushUrl返回值对应
+2003--网络断开
+2004--转发服务器错误
+2005--调度服务器错误
+2006--无可用转发服务器
+2007--转发服务器能力不足
+2008--摄像头视频宽高错误
+2009--视频编码器初始化错误
+2010--错误的摄像头ID
+2011--错误的录音设备ID
+2012--抓屏参数错误
+2013--打开摄像头失败，一种可能是摄像头被其它进程占用
+2014–-打开麦克风失败
+2015--打开播放文件失败
+3206--推流ID被占用
+3309--只要 10 秒内和服务器无法建立连接就会触发一次且仅触发一次(仅互动流)
+*/
+const rtcCaptureErrorCodes = ['2001', '2002', '2003', '2004', '2005', '2006', '2007', '2008', '2009', '2010', '2012', '2013', '3206', '3309'];
+
+// 心跳
+let heartBeatDataReportObj = {};
+let heartBeatDataReportTimer = null;
+let isFirstHeartBeatReport = false;
+let streamIdRtcPlayerInfo = {};
+let streamIdRtcPlayerInfo1 = {};
+const rtcPlayerCodeToNames = {
+  '1002': 'err_core',
+  '1003': 'err_schedule_server',
+  '1004': 'err_relay_server',
+  '1005': 'err_no_available_relay_server',
+  '2003': 'st_streamNotReady',
+  '2013': 'network_disconnect'
+};
+
+//上报拼接状态
+//window.zbztAVSDK_init_params
+let paramInfo ;
+let captureBefore ;//运控获取，一直不变(拼接前摄像头采集分辨率)
+let captureEncodeBefore;//摄像头拼接前编码分辨率云控拿取
+let screenEncodeBefore;//截屏窗拼接前编码分辨率	东奇提供
+// let screenBefore;//拼接前截屏窗采集分辨率
+
+let captureAfter ;//一直不变(拼接前摄像头采集分辨率同上captureBefore)
+let captureEncodeAfter;//摄像头拼接后编码分辨率
+let screenEncodeAfter;//
+// let screenAfter;//
+
+let currStreamIdRtcPlayerInfo ;
+let stStreamNotReadyReport = {};
+//记录底层推流回调的值
+let dataRtcCapture = {};
+/**
+ * @function 调用端提供的回调方法
+ * @param name:String 回调方法名，必选
+ * @param args:Object 回调参数，必选
+ * @return Promise | void
+ */
+const callMethod = (name, args) => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      let noneCamera = (name === 'SetCameraDevice' && !args.close && !args.deviceID);
+      let noneMicrophone = (name === 'SetAudioDevice' && !args.deviceID);
+      let noneSpeaker = (name === 'SetSpeakerDevice' && !args.speakId);
+      if (noneCamera || noneMicrophone || noneSpeaker) {
+        return resolve();
+      }
+      EM.CallMethod(
+        extensionId,
+        name,
+        JSON.stringify({...args, classType}),
+        (code, msg) => {
+          resolve({
+            code,
+            msg
+          });
+          defaultApi.writeLog(`${name} Code: ${code}\nParams: ${JSON.stringify({...args, classType})}\nMessage: ${msg}`);
+          let _msg = msg && JSON.parse(msg);
+          // 数据上报
+          switch (name) {
+          case 'SetAppId':
+            break;
+          case 'SetConfId':
+            break;
+          case 'SetAudioDevice':
+            if (code === 0 && _msg.ret === true) {
+              window.zbztAVSDK_device_checker_init.microphone.use = args.deviceID;
+            }
+            break;
+          case 'SetCameraDevice':
+            if (code === 0 && _msg.ret === true) {
+              window.zbztAVSDK_device_checker_init.camera.use = args.deviceID;
+              if (args.deviceID) {
+                rtcNowUseCamera = args.deviceID;
+              }
+            }
+            break;
+          case 'SetSpeakerDevice':
+            if (code === 0) {
+              window.zbztAVSDK_device_checker_init.speaker.use = args.speakId;
+            }
+            break;
+          case 'CreateRtcCapture':
+            if (code === 0 && args.renderid === 'deviceCheckerInit') {
+              deviceCheckerCaptureInit = true;
+            }
+            break;
+          }
+        }
+      );
+    });
+  }
+};
+
+/**
+ * @function 加载 Rtc 扩展
+ * @param extensionVersion:String 扩展版本号，必选
+ * @return Promise | void
+ */
+export const loadRtc = (extensionVersion, cb) => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      removerListener();
+      EM.Load(
+        extensionId,
+        extensionVersion,
+        false,
+        (code, msg) => {
+          defaultApi.writeLog(`loadRtc Code: ${code}\nMessage: ${msg}`);
+          addListener();
+          resolve();
+        }
+      );
+    });
+  }
+};
+
+/**
+ * @function 卸载 Rtc 扩展
+ * @return Promise | void
+ */
+export const unloadRtc = () => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM) {
+    return new Promise((resolve, reject) => {
+      EM.UnLoad(
+        extensionId,
+        (code, msg) => {
+          defaultApi.writeLog(`unloadRtc Code: ${code}\nMessage: ${msg}`);
+          resolve();
+        }
+      );
+    });
+  }
+};
+
+/**
+ * @function 添加扩展监听机制
+ * @return void
+ */
+const addListener = () => {
+  // EM 是寄宿于端的，浏览器中并不存在，为防止报错需要先进行能力检测
+  if (EM && !hasAddListener) {
+    hasAddListener = true;
+    EM.AddListener(extensionId, (event, data) => {
+      if (data && data.indexOf(extensionId) > -1) {
+        try {
+          const _data = JSON.parse(data);
+          if (_data[extensionId] !== undefined  && EMListenerId == 0) {
+            EMListenerId = _data[extensionId];
+            defaultApi.writeLog(`RTC::addListener-- EMListenerId: ${EMListenerId}`);
+          }
+        } catch (error) {}
+      }
+      if (!event || !data) {
+        return;
+      }
+      let _d = JSON.parse(data);
+      let _e = JSON.parse(event);
+      if (_d && _d.classType === 1) {
+        return false;
+      }
+      if (_e.hasOwnProperty('event_name')) {
+        let name = _e.event_name;
+        currStreamIdRtcPlayerInfo = streamIdRtcPlayerInfo[_d.streamid];
+        switch (name) {
+        case 'deviceStateChanged':
+          {
+            const deviceType = _d.deviceType;
+            // 0=添加设备 1=移除设备 string
+            let state = _d.deviceState;
+            let deviceNameCamera = '';
+            let deviceNameMic = '';
+            let deviceNameSpeak = '';
+            switch (deviceType) {
+            // 摄像头热插拔
+            case '1':
+              {
+                setCameraDevice({deviceId: state == 1 ? '' : _d.deviceID, close: false, operationType: 'hotPlug', deviceState: state, changedDeviceId: _d.deviceID, changedDeviceName: _d.deviceName});
+                deviceNameCamera = _d.deviceName;
+              }
+              break;
+              // 麦克风热插拔
+            case '2':
+              {
+                setMicrophoneDevice({deviceId: state == 1 ? '' : _d.deviceID, operationType: 'hotPlug', deviceState: state, changedDeviceId: _d.deviceID, changedDeviceName: _d.deviceName});
+                deviceNameMic = _d.deviceName;
+              }
+              break;
+              // 扬声器热插拔，暂时不做处理
+            case '3':
+              {
+                // console.log('hsghsghsg扬声器热插拔',_d,state);
+                setSpeakerDevice({
+                  speakId: state == 1 ? '' : _d.deviceID,
+                  operationType: 'hotPlug',
+                  deviceState: state,
+                  changedDeviceId: _d.deviceID,
+                  changedDeviceName: _d.deviceName});
+                deviceNameSpeak = _d.deviceName;
+              }
+              break;
+            }
+            // try {
+            //   dataReport.deviceTest({
+            //     device: deviceType,
+            //     fore_state: state == '0' ? 1 : 2 ,
+            //     camera_name: deviceNameCamera,
+            //     microphone_name: deviceNameMic,
+            //     speaker_name: deviceNameSpeak
+            //   });
+            // } catch (e){
+            // };
+          }
+          break;
+        case 'rtcCaptureCycleDataReport'://推流 fps、bitrate
+        {
+          var keys = Object.keys(_d);
+          if (isNoticeMicVolumeRtc) {
+            if (keys.indexOf('volum') > -1
+                && window.zbztAVSDK_init_sdk_type === 'rtc') {
+              NOTICE.captureMicVolumeChanged({
+                volume: +_d.volum
+              });
+            }
+          }
+          if (keys.indexOf('volum') > -1) {
+            // heartBeatDataReportObj.volume.push(_d.volum);
+            // console.log('声音回调',`${new Date().getMinutes()}:${new Date().getSeconds()}`,_d.volum);
+            heartBeatDataReportObj.volume = heartBeatDataReportObj.volume + _d.volum + ',';
+          }
+        }
+        // 拉流
+        case 'rtcPlayCycleDataReport':
+          {
+            if (_d.errorcode && _d.errorcode == 7000) {
+              NOTICE.playerVolumeChanged({
+                userId: util.getUidByStreamId(_d.streamid),
+                streamId: _d.streamid,
+                volume: _d.volume
+              });
+              // currStreamIdRtcPlayerInfo && currStreamIdRtcPlayerInfo.volume.push(_d.volume);
+              // streamIdRtcPlayerInfo[_d.streamid] && streamIdRtcPlayerInfo[_d.streamid].volume.push(_d.volume);
+              if(streamIdRtcPlayerInfo[_d.streamid]) {
+                streamIdRtcPlayerInfo[_d.streamid].volume = streamIdRtcPlayerInfo[_d.streamid].volume + _d.volume + ',';
+              }
+            };
+            if (_d.hasOwnProperty('codecBitRate')) {
+              if (name === 'rtcPlayCycleDataReport') {
+                NOTICE.pullQuality({
+                  video: {
+                    userId: util.getUidByStreamId(_d.streamid),
+                    streamId: _d.streamid,
+                    bitrate: Math.round(_d.codecBitRate),
+                    fps: Math.round(_d.codecFrameRate),
+                    volume: _d.volume,
+                    realTimeVolume: _d.realTimeVolume
+                  }
+                });
+                NOTICE.playLossAndDelay({
+                  userId: util.getUidByStreamId(_d.streamid),
+                  delay:_d.delay,
+                  lostrate:_d.lostrate
+                });
+              }
+              if (name === 'rtcCaptureCycleDataReport') {
+                NOTICE.pushQuality({
+                  video: {
+                    bitrate: Math.round(_d.codecBitRate),
+                    fps: Math.round(_d.codecFrameRate)
+                  }
+                });
+                NOTICE.pushLossAndDelay({
+                  userId: util.getUidByStreamId(_d.streamid),
+                  delay:_d.delay,
+                  lostrate:_d.lostrate
+                });
+              }
+              heartBeatDataReportCalc(name, _d);
+            }
+            if (_d.hasOwnProperty('realTimeVolume') || _d.hasOwnProperty('volume')) {
+              NOTICE.volumeChange({
+                userId: util.getUidByStreamId(_d.streamid),
+                streamId: _d.streamid,
+                volume: _d.volume
+              });
+            }
+          }
+          break;
+        case 'OnLiveCaptureEvent':
+          break;
+        case 'OnRtcCaptureEvent':
+          {
+            if (_d && _d.hasOwnProperty('errorcode')) {
+              let code = _d.errorcode;
+              switch (code) {
+              case '1003':
+                if (window.zbztAVSDK_init_params.rtc.isTurnPush) {
+                  sendRecordingMsg({ cmd: 'start' });
+                }
+                if (hasNetWrong) {
+                  hasNetWrong = false;
+                  NOTICE.networkRecovery({
+                    message: 'Network recovery'
+                  });
+                }
+                try {
+                  dataReport.publishResult({
+                    code: '0',
+                    // publish_streamid: window.zbztAVSDK_init_params.rtc.streamId,
+                  });
+                  NOTICE.pushFlowSuccess({code:0,publish_streamid: _d.streamid});
+                } catch (e) {};
+                break;
+              case '1005': // 摄像头设备打开成功
+                // 大班数据上报
+                try {
+                  dabanDataReport({
+                    action: 'open_camera',
+                    camera_status: 1,
+                    uid: window.zbztAVSDK_init_params.rtc.userId
+                  });
+                } catch(e) {
+                }
+                break;
+              case '2011': // 摄像头设备打开失败
+                // 大班数据上报
+                try {
+                  dabanDataReport({
+                    action: 'open_camera',
+                    camera_status: 0,
+                    uid: window.zbztAVSDK_init_params.rtc.userId
+                  });
+                } catch(e){}
+                
+                break;
+              case '2008': // 错误的摄像头ID
+                setCameraDevice({deviceId: '', close: false, operationType: 'deviceError'});
+                break;
+              case '1006': // 麦克风设备打开成功
+                break;
+              case '2010': // 麦克风设备打开失败
+              case '2013': // 麦克风设备打开失败
+              case '2012': // 麦克风设备打开失败
+              case '2009': // 错误的录音设备ID
+                setMicrophoneDevice({deviceId: '', operationType: 'deviceError'});
+                break;
+                // 重试推流
+              case '2003':
+              case '2004':
+              case '2005':
+              case '2006':
+              case '2007':
+                // pushFlowExceptionHandler();
+                break;
+              case '2001':
+                hasNetWrong = true;
+                defaultApi.writeLog('error', 'Network error');
+                NOTICE.networkError({
+                  message: 'Network error'
+                });
+                break;
+              }
+              if (rtcCaptureErrorCodes.includes(code)) {
+                try {
+                  dataReport.publishResult({
+                    code: code,
+                    // publish_streamid: window.zbztAVSDK_init_params.rtc.streamId,
+                  });
+                } catch (e) {};
+              }
+            }
+          }
+          break;
+        case 'OnSingleRecordResponse':
+          {
+            NOTICE.recordResponse(_d);
+          }
+          break;
+        case 'live_recovery_start':
+          {
+            console.log('live_recovery_start');
+            NOTICE.liveRecoveryStart();
+          }
+          break;
+        case 'recordingMsg':
+          {
+            if (_d.cmd === 0) {
+              const {errorcode, streamId} = _d;
+              try {
+                dataReport.turnPushResult({
+                  errorcode,
+                  case: 'turn push',
+                  streamid: streamId
+                });
+              } catch (e) {};
+            }
+          }
+          break;
+        case 'OnRecvMediaSideInfo':
+          {
+            console.log('我是sei',_data);
+            NOTICE.seiReceived({data: _data});
+          }
+          break;
+        case 'VideoFrameInterval':
+          {
+            currStreamIdRtcPlayerInfo && (currStreamIdRtcPlayerInfo.video_ifg += _d.video_ifg);
+          }
+          break;
+        case  'AudioFrameInterval':
+          {
+            currStreamIdRtcPlayerInfo && (currStreamIdRtcPlayerInfo.audio_ifg += _d.audio_ifg);
+          }
+          break;
+        case 'OnRtcPlayError':
+          {
+            if (_d && _d.hasOwnProperty('errorcode')) {
+              let code = _d.errorcode;
+              switch (code) {
+              // 重试拉流
+              case '1002':
+              case '1003':
+              case '1004':
+              case '1005':
+              case '1006':
+              case '1007':
+                // pullFlowExceptionHandler(_d.streamid);
+                NOTICE.playError({
+                  userId: util.getUidByStreamId(_d.streamid),
+                  streamId: _d.streamid,
+                  message: 'play error'
+                });
+                break;
+              case '1001':
+                hasNetWrong = true;
+                writeLog('error', 'Network error');
+                NOTICE.networkError({
+                  message: 'Network error'
+                });
+                break;
+              }
+              if (rtcPlayerErrorCodes.includes(code)) {
+                pullResultReport(code, _d.streamid);
+              }
+              NOTICE.playErrorDetail({
+                type: rtcPlayerCodeToNames[code],
+                data: {
+                  userId: util.getUidByStreamId(_d.streamid),
+                  streamId: _d.streamid,
+                  allData: _d
+                }
+              });
+            }
+          }
+          break;
+        case 'OnRtcPlayStatus':
+          {
+            if (_d && _d.hasOwnProperty('errorcode')) {
+              const code = _d.errorcode;
+              switch (code) {
+              case '2004':
+                if (window.zbztAVSDK_init_params.rtc.role === 'student') {
+                  // 大班数据上报
+                  try {
+                    dabanDataReport({
+                      action: 'interact_play',
+                      teammate_streamid: _d.streamid,
+                      uid: window.zbztAVSDK_init_params.rtc.userId
+                    });
+                  } catch(e) {
+                  }
+                }
+                try{
+                  NOTICE.firstVideoSize({
+                    userId: util.getUidByStreamId(_d.streamid),
+                    streamId: _d.streamid,
+                    allData: _d
+                  });
+                  dataReport.firstVideoSize({
+                    pull_streamid: _d.streamid,
+                    pull_uid: util.getUidByStreamIdDr(_d.streamid),
+                    code:'0'
+                  });
+                } catch (e) { };
+                pullResultReport(0, _d.streamid);
+                defaultApi.writeLog(`RTC: pullStream success & haveFirstVideoSize  streamId: ${_d.streamid}`);
+                break;
+              case '2014':
+                try{
+                  NOTICE.firstAudioSize({
+                    userId: util.getUidByStreamId(_d.streamid),
+                    streamId: _d.streamid,
+                    allData: _d
+                  });
+                  dataReport.firstAudioSize({
+                    pull_streamid: _d.streamid,
+                    pull_uid: util.getUidByStreamIdDr(_d.streamid),
+                    code:'0'
+                  });
+                } catch (e) { };
+                break;
+              default:
+                break;
+              }
+              if (rtcPlayerErrorCodes.includes(code)) {
+                if (code == 2003) { //对端未推流
+                  let first_time_marker = new Date().getTime();
+                  if (!stStreamNotReadyReport.hasOwnProperty(_d.streamid)) {
+                    stStreamNotReadyReport[_d.streamid] = new Date().getTime();
+                    pullResultReport(code, _d.streamid);
+                  } else {
+                    if (first_time_marker - stStreamNotReadyReport[_d.streamid] >= 10*1000) {
+                      pullResultReport(code, _d.streamid);
+                      stStreamNotReadyReport[_d.streamid] = new Date().getTime();
+                    }
+                  }
+                } else {
+                  pullResultReport(code, _d.streamid);
+                }
+              };
+              NOTICE.playErrorDetail({
+                type: rtcPlayerCodeToNames[code],
+                data: {
+                  userId: util.getUidByStreamId(_d.streamid),
+                  streamId: _d.streamid,
+                  allData: _d
+                }
+              });
+            }
+          }
+          break;
+        case 'beforeCombineCapInfoMsg':
+          {
+            screenEncodeBefore = _d.width+'*'+_d.height;
+            try {
+              dataReport.splitState({
+                camera_split_start_resolution : captureBefore ,//云控取一直不变ok
+                camera_split_start_encode_resolution : captureEncodeBefore	,//摄像头拼接前编码分辨率云控拿取
+                screen_split_start_encode_resolution:	screenEncodeBefore	,//截屏窗拼接前编码分辨率	东奇提供
+                screen_split_start_resolution	:screenEncodeBefore	,//截屏窗拼接前采集分辨率
+                split:'开始拼接'
+              });
+            } catch (e){};
+          }
+          break;
+        case 'afterCombineInfoMsg':
+          {
+            captureEncodeAfter = _d.head_width+ '*'+ _d.head_height;
+            screenEncodeAfter = _d.cap_width+'*'+_d.cap_height;
+            try {
+              dataReport.splitState({
+                camera_split_end_resolution 	: captureAfter ,//云控取一直不变ok
+                camera_split_end_encode_resolution : captureEncodeAfter ,//摄像头拼接后编码分辨率
+                screen_split_end_encode_resolution: screenEncodeAfter ,//截屏窗拼接后编码分辨率
+                screen_split_end_resolution	:screenEncodeAfter,//截屏窗拼接后采集分辨率
+                split:'拼接完成'
+              });
+            } catch (e){};
+          }
+          break;
+        }
+        // 去掉声音回调日志
+        if(zbztsdk.openListenerLog) {
+          console.log(`[zbzt-live-sdk]--RTC::Listener:: event: ${name}, data: ${data}`);
+        }
+      }
+    });
+  }
+};
+
+//拉流上报
+const pullResultReport = (code, streamid) => {
+  try {
+    dataReport.pullResult({
+      code: code,
+      pull_uid: util.getUidByStreamId(streamid),
+      pull_streamid: streamid
+    });
+    NOTICE.pullFlowResult({code:code,pull_streamid: streamid});
+  } catch (e) {};
+};
+
+
+/**
+ * @function 添加扩展监听机制
+ * @return void
+ */
+const removerListener = () => {
+  hasAddListener = false;
+  defaultApi.writeLog(`RTC::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 RTC::try to pushFlow again');
+  await stopPush();
+  await startPush();
+};
+
+/**
+ * @function 拉流异常恢复
+ */
+export const pullFlowExceptionHandler = async (streamId) => {
+  await new Promise((resolve, reject) => {
+    setTimeout(() => {
+      resolve();
+    }, 1000);
+  });
+  defaultApi.writeLog('断网重拉');
+  defaultApi.writeLog(`avsdk RTC::try to pullFlow again, streamId : ${streamId}`);
+  await stop(streamId);
+  await play(streamId);
+};
+
+/**
+ * @function 设置 appId
+ * @param appId:String 长度不能大于 100，必选
+ * @return Promise | void
+ */
+export const setAppId = (appId) => {
+  return callMethod('SetAppId', {
+    appId
+  });
+};
+
+/**
+ * @function 设置用户名
+ * @param userName:String 用户名，必选
+ * @return Promise | void
+ */
+export const setUserName = (userName) => {
+  return callMethod('SetUserName', {
+    userName
+  });
+};
+
+/**
+ * @function 设置用户 id
+ * @param userId:Number 用户 id，必选
+ * @return Promise | void
+ */
+export const setUserId = (userId) => {
+  return callMethod('SetUserId', {
+    userId: userId + ''
+  });
+};
+
+/**
+ * @function 设置课节 id
+ * @param confId:String 长度不能大于 100
+ * @return Promise | void
+ */
+export const setConfId = (confId) => {
+  defaultApi.writeLog(`RTC SetConfId: ${confId}`);
+  _confId = confId;
+  return callMethod('SetConfId', {
+    confId
+  });
+};
+
+/**
+ * @function 进入音视频房间
+ * @return Promise | void
+ */
+export const joinRtcRoom = async () => {
+  await callMethod('JoinRoom', {});
+  return new Promise((resolve, reject) => {
+    let timer = setInterval(() => {
+      if (hasJoinRtcRoom) {
+        clearInterval(timer);
+        resolve();
+      }
+    }, 50);
+  });
+};
+
+/**
+ * @function 退出音视频房间
+ * @return Promise | void
+ */
+export const leaveRtcRoom = async () => {
+  await callMethod('LeaveRoom', {});
+  return new Promise((resolve, reject) => {
+    let timer = setInterval(() => {
+      if (hasLeaveRtcRoom) {
+        clearInterval(timer);
+        resolve();
+      }
+    }, 50);
+  });
+};
+
+/**
+ * @function 开始混流
+ * @param  args:Object 混流设置信息
+ * @return Promise | void
+ * {
+'sequence':x,//混流任务序列号
+'inputStreams':[
+{
+'confId':'xxx',
+'streamId':'xxxx',
+'mediaControl':x,//0所有1音频2视频
+'left':x,
+'top':x,
+'right':x,
+'bottom':x
+}
+],
+'outputStream':{
+'pushType';x,
+'rtmpUrls';'xxx'，
+'videoFps':x,//视频帧率
+'videoRate':x,//视频码率
+'audioRate':x,//音频码率
+'videoWidth':x,//合成视频宽度
+'videoHeight':x,//合成视频高度
+'audioFormat':x,//音频格式，0aac
+'audioChannels':x,//音频声道数目
+'backgroudColor':x//背景色10进制？
+}
+}
+ */
+export const startRoomMixRecord = (args) => {
+  return callMethod('StartRoomMixRecord', args);
+};
+
+/**
+ * @function 开始混流 id
+ * @param  args: Object 停止混流设置信息
+ * {'sequence':x}//混流任务序列号
+ * @return Promise | void
+ */
+export const stopRoomMixRecord = (args) => {
+  return callMethod('StopRoomMixRecord', args);
+};
+
+/**
+ * @function 开始单路录制--暂停使用
+ * @param  sequence: String
+ * @param  streamId: String 流 id
+ * @return Promise | void
+ */
+export const startSingleRecord = (sequence = '', streamId) => {
+  return callMethod('StartSingleRecord', { sequence, streamId, confId: _getConfId(streamId) });
+};
+
+/**
+ * @function 停止单路录制--暂停使用
+ * @param  streamId: String 停止混流设置信息
+ * @return Promise | void
+ */
+export const stopSingleRecord = (streamId) => {
+  return callMethod('StopSingleRecord', { streamId, confId: _getConfId(streamId) });
+};
+
+/**
+ * @function 创建 Rtc Capture对象
+ * @param renderId:String 采集器的渲染 id，必选
+ * @return Promise | void
+ */
+export const createRtcCapture = (renderId) => {
+  if (renderId === 'deviceCheckerInit' && deviceCheckerCaptureInit) {
+    return;
+  }
+  return callMethod('CreateRtcCapture', {
+    source: 'camera',
+    renderid: renderId
+  });
+};
+
+// 设置采集器配置
+const setRtcCaptureParams = async (args ,from) => {
+  if (!from) {
+    await setCaptureRenderID(args.streamId);
+    await setCaptureStreamId(args.streamId);
+  }
+  await setCameraParam(args.previewResolutionWidth, args.previewResolutionHeight, args.previewCaptureFps);
+  await setEncodeParam(args.encodedResolutionWidth, args.encodedResolutionHeight, args.encodeCaptureFps);
+  await setBitRate(args.encodeCaptureBitrate);
+};
+
+/**
+   * @function 加载采集插件的输入数据  //调用后，rtc 可以向采集插件传送摄像头数据，用于拼接 
+   * @return: Promise
+   */
+ const rtcLoadCollectionEntry = () => {
+  return callMethod('RtcLoadCollectionEntry', {});
+};
+
+/**
+ * @function 加载采集插件的输出数据  //调用后，rtc 可以向采集插件传送学生流数据(加载截屏插件，获取截屏插件设置拉流头像回调函数)
+ * @param stream_ids array 设置需要拼接的学生头像流id，按数组顺序拼接
+ * @return: Promise
+ */
+ export const rtcLoadCollectionEntry2 = (stream_ids) => {
+  return callMethod('RtcLoadCollectionEntry2', {stream_ids});
+};
+
+/**
+ * @function 获取摄像头个数
+ * @return Promise | void
+ */
+export const getCameraDeviceCount = () => {
+  return callMethod('GetCameraDeviceCount', {});
+};
+
+/**
+ * @function 获取摄像头列表
+ * @return Promise | void
+ */
+export const getCameraDevice = async () => {
+  let cameraListObject = JSON.parse((await callMethod('GetCameraDevice', {})).msg);
+  let cameraKeys = [];
+  if (cameraListObject) {
+    cameraKeys = Object.keys(cameraListObject);
+  }
+  let cameraList = [];
+  for (let i = 0, len = cameraKeys.length; i < len; i++) {
+    cameraList.push({
+      deviceId: cameraListObject[cameraKeys[i]].deviceID,
+      deviceName: cameraListObject[cameraKeys[i]].deviceName,
+      isDefault: cameraListObject[cameraKeys[i]].bDefault
+    });
+    deviceListReport.cameraList[cameraListObject[cameraKeys[i]].deviceID] = cameraListObject[cameraKeys[i]].deviceName;
+    // console.log('hsghsghsg_9',deviceListReport.cameraList);
+  }
+  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 = cameraList;
+  return cameraList;
+};
+
+/**
+ * @function 获取扬声器个数
+ * @return Promise | void
+ */
+export const getSpeakerDeviceCount = () => {
+  return callMethod('GetSpeakerDeviceCount', {});
+};
+
+/**
+ * @function 获取扬声器列表
+ * @return Promise | void
+ */
+export const getSpeakerDevice = async () => {
+  let speakerListObject = JSON.parse((await callMethod('GetSpeakerDevice', {})).msg);
+  let speakerKeys = [];
+  if (speakerListObject) {
+    speakerKeys = Object.keys(speakerListObject);
+  }
+  let speakerList = [];
+  for (let i = 0, len = speakerKeys.length; i < len; i++) {
+    speakerList.push({
+      deviceId: speakerListObject[speakerKeys[i]].deviceID,
+      deviceName: speakerListObject[speakerKeys[i]].deviceName,
+      isDefault: speakerListObject[speakerKeys[i]].bDefault
+    });
+    deviceListReport.speakerList[speakerListObject[speakerKeys[i]].deviceID] = speakerListObject[speakerKeys[i]].deviceName;
+    // console.log('hsghsghsg_8',deviceListReport.speakerList);
+  }
+  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 获取麦克风个数
+ * @return Promise | void
+ */
+export const getMicrophoneDeviceCount = () => {
+  return callMethod('GetMicrophoneDeviceCount', {});
+};
+
+/**
+ * @function 获取麦克风列表
+ * @return Promise | void
+ */
+export const getMicrophoneDevice = async () => {
+  let microphoneListObject = JSON.parse((await callMethod('GetMicrophoneDevice', {})).msg);
+  let microphoneKeys = [];
+  if (microphoneListObject) {
+    microphoneKeys = Object.keys(microphoneListObject);
+  }
+  let microphoneList = [];
+  for (let i = 0, len = microphoneKeys.length; i < len; i++) {
+    microphoneList.push({
+      deviceId: microphoneListObject[microphoneKeys[i]].deviceID,
+      deviceName: microphoneListObject[microphoneKeys[i]].deviceName,
+      isDefault: microphoneListObject[microphoneKeys[i]].bDefault
+    });
+    deviceListReport.micList[microphoneListObject[microphoneKeys[i]].deviceID] = microphoneListObject[microphoneKeys[i]].deviceName;
+  }
+  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) => {
+  let {deviceId, operationType, deviceState, changedDeviceId} = args;
+  let deviceName = '';
+  let microPhoneData;
+  if (!deviceId) {
+    microPhoneData = await getMicrophoneDevice();
+    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) {};
+  await callMethod('SetAudioDevice', {
+    deviceID: deviceId
+  });
+  if (operationType == 'hotPlug' || operationType == 'deviceError') {
+    if(!microPhoneData){
+      microPhoneData = await getMicrophoneDevice();
+      deviceName = deviceListReport.micList[deviceId];
+    }
+    NOTICE[operationType]({
+      deviceType: 'microphone',
+      useDeviceId: deviceId,
+      useDeviceName: deviceName,
+      deviceList: microPhoneData,
+      deviceState,
+      changedDeviceId
+    });
+  }
+};
+
+/**
+ * @function 获取麦克风音量
+ * @return Promise | void
+ */
+export const getMicrophoneVolume = () => {
+  return callMethod('GetMicrophoneVolume', {});
+};
+
+/**
+ * @function 设置麦克风音量
+ * @param volume:Number 音量，必选
+ * @param bMuteDevice:Boolean 是否静音，可选
+ * 不传的话默认为 false 不静音
+ * @return Promise | void
+ */
+export const setMicrophoneVolume = (volume, bMuteDevice) => {
+  if (typeof bMuteDevice === 'undefined') {
+    bMuteDevice = false;
+  }
+  return callMethod('SetMicrophoneVolume', {
+    bMuteDevice,
+    volume
+  });
+};
+
+/**
+ * @function 开启/关闭麦克风音量回调
+ * @param open:Boolean true -> 开启，false -> 关闭，必选
+ * @return void
+ */
+export const openMicVolumeCb = (open) => {
+  // if (open) {
+  //   runMicVolumeCb = true;
+  // } else {
+  //   runMicVolumeCb = false;
+  // }
+};
+
+/**
+ * @function 获取当前应用程序音量
+ * @return Promise | void
+ */
+export const getCurrentAppSessionVolume = () => {
+  return callMethod('GetCurrentAppSessionVolume', {});
+};
+
+/**
+ * @function 设置当前应用程序音量
+ * @param volume:Number 音量，必选
+ * @param mute:Boolean 是否静音，可选
+ * 不传的话默认为 false 不静音
+ * @return Promise | void
+ */
+export const setCurrentAppSessionVolume = (volume, mute) => {
+  if (typeof mute === 'undefined') {
+    mute = false;
+  }
+  return callMethod('SetCurrentAppSessionVolume', {
+    muted: mute,
+    volume
+  });
+};
+
+/**
+ * @function 设置当前应用程序静音
+ * @param mute:Boolean 是否静音，必选
+ * @return Promise | void
+ */
+export const setApplicationMute = (mute) => {
+  return callMethod('SetApplicationMute', {
+    muted: mute
+  });
+};
+
+/**
+ * @function 设置预览窗口
+ * @param x:Number x 坐标，必选，推荐 0
+ * @param y:Number y 坐标，必选，推荐 0
+ * @param width:Number 宽，必选，推荐 300
+ * @param height:Number 高，必选，推荐 300
+ * @return Promise | void
+ */
+export const setPreviewPos = (x, y, width, height) => {
+  return callMethod('SetPreviewPos', {
+    x,
+    y,
+    width,
+    height
+  });
+};
+
+/**
+ * @function 指定摄像头设备
+ * @param deviceId:String 摄像头设备 id，必选
+ * @param close:Boolean true -> 关闭摄像头，false -> 不关闭摄像头
+ * Rtc 关闭摄像头是通过指定空的设备来实现的，因此需要做特化
+ * @param operationType:String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置摄像头设备的行为
+ * @return Promise | void
+ */
+export const setCameraDevice = async (args) => {
+  defaultApi.writeLog(`sdk action : setCameraDevice args:${JSON.stringify(args)}`);
+  let {deviceId, close, operationType, deviceState, changedDeviceId} = args;
+  let deviceName = '';
+  let cameraData;
+  if (!deviceId && !close) {
+    cameraData = await getCameraDevice();
+    if (cameraData.length) {
+      let hasGetCamare = false;
+      for (let item of cameraData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetCamare = true;
+          break;
+        }
+      }
+      if (!hasGetCamare) {
+        deviceId = cameraData[0].deviceId;
+        deviceName = cameraData[0].deviceName;
+      }
+      deviceId = cameraData[0].deviceId;
+      deviceName = cameraData[0].deviceName;
+    } else {
+      deviceId = '';
+    }
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'camera'
+      });
+    }
+  }
+  try {
+    dataReport.setDevice({
+      device_type:1,
+      device_id:deviceId,
+      device_name:deviceListReport.cameraList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? +deviceState+1 : '-'
+    });
+    window.zbztAVSDK_device_checker_init.camera.name = deviceListReport.cameraList[deviceId];
+  } catch (e) {};
+  await callMethod('SetCameraDevice', {
+    deviceID: deviceId,
+    close
+  });
+  if (operationType == 'hotPlug' || operationType == 'deviceError') {
+    if(!cameraData){
+      cameraData = await getCameraDevice();
+      deviceName = deviceListReport.cameraList[deviceId];
+    }
+    NOTICE[operationType]({
+      deviceType: 'camera',
+      useDeviceId: deviceId,
+      useDeviceName: deviceName,
+      deviceList: cameraData,
+      deviceState,
+      changedDeviceId
+    });
+  }
+  try {
+    NOTICE.useredCamera({
+      deviceId,
+      deviceName
+    });
+  } catch (e){ };
+};
+
+/**
+ * @function 获取摄像头所支持的分辨率
+ * @param deviceId:String 设备id
+ * @return Promise | void
+ */
+export const getCameraSupportedRes = (deviceId) => {
+  return callMethod('GetCameraSupportedResolution', {
+    deviceId
+  });
+};
+
+/**
+ * @function 设置事件上报链接
+ * @param reportSvr:String 上报服务器链接，必选
+ * @return Promise | void
+ */
+export const setEventReportSvr = (reportSvr) => {
+  return callMethod('SetEventReportSvr', {
+    reportSvr
+  });
+};
+
+/**
+ * @function 设置摄像头参数
+ * @param width:Number 分辨率宽，必选，推荐 1280
+ * @param height:Number 分辨率高，必选，推荐 720
+ * @param frameRate:Number 帧率，必选，推荐 15
+ * @return Promise | void
+ */
+export const setCameraParam = (width, height, frameRate) => {
+  return callMethod('SetCameraParam', {
+    width,
+    height,
+    frameRate
+  });
+};
+
+/**
+ * @function 指定扬声器
+ * @param speakId:String 扬声器 id，必选
+ * @return Promise | void
+ */
+export const setSpeakerDevice = async (args) => {
+  defaultApi.writeLog(`sdk action : setSpeakerDevice args:${JSON.stringify(args)}`);
+  let {speakId, operationType, deviceState, changedDeviceId} = args;
+  let deviceName = '';
+  let speakerData;
+  if (!speakId) {
+    speakerData = await getSpeakerDevice();
+    if (speakerData.length) {
+      let hasGetSpeaker = false;
+      for (let item of speakerData) {
+        if (item.isDefault) {
+          speakId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetSpeaker = true;
+          break;
+        }
+      }
+      if (!hasGetSpeaker) {
+        speakId = speakerData[0].deviceId;
+        deviceName = speakerData[0].deviceName;
+      }
+    } else {
+      speakId = '';
+    }
+    if (speakId === '') {
+      NOTICE.noDevice({
+        deviceType: 'speaker'
+      });
+    }
+  }
+  try {
+    dataReport.setDevice({
+      device_type:3,
+      device_id:speakId,
+      device_name:deviceListReport.speakerList[speakId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? +deviceState+1 : '-'
+    });
+    window.zbztAVSDK_device_checker_init.speaker.name = deviceListReport.speakerList[speakId];
+  } catch (e) {
+    console.error('error',e);
+  };
+  // console.log('hsghsghsg3',speakId);
+  await callMethod('SetSpeakerDevice', {
+    speakId
+  });
+  if (operationType == 'hotPlug' || operationType == 'deviceError') {
+    if(!speakerData){
+      speakerData = await getSpeakerDevice();
+      deviceName = deviceListReport.speakerList[speakId];
+    }
+    NOTICE[operationType]({
+      deviceType: 'speaker',
+      useDeviceId: speakId,
+      useDeviceName: deviceName,
+      deviceList: speakerData,
+      deviceState,
+      changedDeviceId
+    });
+  }
+};
+
+/**
+ * @function 设置扬声器音量
+ * @param volume:Number 音量，必选
+ * @param muted:Boolean 是否静音，可选
+ * 不传的话就默认为 false 不静音
+ * @return Promise | void
+ */
+export const setSpeakerVolume = (volume, muted) => {
+  if (typeof muted === 'undefined') {
+    muted = false;
+  }
+  return callMethod('SetSpeakerVolume', {
+    muted,
+    volume
+  });
+};
+
+/**
+ * @function 设置扬声器静音
+ * @param mute:Boolean 是否静音，可选
+ * @return Promise | void
+ */
+export const setSpeakerMute = (mute) => {
+  // try {
+  //   dataReport.deviceChange({
+  //     device: 3,
+  //     device_state: mute ? 0 :1
+  //   });
+  // } catch (e){};
+  return callMethod('SetSpeakerMute', {
+    muted: mute
+  });
+};
+
+/**
+ * @function 获取扬声器音量
+ * @return Promise | void
+ */
+export const getSpeakerVolume = () => {
+  return callMethod('GetSpeakerVolume', {});
+};
+
+/**
+ * @function 设置拉流的播放器静音
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param mute:Boolean 是否静音，必选 true 静音| false不静音
+ * @return Promise | void
+ */
+export const setMute = (streamId, mute) => {
+  const rtcPlayerId = streamIdToRtcPlayerId[streamId];
+  return pullAudioFlow(rtcPlayerId, mute);
+};
+
+/**
+   * @function 是否拉取音频流--通过播放器id控制
+   * @param operation:Boolean，必选，true 静音| false不静音
+   * @param playerId:Number，必选，播放器id
+   * @return Promise | void
+   */
+export const pullAudioFlow = (playerId, operation, operator, streamid) => {
+  defaultApi.writeLog(`pullAudioFlow -- playerId ${playerId} operation ${operation} streamId ${streamid}`);
+  if(streamid){
+    if(streamIdToRtcPlayerId[streamid] == undefined) {
+        NOTICE.pullAudioFlowError({streamid})
+        return 
+    }else{
+      playerId = streamIdToRtcPlayerId[streamid]
+      console.log('pullAudioFlow-playerId',playerId,streamIdToPreviewId)
+    }
+  }
+  let streamId = rtcPlayerIdToStreamId[playerId];
+  try {
+    streamIdRtcPlayerInfo1[streamId].audio_type = !operation;
+    console.log('pullAudioFlow_rtc ::rtcPlayerIdToStreamId',streamId,rtcPlayerIdToStreamId)
+    console.log('pullAudioFlow_rtc ::streamIdRtcPlayerInfo1',streamId,streamIdRtcPlayerInfo1);
+  } catch (e) {
+    console.log('pullAudioFlow_rtc ::streamIdRtcPlayerInfo1--error',e);
+  };
+  // console.log('hghghg',streamIdRtcPlayerInfo1[streamId]);
+  try {
+    if(operator) {
+      dataReport.setPullVoice({
+        code:+!operation,
+        pull_uid: util.getUidByStreamId(streamId),
+        pull_streamid:streamId,
+        playerId
+      });
+    }
+  } catch (e) {};
+  return callMethod('SetMute', {
+    muted: operation,
+    id: playerId
+  });
+};
+
+/**
+ * @function 控制只拉音频流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param audioOnly:Boolean 是否只拉音频流，必选，true -> 只拉音频流，false -> 音视频都拉
+ * @return Promise | void
+ */
+export const controlPullAudioOnly = (streamId, audioOnly) => {
+  try {
+    streamIdRtcPlayerInfo1[streamId].video_type = !audioOnly;
+    console.log('controlPullAudioOnly_rtc ::streamIdRtcPlayerInfo1',streamId,streamIdRtcPlayerInfo1);
+  } catch (e) {
+    console.log('controlPullAudioOnly_rtc ::streamIdRtcPlayerInfo1--error',e);
+  }
+  const rtcPlayerId = streamIdToRtcPlayerId[streamId];
+  return callMethod('ControlPullAudioOnly', {
+    id: rtcPlayerId,
+    audioOnly
+  });
+};
+
+/**
+ * @function 启动摄像头
+ * @return Promise | void
+ */
+export const startPreview = () => {
+  // try {
+  //   dataReport.deviceChange({
+  //     device: 1,
+  //     device_state: 1
+  //   });
+  // } catch (e){};
+  return callMethod('StartPreview', {});
+};
+
+/**
+ * @function 设置推流的编码参数
+ * @param width:Number 宽，必须，推荐 1280
+ * @param height:Number 高，必须，推荐 720
+ * @param frameRate:Number 码率，必须，推荐 15
+ * @return Promise | void
+ */
+export const setEncodeParam = (width, height, frameRate) => {
+  return callMethod('SetEncodeParam', {
+    width,
+    height,
+    frameRate
+  });
+};
+
+/**
+ * @function 设置推流的比特率
+ * @param bps:Number 码率，必选，推荐 512000
+ * @return Promise | void
+ */
+export const setBitRate = (bps) => {
+  return callMethod('SetBitRate', {
+    bps
+  });
+};
+
+/**
+ * @function 设置推流的的 streamId
+ * @param streamId:String 推流 id，必选，长度不能超过100个字符
+ * @return Promise | void
+ */
+export const setCaptureStreamId = (streamId) => {
+  return callMethod('SetCaptureStreamId', {
+    streamid: streamId
+  });
+};
+
+/**
+ * @function 设置本地摄像头采集器的渲染 id
+ * @param renderId:String 渲染 id，传入推流 id 即可，必选
+ * @return Promise | void
+ */
+export const setCaptureRenderID = (renderId) => {
+
+  return callMethod('SetCaptureRenderID', {
+    renderid: renderId
+  });
+};
+
+/**
+ * @function 开始推流到服务器
+ * 如果收到 error，SDK 回到 startPush 之前的状态，
+ * 应用程序需要重新设置正确的参数，并 startPush
+ * @return Promise | void
+ */
+export const startPush = () => {
+  if (!isFirstHeartBeatReport) {
+    isFirstHeartBeatReport = true;
+    heartBeatDataReport('start');
+  }
+  return callMethod('StartPush', {});
+};
+
+/**
+ * @function 停止推流
+ * @return Promise | void
+ */
+export const stopPush = () => {
+  // try {
+  //   dataReport.stopPublish({publish_streamid:window.zbztAVSDK_init_params.rtc.streamId});
+  // } catch (error) {
+  // }
+  return callMethod('StopPush', {});
+};
+
+/**
+ * @function 关闭摄像头
+ * @return Promise | void
+ */
+export const stopPreview = () => {
+  // try {
+  //   dataReport.deviceChange({
+  //     device: 1,
+  //     device_state: 0
+  //   });
+  // } catch (e){};
+  return callMethod('StopPreview', {});
+};
+
+/**
+ * @function 销毁采集器对象
+ * @return Promise | void
+ */
+export const captureDestroy = async () => {
+  await stopPreview();
+  return callMethod('CaptureDestroy', {});
+};
+
+/**
+ * @function 销毁引擎
+ * @return Promise | void
+ */
+export const destroyEngine = () => {
+  return callMethod('DestroyEngine', {});
+};
+
+/**
+ * @function 创建视频播放器
+ * @param pos:Object
+ * {
+ *   x,        // Number，x 坐标，必选，推荐 500
+ *   y,        // Number，y 坐标，必选，推荐 500
+ *   width,    // Number，宽，必选，推荐 300
+ *   height    // Number，高，必选，推荐 300
+ * }
+ * @param renderId:String，渲染 id，必选
+ * @return Promise | void
+ */
+export const createRtcPlayer = (pos, renderId) => {
+  return callMethod('CreateRtcPlayer', {
+    pos,
+    renderid: renderId
+  });
+};
+
+/**
+ * @function 设置被拉取的流的 id
+ * @param streamId:String 被拉取的流的 id，必选
+ * @return Promise | void
+ */
+export const setPlayerStreamId = (rtcPlayerId, streamId) => {
+  const args = {
+    streamid: streamId,
+    id: rtcPlayerId,
+    // 跨组拉流
+    confId: _getConfId(streamId)
+  };
+
+  defaultApi.writeLog(`RTC::SetPlayerStreamId streamId: ${streamId} id: ${rtcPlayerId} confId:
+  ${util.getDataFromStreamUrl('roomId', streamId)}
+  args : ${JSON.stringify(args)}
+  `);
+
+  return callMethod('SetPlayerStreamId', args);
+};
+
+/**
+ * @function 设置被拉取的流的渲染 id
+ * @param renderId:String 拉流的渲染 id，必选，传入被拉取的流的 id 即可
+ * @return Promise | void
+ */
+export const setPlayRenderID = (rtcPlayerId, renderId) => {
+  defaultApi.writeLog(`RTC::SetPlayRenderID streamId: ${renderId} id: ${rtcPlayerId}`);
+  return callMethod('SetPlayRenderID', {
+    renderid: renderId,
+    id: rtcPlayerId
+  });
+};
+
+/**
+ * @function 关闭客户端
+ * @param streamId:String 被拉取的流的 id，必选
+ * @return Promise | void
+ */
+export const playDestroy = (streamId) => {
+  const rtcPlayerId = streamIdToRtcPlayerId[streamId];
+  defaultApi.writeLog(`RTC::PlayDestroy streamId: ${streamId} id: ${rtcPlayerId}`);
+  delete streamIdToRtcPlayerId[streamId];
+  delete streamIdRtcPlayerInfo[streamId];
+  return callMethod('PlayDestroy', {
+    id: rtcPlayerId
+  });
+};
+
+/**
+ * @function 开启本地或者远程的视频视图
+ * @param isLocal:Boolean 是否是本地的视频预览，必选
+ * @param streamId:String 要拉取的视频流的 id，可选，只有拉取远程的视频流的时候才是必选的
+ * @param domId:String <video> 标签的 id，可选
+ * 如果传了 domId，就把视频绑定到对应的 <video> 标签上
+ * @return Promise | void，可从 Promise 中获取 src，Promise.then((src) => {})
+ */
+export const startLocalOrRemotePreview = async (isLocal, streamId, domId, rtcPlayerId) => {
+  defaultApi.writeLog(`${streamId}----streamId-rtc----`);
+  let isUpdateChromeVersion = await util.getChromeVersion();
+  // 预览本地视频的话，流 id 从全局配置中获取
+  if (isLocal) {
+    streamId = isInRoom ? (window.zbztAVSDK_init_params && window.zbztAVSDK_init_params.rtc.streamId)
+      : 'deviceCheckerInit';
+  }
+  const externalConstraints = {
+    audio: false,
+    video: {
+      mandatory: {
+        chromeMediaSource: 'external',
+        chromeMediaSourceId: `ems://TM/${streamId}`
+      }
+    }
+  };
+
+  return new Promise((resolve, reject) => {
+    const handleExternalSuccess = (stream) => {
+      defaultApi.writeLog(`${stream}----stream-rtc----`);
+      stream.oninactive = () => {
+        defaultApi.writeLog('Stream inactive');
+      };
+      const src = isUpdateChromeVersion? stream : window.URL.createObjectURL(stream);
+      console.log('内核升级', isUpdateChromeVersion);
+      if (domId && document.querySelector(domId)) {
+        if(isUpdateChromeVersion) {
+          console.log('内核升级1');
+          document.querySelector(domId).srcObject = src;
+        } else {
+          console.log('内核升级2');
+          document.querySelector(domId).src = src;
+        }
+      }
+      defaultApi.writeLog(`setVidoeSrc, rtcPlayerId: ${rtcPlayerId}, 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 args:Object
+ * {
+ *   extensionVersion,  // String，扩展版本号，必选
+ *   appId,             // String，Rtc 秘钥，必选
+ *   userName,          // String，用户名，必选
+ *   userId,            // Number，用户 id，必选
+ *   roomId,            // String，房间 id，必选
+ *   streamId           // String，流 id，必选
+ * }
+ * @return Promise | void
+ */
+export const init = async (args) => {
+  const usedDevices = window.zbztAVSDK_device_checker_init;
+  let devices = args.devices;
+  args.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) || ''
+  };
+  await loadRtc(args.extensionVersion);
+  // setStatisticsInterval(1000);
+  addListener();
+  await setAppId(args.appId);
+  await setUserName(args.userName);
+  await setUserId(args.userId);
+  await setConfId(args.confId);
+  // await joinRtcRoom();
+  if (deviceCheckerCaptureInit) {
+    await captureDestroy();
+    deviceCheckerCaptureInit = false;
+  }
+  // if (args.role === 'teacher' && args.classMode === 1) {
+  //   await setUserRole(1);
+  // }
+  //小班课 需要加载采集插件的输入数据,为了拼接rtc头像
+  if (args.classMode === 1 || args.classMode === 2){
+    rtcLoadCollectionEntry();
+  };
+  await createRtcCapture(args.streamId);
+  await setDefaultDevice(args.devices,'default');
+  await setRtcCaptureParams(args);
+  await setPreviewMute(true);
+  await muteLocalVideo(true);
+  await startPreview();
+  isInRoom = true;
+  window.current_sdk_type = 'rtc';
+  defaultApi.writeLog('rtc init finished current_sdk_type : rtc');
+  paramInfo = window.zbztAVSDK_init_params.rtc;
+  captureBefore = paramInfo.encodedResolutionWidth+'*'+paramInfo.encodedResolutionHeight;//运控获取，一直不变(拼接前摄像头采集分辨率)
+  captureEncodeBefore = paramInfo.previewResolutionWidth+'*'+paramInfo.previewResolutionHeight;//摄像头拼接前编码分辨率云控拿取
+  captureAfter = captureBefore;
+};
+
+/**
+ * @function 恢复
+ */
+export const recoverSdk = async (args) => {
+  addListener();
+  await setRtcCaptureParams(args);
+  await setPreviewMute(true);
+  _confId = args.confId;
+  const zbzt_sdk_rtcPlayerIds = localStorage.getItem('zbzt_sdk_rtcPlayerIds');
+  if (zbzt_sdk_rtcPlayerIds) {
+    rtcPlayerIds = zbzt_sdk_rtcPlayerIds.split(',').map(item => +item);
+    defaultApi.writeLog(`RTC sdk action : recoverSdk --> PlayDestroy --> rtcPlayerIds: ${rtcPlayerIds}`);
+    if (rtcPlayerIds.length > 0) {
+      for (let i = 0, len = rtcPlayerIds.length; i < len; i++) {
+        await callMethod('PlayDestroy', {
+          id: rtcPlayerIds[i]
+        });
+      }
+    }
+  }
+  localStorage.removeItem('zbzt_sdk_rtcPlayerIds');
+  isInRoom = true;
+  window.current_sdk_type = 'rtc';
+  defaultApi.writeLog('rtc recoverSdk finished current_sdk_type : rtc');
+};
+
+export const stopCheckDevice = () => {
+  deviceCheckerCaptureInit = false;
+  removerListener();
+  defaultApi.writeLog('rtc stopCheckDevice and removerListener and captureDestroy');
+  return captureDestroy();
+};
+
+//设置拉流质量监控周期
+const setStatisticsInterval = (interval) =>{
+  return callMethod('SetStatisticsInterval',{interval});
+};
+
+/**
+ * @function 设置默认的硬件设备，包括摄像头、麦克风以及扬声器
+ * @return Promise | void
+ */
+export const setDefaultDevice = async (devices, operationType) => {
+  // 设置默认的摄像头
+  if (devices && devices.camera) {
+    await setCameraDevice({deviceId: devices.camera, operationType:`${operationType}_1`});
+  } else {
+    const cameraData = await getCameraDevice();
+    if (cameraData.length) {
+      let hasSetCamera = false;
+      for (let item of cameraData) {
+        if (item.isDefault) {
+          await setCameraDevice({deviceId: item.deviceId, operationType:`${operationType}_2`});
+          hasSetCamera = true;
+          break;
+        }
+      }
+      if (!hasSetCamera) {
+        await setCameraDevice({deviceId: cameraData[0].deviceId, operationType:`${operationType}_3`});
+      }
+    }
+  }
+  // 设置默认的麦克风
+  if (devices && devices.microphone) {
+    await setMicrophoneDevice({deviceId: devices.microphone, operationType:`${operationType}_1`});
+  } else {
+    const microPhoneData = await getMicrophoneDevice();
+    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({speakId: devices.speaker, operationType:`${operationType}_1`});
+  } else {
+    const speakerData = await getSpeakerDevice();
+    if (speakerData.length) {
+      let hasSetSpeaker = false;
+      for (let item of speakerData) {
+        if (item.isDefault) {
+          await setSpeakerDevice({speakId: item.deviceId, operationType:`${operationType}_2`});
+          hasSetSpeaker = true;
+          break;
+        }
+      }
+      if (!hasSetSpeaker) {
+        await setSpeakerDevice({speakId: speakerData[0].deviceId, operationType:`${operationType}_3`});
+      }
+    }
+  }
+};
+
+/**
+ * @function 设置是否只推音频流
+ * @param audioOnly:Boolean 必选
+ * @return Promise | void
+ */
+export const controlPushAudioOnly = (audioOnly) => {
+  return callMethod('ControlPushAudioOnly', {
+    audioOnly
+  });
+};
+
+/**
+ * @function 设置用户角色，新小班独有逻辑
+ * @param {number} userRole 必选 用户角色 1=老师
+ * @return Promise | void
+ */
+export const setUserRole = (userRole) => {
+  return callMethod('SetUserRole', {
+    userRole
+  });
+};
+
+/**
+ * @function 开启或者关闭摄像头
+ * @param operation:Boolean 操作类型，false -> 关闭，true -> 打开，必选
+ * @return Promise | void
+ */
+export const openOrCloseCamera = async (operation) => {
+  // await controlPushAudioOnly(!operation);
+  // await muteStreamVideo(!operation);
+  isNoticeCarVolumeRtc = operation;
+  await muteLocalVideo(!operation);
+  if (operation) {
+    if (window.zbztAVSDK_init_params && window.zbztAVSDK_init_params.rtc) {
+      const rtc = window.zbztAVSDK_init_params.rtc;
+      await setRtcCaptureParams(rtc, 'deviceCheckerInit');
+    }
+    // 打开原本正在使用的摄像头
+    if (rtcNowUseCamera) {
+      await setCameraDevice({deviceId: rtcNowUseCamera});
+    } else {
+      await setCameraDevice({});
+    }
+    // await startPreview();
+  } 
+  // else {
+  //   await setCameraDevice({deviceId: '', close: true});
+  //   // await stopPreview();
+  // }
+};
+
+/**
+ * @function 开启或者关闭摄像头以及麦克风
+ * @param operation:Boolean 操作类型，false -> 关闭，true -> 打开，必选
+ * @return Promise | void
+ */
+export const openOrCloseCameraAndMicrophone = async (operation) => {
+  if (operation) {
+    await startPreview();
+  } else {
+    await stopPreview();
+  }
+};
+
+/**
+ * @function 控制本地视频预览的声音，即播放自己麦克风录到的声音
+ * @param mute:Boolean 操作类型，false -> 不 mute，true -> mute，必选
+ * @return Promise | void
+ */
+export const setPreviewMute = (mute) => {
+  return callMethod('SetPreviewMute', {
+    mute
+  });
+};
+
+/**
+ * @function 设置麦克风静音
+ * @param mute:Boolean false -> 不静音，true -> 静音，必选
+ * @return Promise | void
+ */
+export const setRealTimeAudioMute = async (mute) => {
+  isNoticeMicVolumeRtc = !mute;
+  // await muteStreamAudio(mute);
+  await muteLocalAudio(mute);
+  // return callMethod('SetRealTimeAudioMute', {
+  //   mute
+  // });
+};
+
+/**
+ * @function 初始化拉流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param domId:String <video> 标签的 id，可选
+ * 如果传了就把视频绑定到对应的 <video> 标签上
+ * @return src:String 视频预览地址
+ */
+export const initPullFlow = async (streamId, domId, mute, renderId, notAutoPlay, audioOnly, needScale, scaleParams) => {
+  defaultApi.writeLog(`RTC:: initPullFlow_start ,streamId :${streamId}`);
+  let rtcPlayerId;
+  const _renderId = renderId || streamId;
+  resetStreamIdRtcPlayerInfo1(streamId);
+  resetStreamIdRtcPlayerInfo(streamId);
+  try {
+    if (!isFirstHeartBeatReport) {
+      isFirstHeartBeatReport = true;
+      heartBeatDataReport('start');
+    }
+  } catch (error) {
+
+  }
+  if (streamIdToRtcPlayerId[streamId] && !renderId) {
+    defaultApi.writeLog('RTC::  The streamId queue contains this streamId');
+    rtcPlayerId = streamIdToRtcPlayerId[streamId];
+    await stop(streamId);
+    resetStreamIdRtcPlayerInfo(streamId);
+    console.log('streamIdIsExitedRtc',rtcPlayerId,streamIdToRtcPlayerId[streamId]);
+  } else {
+    defaultApi.writeLog('RTC::  The streamId queue does not contain this streamId');
+    if (stopedRtcPlayers.length > 0) {
+      rtcPlayerId = stopedRtcPlayers.pop();
+      console.log('streamIdIsNoExitedRtc',rtcPlayerId,streamIdToRtcPlayerId[streamId]);
+    } else {
+      rtcPlayerId = JSON.parse(
+        (await createRtcPlayer(
+          {
+            x: 500,
+            y: 500,
+            width: 500,
+            height: 500
+          },
+          _renderId
+        )
+        ).msg
+      ).id;
+    }
+    streamIdToRtcPlayerId[streamId] = rtcPlayerId;
+  }
+  if (rtcPlayerIds.indexOf(rtcPlayerId) < 0) {
+    rtcPlayerIds.push(rtcPlayerId);
+    localStorage.setItem('zbzt_sdk_rtcPlayerIds', rtcPlayerIds.join(','));
+  }
+  // 判断是否创建或者获取窗口ID成功，不成功就删掉重试
+  if (!rtcPlayerId) {
+    delete streamIdToRtcPlayerId[streamId];
+    // delete streamIdToBlobUrl[streamId];
+    return initPullFlow(streamId, domId, mute, renderId);
+  }
+  if (needScale) {
+    setRtcXBScale(rtcPlayerId, scaleParams);
+  }
+  rtcPlayerIdToStreamId[rtcPlayerId] = streamId;
+  // 静音拉流
+  await pullAudioFlow(rtcPlayerId, !!mute);
+  // 只拉音频
+  await controlPullAudioOnly(streamId, !!audioOnly);
+  await setPlayRenderID(rtcPlayerId, _renderId);
+  await setPlayerStreamId(rtcPlayerId, streamId);
+  if (!notAutoPlay) {
+    await play(streamId);
+  }
+  const videoSrc = await startLocalOrRemotePreview(false, _renderId, domId, rtcPlayerId);
+  return {
+    videoSrc,
+    playerId: rtcPlayerId
+  };
+};
+
+/**
+ * @function 切换播放流
+ * @param streamId:String 需要被替换的流的 id，必选
+ * @param toStreamId:String 被拉取的流的 id，必选
+ * @param toDomId:String <video> 标签的 id，可选
+ * 如果传了就把视频绑定到对应的 <video> 标签上
+ * @return src:String 视频预览地址
+ */
+export const changePullFlow = async (streamId, toStreamId, toDomId) => {
+  await stop(streamId, true);
+  return initPullFlow(toStreamId, toDomId);
+};
+
+/**
+ * @function 是否需要缩放
+ * @param { nunber } id 窗口id，必选
+ * @param { object } scaleParams
+ * @param { number } scaleParams.is_need_xb_scale 是否开启缩放
+ * @param { number } scaleParams.height 高
+ * @param { number } scaleParams.width 宽
+ * @return Promise | void
+ */
+const setRtcXBScale = async (id, scaleParams) => {
+  defaultApi.writeLog(`RTC::SetRtcXBScale id: ${id} scaleParams: ${JSON.stringify(scaleParams)}`);
+  await callMethod('SetRtcXBScale', {
+    ...scaleParams,
+    id
+  });
+};
+
+/**
+ * @function 恢复拉指定的流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @return Promise | void
+ */
+export const play = async (streamId) => {
+  const id = streamIdToRtcPlayerId[streamId];
+  defaultApi.writeLog(`RTC::Play streamId: ${streamId} id: ${id}`);
+  await callMethod('Play', {
+    streamId,
+    id
+  });
+};
+
+/**
+ * @function 停止拉指定的流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param recovery:Boolean 是否回收播放器， 可选
+ * @return Promise | void
+ */
+export const stop = async (streamId, recovery) => {
+  currStreamIdRtcPlayerInfo && (currStreamIdRtcPlayerInfo.video_ifg = 0);
+  currStreamIdRtcPlayerInfo && (currStreamIdRtcPlayerInfo.audio_ifg = 0);
+  const id = streamIdToRtcPlayerId[streamId];
+  delete streamIdRtcPlayerInfo[streamId];
+  if (recovery && id && !stopedRtcPlayers.includes(id)) {
+    stopedRtcPlayers.push(id);
+    delete streamIdToRtcPlayerId[streamId];
+    // delete streamIdToBlobUrl[streamId];
+  }
+  return callMethod('Stop', {
+    id
+  });
+};
+
+/**
+ * @function 停止并回收所有拉流
+ * @return Promise | void
+ */
+export const stopAllPullFlow = () => {
+  const toRecoveryArr = [];
+  for (let streamId in streamIdToRtcPlayerId) {
+    if (streamIdToRtcPlayerId.hasOwnProperty(streamId)) {
+      const id = streamIdToRtcPlayerId[streamId];
+      if (id && !stopedRtcPlayers.includes(id)) {
+        stopedRtcPlayers.push(id);
+        toRecoveryArr.push(callMethod('Stop', {
+          id
+        }));
+      }
+    }
+  }
+  streamIdToRtcPlayerId = {};
+  return Promise.all(toRecoveryArr);
+};
+
+/**
+ * @function 停止拉指定的流并销毁播放器
+ * @param streamId:String 被拉取的流的 id，必选
+ * @return Promise
+ */
+export const stopPullFlow = async (streamId) => {
+  await stop(streamId);
+  await playDestroy(streamId);
+};
+
+/**
+ * @function 发送转推命令
+ * @param args: Object
+ * {
+ * @param cmd:String 必选，'start' | 'stop' | 'pause' | 'resume'
+ * @param liveId:String 房间 id，可选，可从 window 的初始化参数中获取
+ * @param rtmpAddr:String 字符串（转推地址使用分号隔开），可选，sdk 可以内部拼接
+ * @param bSaveMp4:Boolean 是否保存为 mp4 文件，可选，默认为 false
+ * @param bPushRtmp:Boolean 是否推 rtmp 流，可选，默认为 true
+ * @param bPushAllRtmp:Boolean 是否全部推 rtmp 流，可选，默认为 false
+ * @param confId:String 分组id，可选，默认为 sdk初始化分组id
+ * }
+ * @return Promise | void
+ */
+export const sendRecordingMsg = (args) => {
+  let { cmd, liveId, rtmpAddr, bSaveMp4, bPushRtmp, bPushAllRtmp, confId } = args;
+  const rtc = window.zbztAVSDK_init_params.rtc;
+  if (typeof liveId === 'undefined') {
+    liveId = rtc.streamId;
+  }
+  if (typeof rtmpAddr === 'undefined') {
+    // 转推的流 id，从全局的初始化参数中获取
+    const sid = rtc.sid;
+    // 拼接转推地址
+    rtmpAddr = rtc.recordUrl + '/' + sid;
+  }
+  if (typeof bSaveMp4 === 'undefined') {
+    bSaveMp4 = false;
+  }
+  if (typeof bPushRtmp === 'undefined') {
+    bPushRtmp = true;
+  }
+  if (typeof bPushAllRtmp === 'undefined') {
+    bPushAllRtmp = true;
+  }
+  const params = {
+    cmd,
+    liveId,
+    rtmpAddr,
+    bSaveMp4,
+    bPushRtmp,
+    bPushAllRtmp,
+    confId
+  };
+  defaultApi.writeLog(`SendRecordingMsg ${JSON.stringify(params)}`);
+  return callMethod('SendRecordingMsg', params);
+};
+
+/**
+ * @function 退出房间
+ * @return Promise
+ */
+export const leaveRoom = async () => {
+  await stopPush();
+  await captureDestroy();
+  for (let i = 0, len = rtcPlayerIds.length; i < len; i++) {
+    await callMethod('PlayDestroy', {
+      id: rtcPlayerIds[i]
+    });
+  }
+  removerListener();
+  heartBeatDataReport('stop');
+  isFirstHeartBeatReport = false;
+  rtcPlayerIds = [];
+  streamIdToRtcPlayerId = {};
+  rtcPlayerIdToStreamId = {};
+  streamIdRtcPlayerInfo = {};
+  streamIdRtcPlayerInfo1 = {};
+  // heartBeatDataReportObj = {};
+  stopedRtcPlayers = [];
+  isInRoom = false;
+};
+
+export const hasStream = streamId => {
+  return Object.keys(streamIdToRtcPlayerId).includes(streamId);
+};
+
+function _getConfId(streamId) {
+  // 如果没有传streamId，取公共confId
+  if (!streamId) {
+    return _confId;
+  }
+  const institutionId = util.getDataFromStreamUrl('orgId', streamId);
+  const roomId = util.getDataFromStreamUrl('roomId', streamId);
+  // 传入streamId，通过roomId_机构id拼接得到confId，用于跨组拉流
+  return util.getConfId(institutionId, roomId);
+}
+/**
+ * @function 开始本地视频录制
+ * @param enableRecord 开始/结束
+ * @param pathFile 录制路径
+ * @return Promise | void
+ */
+export const localRecordVideo = async (enableRecord, pathFile) => {
+  defaultApi.writeLog(`avsdk RTC::localRecordVideo enableRecord: ${enableRecord}, storagePath: ${pathFile}`);
+  if (enableRecord) {
+    await callMethod('SetRecordType', {
+      type: 'type.mp4',
+      bAudioOnly: false
+    });
+    await callMethod('SetRecordPathFile', {
+      pathFile
+    });
+    return callMethod('StartRecord', {});
+  } else {
+    return callMethod('StopRecord', {});
+  }
+};
+
+/**
+ * @function 本地音频录制
+ * @param enableRecord 开始/结束
+ * @param storagePath 录制路径
+ * @return Promise | void
+ */
+export const localRecordAudio = async (enableRecord, storagePath) => {
+  defaultApi.writeLog(`avsdk RTC::localRecordAudio enableRecord: ${enableRecord}, storagePath: ${storagePath}`);
+  return callMethod('EnableSelectedAudioRecord', {
+    enable: true,
+    sampleRate: 16000,
+    channels: 1,
+    mode: 0,
+    samplesPerCall: 320,
+    enableRecord,
+    storagePath
+  });
+};
+//推不推视频（是否推画面）
+export const muteStreamVideo = (mute = false) => {
+  return callMethod('MuteStreamVideo', {
+    mute
+  });
+};
+//推不推视频（是否采集,这个方法直接不采集画面）
+export const muteLocalVideo = (mute = false) => {
+  return callMethod('MuteLocalVideo', {
+    mute
+  });
+};
+
+//推不推声音 （是否推声音）
+export const muteStreamAudio = (mute = false) => {
+  // try {
+  //   dataReport.deviceChange({
+  //     device: 2,
+  //     device_state: mute ? 0 :1
+  //   });
+  // } catch (e){};
+  return callMethod('MuteStreamAudio', {
+    mute
+  });
+};
+//推不推声音 （是否采集,这个方法直接不采集声音）
+export const muteLocalAudio = (mute = false) => {
+  return callMethod('MuteLocalAudio', {
+    mute
+  });
+};
+
+/**
+ * @function 开始连麦
+ * @param mode:number 采集器默认， 默认0=站立 1=坐立
+ * @return Promise | void
+ */
+export const teacherStartLinkMic = async (mode = 0) => {
+  if (mode === 0) {
+    await muteStreamVideo(true);
+    await setMicrophoneDevice({});
+    // await muteStreamAudio(false);
+    await muteLocalAudio(false);
+  } else {
+    // await muteLocalVideo(false);
+    await muteLocalAudio(false);
+  }
+};
+
+/**
+ * @function 结束连麦
+ * @param mode:number 采集器默认， 默认0=站立 1=坐立
+ * @return Promise | void
+ */
+export const teacherStopLinkMic = async (mode = 0) => {
+  if (mode === 0) {
+    await muteStreamVideo(false);
+    await setMicrophoneDevice({deviceId: ''});
+  } 
+  // else {
+  //   await muteLocalVideo(true);
+  // }
+};
+
+/**
+* @function 设置采集扬声器声音(rtc)
+* @param { string }  deviceId 设备id
+* @param {boolean} speaker 采集扬声器声音=true/不采集=false
+* @return: Promise
+*/
+export const setAudioSpeakerCapture = async (deviceId,speaker) => {
+  return callMethod('SetAudioSpeakerCapture', {
+    deviceID:deviceId,
+    bMixSpeaker:speaker
+  });
+};
+
+/**
+  * @function 设置混流和背景色
+  * @param { number }  type  0=不拼接/1=截屏窗+背景图/2=截屏窗+背景图+头像
+  * @param { number } id 需要混合的采集器id
+  * @param { object } rgb
+  * @param { number } rgb.r
+  * @param { number } rgb.g
+  * @param { number } rgb.b
+  * @return: Promise
+  */
+export const setMixStream = async (type, id, rgb) => {
+  await callMethod('SetIsNeedCombineCap', {
+    isNeedCombine: type,
+    id
+  });
+  if (rgb) {
+    await callMethod('SetCombinePadRGB', rgb);
+  }
+  if(!type){
+    try {
+      dataReport.splitState({
+        camera_split_start_resolution : captureAfter ,
+        camera_split_start_encode_resolution : captureEncodeAfter	,//摄像头拼接前编码分辨率
+        camera_split_end_resolution 	: captureBefore ,
+        camera_split_end_encode_resolution : captureEncodeBefore ,//摄像头拼接后编码分辨率
+        screen_split_start_encode_resolution:	screenEncodeAfter	,//截屏窗拼接前编码分辨率
+        screen_split_start_resolution	:screenEncodeAfter	,//截屏窗拼接前采集分辨率
+        screen_split_end_encode_resolution: screenEncodeBefore ,//截屏窗拼接后编码分辨率
+        screen_split_end_resolution	:screenEncodeBefore,//截屏窗拼接后采集分辨率
+        split:'结束拼接'  //拼接状态  不拼接
+      });
+    } catch (e){ };
+  }
+};
+
+/**
+  * @function 采集器截图
+  * @param { string } fileName 文件名，需要后缀名。例如：333.jpg
+  * @return: Promise
+  */
+export const captureSnapShot = (file_name) => {
+  return callMethod('SnapShot', {quality: 70, file_name});
+};
+/**
+  * @function 播放器截图
+  * @param { string } fileName 文件名，需要后缀名。例如：333.jpg
+  * @return: Promise
+  */
+export const playerSnapShot = (id, file_name) => {
+  return callMethod('PlayerSnapShot', {id, quality: 70, file_name});
+};
+
+/**
+  * @function 设置镜像状态（预览）
+  * @param { boolean } isMirror true=开启 false=关闭
+  * @return: Promise
+  */
+export const setMirrorStatus = (isMirror) => {
+  return callMethod('SetRTCPreViewMirror', {isMirror});
+};
+
+/**
+  * @function 设置推流镜像状态
+  * @param { boolean } id 采集器Id
+  * @param { boolean } mode 1=开启 0=关闭
+  * @return: Promise
+  */
+export const setMirrorMode = (mode,id = 0) => {
+  let realId = mode == 0 ? 0 : 2;
+  defaultApi.writeLog(`RTC: setMirrorMode, mode: ${mode}, id:${id}, realId:${realId}`);
+  return callMethod('SetMirrorMode', {id, mode:realId});
+};
+
+/**
+  * @function 设置拉流镜像状态
+  * @param { boolean } isMirror true=开启 false=关闭
+  * @return: Promise
+  */
+export const setRTCPlayViewMirror  = (isMirror, id) => {
+  return callMethod('SetRTCPlayViewMirror', {isMirror, id});
+};
+
+//美颜相关
+/**
+  * @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 发送SEI
+  * @return: Promise
+*/
+export const sendMediaSideInfo = async (text) => {
+  return callMethod('SendMediaSideInfo', {id, text});
+};
+
+// 获取TalMedia.dll版本号
+export const getSDKVersion = async () => {
+  return callMethod('GetSDKVersion', {});
+};
+
+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.rtc.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);
+      //   }
+      // });
+      // heartBeatDataReportObj.volume = heartBeatDataReportObj.volume.join(',');
+      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);
+        
+        // streamIdRtcPlayerInfo[streamid].volume = streamIdRtcPlayerInfo[streamid].volume.join(',');
+        // delete streamIdRtcPlayerInfo[streamid].count;
+        pullInfo.push({
+          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 (!isNoticeMicVolumeRtc) {
+          //   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';
+          };
+          defaultApi.writeLog(`push_type_rtc zbztsdk.deviceStatus.camera: ${zbztsdk.deviceStatus.camera},zbztsdk.deviceStatus.microphone: ${zbztsdk.deviceStatus.microphone}, type: ${zbztsdk.deviceStatus.stream_type}`);
+          defaultApi.writeLog(`push_type_rtc carema: ${isNoticeCarVolumeRtc},mic: ${isNoticeMicVolumeRtc}, a_fps: ${dataRtcCapture.audioInputframes}, a_bit: ${dataRtcCapture.audioencoderate}, v_fps: ${dataRtcCapture.videoInputframes}, v_bit: ${dataRtcCapture.videoencoderate}`);
+          // if (window.zbztAVSDK_init_params.rtc.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.error('hsghsg_error',e);
+        }
+      }
+      resetHeartBeatDataReportObj();
+      rateCount = 0;
+      // cpuRate = 0;
+      // memRate = 0;
+      // appCpuRate = 0;
+      // appMemUsed = 0;
+      clearInterval(rateTimer);
+    }
+  }, 10 * 1000);
+};
+
+const heartBeatDataReport = (type) => {
+  try {
+    if (type === 'start' && !heartBeatDataReportTimer) {
+      resetHeartBeatDataReportObj();
+      _heartBeatDataReport();
+      heartBeatDataReportTimer = setInterval(() => {
+        _heartBeatDataReport();
+      }, 30 * 1000);
+    }
+    if (type === 'stop') {
+      clearInterval(heartBeatDataReportTimer);
+      heartBeatDataReportTimer = null;
+    }
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+const heartBeatDataReportCalc = (name, _d) => {
+  // 拉流
+  const pullKeys = ['videoRenderFrameRate', 'videoCodeRate', 'audioRenderFrameRate', 'audioCodeRate'];
+  if (name === 'rtcPlayCycleDataReport') {
+    // console.log('hsg_tdddd',_d);
+    if (streamIdRtcPlayerInfo && streamIdRtcPlayerInfo.hasOwnProperty(_d.streamid)) {
+      let isReport = true;
+      // streamIdRtcPlayerInfo[_d.streamid].count++;
+      heartBeatRealKeys.forEach((realKey, index) => {
+        if (_d.hasOwnProperty(pullKeys[index])) {
+          if (streamIdRtcPlayerInfo[_d.streamid][realKey] === undefined) {
+            streamIdRtcPlayerInfo[_d.streamid][realKey] = [];
+            isReport = false;
+          }
+          // streamIdRtcPlayerInfo[_d.streamid][realKey].push(parseFloat(parseInt(_d[pullKeys[index]])));
+        }
+      });
+      if (isReport) {
+        let audio_fps_rtc_pull = 0;
+        let audio_bitrate_rtc_pull = 0;
+        let video_fps_rtc_pull = 0;
+        let video_bitrate_rtc_pull = 0;
+
+        if(streamIdRtcPlayerInfo1[_d.streamid].audio_type && streamIdRtcPlayerInfo1[_d.streamid].video_type) {
+          audio_fps_rtc_pull = parseFloat(parseInt(_d.audioRenderFrameRate));
+          audio_bitrate_rtc_pull = parseFloat(parseInt(_d.audioCodeRate));
+          video_fps_rtc_pull = parseFloat(parseInt(_d.videoRenderFrameRate));
+          video_bitrate_rtc_pull = parseFloat(parseInt(_d.videoCodeRate));
+        } else if(!streamIdRtcPlayerInfo1[_d.streamid].audio_type && streamIdRtcPlayerInfo1[_d.streamid].video_type) {
+          video_fps_rtc_pull = parseFloat(parseInt(_d.videoRenderFrameRate));
+          video_bitrate_rtc_pull = parseFloat(parseInt(_d.videoCodeRate));
+        } else if(streamIdRtcPlayerInfo1[_d.streamid].audio_type && !streamIdRtcPlayerInfo1[_d.streamid].video_type) {
+          audio_fps_rtc_pull = parseFloat(parseInt(_d.audioRenderFrameRate));
+          audio_bitrate_rtc_pull = parseFloat(parseInt(_d.audioCodeRate));
+        }
+        streamIdRtcPlayerInfo[_d.streamid].audio_fps.push(audio_fps_rtc_pull);
+        streamIdRtcPlayerInfo[_d.streamid].audio_bitrate.push(audio_bitrate_rtc_pull);
+        streamIdRtcPlayerInfo[_d.streamid].video_fps.push(video_fps_rtc_pull);
+        streamIdRtcPlayerInfo[_d.streamid].video_bitrate.push(video_bitrate_rtc_pull);
+        streamIdRtcPlayerInfo[_d.streamid].pull_loss.push(_d.lostrate);
+        streamIdRtcPlayerInfo[_d.streamid].pull_delay.push(_d.delay);
+
+        streamIdRtcPlayerInfo[_d.streamid].ctime.push(Math.round((new Date().getTime()+dataReport.timestamp)/1000));
+        // console.log('hsg_tpull_keys',JSON.parse(JSON.stringify(streamIdRtcPlayerInfo[_d.streamid])));
+      }
+      // streamIdRtcPlayerInfo[_d.streamid].ctime.push(Math.round((new Date().getTime()+util.diffTime)/1000).toString());
+      // console.log('hsg_tpull_keys',JSON.parse(JSON.stringify(streamIdRtcPlayerInfo[_d.streamid])));
+    }
+  }
+  // 推流
+  const pushKeys = ['videoInputframes', 'videoencoderate', 'audioInputframes', 'audioencoderate'];
+  if (name === 'rtcCaptureCycleDataReport') {
+    let audio_fps_rtc_push = 0;
+    let audio_bitrate_rtc_push = 0;
+    let video_fps_rtc_push = 0;
+    let video_bitrate_rtc_push = 0;
+    dataRtcCapture = _d;
+    // console.log('hsg_d5555',_d,isNoticeMicVolumeRtc,isNoticeCarVolumeRtc);
+    // heartBeatDataReportObj.count++;
+    // heartBeatRealKeys.forEach((realKey, index) => {
+    // if (!heartBeatDataReportObj.hasOwnProperty(realKey) && !_d.hasOwnProperty(pushKeys[index])) {
+    
+    // heartBeatDataReportObj[realKey] += parseFloat(_d[pushKeys[index]]);
+    if (isNoticeMicVolumeRtc && isNoticeCarVolumeRtc) {
+      audio_fps_rtc_push = parseFloat(parseInt(_d.audioInputframes));
+      audio_bitrate_rtc_push = parseFloat(parseInt(_d.audioencoderate));
+      video_fps_rtc_push = parseFloat(parseInt(_d.videoInputframes));
+      video_bitrate_rtc_push= parseFloat(parseInt(_d.videoencoderate));
+      // heartBeatDataReportObj[realKey].push(parseFloat(parseInt(_d[pushKeys[index]])));
+    } else if(!isNoticeMicVolumeRtc && isNoticeCarVolumeRtc) {
+      
+      video_fps_rtc_push = parseFloat(parseInt(_d.videoInputframes));
+      video_bitrate_rtc_push = parseFloat(parseInt(_d.videoencoderate));
+      // heartBeatDataReportObj.audio_fps.push(0);
+      // heartBeatDataReportObj.audio_bitrate.push(0);
+      // heartBeatDataReportObj.video_fps.push(parseFloat(parseInt(_d.videoInputframes)));
+      // heartBeatDataReportObj.video_bitrate.push(parseFloat(parseInt(_d.videoencoderate)));
+    } else if(!isNoticeCarVolumeRtc && isNoticeMicVolumeRtc) {
+      audio_fps_rtc_push = parseFloat(parseInt(_d.audioInputframes));
+      audio_bitrate_rtc_push = parseFloat(parseInt(_d.audioencoderate));
+      // heartBeatDataReportObj.audio_fps.push(parseFloat(parseInt(_d.videoInputframes)));
+      // heartBeatDataReportObj.audio_bitrate.push(parseFloat(parseInt(_d.videoInputframes)));
+      // heartBeatDataReportObj.video_fps.push(0);
+      // heartBeatDataReportObj.video_bitrate.push(0);
+    }
+    heartBeatDataReportObj.audio_fps.push(audio_fps_rtc_push);
+    heartBeatDataReportObj.audio_bitrate.push(audio_bitrate_rtc_push);
+    heartBeatDataReportObj.video_fps.push(video_fps_rtc_push);
+    heartBeatDataReportObj.video_bitrate.push(video_bitrate_rtc_push);
+    heartBeatDataReportObj.push_loss.push(_d.lostrate);
+    heartBeatDataReportObj.push_delay.push(_d.delay);
+    // }
+    // });
+    //
+    heartBeatDataReportObj.ctime.push(Math.round((new Date().getTime()+dataReport.timestamp)/1000));
+    // console.log('hsg_d6',JSON.parse(JSON.stringify(heartBeatDataReportObj)));
+    // console.log('hsg_push_keys',JSON.parse(JSON.stringify(heartBeatDataReportObj)));
+  }
+};
+
+//推流字段
+const resetHeartBeatDataReportObj = () => {
+  // console.log('hsg_d55556重置');
+  heartBeatDataReportObj = {
+    ctime: [],
+    // push_type: zbztsdk ? zbztsdk.deviceStatus.stream_type : 'none',
+    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'
+  };
+  // console.log('hsgshgs_heartbeat',streamIdRtcPlayerInfo1);
+};
+
+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: [],
+    // 累加
+    audio_ifg: 0,
+    video_ifg: 0
+  };
+};
+
+export default {
+  loadRtc,
+  unloadRtc,
+  setAppId,
+  setUserName,
+  setUserId,
+  setConfId,
+  createRtcCapture,
+  getCameraDeviceCount,
+  getCameraDevice,
+  setCameraDevice,
+  getCameraSupportedRes,
+  setCameraParam,
+  setEventReportSvr,
+  getSpeakerDeviceCount,
+  getSpeakerDevice,
+  setSpeakerDevice,
+  setSpeakerVolume,
+  setSpeakerMute,
+  getSpeakerVolume,
+  setMute,
+  pullAudioFlow,
+  getMicrophoneDeviceCount,
+  getMicrophoneDevice,
+  setMicrophoneDevice,
+  getMicrophoneVolume,
+  setMicrophoneVolume,
+  setRealTimeAudioMute,
+  getCurrentAppSessionVolume,
+  setCurrentAppSessionVolume,
+  setApplicationMute,
+  setPreviewPos,
+  startPreview,
+  setEncodeParam,
+  setBitRate,
+  setCaptureStreamId,
+  setCaptureRenderID,
+  startPush,
+  stopPush,
+  stopPreview,
+  captureDestroy,
+  createRtcPlayer,
+  setPlayerStreamId,
+  setPlayRenderID,
+  play,
+  stop,
+  playDestroy,
+  startLocalOrRemotePreview,
+  init,
+  setDefaultDevice,
+  openOrCloseCamera,
+  setPreviewMute,
+  openOrCloseCameraAndMicrophone,
+  initPullFlow,
+  stopPullFlow,
+  stopAllPullFlow,
+  changePullFlow,
+  leaveRoom,
+  sendRecordingMsg,
+  controlPullAudioOnly,
+  openMicVolumeCb,
+  startRoomMixRecord,
+  stopRoomMixRecord,
+  startSingleRecord,
+  stopSingleRecord,
+  hasStream,
+  localRecordAudio,
+  localRecordVideo,
+  teacherStartLinkMic,
+  teacherStopLinkMic,
+  setAudioSpeakerCapture,
+  setMixStream,
+  recoverSdk,
+  captureSnapShot,
+  playerSnapShot,
+  setMirrorStatus,
+  stopCheckDevice,
+  startSenseMe,
+  setBeautifyParam,
+  endSenseMe,
+  setRTCPlayViewMirror,
+  muteStreamVideo,
+  muteLocalVideo,
+  muteStreamAudio,
+  muteLocalAudio,
+  getSDKVersion,
+  setMirrorMode,
+  destroyEngine,
+  rtcLoadCollectionEntry2,
+  sendMediaSideInfo
+};