zby-live-sdk
Version:
This is a live SDK for weclassroom.
2,347 lines • 60.2 kB
JavaScript
/**
* @File: 直播云音视频 SDK
* @Author: xuyuanrui
* @Email: raywhbxyr@163.com
* @Date: 2018-08-09 00:03:46
**/
import rtcsdk from './rtc-sdk.js';
import zegosdk from './zego-sdk.js';
import talrtcsdk from './talrtc-sdk.js';
import trtcsdk from './trtc-sdk.js';
import defaultApi from '../default';
import util from '../util/util';
import globalConfig from '../config/config.js';
const RTC = 'rtc';
const ZEGO = 'zego';
const TALRTC = 'talrtc';
const TRTC = 'trtc';
const NERTC = 'nertc';
const VOLCRTC = 'volcrtc';
// rtc 底层流媒体数据上报地址配置
const rtcReportUrl = {
test: 'test-r.weclassroom.com',
online: 'r.weclassroom.com'
};
const sdkVale = {
zego: 8, //8代表zego采集麦克风+扬声器
talrtc: 101, //101代表talrtc采集声音
nertc: 101, //101代表talrtc采集声音
volcrtc: 101, //101代表talrtc采集声音
trtc: 102, //102代表trtc采集声音
};
/**
* @function 设备检测初始化(新)
*/
export const deviceCheckerInit = async (extension, env) => {
setDefaultZbySDKDeviceCheckerInit();
await zegosdk.loadZego(extension.version.zego);
//此时课堂外端上无法获取roomid,假数据模拟,待确定userId-万一重复（不推流）
zegosdk.addListener('deviceCheckerInit')
await zegosdk.startEngine(2646760764,'/XpDtuxpv4TrBoNTozIs6waxK6LF/mGZK0jVYo003Ws=')//也是需要参数的,还要区分测试环境和线上环境
await zegosdk.setVideoCaptureResolution(320, 240);
await zegosdk.setVideoBitrate(100000);
await zegosdk.setVideoFPS(15);
await zegosdk.startSoundLevelMonitor();
await zegosdk.setSoundLevelMonitorCycle(500);
let isDeviceCheckInitFinished = zegosdk.getDeviceCheckInitStatus();
if(isDeviceCheckInitFinished) {
zegosdk.setDeviceCheckInitStatus();
window.zbyAVSDK_init_sdk_type = 'zego';
defaultApi.writeLog('isDeviceCheckInitFinished1',isDeviceCheckInitFinished)
} else {
await new Promise((resolve, reject) => {
let timer = null;
timer = setInterval(() => {
isDeviceCheckInitFinished = zegosdk.getDeviceCheckInitStatus();
defaultApi.writeLog('isDeviceCheckInitFinished2',isDeviceCheckInitFinished)
if (isDeviceCheckInitFinished) {
zegosdk.setDeviceCheckInitStatus();
clearInterval(timer);
resolve();
}
defaultApi.writeLog('isDeviceCheckInitFinished3',isDeviceCheckInitFinished)
}, 30);
});
window.zbyAVSDK_init_sdk_type = 'zego';
}
defaultApi.writeLog('change zbyAVSDK_init_sdk_type to rtc , from avsdk device check init');
};
/**
* @function 设置设备检测对象默认值
*/
export const setDefaultZbySDKDeviceCheckerInit = async () => {
if(window.zbyAVSDK_device_checker_init){
if(!window.zbyAVSDK_device_checker_init.microphone){
window.zbyAVSDK_device_checker_init.microphone = {
hasTest: false,
list: [],
use: '',
name:''
};
};
if(!window.zbyAVSDK_device_checker_init.camera){
window.zbyAVSDK_device_checker_init.camera = {
hasTest: false,
list: [],
use: '',
name: ''
};
};
if(!window.zbyAVSDK_device_checker_init.speaker){
window.zbyAVSDK_device_checker_init.speaker = {
hasTest: false,
list: [],
use: '',
name: ''
};
};
} else {
window.zbyAVSDK_device_checker_init = {
microphone: {
hasTest: false,
list: [],
use: '',
name: ''
},
camera: {
hasTest: false,
list: [],
use: '',
name: ''
},
speaker: {
hasTest: false,
list: [],
use: '',
name: ''
}
};
}
// window.zbyAVSDK_device_checker_init = window.zbyAVSDK_device_checker_init || {
// window.zbyAVSDK_device_checker_init = {
// microphone: {
// hasTest: false,
// list: [],
// use: ''
// },
// camera: {
// hasTest: false,
// list: [],
// use: ''
// },
// speaker: {
// hasTest: false,
// list: [],
// use: ''
// }
// };
defaultApi.writeLog(`setDefaultZbySDKDeviceCheckerInit, ${window.zbyAVSDK_device_checker_init}`);
};
/**
* @function 结束设备检测
*/
export const stopCheckDevice = async () => {
defaultApi.writeLog('zby_av_sdk stop checkDevice');
return zegosdk.stopCheckDevice();
};
/**
* @function 初始化
* @param sdk_type:String 'rtc' | 'zego' | 'agora'，必选
* @param args:Object 必选
* {
* rtc: {},
* zego: {},
* agora: {}
* }
* @return Promise | void
*/
export const init = (sdk_type, args) => {
// 将初始化参数存储到全局
window.zbyAVSDK_init_sdk_type = sdk_type;
defaultApi.writeLog(`change zbyAVSDK_init_sdk_type to ${sdk_type} , from avsdk init action`);
window.zbyAVSDK_init_params = args;
setDefaultZbySDKDeviceCheckerInit();
// if (sdk_type !== 'talrtc') { // TODO: 临时处理，后续需要优化
// const config = window.zbyAVSDK_init_params[window.zbyAVSDK_init_sdk_type];
// defaultApi.writeLog(`start checkUpdate, from avsdk init action, config: ${JSON.stringify(config)}`);
// talrtcsdk.checkUpdate(config.institutionId, config.userId, config.role);
// }
return changeSDK(undefined);
};
/**
* @function 恢复sdk
*/
export const recoverSdk = (args) => {
window.zbyAVSDK_init_params = args;
const config = window.zbyAVSDK_init_params[window.zbyAVSDK_init_sdk_type];
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.recoverSdk(config);
case ZEGO:
// return zegosdk.recoverSdk(dealSDKMsg);
default:
break;
}
};
/**
* @function 切换线路
* @param args:Object 可选
* {
* sdk_type, // String，'rtc' | 'zego' | 'agora'，可选
* // 无传入的话，sdk 线路默认选择 window.zbyAVSDK_init_sdk_type
* config // Object，配置的参数对象，不同的线路参数对象不同，可选
* // 无传入的话，sdk 线路默认选择 window.zbyAVSDK_init_params 中相应线路的配置
* }
* @return Promise | void
*/
export const changeSDK = async (args) => {
if (args) {
rtcsdk.stopCheckDevice();
await leaveRoomWithChangeSDK().catch((err) => {
console.error('leave room fail:', err);
});
// await unloadExtension();
}
if (args && args.sdk_type) {
window.zbyAVSDK_init_sdk_type = args.sdk_type;
defaultApi.writeLog(`change zbyAVSDK_init_sdk_type to ${args.sdk_type} , from avsdk changeSDK action`);
}
if (args && args.config) {
window.zbyAVSDK_init_params[window.zbyAVSDK_init_sdk_type] = args.config;
}
const sdk_type = window.zbyAVSDK_init_sdk_type;
const config = window.zbyAVSDK_init_params[window.zbyAVSDK_init_sdk_type];
// 默认使用pomelo
globalConfig.usePomelo = true;
// 切换引擎会走到这里
if (args && config) {
delete config.devices;
}
switch (sdk_type) {
case RTC:
return rtcsdk.init(config);
case ZEGO:
return zegosdk.init(config);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.init(config);
case TRTC:
return trtcsdk.init(config);
default:
break;
}
};
/**
* @function 卸载扩展
* @return Promise | void
*/
export const unloadExtension = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.unloadRtc();
case ZEGO:
return zegosdk.unloadZego();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.unloadTalrtc();
case TRTC:
return trtcsdk.unloadTrtc();
default:
break;
}
};
/**
* @function 获取摄像头列表
* @return Promise | void
*/
export const getCameraDeviceList = async () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.getCameraDevice();
case ZEGO:
return await zegosdk.getVideoDeviceList();
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.getCameraDeviceList();
case TRTC:
return await trtcsdk.getCameraDeviceListTrtc();
default:
return await zegosdk.getVideoDeviceList();
break;
}
};
/**
* @function 指定摄像头
* @param deviceId:String 摄像头 id，必须
* @return Promise | void
*/
export const setCameraDevice = async (deviceId, operationType) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.setCameraDevice({deviceId, operationType});
case ZEGO:
return await zegosdk.setVideoDevice({deviceId, operationType});
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.setCameraDevice({ deviceId });
case TRTC:
return await trtcsdk.setVideoDevice({deviceId});
default:
break;
}
};
/**
* @function 开摄像/关摄像
* @param operation:Boolean 操作类型，false -> 关闭，true -> 打开，必选
* @return Promise | void
*/
export const openOrCloseCamera = (operation) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.openOrCloseCamera(operation);
case ZEGO:
return zegosdk.enableCamera(operation);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.openOrCloseCamera(operation);
case TRTC:
return trtcsdk.openOrCloseCamera(operation);
default:
break;
}
};
//是否推画面 false/不推 true/推
export const setPushStreamVideo = (operation) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.muteStreamVideo(!operation);
case ZEGO:
return zegosdk.setMuteStreamVideo(!operation);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.muteLocalVideo(!operation);
case TRTC:
default:
break;
}
};
/**
* @function 是否推声音 ---暂时没有用到,未抛出去未测
* @param operation:Boolean 操作类型，false -> 关闭，true -> 打开，必选
* @return Promise | void
*/
export const setPushAudioMute = (operation) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.muteStreamAudio(!operation);
case ZEGO:
return zegosdk.setMuteStreamAudio(!operation);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.muteLocalAudio(!operation);
case TRTC:
default:
break;
}
};
/**
* @function 开启预览
* @param operation:Boolean 操作类型，false -> 关闭，true -> 打开，必选
* @return Promise | void
*/
export const startPreview = (operation) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.startPreview(operation);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.startPreview(operation);
case ZEGO:
case TRTC:
default:
break;
}
};
/**
* @function 结束预览
* @param operation:Boolean 操作类型，false -> 关闭，true -> 打开，必选
* @return Promise | void
*/
export const stopPreview = (operation) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.stopPreview(operation);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.stopPreview(operation);
case ZEGO:
case TRTC:
default:
break;
}
};
/**
* @function 开始连麦
* @param mode:number 采集器默认， 默认0=站立 1=坐立
* @return Promise | void
*/
export const teacherStartLinkMic = (mode) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.teacherStartLinkMic(mode);
case ZEGO:
return zegosdk.teacherStartLinkMic(mode);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.teacherStartLinkMic(mode);
case TRTC:
return trtcsdk.teacherStartLinkMic(mode)
default:
break;
}
};
/**
* @function 结束连麦
* @param mode:number 采集器默认， 默认0=站立 1=坐立
* @return Promise | void
*/
export const teacherStopLinkMic = (mode) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.teacherStopLinkMic(mode);
case ZEGO:
return zegosdk.teacherStopLinkMic(mode);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.teacherStopLinkMic(mode);
case TRTC:
return trtcsdk.teacherStopLinkMic(mode);
default:
break;
}
};
/**
* @function 获取视频 src 或者将视频绑定到某一个 <video> 标签上
* @param args:Object
* {
* isLocal, // Boolean，是否是本地的视频预览
* streamId, // String，要拉取的视频流的 id，可选，只有拉取远程的视频流的时候才是必选的，本地不用
* domId // String，<video> 标签的 id，可选，如果传了就把视频绑定到对应的 <video> 标签上
* }
* @return Promise | void，可从 Promise 中获取 src，Promise.then((src) => {})
*/
export const getOrLocateVideo = (args) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.startLocalOrRemotePreview(args.isLocal, args.streamId, args.domId);
case ZEGO:
return zegosdk.startLocalOrRemotePreview(args.isLocal, args.streamId, args.domId, args.isTeacherNewWindowPreview);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.startLocalOrRemotePreview(args.isLocal, args.streamId, args.domId, args.isTeacherNewWindowPreview);
case TRTC:
return trtcsdk.startLocalOrRemotePreview(args.isLocal, args.streamId, args.domId, args.isTeacherNewWindowPreview);
default:
return zegosdk.startLocalOrRemotePreview(args.isLocal, args.streamId, args.domId);
break;
}
};
/**
* @function 开始推流
* @return Promise | void
*/
export const startPushFlow = async (streamid, idx) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.startPush();
case ZEGO:
return await zegosdk.startPublish2(streamid, idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.startPush(streamid, idx); // 可能为空，函数内部有判断逻辑，为空时，根据规则生成streamId
case TRTC:
return await trtcsdk.startPush(streamid, idx);//流id需要做兼容处理
default:
break;
}
};
/**
* @function 暂停推流
* @return Promise | void
*/
export const stopPushFlow = (idx, streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.stopPush();
case ZEGO:
return zegosdk.stopPublish(idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.stopPush(streamId);
case TRTC:
return trtcsdk.stopPush(idx);
default:
break;
}
};
/**
* @function 初始化拉流
* @param args:Object
* {
* streamId, // String，被拉取的流的 id，必选
* domId // String，<video> 标签的 id，可选，如果传了就把视频绑定到对应的 <video> 标签上
* }
* @return Promise | void，可从 Promise 中获取 src，Promise.then((src) => {})
*/
export const initPullFlow = (args) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
if (window.zby_isM1Type) {
return;
}
return {
sdk_type: RTC,
videoSrc: rtcsdk.initPullFlow(args.streamId, args.domId, args.mute, args.renderId, args.notAutoPlay, args.audioOnly, args.needScale, args.scaleParams, args.streamType)
};
case ZEGO:
return {
sdk_type: ZEGO,
videoSrc: zegosdk.initPullFlow(args.streamId, args.domId, args.mute, args.renderId, args.notAutoPlay, args.audioOnly)
};
case TALRTC:
case NERTC:
case VOLCRTC:
return {
sdk_type: window.zbyAVSDK_init_sdk_type,
videoSrc: talrtcsdk.initPullFlow(args.streamId, args.domId, args.mute, args.renderId, args.notAutoPlay, args.audioOnly)
};
case TRTC:
return {
sdk_type: TRTC,
videoSrc: trtcsdk.initPullFlow(args.streamId, args.domId, args.mute, args.renderId, args.notAutoPlay, args.audioOnly)
};
default:
break;
}
};
/**
* @function 恢复拉指定的流
* @param streamId:String 被拉取的流的 id，必选
* @return Promise | void
*/
export const startPullFlow = (streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.play(streamId);
case ZEGO:
return zegosdk.playStream(streamId);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.startPlay(streamId);
case TRTC:
return trtcsdk.startPlay(streamId);
default:
break;
}
};
/**
* @function 暂停拉指定的流
* @param streamId:String 被拉取的流的 id，必选
* @param recovery:Boolean 是否回收播放器， 可选
* @return Promise | void
*/
export const stopPullFlow = (streamId, recovery) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
if (window.zby_isM1Type) {
return;
}
return rtcsdk.stop(streamId, recovery);
case ZEGO:
return zegosdk.stopPlayStream(streamId, recovery);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.stopPlay(streamId, recovery);
case TRTC:
return trtcsdk.stopPlay(streamId);
default:
break;
}
};
/**
* @function 暂停拉所有的流
* @return Promise | void
*/
export const stopAllPullFlow = (streamId, recovery) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.stopAllPullFlow(streamId, recovery);
case ZEGO:
return zegosdk.stopAllPlayStream(streamId, recovery);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.stopPlayAll();
case TRTC:
return trtcsdk.stopPlayAll();
default:
break;
}
};
/**
* @function 销毁拉指定的流
* @param streamId:String 被拉取的流的 id，必选
* @return Promise | void
*/
export const playDestroy = (streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.playDestroy(streamId);
case ZEGO:
return zegosdk.stopPlayStream(streamId, true);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.stopPlay(streamId);
case TRTC:
return trtcsdk.stopPlay(streamId);
default:
break;
}
};
/**
* @function 切换播放流
* @param streamId:String 需要停止流的 id，必选
* @param toStreamId:String 被拉取的流的 id，必选
* @param toDomId:String <video> 标签的 id，可选
* @return Promise | void
*/
export const changePullFlow = (args) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.changePullFlow(args.streamId, args.toStreamId, args.toDomId);
case ZEGO:
return zegosdk.changePullFlow(args.streamId, args.toStreamId, args.toDomId);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.changePullFlow(args.streamId, args.toStreamId, args.toDomId);
case TRTC:
default:
break;
}
};
/**
* @function 获取本地扬声器列表
* @return Promise | void
*/
export const getSpeakerDeviceList = async () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.getSpeakerDevice();
case ZEGO:
return await zegosdk.getSpeakerDeviceList();
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.getSpeakerDeviceList();
case TRTC:
return await trtcsdk.getSpeakerDeviceListTrtc();
default:
return await zegosdk.getSpeakerDeviceList();
break;
}
};
/**
* @function 指定扬声器
* @param deviceId:String 扬声器设备 id，必选
* @return Promise | void
*/
export const setSpeakerDevice = async (deviceId, operationType) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.setSpeakerDevice({speakId:deviceId, operationType});
case ZEGO:
return await zegosdk.setSpeakerDevice({deviceId, operationType});
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.setSpeakerDevice({ deviceId });
case TRTC:
return await trtcsdk.setSpeakerDevice({deviceId});
default:
break;
}
};
export const getSpeakerDevice = async () => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.getCurrentSpeakerDevice();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getCurrentSpeakerDevice();
default:
return null;
}
};
/**
* @function 获取扬声器音量
* @return Promise | void
*/
export const getSpeakerVolume = async () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return JSON.parse((await rtcsdk.getSpeakerVolume()).msg).volume;
case ZEGO:
return JSON.parse((await zegosdk.getSpeakerDeviceVolume()).msg).ret;
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.getCurrentSpeakerVolume();
case TRTC:
return JSON.parse((await trtcsdk.getCurrentSpeakerVolume()).msg).speakerVolume;
default:
break;
}
};
/**
* @function 设置扬声器音量
* @param volume:Number 扬声器音量，必选，范围 [0, 100]
* @return Promise | void
*/
export const setSpeakerVolume = (volume) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setSpeakerVolume(volume);
case ZEGO:
return zegosdk.setSpeakerDeviceVolume(volume);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setCurrentSpeakerVolume(volume);
case TRTC:
return trtcsdk.setCurrentSpeakerVolume(volume);
default:
break;
}
};
/**
* @function 控制扬声器是否静音
* @param mute:Boolean 是否静音，必选
* @return Promise | void
*/
export const setSpeakerMute = (mute) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setSpeakerMute(mute);
case ZEGO:
return zegosdk.setSpeakerDeviceMute(mute);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setSpeakerDeviceMute(mute);
case TRTC:
default:
break;
}
};
/**
* @function 获取 App 应用音量
* @return Promise | void
*/
export const getAppVolume = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.getCurrentAppSessionVolume();
case ZEGO:
return zegosdk.getSpeakerSimpleVolume();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getSpeakerSimpleVolume();
case TRTC:
default:
break;
}
};
/**
* @function 设置 App 应用音量
* @param volume:Number App 音量，必选，范围 [0, 100]
* @return Promise | void
*/
export const setAppVolume = (volume) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setCurrentAppSessionVolume(volume);
case ZEGO:
return zegosdk.setSpeakerSimpleVolume(volume);
// 由于 Agora 的 App 音量取值范围是 [0, 255]，所以需要做比例兼容
// volume = Math.floor((volume / 100) * 255);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setSpeakerSimpleVolume(volume);
case TRTC:
default:
break;
}
};
/**
* @function 设置 App 静音
* @param mute:Boolean 是否静音，必选
* @return Promise | void
*/
export const setAppMute = (mute) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setApplicationMute(mute);
case ZEGO:
return zegosdk.setSpeakerSimpleMute(mute);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setSpeakerSimpleMute(mute);
case TRTC:
default:
break;
}
};
/**
* @function 获取麦克风列表
* @return Promise | void
*/
export const getMicrophoneDeviceList = async () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.getMicrophoneDevice();
case ZEGO:
return await zegosdk.getMicrophoneDeviceList();
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.getMicrophoneDeviceList();
case TRTC:
return await trtcsdk.getMicrophoneDeviceListTrtc();
default:
return await zegosdk.getMicrophoneDeviceList();
break;
}
};
/**
* @function 指定麦克风
* @param deviceId:String 麦克风 id，必须
* @return Promise | void
*/
export const setMicrophoneDevice = async (deviceId, operationType) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.setMicrophoneDevice({deviceId, operationType});
case ZEGO:
return await zegosdk.setMicrophoneDevice({deviceId, operationType});
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.setMicrophoneDevice({ deviceId, operationType });
case TRTC:
return await trtcsdk.setMicrophoneDevice({deviceId});
default:
break;
}
};
/**
* @function 开麦/禁麦
* @param operation:Boolean 操作类型，false -> 关闭，true -> 打开，必选
* @return Promise | void
*/
export const openOrCloseMicrophone = async (operation) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.setRealTimeAudioMute(!operation);
case ZEGO:
return await zegosdk.enableMic(operation);
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.openOrCloseMicrophone(operation);
case TRTC:
return await trtcsdk.openOrCloseMicrophone(operation);
default:
break;
}
};
/**
* @function 获取麦克风音量
* @return Promise | void
*/
export const getMicrophoneVolume = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.getMicrophoneVolume();
case ZEGO:
return zegosdk.getMicDeviceVolume();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getCurrentMicrophoneVolume();
case TRTC:
return trtcsdk.getCurrentMicrophoneVolume();
default:
break;
}
};
/**
* @function 设置麦克风音量
* @param volume:Number App 音量，必选，范围 [0, 100]
* @param mute:Boolean 是否静音
* @return Promise | void
*/
export const setMicrophoneVolume = (volume, mute) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setMicrophoneVolume(volume, mute);
case ZEGO:
return zegosdk.setMicDeviceVolume(volume);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setCurrentMicrophoneVolume(volume);
case TRTC:
return trtcsdk.setCurrentMicrophoneVolume(volume);
default:
break;
}
};
/**
* @function 控制麦克风是否静音
* @param mute:Boolean 是否静音，必选
* @return Promise | void
*/
export const setMicrophoneMute = (mute) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setRealTimeAudioMute(mute);
case ZEGO:
return zegosdk.setMicDeviceMute(mute);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.muteLocalAudio(mute);
case TRTC:
default:
break;
}
};
/**
* @function 切换云控时退出房间、退出频道
* @return Promise | void
*/
export const leaveRoomWithChangeSDK = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.leaveRoom();
case ZEGO:
return zegosdk.leaveRoomWithChangeSDK();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.leaveRoom();
case TRTC:
return trtcsdk.leaveRoom();
default:
break;
}
};
/**
* @function 退出房间、退出频道
* @return Promise | void
*/
export const leaveRoom = (type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.leaveRoom();
case ZEGO:
return zegosdk.leaveRoom(type);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.leaveRoom();
case TRTC:
return trtcsdk.leaveRoom();
default:
break;
}
};
/**
* @function 反初始化
* @return Promise | void
*/
export const deinit = () => {
window.zbyAVSDK_init_sdk_type=localStorage.getItem('zbyAVSDK_init_sdk_type');
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.destroyEngine();
case ZEGO:
return zegosdk.destroyEngine();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.destroyEngine();
default:
console.error('unknown zbyAVSDK_init_sdk_type:', zbyAVSDK_init_sdk_type);
break;
}
};
//开启拉流音量监听
export const startSoundLevelMonitor = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.startSoundLevelMonitor();
case TALRTC:
case NERTC:
case VOLCRTC:
// TODO StartMicrophone 里面有调用 enableAudioVolumeIndication 但目前是注释掉的状态
break;
default:
break;
}
};
/**
* @function 转推，录课
* @param type:String 动作类型，必选，'start' | 'stop' | 'pause' | 'resume'
* @return Promise | void
*/
export const turnPush = (type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.sendRecordingMsg({ cmd: type });
case ZEGO:
return zegosdk.singleRecord(type);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.controlCdnStreaming(type);
case TRTC:
default:
break;
}
};
/**
* @function 听不听指定的用户的声音
* @param streamId:String 被拉取的流的 id，必选
* @param mute:Boolean 是否静音，必选，true -> 静音，false -> 不静音
* @return Promise | void
*/
export const setAudioMute = (streamId, mute) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setMute(streamId, mute);
case ZEGO:
return zegosdk.activateAudioPlayStream(streamId, !mute);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.muteRemoteAudio(streamId, mute);
case TRTC:
return trtcsdk.muteRemoteAudio(streamId, mute);
default:
break;
}
};
/**
* @function 是否拉取音频流-是否关闭音频流--通过播放器id控制
* @param operation:Boolean，必选，true关闭 | false不关闭
* @param playerId:Number，必选, 播放器id
* @return Promise | void
*/
export const pullAudioFlow = (playerId, operation, streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.pullAudioFlow(playerId, operation, 'client', streamId);
case ZEGO:
return zegosdk.pullAudioFlow(playerId, !operation, streamId);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.pullAudioFlow(playerId, operation, streamId);
case TRTC:
return trtcsdk.pullAudioFlow(playerId, operation, streamId);
default:
break;
}
};
/**
* @function 获取设备状态
* * @param { string } devicename //（设备名称，可为空）
* * @param { number } devicetype //（设备类型，1摄像头，2麦克风）,3扬声器(mac端没有)
* @return: Promise
*/
// export const getDeviceState = (devicename, devicetype) => {
// switch (window.zbyAVSDK_init_sdk_type) {
// case RTC:
// return rtcsdk.getDeviceState(devicename, devicetype);
// case ZEGO:
// return zegosdk.getDeviceState(devicename, devicetype);
// default:
// break;
// }
// };
/**
* @function 看不看指定的用户的画面
* @param streamId:String 被拉取的流的 id，必选
* @param mute:Boolean 是否关闭画面，必选，true -> 关闭画面，false -> 不关闭画面
* @return Promise | void
*/
export const setVideoMute = (streamId, mute) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.controlPullAudioOnly(streamId, mute);
case ZEGO:
return zegosdk.activateVideoPlayStream(streamId, !mute);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.muteRemoteVideo(streamId, mute);
case TRTC:
return trtcsdk.muteRemoteVideo(streamId, mute);
default:
break;
}
};
/**
* @function 开启/关闭麦克风音量回调
* @param open:Boolean true -> 开启，false -> 关闭，必选
* @return void
*/
export const openMicVolumeCb = (open) => {
rtcsdk.openMicVolumeCb(open);
zegosdk.openMicVolumeCb(open);
};
export const startMixtStream = (args) => {
let params = {};
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
const { config } = args;
params = {
sequence: args.sequence,
outputStream: {
pushType: args.pushType,
rtmpUrls: config.szOutputStream,
videoFps: config.nOutputFps,
videoRate: config.nOutputBitrate,
audioRate: config.nOutputAudioBitrate,
videoWidth: config.nOutputWidth,
videoHeight: config.nOutputHeight,
audioFormat: config.nOutputAudioConfig,
audioChannels: config.nChannels,
backgroundColor: config.nOutputBackgroundColor,
},
inputStreams: [],
};
config.pInputStreamList.forEach(item => {
params.inputStreams.push({
confId: item.confId,
streamId: item.szStreamID,
top: item.layout.top,
right: item.layout.right,
bottom: item.layout.bottom,
left: item.layout.left,
mediaControl: item.nContentControl
});
});
console.log(params);
rtcsdk.startRoomMixRecord(params);
break;
case ZEGO:
params = Object.assign(args, {});
delete params.pushType;
delete params.sequence;
params.config.pInputStreamList = params.config.pInputStreamList.map(item => {
const tempObj = Object.assign(item, {});
delete tempObj.confId;
return tempObj;
});
zegosdk.mixStream('start', params);
break;
default:
break;
}
};
export const stopMixtStream = (args) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
rtcsdk.stopRoomMixRecord({ sequence: args.sequence });
break;
case ZEGO:
const params = Object.assign(args, {});
delete params.sequence;
zegosdk.mixStream('stop', params);
break;
default:
break;
}
};
/**
* @function 单路录制
* @param args:Object 必选
* {
* type:String 开始/结束, 对应取值start/stop，必选
* groupId: String 分组id，可选，默认为 sdk初始化分组id
* streamId: String 流id，必选
* seqNum: String
* }
* @return void
*/
export const singleRecord = async (args) => {
const { type, groupId, streamId, userId, seqNum } = args;
const sid = `xrs51_${groupId}_${userId}`;
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
const { institutionId } = window.zby_sdk_init_params;
const rtc = window.zbyAVSDK_init_params.rtc;
let rtmpAddr = `${rtc.recordUrl}/${sid}`;
if (seqNum) {
rtmpAddr += `?seqNum=${seqNum}`;
}
const rtcParams = {
cmd: type,
confId: util.getConfId(institutionId, groupId),
liveId: streamId,
rtmpAddr
};
return rtcsdk.sendRecordingMsg(rtcParams);
case ZEGO:
const zego = window.zbyAVSDK_init_params.zego;
let strTarget = `${zego.recordUrl}/${sid}`;
if (seqNum) {
strTarget += `?seqNum=${seqNum}`;
}
return zegosdk.singleRecord(type, strTarget, streamId);
break;
default:
break;
}
};
/**
* @function 单路录制
* @param args:Object 必选
* {
* type:String 开始/结束, 对应取值start/stop，必选
* groupId: String 分组id，可选，默认为 sdk初始化分组id
* streamId: String 流id，必选
* }
* @return void
*/
export const recordPublishTarget = (args) => {
const { type, groupId, streamId, userId } = args;
const sid = `xrs51_${groupId}_${userId}`;
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
const { institutionId } = window.zby_sdk_init_params;
const rtc = window.zbyAVSDK_init_params.rtc;
const rtcParams = {
cmd: type,
confId: util.getConfId(institutionId, groupId),
liveId: streamId,
rtmpAddr: `rtmp://globalpush.aliyun.zhiboyun.eaydu.com/live_haibian/${streamId}`
};
return rtcsdk.sendRecordingMsg(rtcParams);
case ZEGO:
const zego = window.zbyAVSDK_init_params.zego;
const strTarget = `rtmp://globalpush.aliyun.zhiboyun.eaydu.com/live_haibian/${streamId}`;
zegosdk.singleRecord(type, strTarget, streamId);
break;
default:
break;
}
};
export const getSnapshootId = (streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
if (rtcsdk.hasStream(streamId)) {
return streamId;
} else {
defaultApi.writeLog(`zbyavsdk getSnapshootId , no streamId: ${streamId} in rtc room`);
}
break;
case ZEGO:
if (zegosdk.hasStream(streamId)) {
return zegosdk.getChannelIndex(streamId);
} else {
defaultApi.writeLog(`zbyavsdk getSnapshootId , no streamId: ${streamId} in zego room`);
}
break;
case TALRTC:
case NERTC:
case VOLCRTC:
if (talrtcsdk.hasStream(streamId)) {
return talrtcsdk.getChannelIndex(streamId);
} else {
defaultApi.writeLog(`talrtcsdk getSnapshootId , no streamId: ${streamId} in talrtc room`);
}
default:
break;
}
};
export const getAllChannelIndex = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.getAllChannelIndex();
case TRTC:
return trtcsdk.getAllChannelIndex();
default:
break;
}
};
/**
* @function 设置摄像头参数（采集分辨率）
* @param width:Number 分辨率宽，必选，推荐 1280
* @param height:Number 分辨率高，必选，推荐 720
* @param frameRate:Number 帧率，必选，推荐 15
* @return Promise | void
*/
export const setCameraParams = (args, idx, streamId) => {
const { width, height, frameRate } = args;
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setCameraParam(width, height, frameRate);
case ZEGO:
return zegosdk.setCameraParam(width, height, idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setCameraCaptureResolution(width, height, streamId);
case TRTC:
return trtcsdk.setCameraCaptureResolution(width, height);
default:
break;
}
};
/**
* @function 设置编码分辨率
* @param width:Number 分辨率宽，必选，推荐 1280
* @param height:Number 分辨率高，必选，推荐 720
* @param frameRate:Number 帧率，必选，推荐 15
* @return Promise | void
*/
export const setEncodeParams = (args, idx, streamId) => {
const { width, height, frameRate } = args;
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setEncodeParam(width, height, frameRate);
case ZEGO:
return zegosdk.setVideoEncodeResolution(width, height, idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setCameraEncodeFps(frameRate, streamId) && talrtcsdk.setCameraEncodeResolution(width, height, streamId);
case TRTC:
return zegosdk.setVideoEncodeResolution(width, height);
default:
break;
}
};
/**
* @function 设置码率
* @param bitrate:Number 码率，必选，推荐 15
* @return Promise | void
*/
export const setBitRate = (bitrate, idx, streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setBitRate(bitrate);
case ZEGO:
return zegosdk.setVideoBitrate(bitrate, idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setCameraEncodeBitrate(bitrate, streamId);
case TRTC:
return trtcsdk.setCameraEncodeBiarate(bitrate);
default:
break;
}
};
/**
* @function 本地视频录制
* @param type 开始/结束
* @param path 录制路径
* @return Promise | void
*/
export const localRecordVideo = (type, path) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
rtcsdk.localRecordVideo(type, path);
break;
case ZEGO:
zegosdk.localRecordVideo(type, path);
break;
case TALRTC:
case NERTC:
case VOLCRTC:
talrtcsdk.localRecordVideo(type, path);
break;
default:
break;
}
};
/**
* @function 本地音频录制
* @param type 开始/结束
* @param path 录制路径
* @return Promise | void
*/
export const localRecordAudio = (type, path) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
rtcsdk.localRecordAudio(type, path);
break;
case ZEGO:
zegosdk.localRecordAudio(type, path);
break;
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
export const getDesktopPath = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.getDesktopPath();
case TALRTC:
case NERTC:
case VOLCRTC:
// return talrtcsdk.getDesktopPath();
default:
return zegosdk.getDesktopPath();
}
};
/**
* @function 本地录制
* @param {string | undefined} fileName
* @param {number} fileType 1:flv 2:mp4
* @param {number} idx 0:主流 1:辅流 2:RTMP流
* @returns {Promise<any>}
*/
export const startCaptureRecord = (fileName, fileType, idx, path) => {
if (idx === 2) {
defaultApi.writeLog(`zbyAVSDK startCaptureRecord idx: ${idx}, use zego sdk`);
return zegosdk.startCaptureRecord(fileName, fileType, idx, path);
}
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.startCaptureRecord(fileName, fileType, idx, path);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.startRecord(fileName, fileType, idx, path);
default:
break;
}
};
/**
* 结束外部音频采集（通知sdk）
* @param {number} idx 0 | 1 | 2
* @returns
*/
export const stopCaptureRecord = (idx) => {
if (idx === 2) {
defaultApi.writeLog(`zbyAVSDK stopCaptureRecord idx: ${idx}, use zego sdk`);
return zegosdk.stopCaptureRecord(idx);
}
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.stopCaptureRecord(idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.stopRecord(idx);
default:
break;
}
};
/**
* @function 设置采集扬声器声音
* @param { string } deviceId 设备id
* @param {boolean} speaker 采集扬声器声音=true/不采集=false
* @return void
*/
export const setSpeakerCapture = (deviceId,speaker) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setAudioSpeakerCapture(deviceId,speaker);
case ZEGO:
return zegosdk.setAudioSpeakerCapture(speaker);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.enableAudioSpeakerCapture(speaker);
case TRTC:
return trtcsdk.setAudioSpeakerCapture(speaker);
default:
break;
}
};
/**
* @function 设置混流和背景色
* @param { boolean } type true=开启/false=关闭
* @param { number } id 需要混合的采集器id
* @param { object } rgb
* @param { number } rgb.r
* @param { number } rgb.g
* @param { number } rgb.b
* @return: Promise
*/
export const setMixStream = (type, id, rgb) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setMixStream(type, id, rgb);
case ZEGO:
break;
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
};
};
/**
* @function 采集器截图
* @param { string } fileName 文件名，需要后缀名。例如：333.jpg
* @return: Promise
*/
export const captureSnapShot = (fileName) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.captureSnapShot(fileName);
case ZEGO:
break;
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* @function 播放器截图
* @param { string } fileName 文件名，需要后缀名。例如：333.jpg
* @return: Promise
*/
export const playerSnapShot = (id, fileName) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.playerSnapShot(id, fileName);
case ZEGO:
break;
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* @function 设置打开/关闭摄像头
* @param { boolean } type true=开启/false=关闭
* @return: Promise
*/
export const openOrCloseCameraAndMicrophone = (type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.openOrCloseCameraAndMicrophone(type);
case ZEGO:
break;
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* @function 加载采集插件的输入数据 //调用后，zego 可以向采集插件传送摄像头数据，用于拼接
* @return: Promise
*/
export const loadCollectionInputEntry = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.loadCollectionInputEntry();
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* @function 加载采集插件的输出数据 //调用后，采集插件向zego传送数据
* @return: Promise
*/
export const loadCollectionOutputEntry = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.loadCollectionOutputEntry();
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
export const mixedstuVideo = (stuArray) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.rtcLoadCollectionEntry2(stuArray);
case ZEGO:
return zegosdk.loadCollectionInputEntry2(stuArray);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.loadCollectionInputEntry2(stuArray);
default:
break;
}
};
/**
* @function 加载采集插件的输出数据 //调用后，zego 可以向采集插件传送摄像头数据，用于拼接
* @return: Promise
*/
export const setCDNPublishTarget = (pRtmpUrl,idx) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return rtcsdk.setCDNPublishTarget(pRtmpUrl,idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.addPublishRtmpStreamUrl(pRtmpUrl);
default:
break;
}
};
/**
* @function 设置预览镜像状态
* @param { boolean } type true=开启 false=关闭
* @return: Promise
*/
export const setMirrorStatus = (type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setMirrorStatus(type);
case ZEGO:
return zegosdk.setMirrorStatus(type);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setMirrorStatus(type);
default:
break;
}
};
/**
* @function 设置拉流镜像状态
* @param { boolean } type true=开启 false=关闭
* @return: Promise
*/
export const setPlayViewMirror = (type, id) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setRTCPlayViewMirror(type, id);
case ZEGO:
return zegosdk.setPlayViewMirror(type);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setPlayViewMirror(type, id);
default:
break;
}
};
/**
* @function 设置推流镜像状态
* * @param { boolean } id 采集器Id
* @param { boolean } mode 1=开启 0=关闭
* @return: Promise
*/
export const setPushViewMirror = (mode) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setMirrorMode(mode);
case ZEGO:
return zegosdk.setVideoMirrorMode(mode);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setMirrorStatus(mode);
default:
break;
}
};
/**
* @function 开启美颜
* @param { boolean } type true=开启 false=关闭
* @return: Promise
*/
export const startSenseMe = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.startSenseMe();
case ZEGO:
return zegosdk.startSenseMe();
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* @function 设置美颜参数
* @param { boolean } type true=开启 false=关闭
* @return: Promise
*/
export const setBeautifyParam = (type, value) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.setBeautifyParam(type, value);
case ZEGO:
return zegosdk.setBeautifyParam(type, value);
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* @function 关闭美颜
* @param { boolean } type true=开启 false=关闭
* @return: Promise
*/
export const endSenseMe = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.endSenseMe();
case ZEGO:
return zegosdk.endSenseMe();
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* @function 40路混音
* @param { number } mixMode //混流模式 0=关闭混流 1=开启混流
* @param { array } streamIdArr //表示要突出声音的channel
* @return: Promise
*/
export const setAudioMixMode = (mixMode, streamIdArr) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.setAudioMixMode(mixMode, streamIdArr);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setAudioMixMode(mixMode, streamIdArr);
default:
break;
}
};
//获取第三方底层流媒体版本号
export const getSDKVersion = async () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.getSDKVersion();
case ZEGO:
return zegosdk.getSDKVersion();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getSDKVersion();
default:
break;
}
};
//获取第三方底层流媒体内核版本号
export const getSDKCoreVersion = async () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return rtcsdk.getSDKVersion();
case ZEGO:
return zegosdk.getSDKVersion();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getSDKCoreVersion();
default:
break;
}
};
//获取摄像头所支持的分辨率
export const getCameraSupportedResolution = async (deviceId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return await rtcsdk.getCameraSupportedRes(deviceId);
case ZEGO:
return await zegosdk.getCameraSupportedRes(deviceId);
case TALRTC:
case NERTC:
case VOLCRTC:
return await talrtcsdk.getCameraResolution(deviceId);
case TRTC:
return await trtcsdk.getCameraResolution(deviceId);
default:
break;
}
};
/**
* @function 发送SEI
* @return: Promise
*/
export const sendMediaSideInfo = (info) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.sendMediaSideInfo(info);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.sendSEIMsg(info);
case TRTC:
return trtcsdk.sendSEIMsg(info);
default:
break;
}
};
/**
* @function 开启rtc同屏
* @return: Promise
*/
export const startMultiScreen = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.startMultiScreen();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.startMultiScreen();
case TRTC:
return trtcsdk.startMultiScreen();
default:
break;
}
};
/**
* @function 开启rtc同屏
* @return: Promise
*/
export const enableHighlight = (enable) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
break;
case TRTC:
return trtcsdk.enableHighlight(enable);
default:
break;
}
};
/**
* @function 开启音频外部采集
* @return: Promise
*/
export const startAudioExCapture = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.startAudioExCapture(1);
case TALRTC:
case NERTC:
case VOLCRTC:
// FIXME METHOD_NOT_IMPLEMENT;
break;
default:
break;
}
};
/**
* 第四路流类型设置
* @param {number} type 6: 视频:主流 音频:麦克风+扬声器 7: 外部音频源，外部视频源，数据来源player
* @returns
*/
export const setFourthStreamType = (type, idx, streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.setFourthStreamType(type, idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setFourthStreamType(type, streamId);
default:
break;
}
};
export const setVideoSource = (idx, type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.setVideoSource(idx, type);
case TALRTC:
case NERTC:
case VOLCRTC:
// return talrtcsdk.setVideoSource(idx, type);
default:
break;
}
};
/**
* @function 设置辅路通道音频采集模式
* @return: Promise
*/
export const setAUXAudioType = (type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.setAUXAudioType(type);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setAudioType(type);
default:
break;
}
};
/**
* @function 设置录制通道音频采集模式
* @return: Promise
*/
export const setThirdAudioType = (type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.setThirdAudioType(type);
default:
break;
}
};
/**
* @function 设置录制通道音频采集模式
* @return: Promise
*/
export const setThirdAudioType2 = async (type) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.setThirdAudioType(type);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.enableRTCAudioMixMode(type === 32, type);
default:
break;
}
};
/**
* @function 判断推流类型
* @return: Promise
*/
export const getStreamType_zego = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
break;
case ZEGO:
return zegosdk.getStreamType();
default:
break;
}
};
export const enableBeautify = (enable, streamId, idx) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return;
case ZEGO:
return zegosdk.enableBeautify(enable, streamId, idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.enableBeautify(enable, streamId, idx);
default:
return zegosdk.enableBeautify(enable, streamId, idx);
}
};
export const setBeautifyParam2 = (mode, submode, value, streamId, idx, image) => {
switch (window.zbyAVSDK_init_sdk_type) {
case RTC:
return;
case ZEGO:
return zegosdk.setBeautifyParam2(mode, submode, value, streamId, idx, image);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setBeautifyParam(mode, submode, value, streamId, image);
default:
return zegosdk.setBeautifyParam2(mode, submode, value, streamId, idx, image);
}
};
export const setEngineConfig = (key, value) => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.setEngineConfig(key, value);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.setEngineConfig(key, value);
default:
return zegosdk.setEngineConfig(key, value);
}
};
export const getMicrophoneLoudness = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.getMicrophoneLoudness();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getMicrophoneLoudness();
default:
return zegosdk.getMicrophoneLoudness();
}
};
export const getCurrentSpeakerId = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.getCurrentSpeakerId();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getCurrentSpeakerId();
default:
return zegosdk.getCurrentSpeakerId();
}
};
export const getCurrentMicrophoneId = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.getCurrentMicrophoneId();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getCurrentMicrophoneId();
default:
return zegosdk.getCurrentMicrophoneId();
}
};
export const getCurrentCameraId = () => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.getCurrentCameraId();
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.getCurrentCameraId();
default:
return zegosdk.getCurrentCameraId();
}
};
export const takeLocalSnapShot = (streamId, idx) => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.takeLocalSnapShot(streamId, idx);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.takeLocalSnapShot(streamId, idx);
default:
return zegosdk.takeLocalSnapShot(streamId, idx);
}
};
export const takeRemoteSnapShot = (streamId) => {
switch (window.zbyAVSDK_init_sdk_type) {
case ZEGO:
return zegosdk.takeRemoteSnapShot(streamId);
case TALRTC:
case NERTC:
case VOLCRTC:
return talrtcsdk.takeRemoteSnapShot(streamId);
default:
return zegosdk.takeRemoteSnapShot(streamId);
}
};
const setThirdAudioCallbackType = (sdkType) => {
let type = sdkVale[sdkType];
return zegosdk.setThirdAudioType(type);
};
export default {
init,
recoverSdk,
deviceCheckerInit,
stopCheckDevice,
changeSDK,
unloadExtension,
startPushFlow,
stopPushFlow,
initPullFlow,
startPullFlow,
stopPullFlow,
stopAllPullFlow,
playDestroy,
changePullFlow,
getCameraDeviceList,
setCameraDevice,
openOrCloseCamera,
startPreview,
stopPreview,
getOrLocateVideo,
getSpeakerDeviceList,
setSpeakerDevice,
getSpeakerDevice,
getSpeakerVolume,
setSpeakerVolume,
setSpeakerMute,
getAppVolume,
setAppVolume,
setAppMute,
getMicrophoneDeviceList,
setMicrophoneDevice,
openOrCloseMicrophone,
getMicrophoneVolume,
setMicrophoneVolume,
setMicrophoneMute,
leaveRoomWithChangeSDK,
leaveRoom,
turnPush,
setAudioMute,
pullAudioFlow,
setVideoMute,
openMicVolumeCb,
startMixtStream,
stopMixtStream,
singleRecord,
getSnapshootId,
setCameraParams,
setEncodeParams,
setBitRate,
recordPublishTarget,
localRecordVideo,
localRecordAudio,
getDesktopPath,
startCaptureRecord,
stopCaptureRecord,
teacherStartLinkMic,
teacherStopLinkMic,
setSpeakerCapture,
setMixStream,
captureSnapShot,
playerSnapShot,
openOrCloseCameraAndMicrophone,
setMirrorStatus,
getStreamType_zego,
startSenseMe,
setBeautifyParam,
endSenseMe,
setPlayViewMirror,
setPushStreamVideo,
getSDKVersion,
getSDKCoreVersion,
getCameraSupportedResolution,
setAudioMixMode,
setPushViewMirror,
deinit,
startMultiScreen,
getAllChannelIndex,
startAudioExCapture,
setFourthStreamType,
startSoundLevelMonitor,
sendMediaSideInfo,
enableHighlight,
setVideoSource,
setAUXAudioType,
setThirdAudioType,
setThirdAudioType2,
mixedstuVideo,
setThirdAudioCallbackType,
enableBeautify,
setBeautifyParam2,
setEngineConfig,
getMicrophoneLoudness,
getCurrentSpeakerId,
getCurrentMicrophoneId,
getCurrentCameraId,
takeLocalSnapShot,
takeRemoteSnapShot,
// getDeviceState
};