zbzt-live-sdk 0.0.2

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

@@ -0,0 +1,1718 @@
+/**
+ * @File: Zego 音视频 SDK
+ * @Author: xuyuanrui
+ * @Email: raywhbxyr@163.com
+ * @Date: 2024-01-26 10:14:41
+ **/
+import ZegoExpressEngine from 'zego-express-engine-webrtc';
+
+import dataReport from '../network/dataReport.js';
+import defaultApi from '../default';
+import util from '../util/util';
+import NOTICE from '../notice';
+import { deviceListReport } from './device.js';
+import { getZegoGateway } from '../config/config.js';
+import commonFetch from '../network/commonFetch.js';
+
+// 留存初始化参数 initParams;
+let initParams = {};
+// 创摄像头流的参数, 维持原相关set约束的调用方式
+let cameraConstraints = {
+  camera: {
+    audio: {
+      // input,
+      // ANS, 降噪
+      // AGC, 增益
+      // AEC, 回声消除
+    },
+    video: {
+      // input, // 采集设备id
+      quality: 4,
+      width: initParams.encodedResolutionWidth,
+      height: initParams.encodedResolutionHeight,
+      frameRate: initParams.encodeCaptureFps,
+    }
+  },
+  videoBitrate: initParams.encodeCaptureBitrate/1000,
+  audioBitrate: 48,
+  captureView: null,
+  // autoPlay: true,
+};
+let screenConstraints = {
+  videoBitrate: 800,
+  captureView: null,
+  // autoPlay: true,
+  screen: {
+    audio: false,
+    video: {
+      quality: 4,
+      frameRate: 15,
+      width: 960,
+      height: 540
+    }
+  }
+};
+// enableCamera、enableMic
+let hasCamera = true;
+let hasMicrophone = true;
+/**
+ * zegoWebExpressEngine 实例
+ * @type { ZegoExpressEngine.ZegoExpressEngine | null }
+ */
+let zg = null;
+// 声浪回调周期
+let soundLevelMonitorCycle = 1000;
+// 推流id
+let localStreamId;
+/**
+ * @type { import('zego-express-engine-webrtc/sdk/code/zh/ZegoLocalStream.web').default | null }
+ */
+let localStream;
+let screenStreamId = '';
+/**
+ * @type { import('zego-express-engine-webrtc/sdk/code/zh/ZegoLocalStream.web').default | null }
+ */
+let screenStream;
+//记录当前角色
+let currentRole = '';
+//记录当前课态类型：小组课=0/小班课=1
+let currentClassMode = null;
+//记录当前rtmp推流sdk类型
+let currentGroupSdkType = ''; // ???
+// 维护的一份当前正在使用的音频设备的 deviceId 的列表
+let usingAudioDeviceId = {
+  speaker: '',
+  microphone: ''
+};
+// // 维护的一份拉流的 streamId 与本地预览通道的映射表
+let streamIdToPreviewId = {};
+let previewIdToStreamId = {};
+let streamIdToStream = {}; // 维护一份流id跟播放器的映射关系type: { streamId: stream }
+let streamIdToStreamView = {}; // 维护一份流id跟播放器的映射关系type: { streamid: remoteview }
+// 拉流的播放通道初始化从 0 开始依次递增至44(共45路流)，-1 为推流的本地视频预览
+const uiChnIndexs = new Array(48).fill(0).map((a, b) => b).reverse();
+
+
+// WEB没有获取系统音量，维护麦克风音量、
+let microphoneVolume = 100;
+let speakerVolume = 100;
+
+//静音推流时，音量值是否上抛上层标志 false=没有声音不往上层通知/true=有声音有上层通知
+let isNoticeMicVolumeZego = false;
+// 心跳
+let heartBeatDataReportObj = {};
+let heartBeatDataReportTimer = null;
+let isFirstHeartBeatReport = false;
+let streamIdRtcPlayerInfo = {}; // 埋点数据格式
+let streamIdRtcPlayerInfo1 = {}; // 埋点数据格式
+let currStreamIdRtcPlayerInfo;
+const heartBeatRealKeys = ['video_fps', 'video_bitrate', 'audio_fps', 'audio_bitrate'];
+
+//记录底层推流回调的值
+let dataZegoCapture = {};
+
+let hasLoginChannel = 0;
+// TODO 测试代码，token接入完成后删除
+async function getToken(appId, userId) {
+  const querys = {
+    appId,
+    userId,
+  };
+  return commonFetch('https://dev-webrtc.weclassroom.com/webrtc/zegotoken', querys, 'GET');
+}
+
+async function init(args) {
+  // args.appId = 1739272706;
+  // args.server = 'wss://webliveroom-test.zego.im/ws';
+  // args.appKey = 'eyJ2ZXIiOjEsImhhc2giOiI3ZGRmMjMwZjRiYzYxNTNlNGViN2U2Zjc4M2Q1N2Y0NiIsIm5vbmNlIjoiMjgyMWEyYWE5YWU0NDM3MWY1NGI2NWYzMDk0OWNmYWYiLCJleHBpcmVkIjoxNzA5NDMxODkwfQ==';
+  args.server = getZegoGateway();
+  args.appKey = await getToken(args.appId, args.userId);
+  console.warn('[初始化]', args);
+  // NOTE 1. 参数保留
+  initParams = Object.assign({}, args);
+  localStreamId = initParams.streamId;
+  screenStreamId = `${args.institutionId}_${args.roomId}_${args.userId}_${args.live_id}_1`;
+  currentRole = initParams.role;
+  currentClassMode = initParams.classMode;
+  currentGroupSdkType = initParams.sdkTypeGroup;
+  // NOTE 2. 加载扩展插件
+  // NOTE 此处没用到Web拓展能力
+  // NOTE 3. 初始化ZegoWebExpressEngine & 登录房间
+  await startEngine(initParams);
+  // NOTE 4. 注册回调 注意: 渲染相关的事件在streamView上管理
+  addListener();
+  // NOTE 5. 实例化zego实例之后的动作
+  await afterInitSDK(initParams);
+  // NOTE 6. 创流参数保留
+  if (initParams.noiseSuppressMode == -2) {
+    defaultApi.writeLog(`noiseSuppressMode 关闭噪声消除 ${initParams.noiseSuppressMod}`);
+    await setEnableNoiseSuppress(false);
+  } else if (initParams.noiseSuppressMode == -1) {
+    defaultApi.writeLog(`noiseSuppressMode 由底层进行配置，js层不进行配置 ${initParams.noiseSuppressMode}`);
+  } else {
+    await setEnableNoiseSuppress(true);
+  };
+  //aecMode为-1是关闭回音消除，云控下传
+  if (initParams.aecMode == -2) {
+    defaultApi.writeLog(`aecMode 关闭回音消除 ${initParams.aecMode}`);
+    await setEnableAEC(false);
+  } else if (initParams.aecMode == -1) {
+    defaultApi.writeLog(`aecMode 由底层进行配置，js层不进行配置 ${initParams.aecMode}`);
+  } else {
+    defaultApi.writeLog(`aecMode 启动回音消除,模式为： ${initParams.aecMode}`);
+    await setEnableAEC(true);
+  };
+  await setVideoBitrate(initParams.encodeCaptureBitrate);
+  await setAudioBitrate(initParams.encodeCaptureBitrate);
+  await setVideoFPS(initParams.encodeCaptureFps);
+  // NOTE WEB没有分开设置
+  // await setVideoCaptureResolution(initParams.previewResolutionWidth, initParams.previewResolutionHeight);
+  await setVideoEncodeResolution(initParams.encodedResolutionWidth, initParams.encodedResolutionHeight);
+  window.current_sdk_type = 'zego';
+  defaultApi.writeLog('zego init finished current_sdk_type : zego');
+}
+async function startEngine(args) {
+  if(!zg){
+    zg = new ZegoExpressEngine.ZegoExpressEngine(args.appId, args.server);
+  }
+  zg.setDebugVerbose(false);
+  zg.setLogConfig({ logLevel: 'disable' });
+  // NOTE 开启多房间
+  // zg.enableMultiRoom(true); // 开多房间，推流需要指定房间号
+  // NOTE web没有onInitSDK, 登录房间放在注册事件之后
+  // deviceCheckerInitSDK 区别设备检测
+}
+
+async function afterInitSDK(args) {
+  // NOTE 1. 设置默认设备
+  const usedDevices = window.zbyAVSDK_device_checker_init;
+  const { devices } = args;
+  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) || ''
+  };
+  await setDefaultDevice(_devices, 'default');
+  // NOTE 2. 登录房间
+  const { roomId, appKey, userId, userName } = args;
+  await zg.loginRoom(roomId, appKey, { userID: userId, userName }, { userUpdate: true });
+  // NOTE 3. 设置质量回调周期 web 无此接口，回调周期写死3s
+  // NOTE 4. 设置声浪回调周期;
+  setSoundLevelMonitorCycle(1000);
+  // NOTE 5. 设置SEI开关
+  setMediaSideFlags();
+}
+
+function destroyEngine() {
+  zg.destroyEngine();
+}
+function setMediaSideFlags() {
+  // SEI开关 web跟native模式不一样，此接口需调整
+  // NOTE 当前需求不用此功能
+}
+/**
+ * @function 设置默认的硬件设备，包括摄像头、麦克风以及扬声器
+ * @return Promise
+ */
+async function setDefaultDevice(devices, operationType) {
+  console.warn('[设置默认设备]', devices, operationType);
+  // 设置默认的摄像头
+  if (devices && devices.camera) {
+    if (zbyAVSDK_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 (zbyAVSDK_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` });
+      }
+    }
+  }
+}
+async function getVideoDeviceList() {
+  if(!zg) {
+    return Promise.resolve([]);
+  }
+  let videoListArr = await zg.getCameras();
+  let videoList = [];
+  for (let i = 0, len = videoListArr.length; i < len; i++) {
+    videoList.push({
+      deviceId: videoListArr[i].deviceID,
+      deviceName: videoListArr[i].deviceName,
+      isDefault: i === 0
+    });
+    deviceListReport.cameraList[videoListArr[i].deviceID] = videoListArr[i].deviceName;
+  }
+  if (!window.zbyAVSDK_device_checker_init) {
+    window.zbyAVSDK_device_checker_init = {};
+  }
+  if (!window.zbyAVSDK_device_checker_init.camera) {
+    window.zbyAVSDK_device_checker_init.camera = {};
+  }
+  window.zbyAVSDK_device_checker_init.camera.hasTest = true;
+  window.zbyAVSDK_device_checker_init.camera.list = videoList;
+  return videoList;
+}
+
+async function setVideoDevice(args) {
+  let { deviceId, idx, operationType, deviceState, code, changedDeviceId } = args;
+  let deviceName = '';
+  let cameraData;
+  // NOTE 1. 没传deviceId, 设置默认设备
+  if (!deviceId) {
+    cameraData = await getVideoDeviceList();
+    if (cameraData.length) {
+      let hasGetCamare = false;
+      for (let item of cameraData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetCamare = true;
+          break;
+        }
+      }
+      if (!hasGetCamare) {
+        deviceId = cameraData[0].deviceId;
+        deviceName = cameraData[0].deviceName;
+      }
+    } else {
+      deviceId = '';
+    }
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'camera'
+      });
+    }
+  }
+  window.zbyAVSDK_device_checker_init.camera.use = deviceId;
+  window.zbyAVSDK_device_checker_init.camera.name = deviceListReport.cameraList[deviceId];
+  // NOTE 2. ???
+  try {
+    dataReport.setDevice({
+      device_type: 1,
+      device_id: deviceId,
+      device_name: deviceListReport.cameraList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+  } catch (e) { };
+  // NOTE 3. 切摄像头
+  if(localStream && deviceId) {
+    await zg.useVideoDevice(localStream, deviceId);
+  }
+  // NOTE 4. 热插拔
+  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
+ */
+async function enableCamera(enable) {
+  defaultApi.writeLog(`avsdk ZEGO::enableCamera ${enable}`);
+  // NOTE WEB无预设接口，此接口可能在创流之前调用，所以增加保存字段
+  hasCamera = enable;
+
+  if(!localStream) {
+    await startPreview();
+  }
+
+  if(enable) {
+    await localStream.startCaptureCamera(cameraConstraints.camera.video);
+    await zg.updatePublishingStream(localStream, 0); // 更新类型，0为视频，1为音频，2为音视频
+  }else {
+    await localStream.stopCaptureVideo();
+  }
+}
+async function enableMic(enable) {
+  defaultApi.writeLog(`avsdk ZEGO::enableMic ${enable}`);
+  // NOTE WEB无预设接口，此接口可能在创流之前调用，所以增加保存字段
+  // NOTE 关联地方：创流渲染前
+  hasMicrophone = enable;
+  isNoticeMicVolumeZego = enable;
+
+  if(!localStream) {
+    await startPreview();
+  }
+
+  if(enable) {
+    await localStream.startCaptureMicrophone(cameraConstraints.camera.audio);
+    await zg.updatePublishingStream(localStream, 1); // 更新类型，0为视频，1为音频，2为音视频
+  }else {
+    await localStream.stopCaptureAudio();
+  }
+}
+//设置采集声音
+async function setAudioSpeakerCapture(bEnable) {
+  // NOTE native接口enableMixSystemPlayout是开启/关闭采集的
+  if(!localStream) { return; }
+  if(bEnable) {
+    localStream.startCaptureMicrophone();
+    // NOTE 用于更新处于推流中的ZegoLocalStream实例的音视轨
+    await zg.updatePublishingStream(localStream, 1); // 更新类型，0为视频，1为音频，2为音视频
+  }else {
+    localStream.stopCaptureAudio(); // 停止采集音频
+  }
+}
+
+/**
+ * @function 获取音频设备
+ * @param deviceType:Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @return Promise | void
+ */
+async function getAudioDeviceList(deviceType) {
+  if(deviceType) {
+    return await getSpeakerDeviceList(); 
+  }else {
+    return await getMicrophoneDeviceList();
+  }
+}
+/**
+ * @function 指定音频设备
+ * @param deviceType:Number 音频设备类型，0 -> 麦克风，1 -> 扬声器，必选
+ * @param deviceId:String 音频设备 id，必选
+ * @return Promise | void
+ */
+async function setAudioDevice(deviceType, deviceId) {
+  if (deviceType == 0) {
+    // NOTE 1. 设置麦克风设备
+    window.zbyAVSDK_device_checker_init.microphone.use = deviceId;
+    zg.useAudioDevice(localStream, deviceId);
+  } else {
+    // NOTE 2. 设置扬声器设备
+    window.zbyAVSDK_device_checker_init.speaker.use = deviceId;
+    Object.keys(streamIdToStreamView).forEach(streamId=> {
+      streamIdToStreamView[streamId].useAudioOutputDevice(deviceId);
+    });
+  }
+}
+
+async function getSpeakerDeviceList() {
+  if(!zg) {
+    return Promise.resolve([]);
+  }
+  let speakerListArr = await zg.getSpeakers();
+  let speakerList = [];
+  for (let i = 0, len = speakerListArr.length; i < len; i++) {
+    speakerList.push({
+      deviceId: speakerListArr[i].deviceID,
+      deviceName: speakerListArr[i].deviceName,
+      isDefault: i === 0
+    });
+    deviceListReport.speakerList[speakerListArr[i].deviceID] = speakerListArr[i].deviceName;
+  }
+  if (!window.zbyAVSDK_device_checker_init) {
+    window.zbyAVSDK_device_checker_init = {};
+  }
+  if (!window.zbyAVSDK_device_checker_init.speaker) {
+    window.zbyAVSDK_device_checker_init.speaker = {};
+  }
+  window.zbyAVSDK_device_checker_init.speaker.hasTest = true;
+  window.zbyAVSDK_device_checker_init.speaker.list = speakerList;
+  return speakerList;
+}
+/**
+ * @function 指定扬声器
+ * @param deviceId:String 扬声器 id，必选
+ * @param operationType:String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置扬声器设备的行为
+ * @return Promise | void
+ */
+async function setSpeakerDevice(args) {
+  // NOTE 1. 没传deviceId则用默认设备
+  defaultApi.writeLog(`${JSON.stringify(args)}----setSpeakerDevice-zego----`);
+  let { deviceId, operationType, deviceState, code, changedDeviceId } = args;
+  let deviceName = '';
+  let speakerData;
+  if (!deviceId) {
+    speakerData = await getSpeakerDeviceList();
+    if (speakerData.length) {
+      let hasGetSpeaker = false;
+      for (let item of speakerData) {
+        if (item.isDefault) {
+          deviceId = item.deviceId;
+          deviceName = item.deviceName;
+          hasGetSpeaker = true;
+          break;
+        }
+      }
+      if (!hasGetSpeaker) {
+        deviceId = speakerData[0].deviceId;
+        deviceName = speakerData[0].deviceName;
+      }
+    } else {
+      deviceId = '';
+    }
+    if (deviceId === '') {
+      NOTICE.noDevice({
+        deviceType: 'speaker'
+      });
+    }
+  }
+  // NOTE 2. ???
+  try {
+    dataReport.setDevice({
+      device_type: 3,
+      device_id: deviceId,
+      device_name: deviceListReport.speakerList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+    window.zbyAVSDK_device_checker_init.speaker.name = deviceListReport.speakerList[deviceId];
+  } catch (e) { };
+  // NOTE 3. 设置扬声器
+  usingAudioDeviceId.speaker = deviceId;
+  await setAudioDevice(1, deviceId);
+  // NOTE 4. 热插拔处理逻辑
+  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
+    });
+  }
+}
+/**
+ * 获取当前扬声器设备id
+ * @return {String} 当前扬声器设备id
+ */
+function getCurrentSpeakerDevice() {
+  defaultApi.writeLog(`avsdk ZEGO::getSpeakerDevice ${usingAudioDeviceId.speaker}`);
+  return usingAudioDeviceId.speaker;
+}
+function getSpeakerDeviceVolume() {
+  return speakerVolume;
+}
+function setSpeakerDeviceVolume(volume) {
+  speakerVolume = volume;
+  // NOTE 1. 遍历所有播放器，全部设置
+  Object.keys(streamIdToStreamView).forEach(streamId=> {
+    streamIdToStreamView[streamId].setVolume(speakerVolume);
+  });
+}
+/**
+ * @function 设置扬声器静音
+ * @param mute:Boolean 必选
+ * @return Promise | void
+ */
+function setSpeakerDeviceMute(mute) {
+  // NOTE 1. 遍历所有播放器，全部设置
+  Object.keys(streamIdToStreamView).forEach(streamId=> {
+    const streamView = streamIdToStreamView[streamId];
+    streamView.setAudioMuted(mute);
+  });
+}
+
+/**
+ * @function 获取麦克风列表
+ * @return Promise | void
+ */
+async function getMicrophoneDeviceList() {
+  if(!zg) {
+    return Promise.resolve([]);
+  }
+  let microphoneListArr = await zg.getMicrophones();
+  let microphoneList = [];
+  for (let i = 0, len = microphoneListArr.length; i < len; i++) {
+    microphoneList.push({
+      deviceId: microphoneListArr[i].deviceID,
+      deviceName: microphoneListArr[i].deviceName,
+      isDefault: i === 0,
+    });
+    deviceListReport.micList[microphoneListArr[i].deviceID] = microphoneListArr[i].deviceName;
+  }
+  if (!window.zbyAVSDK_device_checker_init) {
+    window.zbyAVSDK_device_checker_init = {};
+  }
+  if (!window.zbyAVSDK_device_checker_init.microphone) {
+    window.zbyAVSDK_device_checker_init.microphone = {};
+  }
+  window.zbyAVSDK_device_checker_init.microphone.hasTest = true;
+  window.zbyAVSDK_device_checker_init.microphone.list = microphoneList;
+  return microphoneList;
+}
+/**
+ * @function 指定麦克风
+ * @param deviceId:String 麦克风 id，必选
+ * @param operationType:String 操作类型，可选
+ * 'device_error' -> 设备出错处理，'plug_and_unplug' -> 热插拔处理，
+ * 不传即是普通的设置麦克风设备的行为
+ * @return Promise | void
+ */
+async function setMicrophoneDevice(args) {
+  defaultApi.writeLog(`${JSON.stringify(args)}----setMicrophoneDevice-zego----`);
+  let { deviceId, operationType, deviceState, code, changedDeviceId } = args;
+  let deviceName = '';
+  let microPhoneData;
+  // NOTE 1. 没设备就用默认设备
+  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'
+      });
+    }
+  }
+  // NOTE 2. ???
+  try {
+    dataReport.setDevice({
+      device_type: 2,
+      device_id: deviceId,
+      device_name: deviceListReport.micList[deviceId],
+      operationType,
+      fore_state: operationType == 'hotPlug' ? deviceState + 1 : '-'
+    });
+    window.zbyAVSDK_device_checker_init.microphone.name = deviceListReport.micList[deviceId];
+  } catch (e) { };
+  usingAudioDeviceId.microphone = deviceId;
+  // NOTE 3. 设置麦克风
+  await setAudioDevice(0, deviceId);
+  // NOTE WEB无此功能，native 此接口是音量变化事件的开关。
+  // 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 getMicDeviceVolume() {
+  return microphoneVolume;
+}
+function setMicDeviceVolume(volume) {
+  microphoneVolume = volume;
+  return localStream.setVolume(volume);
+}
+/**
+ * @function 设置麦克风静音
+ * @param mute:Boolean 必选
+ * @return Promise | void
+ */
+function setMicDeviceMute(mute) {
+  if(localStream) {
+    return zg.mutePublishStreamAudio(localStream, mute);
+  }
+}
+/**
+ * @function 获取当前应用程序音量
+ * @return Promise | void
+ */
+function getSpeakerSimpleVolume() {
+  // NOTE native端是设置扬声器的程序音量
+  return speakerVolume;
+}
+function setSpeakerSimpleVolume(volume) {
+  speakerVolume = volume;
+  // NOTE 遍历播放器，分别设置
+  // NOTE TODO ...
+  Object.keys(streamIdToStreamView).forEach(streamId=> {
+    const streamView = streamIdToStreamView[streamId];
+    streamView.setVolume(volume);
+  });
+}
+function setSpeakerSimpleMute(mute) {
+  // NOTE 遍历所有的拉流播放器，设置mute
+  // 用setAudioMuted，因为禁流轨道有active接口
+  setSpeakerDeviceMute(mute);
+}
+function setPreviewView() {
+  // NOTE WEB无此功能
+}
+async function startPreview(viewElement) {
+  if(!localStream) {
+    cameraConstraints.captureView = viewElement;
+    cameraConstraints.camera.audio.input = window.zbyAVSDK_device_checker_init.microphone.use;
+    cameraConstraints.camera.video.input = window.zbyAVSDK_device_checker_init.camera.use;
+    const constraints = Object.assign({}, cameraConstraints);
+    if(!hasCamera) {
+      constraints.camera.video = false;
+    }
+    if(!hasMicrophone) {
+      constraints.camera.audio = false;
+    }
+    localStream = await zg.createZegoStream(constraints);
+    localStream.on('canPlayCaptureVideo', function(){
+      console.warn('[采集首帧]', localStream);
+      // 大班数据上报 TODO ...
+      // dabanDataReport({
+      //   action: 'open_camera',
+      //   camera_status: 1,
+      //   uid: window.zbyAVSDK_init_params.zego.userId // zbyAVSDK_init_params这个对象在上层没被定义
+      // });
+    });
+    setMicDeviceVolume(microphoneVolume);
+  }
+
+  if(viewElement) {
+    localStream.playVideo(viewElement); // NOTE 渲染
+  }
+}
+async function startLocalOrRemotePreview(isLocal, streamId, domId) {
+  if(!domId) { return; }
+  // NOTE 1. 预览流渲染
+  if(isLocal) {
+    if (streamId === localStreamId) {
+      return startPreview(document.querySelector(`#${domId}`));
+    }
+    if (streamId === screenStreamId) {
+      return startScreenPreview(document.querySelector(`#${domId}`));
+    }
+    defaultApi.writeLog(`ZEGO: startLocalOrRemotePreview wrong streamId: ${streamId} domId: ${domId}`, null, error);
+  }else {
+    // NOTE 拉流渲染前，先读取activate预置的参数
+    const playInfo1 = streamIdRtcPlayerInfo1[streamId];//true -> 拉取，false -> 不拉取，必选
+    if(!playInfo1.video_type) {
+      try {
+        zg.mutePlayStreamVideo(streamId, !playInfo1.video_type); // NOTE 没视轨会报错
+      } catch (error) { }
+    }
+    if(!playInfo1.audio_type) {
+      try {
+        zg.mutePlayStreamAudio(streamId, !playInfo1.audio_type); // NOTE 没音轨会报错
+      } catch (error) { }
+      
+    }
+    const remoteStream = streamIdToStream[streamId];
+    const remoteView = zg.createRemoteStreamView(remoteStream);
+    streamIdToStreamView[streamId] = remoteView;
+    remoteView.setVolume(speakerVolume);
+    remoteView.useAudioOutputDevice(window.zbyAVSDK_device_checker_init.speaker.use);
+    remoteView.on('canPlayVideo', function() {
+      console.warn('[拉流视频首帧]', streamId, remoteView);
+      // TODO 
+      // if (window.zbyAVSDK_init_params.zego.role === 'student') {
+      //   dabanDataReport({
+      //     action: 'interact_play',
+      //     teammate_streamid: _data.pszStreamID,
+      //     uid: window.zbyAVSDK_init_params.zego.userId // NOTE zbyAVSDK_init_params这个对象在上层没被定义
+      //   });
+      // }
+      try {
+        NOTICE.firstVideoSize({
+          streamId: streamId,
+          userId: util.getUidByStreamId(streamId)
+        });
+        dataReport.firstVideoSize({
+          pull_streamid: streamId,
+          pull_uid: util.getUidByStreamIdDr(streamId),
+          code: '0'
+        });
+      } catch (e) { };
+      defaultApi.writeLog(`ZEGO: pullStream success & haveFirstVideoSize  streamId: ${streamId}`);
+    });
+    remoteView.on('canPlayAudio', function() {
+      console.warn('[拉流音频首帧]', streamId);
+      try {
+        NOTICE.firstAudioSize({
+          streamId: streamId,
+          userId: util.getUidByStreamId(streamId)
+        });
+        dataReport.firstAudioSize({
+          pull_streamid: streamId,
+          pull_uid: util.getUidByStreamIdDr(streamId),
+          code: '0'
+        });
+      } catch (e) { };
+    });
+    remoteView.on('autoplayFailed', function() {
+      console.error('自动播放音频失败');
+    });
+    remoteView.play(domId);
+    try {
+      // NOTE 防止二次拉流，业务侧创重名播放容器
+      document.querySelectorAll('#' + domId)[1].remove();
+    } catch (error) {}
+  }
+}
+async function setEnableNoiseSuppress(ANS) { // 降噪
+  // NOTE 1. 保存设置 
+  cameraConstraints.camera.audio['ANS'] = ANS;
+  // NOTE 2. 已创建流了, 更新
+  if(localStream) {
+    return zg.setAudioConfig(localStream, { ANS });
+  }
+  return Promise.resolve(true);
+}
+async function setEnableAEC(AEC) { // 回声消除
+  // NOTE 1. 保存设置 
+  cameraConstraints.camera.audio['AEC'] = AEC;
+  // NOTE 2. 已创建流了, 更新
+  if(localStream) {
+    return zg.setAudioConfig(localStream, { AEC });
+  }
+  return Promise.resolve(true);
+}
+async function setVideoFPS(frameRate) {
+  // NOTE 1. 保存设置
+  cameraConstraints.camera.video.frameRate = frameRate;
+  // NOTE 2. 已创建流了, 更新
+  if(localStream) {
+    return zg.setVideoConfig(localStream, { frameRate });
+  }
+  return Promise.resolve(true);
+}
+async function setVideoBitrate(maxBitrate) {
+  // NOTE 1. 保存设置
+  cameraConstraints.videoBitrate = maxBitrate/1000;
+  // NOTE 2. 已创建流了, 更新
+  if(localStream) {
+    return zg.setVideoConfig(localStream, { maxBitrate });
+  }
+  return Promise.resolve(true);
+}
+async function setAudioBitrate(maxBitrate) {
+  // NOTE 1. 保存设置
+  cameraConstraints.audioBitrate = maxBitrate/1000;
+  // NOTE 2. WEB 不支持动态改音频码率，非要改的话需要销毁音频重新创建
+  return Promise.resolve(true);
+}
+async function setVideoCaptureResolution(width, height) {
+  // NOTE 1. 保存设置
+  cameraConstraints.camera.video.width = width;
+  cameraConstraints.camera.video.height = height;
+  // NOTE 2. 已创建流了, 更新
+  if(localStream) {
+    console.warn(localStream, { width, height });
+    return zg.setVideoConfig(localStream, { width, height });
+  }
+  // NOTE 3. setCapturePipelineScaleMode WEB无缩放时机
+  return Promise.resolve(true);
+}
+async function setCameraParam(width, height) {
+  // NOTE WEB没有采集、编码分辨率，只是提供一个目标值，采多少编多少浏览器动态调控
+  return setVideoCaptureResolution(width, height);
+}
+async function setVideoEncodeResolution(width, height) {
+  // NOTE WEB没有采集、编码分辨率，只是提供一个目标值，采多少编多少浏览器动态调控
+  return setVideoCaptureResolution(width, height);
+}
+/**
+ * 开始推流
+ * @param {string} streamId 流唯一标识
+ * @param {0 | 1} idx 0: 启动摄像头 1: 启动屏幕共享
+ * @returns 
+ */
+async function startPublish2(streamId, idx) {
+  if (!streamId) {
+    streamId = localStreamId;
+  }
+
+  if (streamId === localStreamId) {
+    // NOTE 初始化推流埋点数据
+    resetHeartBeatDataReportObj();
+    const publisRes = zg.startPublishingStream(streamId, localStream);
+    if(!publisRes) { 
+      NOTICE.pushStreamError({
+        streamId,
+      });
+      return;
+    }
+  } else if (streamId === screenStreamId) {
+    screenStream = await startScreenPreview();
+    const publisRes = zg.startPublishingStream(streamId, screenStream);
+    if(!publisRes) { 
+      NOTICE.pushStreamError({
+        streamId,
+      });
+      return;
+    }
+  } else {
+    defaultApi.writeLog(`ZEGO:: startPublish2 streamId:${streamId} is not exist[${localStreamId}, ${screenStreamId}]`, null, 'error');
+    NOTICE.pushStreamError({
+      streamId,
+      msg: `streamId:${streamId} is not exist[${localStreamId}, ${screenStreamId}]`
+    });
+  
+  }
+}
+function stopPublish(idx) {
+  console.log('[停止推流]', localStreamId);
+  if (idx !== 0 || idx !== 1) {
+    defaultApi.writeLog(`ZEGO:: stopPublish idx:${idx} is not exist[${localStreamId}, ${screenStreamId}]`, null, 'error');
+  }
+  return zg.stopPublishingStream(idx === 0 ? localStreamId : screenStreamId);
+}
+async function startScreenPreview(captureView) {
+  if (!screenStream) {
+    screenConstraints.videoBitrate = initParams.screenSameBitrate / 1000;
+    screenConstraints.captureView = captureView;
+    screenConstraints.screen.video.frameRate = initParams.screenSameFps;
+    screenConstraints.screen.width = initParams.screenSameResolutionWidth;
+    screenConstraints.screen.height = initParams.screenSameResolutionHeight;
+    screenConstraints.screen.audio = false;
+    console.warn('[创建屏幕共享流]', screenConstraints);
+    screenStream = await zg.createZegoStream(screenConstraints);
+  }
+
+  if (captureView) {
+    screenStream.playVideo(captureView);
+  }
+  return screenStream;
+}
+
+async function initPullFlow(streamId, domId, mute, pInfo, notAutoPlay, audioOnly) {
+  defaultApi.writeLog(`ZEGO:: initPullFlow_start ,streamId :${streamId}, domId: ${domId}, mute: ${mute}, pInfo: ${pInfo}, notAutoPlay: ${notAutoPlay}, audioOnly: ${audioOnly}`);
+  // NOTE 1. 重置埋点数据
+  let playChannel = _initPullData(streamId);
+  // NOTE 5. 配置拉流参数
+  //是否拉取声音
+  await activateAudioPlayStream(streamId, !mute);
+  //是否拉取画面
+  await activateVideoPlayStream(streamId, !audioOnly);
+  // NOTE 6. 拉流
+  // if (!notAutoPlay) { // NOTE 此处不自动播放，什么地方拉流？
+  //   await playStream(streamId, playChannel, pInfo);
+  // }
+  const remoteStream = await playStream(streamId, playChannel, pInfo);
+  streamIdToStream[streamId] = remoteStream;
+  // 创建视图
+  await startLocalOrRemotePreview(false, streamId, domId);
+  return {
+    videoSrc: '',
+    playerId: playChannel
+  };
+}
+
+function _initPullData(streamId) {
+  let playChannel;
+  // NOTE 1. 重置埋点数据
+  resetStreamIdRtcPlayerInfo1(streamId);
+  resetStreamIdRtcPlayerInfo(streamId);
+  // NOTE 2. 首次拉流，启动埋点上报程序
+  try {
+    if (!isFirstHeartBeatReport) {
+      isFirstHeartBeatReport = true;
+      heartBeatDataReport('start');
+    }
+  } catch (error) { }
+  // NOTE 3. 程序限制了拉流49条，给每条拉流设置一个编号
+  if (streamIdToPreviewId[streamId] == undefined) {
+    defaultApi.writeLog(`ZEGO::  The streamId queue does not contain this streamId ${uiChnIndexs}`);
+    // NOTE 3.1 超50条，不能再拉流了
+    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 {
+    // NOTE 3.2 已存在，停拉重拉
+    playChannel = streamIdToPreviewId[streamId];
+    defaultApi.writeLog(`ZEGO::  The streamId queue contains this streamId ${playChannel} ${uiChnIndexs}`);
+    stopPlayStream(streamId);
+    resetStreamIdRtcPlayerInfo(streamId);
+  }
+  // NOTE 4. 判断是否创建或者获取播放编号成功，不成功就删掉重试
+  if (playChannel == undefined) {
+    delete streamIdToPreviewId[streamId];
+    defaultApi.writeLog('error', 'ZEGO::  uiChnIndex is not exist');
+    return initPullFlow(streamId);
+  }
+  previewIdToStreamId[playChannel] = streamId;
+  return playChannel;
+}
+
+/**
+ * @function 恢复拉指定的流
+ * @param streamId:String 被拉取的流的 id，必选
+ * @param uiChnIndex:Number 播放通道，可选
+ * @param pInfo:String 多媒体流附加信息，可选，默认为 'none'
+ * @return Promise | void
+ */
+async function playStream(streamId, uiChnIndex, pInfo) {
+  if (typeof pInfo === 'undefined') { // SEI
+    pInfo = 'none';
+  }
+  const streamInfo = streamIdRtcPlayerInfo1[streamId];
+  defaultApi.writeLog(`avsdk ZEGO::PlayStream streamId: ${streamId} streamInfo: ${JSON.stringify(streamInfo)}`);
+  return zg.startPlayingStream(streamId, {
+    // TODO 拉流参数配置
+    // video: !!!audioOnly,
+    video: streamInfo.video_type,
+    audio: streamInfo.audio_type,
+    isSEIStart: pInfo != 'none'? true: false,
+  });
+}
+async function stopPlayStream(streamId, recovery) {
+  console.warn('[停止拉流]', 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 streamIdToStream[streamId];
+  delete streamIdToStreamView[streamId];
+  zg.stopPlayingStream(streamId);
+  // NOTE 清除渲染节点 拉纯音频，渲染节点直接挂在body上
+  try {
+    const dom = document.querySelector('#' + streamId); // id不存在会抛错
+    if(dom) { dom.remove(); }
+  } catch (error) { }
+  
+}
+function stopAllPlayStream() {
+  Object.keys(streamIdToPreviewId).forEach(streamId=> {
+    const id = streamIdToPreviewId[streamId];
+    if (id !==void(0) && !uiChnIndexs.includes(id)) {
+      uiChnIndexs.push(id);
+      stopPlayStream(streamId);
+    }
+  });
+  streamIdToPreviewId = {};
+  streamIdToStream = {};
+  streamIdToStreamView = {};
+}
+async function leaveRoom(type) {
+  // NOTE 1. 停止声浪监听 WEB端无需单独停止
+  // NOTE 2. 停拉 
+  for (let key in streamIdToPreviewId) {
+    stopPlayStream(key, true);
+  }
+  // NOTE 3. 停推
+  zg.stopPublishingStream(localStreamId);
+  // NOTE 4. 停事件监听
+  removerListener();
+  // NOTE 5. 刷新按钮
+  if(type == 'reload') {
+    // TODO ...
+  }else {
+    // 停预览
+    zg.destroyStream(localStream);
+    // 销毁引擎
+    zg.destroyEngine();
+  }
+  // NOTE 6. 其它业务逻辑
+  heartBeatDataReport('stop');
+  isFirstHeartBeatReport = false;
+  streamIdToPreviewId = {};
+  previewIdToStreamId = {};
+  streamIdRtcPlayerInfo = {};
+  streamIdRtcPlayerInfo1 = {};
+  // heartBeatDataReportObj = {};
+  hasLoginChannel = 0;
+}
+
+async function playerSnapShot(streamId) {
+  defaultApi.writeLog(`avsdk ZEGO::playerSnapShot streamId: ${streamId}`);
+  let uri;
+  if (streamId === localStreamId) {
+    uri = localStream.takeStreamSnapshot();
+  } else {
+    uri = screenStream.takeStreamSnapshot();
+  }
+  defaultApi.writeLog(`avsdk ZEGO::playerSnapShot uri: ${uri}`);
+  return util.getImageDataFromURL(uri);
+}
+async function activateAudioPlayStream(streamId, bActive) {
+  // NOTE WEB无此接口，此处业务侧应该是想达到是否渲染音视频的目的。所以web端先拉流，再按此设置值渲染
+  // NOTE 关联代码 streamview.play()
+  if(!streamIdRtcPlayerInfo1[streamId]) { 
+    resetStreamIdRtcPlayerInfo1(streamId);
+  }
+  streamIdRtcPlayerInfo1[streamId].audio_type = bActive;
+  if(streamIdToStream[streamId]) { // 流已存在
+    await zg.mutePlayStreamAudio(streamId, !bActive);
+  }
+}
+/**
+ * @function 拉取音频流
+ * @param operation:Boolean true/不拉音频，false/拉音频,必选
+ * @param streamid:String 被拉取的流的 id，必选
+ */
+async function pullAudioFlow(streamId, operation) {
+  // NOTE 1. 数据埋点、上报
+  defaultApi.writeLog(`pullAudioFlow -- operation ${operation} streamId ${streamId}`);
+  if (!streamId) {
+    throw new Error('pullAudioFlow -- streamId is not allowed to be empty');
+  }
+  if (streamIdToPreviewId[streamId] == undefined) {
+    // NOTICE.pullAudioFlowError({ streamid })
+    _initPullData(streamId); // 启动
+  }
+  try {
+    streamIdRtcPlayerInfo1[streamId].audio_type = operation;
+  } 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) { };
+  // NOTE 2. 正式拉流；
+  if (!streamIdToStream[streamId]) {
+    streamIdToStream[streamId] = await zg.startPlayingStream(streamId, { video: false });
+  };
+  // NOTE 3. 流挂载到body上
+  if (!operation) {
+    try {
+      const dom = document.querySelector('#' + streamId); // id不存在会抛错
+      if(dom) { dom.remove(); }
+    } catch (error) { }
+    const div = document.createElement('div');
+    div.style.display = 'none';
+    div.id = streamId;
+    document.body.appendChild(div);
+    await startLocalOrRemotePreview(false, streamId, streamId);
+  }
+
+  await zg.mutePlayStreamAudio(streamId, operation);
+}
+async function activateVideoPlayStream(streamId, bActive) {
+  // NOTE WEB无此接口，此处业务侧应该是想达到是否渲染音视频的目的。所以web端先拉流，再按此设置值渲染
+  if(!streamIdRtcPlayerInfo1[streamId]) { 
+    resetStreamIdRtcPlayerInfo1(streamId);
+  }
+  streamIdRtcPlayerInfo1[streamId].video_type = bActive;
+  if(streamIdToStream[streamId]) { // 流已拉取
+    await zg.mutePlayStreamVideo(streamId, !bActive);
+  }
+}
+
+function setAudioVolumeNotify() {
+  // NOTE WEB无此功能
+}
+function stopAudioVolumeNotify() {
+  // NOTE WEB无此功能
+}
+function openMicVolumeCb() {}
+// 声浪开关
+function startSoundLevelMonitor() {
+  zg.setSoundLevelDelegate(true, soundLevelMonitorCycle);
+}
+function stopSoundLevelMonitor() {
+  zg.setSoundLevelDelegate(false);
+}
+// 设置声浪回调周期
+function setSoundLevelMonitorCycle(interval) {
+  console.warn('[声浪周期]', interval);
+  soundLevelMonitorCycle = interval;
+  zg.setSoundLevelDelegate(true, soundLevelMonitorCycle);
+}
+function setMirrorStatus(mirror) {
+  setVideoMirrorMode(mirror);
+}
+function getStreamType() {
+  // NOTE 此接口 外层未被使用
+}
+/**
+  * @function 设置拉流镜像状态
+  * @param { boolean } type true=开启 false=关闭
+  * @return: Promise
+  */
+function setPlayViewMirror(mirror) {
+  // 遍历所有的拉流streamview,逐个镜像
+  Object.keys(streamIdToStreamView).forEach(streamId=> {
+    try {
+      const streamView = streamIdToStreamView[streamId];
+      streamView.play(streamView.v.container, { mirror });
+    } catch (error) { }
+  });
+}
+/**
+ * @function 是否推声音
+ * @param mute:Boolean true/不推声音，false/推声音,必选
+ * @return Promise | void
+ */
+function setMuteStreamAudio(mute) {
+  if(localStream) {
+    return zg.mutePublishStreamAudio(localStream, mute);
+  }
+}
+/**
+ * @function 是否推画面
+ * @param mute:Boolean true/不推画面，false/推画面,必选
+ * @return Promise | void
+ */
+function setMuteStreamVideo() {
+  if(localStream) {
+    return zg.mutePublishStreamVideo(localStream, mute);
+  }
+}
+function teacherStartLinkMic() {
+  // NOTE 此接口 暂时不用实现
+}
+function teacherStopLinkMic() {
+  // NOTE 此接口 暂时不用实现
+}
+function getSDKVersion() {
+  return zg.getVersion();
+}
+function getCameraSupportedRes() {
+  // TODO WEB需要创建流去确认，能创成则支持
+}
+function setVideoMirrorMode(mirror) {
+  // localStream.stopVideo();
+  localStream.playVideo(cameraConstraints.captureView, {mirror});
+}
+function startMultiScreen() {}
+function addListener() {
+  console.warn('[注册监听]');
+  // OnInitSDK
+  // NOTE WEB没有此事件
+  // OnLoginChannel
+  zg.on('roomStateChanged', _onRoomStateChanged);
+  // OnPublishStateUpdate
+  zg.on('publisherStateUpdate', _onPublisherStateUpdate);
+  // OnPublishQualityUpdate
+  zg.on('publishQualityUpdate', _onPublishQualityUpdate); // 重要
+  // OnCaptureSoundLevelUpdate
+  zg.on('capturedSoundLevelUpdate', _onCapturedSoundLevelUpdate);
+  // OnSoundLevelUpdate
+  zg.on('soundLevelUpdate', _onSoundLevelUpdate); // 重要
+  // OnPlayStateUpdate
+  zg.on('playerStateUpdate', _onPlayerStateUpdate);
+  // OnPlayQulityUpdate
+  zg.on('playQualityUpdate', _onPlayQualityUpdate); // 重要
+  // OnVideoDeviceStateChanged
+  zg.on('videoDeviceStateChanged', _onVideoDeviceStateChanged);
+  // OnAudioDeviceStateChanged
+  zg.on('audioDeviceStateChanged', _onAudioDeviceStateChanged);
+  // OnDeviceError
+  zg.on('deviceError', _onDeviceError);
+  // screenSharingEnded
+  zg.on('screenSharingEnded', _onScreenSharingEnded);
+  // OnAVKitEvent
+  // OnAVEngineStop
+  // OnMixStream
+  // OnRenderRemoteVideoFirstFrame 渲染相关的事件在streamView上管理
+  // OnRecvRemoteAudioFirstFrame 渲染相关的事件在streamView上管理
+  // onRecvMediaSideInfo
+  // zego_recovery_start
+  // OnRelayCDNStateUpdate
+  // OnCaptureVideoFirstFrame 渲染相关的事件在streamView上管理
+  // OnKaDunEvent
+
+  // NOTE 原native代码里缺少流更新事件监听
+  zg.on('roomStreamUpdate', _onRoomStreamUpdate);
+}
+function removerListener() {
+  console.warn('[注销监听]');
+  // OnInitSDK
+  // NOTE WEB没有此事件
+  // OnLoginChannel
+  zg.off('roomStateChanged');
+  // OnPublishStateUpdate
+  zg.off('publisherStateUpdate');
+  // OnPublishQualityUpdate
+  zg.off('publishQualityUpdate'); // 重要
+  // OnCaptureSoundLevelUpdate
+  zg.off('capturedSoundLevelUpdate'); // 重要
+  // OnSoundLevelUpdate
+  zg.off('soundLevelUpdate');  // 重要
+  // OnPlayStateUpdate
+  zg.off('playerStateUpdate');
+  // OnPlayQulityUpdate
+  zg.off('playQualityUpdate'); // 重要
+  // OnVideoDeviceStateChanged
+  zg.off('videoDeviceStateChanged');
+  // OnAudioDeviceStateChanged
+  zg.off('audioDeviceStateChanged');
+  // OnDeviceError
+  zg.off('deviceError');
+  // screenSharingEnded
+  zg.off('screenSharingEnded');
+  // OnAVKitEvent
+  // OnAVEngineStop
+  // OnMixStream
+  // OnRenderRemoteVideoFirstFrame 渲染相关的事件在streamView上管理 重要
+  // OnRecvRemoteAudioFirstFrame 渲染相关的事件在streamView上管理 重要
+  // onRecvMediaSideInfo
+  // zego_recovery_start
+  // OnRelayCDNStateUpdate
+  // OnCaptureVideoFirstFrame 渲染相关的事件在streamView上管理
+  // OnKaDunEvent
+
+  // NOTE 原native代码里缺少流更新事件监听
+  zg.off('roomStreamUpdate');
+}
+
+function _onRoomStateChanged(roomID, reason, errorCode, extendData) {
+  console.warn('[房间状态回调]', roomID, reason, errorCode, extendData);
+  if (reason == 'LOGINED') {
+    hasLoginChannel = 1;
+  }
+  if (errorCode >= 1002050 && errorCode < 1002060) {
+    defaultApi.writeLog('ZEGO::leaveRoom-- trigger by roomStateChange');
+    window.zbztsdk.leaveRoom();
+  }
+  defaultApi.writeLog(`ZEGO::addListener-- OnLoginChannel: ${errorCode}`);
+}
+function _onPublisherStateUpdate(result) {
+  const { state, streamID, errorCode, extendedData } = result;
+  console.log('[推流状态回调]', result);
+  // NOTE 状态码变化相关日志 待补充
+  // NOTE 1. hasPushFlow: 推流成功后启动数据上报; window.zegoHasPushFlow: 加学生端加入房间消息; 当前都用不着
+  if (state == 'PUBLISHING') {
+    // 心跳开始
+    if (!isFirstHeartBeatReport) {
+      isFirstHeartBeatReport = true;
+      heartBeatDataReport('start');
+    }
+    NOTICE.pushFlowSuccess({ code: 0, publish_streamid: streamID });
+  }
+  // 
+  let ReportArgs = { publish_rtc_streamid: streamID };
+  dataReport.publishResult({
+    code: errorCode,
+    ...ReportArgs
+  });
+}
+function _onPublishQualityUpdate(streamId, stats) {
+  console.log('推流质量回调', streamId, stats);
+  NOTICE.pushQuality({
+    video: {
+      streamId,
+      bitrate: Math.round(stats.video.videoBitrate),
+      fps: Math.round(stats.video.videoFPS)
+    }
+  });
+  NOTICE.pushLossAndDelay({
+    userId: util.getUidByStreamId(streamId),
+    delay: stats.currentRoundTripTime,
+    lostrate: stats.video.videoPacketsLostRate
+  });
+  heartBeatDataReportCalc('onPublishQualityUpdate', stats, streamId);
+}
+function _onCapturedSoundLevelUpdate(soundLevel) {
+  if (isNoticeMicVolumeZego) {
+    NOTICE.captureMicVolumeChanged({
+      volume: Math.round(soundLevel)
+    });
+  }
+  heartBeatDataReportObj.volume = heartBeatDataReportObj.volume + Math.round(soundLevel) + ',';
+}
+function _onSoundLevelUpdate(soundLevelList) {
+  soundLevelList.forEach(item => {
+    const cbData = {
+      streamid: item.streamID,
+      userId: util.getUidByStreamId(item.streamID),
+      volume: Math.round(item.soundLevel)
+    };
+    NOTICE.playerVolumeChanged(cbData);
+    NOTICE.volumeChange(cbData);
+    if (streamIdRtcPlayerInfo[item.streamID]) {
+      streamIdRtcPlayerInfo[item.streamID].volume = streamIdRtcPlayerInfo[item.streamID].volume + Math.round(item.soundLevel) + ',';
+    }
+  });
+}
+function _onPlayerStateUpdate(result) {
+  // TODO 
+  const { state, streamID, errorCode, extendedData } = result;
+  if (state == 'PLAYING') {
+    console.log('成功拉取音视频流：', streamID);
+  } else if (state == 'NO_PLAY') {
+    console.log('未拉取音视频流');
+  } else if (state == 'PLAY_REQUESTING') {
+    console.log('请求拉取音视频流：', streamID);
+  }
+  console.log('错误码:', errorCode,' 额外信息:', extendedData);
+}
+function _onPlayQualityUpdate(streamID,stats) {
+  console.log('拉流质量回调', streamID, stats);
+  NOTICE.pullQuality({
+    video: {
+      streamId: streamID,
+      userId: util.getUidByStreamId(streamID),
+      bitrate: stats.video.videoBitrate,
+      fps: stats.video.videoFPS,
+      volume: stats.audio.audioLevel * 100 >> 0,
+    }
+  });
+  // console.log('拉流延迟丢包zego',_data);
+  NOTICE.playLossAndDelay({
+    userId: util.getUidByStreamId(streamID),
+    delay: stats.currentRoundTripTime,
+    lostrate: stats.video.videoPacketsLostRate
+  });
+  currStreamIdRtcPlayerInfo = streamIdRtcPlayerInfo[streamID]; // ???
+  heartBeatDataReportCalc('onPlayQualityUpdate', stats, streamID);
+}
+function _onRoomStreamUpdate(roomID, updateType, streamList, extendedData) {
+  console.warn('[房间流回调]', roomID, updateType, streamList, extendedData);
+}
+function _onVideoDeviceStateChanged(updateType, deviceInfo) {
+  // NOTE 1. state 0=添加设备 1=移除设备
+  const state = updateType == 'ADD'? 0: 1;
+  const agrs = { 
+    // NOTE 2. 插设备，用新设备；拔设备，用默认设备
+    deviceId: updateType == 'DELETE' ? '' : deviceInfo.deviceID, 
+    idx: 0, 
+    operationType: 'hotPlug', 
+    deviceState: state,
+    changedDeviceId: deviceInfo.deviceID
+  };
+  setVideoDevice(agrs);
+}
+function _onAudioDeviceStateChanged(updateType, deviceType, deviceInfo) {
+  const state = updateType == 'ADD'? 0: 1;
+  const agrs = { 
+    // NOTE 2. 插设备，用新设备；拔设备，用默认设备
+    deviceId: updateType == 'DELETE' ? '' : deviceInfo.deviceID, 
+    idx: 0, 
+    operationType: 'hotPlug', 
+    deviceState: state,
+    changedDeviceId: deviceInfo.deviceID
+  };
+  if(deviceType == 'Input') { // microphone
+    setMicrophoneDevice(agrs);
+  }else { // speaker
+    setSpeakerDevice(agrs);
+  }
+}
+
+function _onDeviceError(errorCode, deviceName) {
+  defaultApi.writeLog(`avsdk ZEGO:: OnDeviceError ${deviceName} ${errorCode}`);
+  dataReport.deviceError({ deviceName, errorCode });
+}
+
+function _onScreenSharingEnded() {
+  defaultApi.writeLog('avsdk ZEGO:: _onScreenSharingEnded');
+  zg.stopPublishingStream(screenStreamId);
+  zg.destroyStream(screenStream);
+  NOTICE.screenShareEnded();
+}
+
+function loadZego() {}
+
+//推流字段
+function 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: ''
+  };
+};
+//记录拉流类型，用作数据上报
+function resetStreamIdRtcPlayerInfo1(streamId) {
+  streamIdRtcPlayerInfo1[streamId] = {
+    audio_type: false,
+    video_type: false,
+    stream_type: 'none'
+  };
+}
+//拉流字段
+function resetStreamIdRtcPlayerInfo(streamId) {
+  streamIdRtcPlayerInfo[streamId] = {
+    pull_uid: util.getUidByStreamId(streamId),
+    streamid: streamId,
+    ctime: [],
+    pull_type: streamIdRtcPlayerInfo1[streamId].stream_type,
+    volume: '',
+    // 平均值
+    video_fps: [],
+    video_bitrate: [],
+    audio_fps: [],
+    audio_bitrate: [],
+    pull_loss: [],
+    pull_delay: [],
+    //音画不同步字段
+    avtimestampdiff: [],
+    // 累加
+    audio_ifg: 0,
+    video_ifg: 0
+  };
+}
+function 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);
+  }
+};
+
+function _heartBeatDataReport() {
+  let rateCount = 0;
+  let rateTimer = setInterval(async () => {
+    rateCount++;
+    // NOTE 30s后上报？
+    if (rateCount >= 3) {
+      const pullInfo = [];
+      Object.keys(streamIdRtcPlayerInfo).forEach(streamid => {
+        heartBeatRealKeys.forEach(realKey => {
+          if (!streamIdRtcPlayerInfo[streamid].hasOwnProperty(realKey)) {
+            streamIdRtcPlayerInfo[streamid][realKey] = [];
+          }
+        });
+
+        //获取拉流类型，后期可写为函数提出去
+        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';
+        }
+
+        pullInfo.push({
+          streamid,
+          ...streamIdRtcPlayerInfo[streamid],
+          pull_type: streamIdRtcPlayerInfo1[streamid].stream_type,
+          volume: streamIdRtcPlayerInfo[streamid].volume.slice(0, streamIdRtcPlayerInfo[streamid].volume.length - 1)
+        });
+        resetStreamIdRtcPlayerInfo(streamid);
+      });
+      if (isFirstHeartBeatReport && rateCount > 0) {
+        try {
+          //静音推流时过滤掉音频帧率和码率，上报为0；
+
+          //获取推流类型，后期可写为函数提出去
+          // TODO
+          // if (zbysdk.deviceStatus.camera && zbysdk.deviceStatus.microphone) {
+          //   zbysdk.deviceStatus.stream_type = 'both';
+          // } else if (!zbysdk.deviceStatus.camera && zbysdk.deviceStatus.microphone) {
+          //   zbysdk.deviceStatus.stream_type = 'audio';
+          // } else if (zbysdk.deviceStatus.camera && !zbysdk.deviceStatus.microphone) {
+          //   zbysdk.deviceStatus.stream_type = 'video';
+          // } else {
+          //   zbysdk.deviceStatus.stream_type = 'none';
+          // };
+          // defaultApi.writeLog(`push_type_zego,camera: ${zbysdk.deviceStatus.camera},microphone: ${zbysdk.deviceStatus.microphone},type: ${zbysdk.deviceStatus.stream_type},a_fps: ${dataZegoCapture.afps}, a_bit: ${dataZegoCapture.akbps}, v_fps: ${dataZegoCapture.fps}, v_bit: ${dataZegoCapture.kbps}`);
+
+          // dataReport.heartbeat({
+          //   ...{ ...heartBeatDataReportObj, push_type: zbysdk.deviceStatus.stream_type, volume: heartBeatDataReportObj.volume.slice(0, heartBeatDataReportObj.volume.length - 1) },
+          //   pull_info: pullInfo,
+          // });
+        } catch (e) {
+          console.log(e);
+        }
+      }
+      resetHeartBeatDataReportObj();
+      rateCount = 0;
+
+      clearInterval(rateTimer);
+    }
+  }, 10 * 1000);
+};
+
+function heartBeatDataReportCalc(name, stats, streamId) {
+  const audioFPS = parseFloat(parseInt(stats.audio.audioFPS));
+  const audioBitrate = parseFloat(parseInt(stats.audio.audioBitrate));
+  const videoFPS = parseFloat(parseInt(stats.video.videoFPS));
+  const videoBitrate = parseFloat(parseInt(stats.video.videoBitrate));
+  let info = {};
+  if(name == 'onPublishQualityUpdate') {
+    info = heartBeatDataReportObj;
+    dataZegoCapture = stats;
+    info.push_loss.push(stats.video.videoPacketsLostRate);
+    info.push_delay.push(stats.currentRoundTripTime);
+  } else if(name == 'onPlayQualityUpdate') {
+    info = streamIdRtcPlayerInfo[streamId];
+    // streamIdRtcPlayerInfo[streamId].avtimestampdiff.push(_d.avTimestampDiff); // 时间差？？？ TODO
+    info.pull_loss.push(stats.video.videoPacketsLostRate);
+    info.pull_delay.push(stats.currentRoundTripTime);
+  }
+  info.audio_fps.push(audioFPS);
+  info.audio_bitrate.push(audioBitrate);
+  info.video_fps.push(videoFPS);
+  info.video_bitrate.push(videoBitrate);
+
+  info.ctime.push(Math.round((new Date().getTime() + dataReport.timestamp) / 1000));
+  
+}
+ 
+export default {
+  startEngine,
+  destroyEngine,
+  setDefaultDevice,
+  getVideoDeviceList,
+  setVideoDevice,
+  enableCamera,
+  enableMic,
+  setAudioSpeakerCapture, // done 
+  getAudioDeviceList,
+  setAudioDevice,
+  getSpeakerDeviceList,
+  setSpeakerDevice,
+  getCurrentSpeakerDevice,
+  getSpeakerDeviceVolume,
+  setSpeakerDeviceVolume,
+  setSpeakerDeviceMute,
+  getMicrophoneDeviceList,
+  setMicrophoneDevice,
+  getMicDeviceVolume,
+  setMicDeviceVolume,
+  setMicDeviceMute,
+  getSpeakerSimpleVolume,
+  setSpeakerSimpleVolume,
+  setSpeakerSimpleMute,
+  setPreviewView, // native端是先设置视图再预览，WEB不需要设置视图，无此功能
+  startPreview,
+  startLocalOrRemotePreview,
+  setVideoFPS,
+  setVideoBitrate,
+  setAudioBitrate,
+  setVideoCaptureResolution,
+  setCameraParam,
+  setVideoEncodeResolution,
+  init,
+  startPublish2,
+  stopPublish,
+  initPullFlow,
+  playStream,
+  stopPlayStream,
+  stopAllPlayStream,
+  leaveRoom,
+  playerSnapShot,
+  activateAudioPlayStream,
+  pullAudioFlow,
+  activateVideoPlayStream,
+  setAudioVolumeNotify, // native 监听系统设备音量变化开关，WEB无此接口
+  stopAudioVolumeNotify,
+  openMicVolumeCb,
+  startSoundLevelMonitor,
+  stopSoundLevelMonitor,
+  setSoundLevelMonitorCycle,
+  setMirrorStatus,
+  getStreamType,
+  setPlayViewMirror,
+  setMuteStreamAudio,
+  setMuteStreamVideo,
+  teacherStartLinkMic,
+  teacherStopLinkMic, // 不要
+  getSDKVersion,
+  getCameraSupportedRes,
+  setVideoMirrorMode,
+  startMultiScreen,
+  addListener,
+};
+