test-cloudhub-electron-sdk
Version:
cloudhub-electron-sdk
792 lines (791 loc) • 26.2 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
/**
* @module EngineController
* @description 对外提供的接口
* @author 党萌
* @date 2020-05-06
* */
const event_1 = require("../helpers/event");
const BaseEngineController_1 = __importDefault(require("../baseControllers/BaseEngineController"));
const LoggerController_1 = __importDefault(require("./LoggerController"));
const utils_1 = __importDefault(require("../helpers/utils"));
const logger = new LoggerController_1.default('CloudHub-engine-log');
class EngineController extends BaseEngineController_1.default {
/**
* @description 初始化房间
* @param {string} appId 企业Id
* @param {{}} config 配置项
*/
initialize(appId, config) {
logger.info(`init appId:${appId} config:${utils_1.default.jsonToStr(config)}`);
this._initialize(appId, config);
}
/**
* @description 更新token
* @param {string} token
*/
renewToken(token) {
logger.info(`renewToken token:${token}`);
this.engine.renewToken(token);
}
/**
* @description 设置客户端角色
* @param {number} role
*/
setClientRole(role) {
logger.info(`setClientRole role:${role}`);
this.engine.setClientRole(role);
}
/**
* @description 设置房间配置
* @param {{}} profile
*/
setChannelProfile(profile) {
logger.info(`setChannelProfile profile:${profile}`);
this.engine.setChannelProfile(profile);
}
/**
* @description 加入房间
* @param {string} token 验证的token
* @param {string} channelId 房间id
* @param {{}} info 配置项
* @param {string} uid 用户id
*/
joinChannel(token, channelId, info, uid) {
logger.info(`joinChannel token:${token} channelId:${channelId} info:${utils_1.default.jsonToStr(info)} uid:${uid}`);
if (!channelId) {
return false;
}
this.engine.joinChannel(token, channelId, utils_1.default.jsonToStr(info), uid);
}
/**
* @description 离开房间
*/
leaveChannel() {
logger.info('leaveChannel');
this.engine.leaveChannel();
}
/**
* @description 发布本地视频
*/
publish() {
logger.info('publish');
this.engine.publish();
}
/**
* @description 取消发布本地视频
*/
unPublish() {
logger.info('unPublish');
this.engine.unPublish();
}
/**
* @description 开启/关闭本地视频
*/
enableLocalVideo(enable) {
logger.info(`enableLocalVideo enable:${enable}`);
this.engine.enableLocalVideo(enable);
}
/**
* @description 开启/关闭本地音频
*/
enableLocalAudio(enable) {
logger.info(`enableLocalAudio enable:${enable}`);
this.engine.enableLocalAudio(enable);
}
/**
* @description 开启视频
*/
enableVideo() {
logger.info('enableVideo');
this.engine.enableVideo();
}
/**
* @description 关闭视频
*/
disableVideo() {
logger.info('disableVideo');
this.engine.disableVideo();
}
/**
* @description 开启/关闭发布后的本地视频
* @param {boolean} mute 是否关闭
*/
muteLocalVideoStream(mute) {
logger.info(`muteLocalVideoStream mute:${mute}`);
this.engine.muteLocalVideoStream(mute);
}
/**
* @description 开启/关闭发布后的本地音频
* @param {boolean} mute 是否关闭
*/
muteLocalAudioStream(mute) {
logger.info(`muteLocalAudioStream mute:${mute}`);
this.engine.muteLocalAudioStream(mute);
}
/**
* @description 开启/关闭指定的远端视频
* @param {string} uid 用户id
* @param {boolean} mute 是否关闭
* @param {string} sourceId 摄像头id
*/
muteRemoteVideoStream(uid, mute, sourceId) {
logger.info(`muteRemoteVideoStream uid:${uid} mute:${mute} sourceId:${sourceId}`);
this.engine.muteRemoteVideoStream(uid, mute, sourceId);
}
/**
* @description 开启/关闭指定的远端音频
* @param {string} uid 用户id
* @param {boolean} mute 是否关闭
*/
muteRemoteAudioStream(uid, mute) {
logger.info(`muteRemoteAudioStream uid:${uid} mute:${mute}`);
this.engine.muteRemoteAudioStream(uid, mute);
}
/**
* @description 开启/关闭所有的远端视频
* @param {boolean} mute 是否关闭
*/
muteAllRemoteVideoStreams(mute) {
logger.info(`muteAllRemoteVideoStreams mute:${mute}`);
this.engine.muteAllRemoteVideoStreams(mute);
}
/**
* @description 开启/关闭所有的远端音频
* @param {boolean} mute 是否关闭
*/
muteAllRemoteAudioStreams(mute) {
logger.info(`muteAllRemoteAudioStreams mute:${mute}`);
this.engine.muteAllRemoteAudioStreams(mute);
}
/**
* @description 获取摄像头列表
*/
getVideoDevices() {
logger.info('getVideoDevices');
return this.engine.getVideoDevices();
}
/**
* @description 获取麦克风列表
*/
getAudioRecordingDevices() {
logger.info('getAudioRecordingDevices');
return this.engine.getAudioRecordingDevices();
}
/**
* @description 获取扬声器列表
*/
getAudioPlaybackDevices() {
logger.info('getAudioPlaybackDevices');
return this.engine.getAudioPlaybackDevices();
}
/**
* @description 获取当前的摄像头
*/
getCurrentVideoDevice() {
logger.info('getCurrentVideoDevice');
return this.engine.getCurrentVideoDevice();
}
/**
* @description 获取当前的麦克风
*/
getCurrentAudioRecordingDevice() {
logger.info('getCurrentAudioRecordingDevice');
return this.engine.getCurrentAudioRecordingDevice();
}
/**
* @description 获取当前的扬声器
*/
getCurrentAudioPlaybackDevice() {
logger.info('getCurrentAudioPlaybackDevice');
return this.engine.getCurrentAudioPlaybackDevice();
}
/**
* @description 设置摄像头
* @param {string} deviceId 设备id
*/
setVideoDevice(deviceId) {
logger.info('setVideoDevice', deviceId);
if (!deviceId)
return false;
this.engine.setVideoDevice(deviceId);
}
/**
* @description 设置麦克风
* @param {string} deviceId 设备Id
*/
setAudioRecordingDevice(deviceId) {
logger.info('setAudioRecordingDevice', deviceId);
if (!deviceId)
return false;
this.engine.setAudioRecordingDevice(deviceId);
}
/**
* @description 设置扬声器
* @param {string} deviceId 设备Id
*/
setAudioPlaybackDevice(deviceId) {
logger.info('setAudioPlaybackDevice', deviceId);
if (!deviceId)
return false;
this.engine.setAudioPlaybackDevice(deviceId);
}
/**
* @description 注册本地视频
* @param {Element} view 显示视频的dom元素
*/
setupLocalVideo(view) {
this._setupLocalVideo(view);
}
/**
* @description 注册本地电影
* @param {Element} view 显示视频的dom元素
* @param {string} movieUrl 本地电影的路径
*/
setupLocalMovie(view, movieUrl) {
logger.info(`setupLocalMovie view:${view} movieUrl:${movieUrl}`);
this._setupLocalVideo(view, movieUrl, 'movie');
}
/**
* @description 注册远端视频
* @param {string} uid 用户id
* @param {number} type 视频类型
* @param {Element} view 显示视频的dom元素
*/
setupRemoteVideo(uid, type, view) {
logger.info('setupRemoteVideo', uid, type, view);
this._setupRemoteVideo(uid, type, view);
}
/**
* @description 取消本地视频
*/
removeLocalVideo() {
this._removeLocalVideo();
}
/**
* @description 取消本地电影
* @param {string} movieUrl 本地电影的路径
*/
removeLocalMovie(movieUrl) {
logger.info(`removeLocalMovie movieUrl:${movieUrl}`);
this._removeLocalVideo(movieUrl, 'movie');
}
/**
* @description 取消远端视频
* @param {string} uid 用户id
* @param {number} type 视频类型
*/
removeRemoteVideo(uid, type) {
logger.info(`removeRemoteVideo uid:${uid} type:${type}`);
this._removeRemoteVideo(uid, type);
}
/**
* @description 获取电影时长
* @param {string} mediaFile 文件路径
*/
getMovieDuration(mediaFile) {
logger.info(`getMovieDuration mediaFile:${mediaFile}`);
return this.engine.getMovieDuration(mediaFile);
}
/**
* @description 开启/关闭本地视频镜像
* @param {boolean} mirror
*/
setLocalVideoMirror(mirror) {
logger.info(`setLocalVideoMirror mirror:${mirror}`);
this._setLocalVideoMirror(mirror);
}
/**
* @description 设置指定视频显示模式
* @param {string} uid 用户id 默认为空 代表自己
* @param {number} type 视频类型
* @param {number} mode 显示模式 0 - cover, 1 - fit
*/
setVideoMode(uid, type, mode) {
logger.info(`setVideoMode uid:${uid} type:${type} mode:${mode}`);
this._setVideoMode(uid, type, mode);
}
/**
* @description 点播在线媒体流
* @param {string} url 媒体流的绝对路径
* @param {number} attr 扩展参数
*/
addInjectStreamUrl(url, attr) {
logger.info('addInjectStreamUrl', url, utils_1.default.jsonToStr(attr));
if (!url)
return false;
this.engine.addInjectStreamUrl(url, utils_1.default.jsonToStr(attr));
}
/**
* @description 删除在线媒体流
* @param {string} url 媒体流的绝对路径
*/
removeInjectStreamUrl(url) {
logger.info('removeInjectStreamUrl', url);
if (!url)
return false;
this.engine.removeInjectStreamUrl(url);
}
/**
* @description 暂停/继续播放在线媒体流
* @param {string} url 媒体流的绝对路径
* @param {boolean} isPause 是否暂停
*/
pauseInjectStreamUrl(url, isPause) {
logger.info('pauseInjectStreamUrl', url, isPause);
if (!url)
return false;
this.engine.pauseInjectStreamUrl(url, isPause);
}
/**
* @description 快进在线媒体流
* @param {string} url 媒体流的绝对路径
* @param {} position 快进的进度
*/
seekInjectStreamUrl(url, position) {
logger.info('seekInjectStreamUrl', url, position);
if (!url)
return false;
this.engine.seekInjectStreamUrl(url, position);
}
/**
* @description 播放本地电影
* @param {string} mediaFile 本地电影的绝对路径
* @param {boolean} loopback 是否只给自己听
* @param {boolean} replace 是否将声音替换到麦克风上
* @param {boolean} cycle 是否循环播放
*/
startPlayMovie(mediaFile, loopback, replace, cycle, paused = false) {
logger.info('startPlayMovie', mediaFile, loopback, replace, cycle, paused);
if (!mediaFile)
return false;
this.engine.startPlayMovie(mediaFile, loopback, replace, cycle, paused);
}
/**
* @description 停止播放本地电影
* @param {string} mediaFile 本地电影的绝对路径
*/
stopPlayMovie(mediaFile) {
logger.info('stopPlayMovie', mediaFile);
if (!mediaFile)
return false;
this.engine.stopPlayMovie(mediaFile);
}
/**
* @description 设置本地电影播放进度
* @param {string} mediaFile 本地电影的绝对路径
* @param {number} pos 设置的进度
*/
setMoviePosition(mediaFile, pos) {
logger.info('setMoviePosition', mediaFile, pos);
if (!mediaFile)
return false;
this.engine.setMoviePosition(mediaFile, utils_1.default.strToNum(pos));
}
/**
* @description 暂停本地电影
* @param {string} mediaFile 本地电影的绝对路径
*/
pausePlayMovie(mediaFile) {
logger.info('pausePlayMovie', mediaFile);
if (!mediaFile)
return false;
this.engine.pausePlayMovie(mediaFile);
}
/**
* @description 继续播放本地电影
* @param {string} mediaFile 本地电影的绝对路径
*/
resumePlayMovie(mediaFile) {
logger.info('resumePlayMovie', mediaFile);
if (!mediaFile)
return false;
this.engine.resumePlayMovie(mediaFile);
}
/**
* @description 获取本地电影的进度
* @param {string} mediaFile 本地电影的绝对路径
*/
getMovieCurrentPosition(mediaFile) {
logger.info('getMovieCurrentPosition', mediaFile);
if (!mediaFile)
return false;
return this.engine.getMovieCurrentPosition(mediaFile);
}
/**
* @description 获取本地电影的基本信息
* @param {string} mediaFile 本地电影的绝对路径
*/
getMovieInfo(mediaFile) {
logger.info('getMovieInfo', mediaFile);
if (!mediaFile)
return false;
return this.engine.getMovieInfo(mediaFile);
}
/**
* @description 踢出指定用户
* @param {string} uid 踢出用户的id
* @param {number} reason 踢出的原因
*/
evictUser(uid, reason) {
logger.info('evictUser', uid, reason);
this.engine.evictUser(uid, reason);
}
/**
* @description 开始摄像头测试
* @param {string} deviceId 摄像头id
* @param {Element} view 显示视频的dom元素
* @param {Function} onCallback 回调函数
*/
startVideoDeviceTest(deviceId, view, onCallback) {
logger.info(`startVideoDeviceTest deviceId:${deviceId} view:${view}`);
if (deviceId) {
this.setVideoDevice(deviceId);
}
this._startVideoDeviceTest(view, onCallback);
}
/**
* @description 停止视频设备测试
*/
stopVideoDeviceTest() {
logger.info(`stopVideoDeviceTest`);
this._stopVideoDeviceTest();
}
/**
* @description 设置房内音频音量返回的速度
* @param {number} interval
*/
enableAudioVolumeIndication(interval) {
logger.info(`enableAudioVolumeIndication interval:${interval}`);
this._enableAudioVolumeIndication(interval);
}
/**
* @description 测试扬声器
* @param {string} deviceId deviceId
* @param {string} filepath 播放测试音乐的文件路径
* @param {{}} options 配置项
*/
startAudioPlaybackDeviceTest(deviceId, filepath, options) {
logger.info(`startAudioPlaybackDeviceTest deviceId:${deviceId} filepath:${filepath} options:${options}`);
if (deviceId) {
this.setAudioPlaybackDevice(deviceId);
}
this._startAudioPlaybackDeviceTest(filepath, options);
}
/**
* @description 停止测试扬声器
*/
stopAudioPlaybackDeviceTest() {
logger.info(`stopAudioPlaybackDeviceTest`);
this._stopAudioPlaybackDeviceTest();
}
/**
* @description 开始测试麦克风
* @param {string} deviceId deviceId
* @param {number} interval 返回音量间隔
*/
startAudioRecordingDeviceTest(deviceId, interval = 200) {
logger.info(`startAudioRecordingDeviceTest deviceId:${deviceId} interval:${interval}`);
if (deviceId) {
this.setAudioRecordingDevice(deviceId);
}
this.engine.startAudioRecordingDeviceTest(interval);
}
/**
* @description 停止测试麦克风
*/
stopAudioRecordingDeviceTest() {
logger.info(`stopAudioRecordingDeviceTest`);
this.engine.stopAudioRecordingDeviceTest();
}
/**
* @description 返回当前的sdk版本
*/
getVersion() {
logger.info('getVersion');
return this.engine.getVersion();
}
/**
* @description 绑定监听事件
* @param {string} event
* @param {function} callback
* @param {string|number} markId
* */
on(event, callback, markId) {
event_1.EventInner.on(event, callback, markId);
}
/**
* @description 取消监听事件
* @param {string} event
* @param {function} callback
* */
off(event, callback) {
event_1.EventInner.off(event, callback);
}
/**
* @description 取消event相关的所有监听事件
* @param {string} event
* */
offAll(event) {
event_1.EventInner.offAll(event);
}
/**
* @description 根据markId取消相关的所有监听事件
* @param {string | number} markId
* */
offAllByMarkId(markId) {
event_1.EventInner.offAllByMarkId(markId);
}
/**
* @description 主动触发监听事件
* @param {string} event
* @param {} data
* */
trigger(event, data) {
event_1.EventInner.trigger(event, data);
}
/**
* @description 发送聊天消息
* @param {string} toId 通知哪些用户
* @param {string} message 聊天消息
* @param {string} extraData 额外的数据 可选参数
*/
sendChatMsg(toId, message, extraData) {
logger.info('sendChatMsg', toId, message, utils_1.default.jsonToStr(extraData));
if (!message)
return false;
this.engine.sendChatMsg(toId, message, utils_1.default.jsonToStr(extraData));
}
/**
* @description 更改用户属性
* @param {string} uid 用户id
* @param {string} toId 通知给哪些人
* @param {{}} prop 更改的属性
*/
setProperty(uid, toId, prop) {
logger.info('setProperty', uid, toId, utils_1.default.jsonToStr(prop));
if (!uid)
return false;
this.engine.setProperty(uid, toId, utils_1.default.jsonToStr(prop));
}
/**
* @description 发送信令消息
* @param {string} msgName 信令名
* @param {string} msgId 信令Id
* @param {string} toId 发送给哪些用户
* @param {string} data 信令数据
* @param {string} associatedUserId 关联的用户Id 可选 默认""
* @param {string} associatedMsgId 关联的消息Id 可选 默认""
* @param {boolean} bSave 是否保存 默认false
* @param {string} extraInfo 扩展信息 可选
*/
pubMsg(msgName, msgId, toId, data, associatedUserId, associatedMsgId, bSave, extraInfo) {
logger.info('pubMsg', msgName, msgId, toId, data, associatedUserId, associatedMsgId, bSave, extraInfo);
this.engine.pubMsg(msgName, msgId, toId, utils_1.default.jsonToStr(data), associatedUserId, associatedMsgId, bSave, utils_1.default.jsonToStr(extraInfo));
}
/**
* @description 删除信令消息
* @param {string} msgName 信令名
* @param {string} msgId 信令Id
* @param {string} toId 发送给哪些用户
* @param {string} data 信令数据
*/
delMsg(msgName, msgId, toId, data) {
logger.info('delMsg', msgName, msgId, toId, utils_1.default.jsonToStr(data));
this.engine.delMsg(msgName, msgId, toId, utils_1.default.jsonToStr(data));
}
/**
* @description 设置房间内视频的配置
* @param {{}} config 配置项
*/
setVideoEncoderConfiguration(config) {
logger.info('setVideoEncoderConfiguration', config);
if (!config)
return false;
this.engine.setVideoEncoderConfiguration(config);
}
/**
* @description 获取窗口列表
*/
getScreenWindowsInfo() {
logger.info(`getScreenWindowsInfo`);
return this.engine.getScreenWindowsInfo();
}
/**
* @description 获取屏幕列表
*/
getScreenDisplaysInfo() {
logger.info(`getScreenDisplaysInfo`);
return this.engine.getScreenDisplaysInfo();
}
/**
* @description 开始屏幕共享
* @param {number} displayId 共享的屏幕id
* @param {number} excludeWindow 不共享的窗口id 只能不共享一个窗口
* @param {number} framerate 帧率
* @param {number} bitrate 码率
* @param {boolean} isCaptureCursor 是否捕获鼠标
*/
startScreenCaptureByDisplayId(displayId, excludeWindow, framerate, bitrate, isCaptureCursor) {
logger.info('startScreenCaptureByDisplayId', displayId, excludeWindow, framerate, bitrate, isCaptureCursor);
this.engine.startScreenCaptureByDisplayId(displayId, excludeWindow, framerate, bitrate, isCaptureCursor);
}
/**
* @description 停止屏幕共享
*/
stopScreenCapture() {
logger.info(`stopScreenCapture`);
this.engine.stopScreenCapture();
}
/**
* @description 开始服务器录制
*/
startServerRecord() {
logger.info(`startServerRecord`);
this.engine.startServerRecord();
}
/**
* @description 停止服务器录制
*/
stopServerRecord() {
logger.info(`stopServerRecord`);
this.engine.stopServerRecord();
}
/**
* @description 暂停服务器录制
*/
pauseServerRecord() {
logger.info(`pauseServerRecord`);
this.engine.pauseServerRecord();
}
/**
* @description 恢复服务器录制
*/
resumeServerRecord() {
logger.info(`resumeServerRecord`);
this.engine.resumeServerRecord();
}
/**
* @description 获取播放音效文件音量
*/
getEffectsVolume() {
logger.info(`getEffectsVolume`);
return this.engine.getEffectsVolume();
}
/**
* @description 设置音效文件的播放音量
*/
setEffectsVolume(volume) {
logger.info(`setEffectsVolume`);
return this.engine.setEffectsVolume(volume);
}
/**
* @description 设置单个音效文件的音量
*/
setVolumeOfEffect(soundId, volume) {
logger.info(`setVolumeOfEffect`);
return this.engine.setVolumeOfEffect(soundId, volume);
}
/**
* @description 播放指定音效文件
*/
playEffect(soundId, filePath, loopcount, gain, publish, startTimeMS, endTimeMS) {
logger.info(`playEffect`);
return this.engine.playEffect(soundId, filePath, loopcount, gain, publish, startTimeMS, endTimeMS);
}
/**
* @description 停止播放指定音效文件
*/
stopEffect(soundId) {
logger.info(`stopEffect`);
return this.engine.stopEffect(soundId);
}
/**
* @description 停止播放所有音效文件
*/
stopAllEffects() {
logger.info(`stopAllEffects`);
return this.engine.stopAllEffects();
}
/**
* @description 暂停音效文件播放
*/
pauseEffect(soundId) {
logger.info(`pauseEffect`);
return this.engine.pauseEffect(soundId);
}
/**
* @description 暂停所有音效文件播放
*/
pauseAllEffects() {
logger.info(`pauseAllEffects`);
return this.engine.pauseAllEffects();
}
/**
* @description 恢复播放指定音效文件
*/
resumeEffect(soundId) {
logger.info(`resumeEffect`);
return this.engine.resumeEffect(soundId);
}
/**
* @description 恢复播放所有音效文件
*/
resumeAllEffects() {
logger.info(`resumeAllEffects`);
return this.engine.resumeAllEffects();
}
/**
* @description 增加旁路推流地址
*/
addPublishStreamUrl(url, transcodingEnabled) {
logger.info(`addPublishStreamUrl`);
return this.engine.addPublishStreamUrl(url, transcodingEnabled);
}
/**
* @description 删除旁路推流地址
*/
removePublishStreamUrl(url) {
logger.info(`removePublishStreamUrl`);
return this.engine.removePublishStreamUrl(url);
}
/**
* @description 设置直播转码
*/
setLiveTranscoding(transcoding) {
logger.info(`setLiveTranscoding`);
transcoding.transcodingStreams = transcoding.transcodingStreams.map((it) => {
if (it.type === 'video') {
it.sourceID = 'default_source_id';
}
else if (it.type === 'screen ') {
it.sourceID = 'screen';
}
else if (it.type === 'file') {
it.sourceID = 'file';
}
return it;
});
console.error('设置直播转码', transcoding);
return this.engine.setLiveTranscoding(JSON.stringify(transcoding));
}
/**
* @description 开始通话前网络质量探测
*/
startLastmileProbeTest(config) {
logger.info(`startLastmileProbeTest`);
return this.engine.startLastmileProbeTest(config);
}
/**
* @description 停止通话前 last mile 网络质量探测
*/
stopLastmileProbeTest() {
logger.info(`stopLastmileProbeTest`);
return this.engine.stopLastmileProbeTest();
}
}
exports.default = EngineController;