import * as mediasoupClient from "mediasoup-client"; import { config, defaultAudioConfig, defaultVideoConfig, defaultShareScreenConfig, defaultSvcEncodings, defaultSimulcastEncodings, defaultRTCPeerConnectionConfig, } from "./Config.js"; /** * 成功编码 */ const SUCCESS_CODE = "0000"; /** * 成功描述 */ const SUCCESS_MESSAGE = "成功"; /** * 信令协议 */ const protocol = { // 当前索引 index : 0, // 最大索引 maxIndex : 999, // 终端索引 clientIndex: 99999, /** * @returns 索引 */ buildId() { const me = this; if (++me.index > me.maxIndex) { me.index = 0; } const date = new Date(); return ( 100000000000000 * date.getDate() + 1000000000000 * date.getHours() + 10000000000 * date.getMinutes() + 100000000 * date.getSeconds() + 1000 * me.clientIndex + me.index ); }, /** * @param {*} signal 信令标识 * @param {*} body 消息主体 * @param {*} id 消息ID * @param {*} v 消息版本 * * @returns 信令消息 */ buildMessage(signal, body = {}, id, v) { const me = this; const message = { header: { v : v || config.signal.version, id : id || me.buildId(), signal: signal, }, body: body, }; return message; }, }; /** * 名称冲突 */ const taoyaoProtocol = protocol; /** * 信令通道 */ const signalChannel = { // 桃夭信令 taoyao : null, // 信令通道 channel: null, // 信令地址 address: null, // 心跳时间 heartbeatTime : 30 * 1000, // 心跳定时器 heartbeatTimer: null, // 是否重连 reconnection : true, // 防止重复重连 lockReconnect : false, // 重连定时器 reconnectTimer: null, // 当前重连时间 reconnectionTimeout : 5 * 1000, // 最小重连时间 minReconnectionDelay: 5 * 1000, // 最大重连时间 maxReconnectionDelay: 30 * 1000, /** * 心跳 */ heartbeat() { const me = this; if (me.heartbeatTimer) { clearTimeout(me.heartbeatTimer); } me.heartbeatTimer = setTimeout(async () => { if (me.connected()) { const battery = await navigator.getBattery(); me.taoyao.push(protocol.buildMessage("client::heartbeat", { battery : battery.level * 100, charging: battery.charging, })); me.heartbeat(); } else { console.warn("心跳失败", me.address); } }, me.heartbeatTime); }, /** * @returns 是否连接成功 */ connected() { const me = this; return me.channel && me.channel.readyState === WebSocket.OPEN; }, /** * 连接信令 * * @param {*} address 信令地址 * @param {*} reconnection 是否重连 * * @returns Promise */ async connect(address, reconnection = true) { const me = this; if (me.connected()) { this.taoyao.connect = true; return new Promise((resolve, reject) => { resolve(me.channel); }); } else { this.taoyao.connect = false; } me.address = address; me.reconnection = reconnection; return new Promise((resolve, reject) => { console.debug("连接信令通道", me.address); me.channel = new WebSocket(me.address); me.channel.onopen = async () => { console.info("打开信令通道", me.address); const battery = await navigator.getBattery(); const { body } = await me.taoyao.request(protocol.buildMessage("client::register", { name : me.taoyao.name, clientId : me.taoyao.clientId, clientType: config.signal.clientType, username : me.taoyao.username, password : me.taoyao.password, battery : battery.level * 100, charging : battery.charging, })); protocol.clientIndex = body.index; console.info("终端注册成功", protocol.clientIndex); me.reconnectionTimeout = me.minReconnectionDelay; me.taoyao.connect = true; me.heartbeat(); resolve(me.channel); }; me.channel.onclose = async () => { console.warn("信令通道关闭", me.channel); me.taoyao.connect = false; if(!me.connected()) { me.taoyao.closeRoomMedia(); me.taoyao.closeSessionMedia(); } if (me.reconnection) { me.reconnect(); } // 不要失败回调 }; me.channel.onerror = async (e) => { console.error("信令通道异常", me.channel, e); // 不要失败回调 }; me.channel.onmessage = async (e) => { const content = e.data; try { console.debug("信令通道消息", content); me.taoyao.on(JSON.parse(content)); } catch (error) { console.error("处理信令通道消息异常", e, error); } }; }); }, /** * 重连信令 */ reconnect() { const me = this; if ( me.lockReconnect || me.taoyao.connect || me.connected() ) { return; } me.lockReconnect = true; if (me.reconnectTimer) { clearTimeout(me.reconnectTimer); } // 定时重连 me.reconnectTimer = setTimeout(() => { console.info("重连信令通道", me.address); me.connect(me.address, me.reconnection); me.lockReconnect = false; }, me.reconnectionTimeout); me.reconnectionTimeout = Math.min( me.reconnectionTimeout + me.minReconnectionDelay, me.maxReconnectionDelay ); }, /** * 关闭通道 */ close() { const me = this; console.info("关闭信令通道", me.address); clearTimeout(me.heartbeatTimer); clearTimeout(me.reconnectTimer); me.reconnection = false; me.taoyao.connect = false; me.channel.close(); }, }; /** * 视频会话 */ class Session { // 会话ID id; // 是否关闭 closed; // 代理对象 proxy; // 音量 volume; // 远程终端名称 name; // 远程终端ID clientId; // 会话ID sessionId; // 本地媒体流 localStream; // 是否打开音频 audioEnabled; // 是否打开视频 videoEnabled; // 本地音频 localAudioTrack; // 本地音频发送者 localAudioSender; // 本地音频是否可用（暂停关闭） localAudioEnabled; // 本地视频 localVideoTrack; // 本地视频发送者 localVideoSender; // 本地视频是否可用（暂停关闭） localVideoEnabled; // 远程音频 remoteAudioTrack; // 远程音频是否可用（暂停关闭） remoteAudioEnabled; // 远程视频 remoteVideoTrack; // 远程视频是否可用（暂停关闭） remoteVideoEnabled; // WebRTC PeerConnection peerConnection; constructor({ name, clientId, sessionId, audioEnabled, videoEnabled }) { this.id = sessionId; this.closed = false; this.volume = "100%"; this.name = name; this.clientId = clientId; this.sessionId = sessionId; this.audioEnabled = audioEnabled; this.videoEnabled = videoEnabled; } /** * 暂停本地媒体 * * @param {*} type 媒体类型 */ async pause(type) { if(type === 'audio' && this.localAudioTrack) { this.localAudioEnabled = false; this.localAudioTrack.enabled = false; } if(type === 'video' && this.localVideoTrack) { this.localVideoEnabled = false; this.localVideoTrack.enabled = false; } } /** * 恢复本地媒体 * * @param {*} type 媒体类型 */ async resume(type) { if(type === 'audio' && this.localAudioTrack) { this.localAudioEnabled = true; this.localAudioTrack.enabled = true; } if(type === 'video' && this.localVideoTrack) { this.localVideoEnabled = true; this.localVideoTrack.enabled = true; } } /** * 暂停远程媒体 * * @param {*} type 媒体类型 */ async pauseRemote(type) { if(type === 'audio' && this.remoteAudioTrack) { this.remoteAudioEnabled = false; this.remoteAudioTrack.enabled = false; } if(type === 'video' && this.remoteVideoTrack) { this.remoteVideoEnabled = false; this.remoteVideoTrack.enabled = false; } } /** * 恢复远程媒体 * * @param {*} type 媒体类型 */ async resumeRemote(type) { if(type === 'audio' && this.remoteAudioTrack) { this.remoteAudioEnabled = true; this.remoteAudioTrack.enabled = true; } if(type === 'video' && this.remoteVideoTrack) { this.remoteVideoEnabled = true; this.remoteVideoTrack.enabled = true; } } /** * 关闭视频会话 */ async close() { if(this.closed) { return; } console.debug("会话关闭", this.sessionId); this.closed = true; this.localAudioEnabled = false; this.localVideoEnabled = false; this.remoteAudioEnabled = false; this.remoteVideoEnabled = false; if(this.localAudioTrack) { this.localAudioTrack.stop(); this.localAudioTrack = null; } if(this.localVideoTrack) { this.localVideoTrack.stop(); this.localVideoTrack = null; } if(this.remoteAudioTrack) { this.remoteAudioTrack.stop(); this.remoteAudioTrack = null; } if(this.remoteVideoTrack) { this.remoteVideoTrack.stop(); this.remoteVideoTrack = null; } if(this.peerConnection) { this.peerConnection.close(); this.peerConnection = null; } } /** * 添加媒体协商 * * @param {*} candidate 媒体协商 * @param {*} index 重试次数 */ async addIceCandidate(candidate, index = 0) { if(this.closed) { return; } if(index >= 32) { console.debug("添加媒体协商次数超限", candidate, index); return; } if( !candidate || candidate.sdpMid === undefined || candidate.candidate === undefined || candidate.sdpMLineIndex === undefined ) { console.debug("无效媒体协商", candidate); return; } if(this.peerConnection) { await this.peerConnection.addIceCandidate(new RTCIceCandidate(candidate)); } else { console.debug("延迟添加媒体协商", candidate, index); setTimeout(() => this.addIceCandidate(candidate, ++index), 100); } } }; /** * 远程终端 */ class RemoteClient { // 终端ID id; // 是否关闭 closed; // 代理对象 proxy; // 音量 volume; // 终端名称 name; // 终端标识 clientId; // 数据消费者 dataConsumer; // 音频消费者 audioConsumer; // 视频消费者 videoConsumer; // 音频Track audioTrack; // 视频Track videoTrack; // 终端录制状态 clientRecording; // 服务端录制状态 serverRecording; constructor({ name, clientId, }) { this.id = clientId; this.closed = false; this.name = name; this.volume = "100%"; this.clientId = clientId; } /** * 设置音量 * * @param {*} volume 音量 */ setVolume(volume) { this.volume = ((volume + 127) / 127 * 100) + "%"; } /** * 关闭媒体 */ async close() { const me = this; if(me.closed) { return; } console.debug("关闭终端", me.clientId); me.closed = true; if(me.audioTrack) { await me.audioTrack.stop(); me.audioTrack = null; } if(me.videoTrack) { await me.videoTrack.stop(); me.videoTrack = null; } if(me.dataConsumer) { await me.dataConsumer.close(); me.dataConsumer = null; } if(me.audioConsumer) { await me.audioConsumer.close(); me.audioConsumer = null; } if(me.videoConsumer) { await me.videoConsumer.close(); me.videoConsumer = null; } } } /** * 桃夭终端 */ class Taoyao extends RemoteClient { // 信令连接 connect; // 信令地址 host; // 信令端口 port; // 信令帐号 username; // 信令密码 password; // 房间标识 roomId; // 视频质量 options; // 回调事件 callback; // 请求回调 callbackMapping = new Map(); // 音频媒体配置 audioConfig = defaultAudioConfig; // 视频媒体配置 videoConfig = defaultVideoConfig; // 媒体配置 mediaConfig; // WebRTC配置 webrtcConfig; // 信令通道 signalChannel; // 发送媒体通道 sendTransport; // 接收媒体通道 recvTransport; // 媒体设备 mediasoupDevice; // 文件共享 fileVideo; // 文件共享地址 fileVideoObjectURL; // 视频来源：file|camera|screen videoSource; // 强制使用TCP forceTcp; // 强制使用VP8 forceVP8; // 强制使用VP9 forceVP9; // 强制使用H264 forceH264; // 多种质量媒体 useLayers; // 是否消费数据 dataConsume; // 是否消费音频 audioConsume; // 是否消费视频 videoConsume; // 是否生产数据 dataProduce; // 是否生产音频 audioProduce; // 是否生产视频 videoProduce; // 数据生产者 dataProducer; // 音频生产者 audioProducer; // 视频生产者 videoProducer; // 消费者：音频、视频 consumers = new Map(); // 消费者：数据 dataConsumers = new Map(); // 远程终端 remoteClients = new Map(); // 会话终端 sessionClients = new Map(); // 本地录像机 mediaRecorder; // 本地录像数据 mediaRecorderChunks = []; // TODO：默认关闭data通道 constructor({ name, clientId, host, port, username, password, roomId = null, dataConsume = true, audioConsume = true, videoConsume = true, dataProduce = true, audioProduce = true, videoProduce = true, videoSource = "camera", forceTcp = false, forceVP8 = false, forceVP9 = false, forceH264 = false, useLayers = false, }) { super({ name, clientId }); this.connect = false; this.name = name; this.clientId = clientId; this.host = host; this.port = port; this.username = username; this.password = password; this.roomId = roomId; this.dataConsume = dataConsume; this.audioConsume = audioConsume; this.videoConsume = videoConsume; this.dataProduce = dataProduce; this.audioProduce = audioProduce; this.videoProduce = videoProduce; this.videoSource = videoSource; this.forceTcp = forceTcp; this.forceVP8 = forceVP8; this.forceVP9 = forceVP9; this.forceH264 = forceH264; this.useLayers = useLayers; } /** * 连接信令 * * @param {*} callback 回调事件 * * @returns Promise */ async connectSignal(callback) { const me = this; me.callback = callback; signalChannel.taoyao = me; return await signalChannel.connect( `wss://${me.host}:${me.port}/websocket.signal` ); } /** * 异步请求 * * @param {*} message 信令消息 * @param {*} callback 信令回调 */ push(message, callback) { const me = this; const { header, body } = message; const { id } = header; // 请求回调 if (callback) { me.callbackMapping.set(id, callback); } // 发送消息 try { signalChannel.channel.send(JSON.stringify(message)); } catch (error) { console.error("异步请求异常", message, error); } } /** * 同步请求 * * @param {*} message 信令消息 * * @returns Promise */ async request(message) { const me = this; return new Promise((resolve, reject) => { const { header, body } = message; const { id } = header; // 设置超时 const rejectTimeout = setTimeout(() => { me.callbackMapping.delete(id); reject("请求超时", message); }, 5000); // 请求回调 me.callbackMapping.set(id, (response) => { resolve(response); clearTimeout(rejectTimeout); // 默认不用继续处理 return true; }); // 发送消息 try { signalChannel.channel.send(JSON.stringify(message)); } catch (error) { reject("同步请求异常", error); } }); } /** * 回调策略： * * 1. 如果注册请求回调，同时执行结果返回true不再执行后面所有回调。 * 2. 执行前置回调 * 3. 如果注册全局回调，同时执行结果返回true不再执行后面所有回调。 * 4. 执行后置回调 * * @param {*} message 信令消息 */ async on(message) { const me = this; const { code, header, body } = message; const { id, signal } = header; if(code !== "0000") { console.warn("信令错误", message); } // 请求回调 if (me.callbackMapping.has(id)) { try { if( me.callbackMapping.get(id)(message) ) { return; } } finally { me.callbackMapping.delete(id); } } // 前置回调 await me.preCallback(message); // 全局回调 if ( me.callback && await me.callback(message) ) { return; } // 后置回调 await me.postCallback(message); } /** * 前置回调 * * @param {*} message 消息 */ async preCallback(message) { const me = this; const { header, body } = message; const { signal } = header; switch (signal) { case "client::config": me.defaultClientConfig(message, body); break; case "media::consume": await me.defaultMediaConsume(message, body); break; case "media::data::consume": me.defaultMediaDataConsume(message, body); break; case "platform::error": me.defaultPlatformError(message, body); break; } } /** * 后置回调 * * @param {*} message 信令消息 */ async postCallback(message) { const me = this; const { header, body } = message; const { signal } = header; switch (signal) { case "client::broadcast": me.defaultClientBroadcast(message, body); break; case "client::offline": me.defaultClientOffline(message, body); break; case "client::online": me.defaultClientOnline(message, body); break; case "client::reboot": me.defaultClientReboot(message, body); break; case "client::shutdown": me.defaultClientShutdown(message, body); break; case "client::unicast": me.defaultClientUnicast(message, body); break; case "control::bell": me.defaultControlBell(message, body); break; case "control::client::record": me.defaultControlClientReccord(message, body); break; case "control::config::audio": me.defaultControlConfigAudio(message, body); break; case "control::config::video": me.defaultControlConfigVideo(message, body); break; case "control::photograph": me.defaultControlPhotograph(message, body); break; case "control::wakeup": me.defaultControlWakeup(message, body); break; case "media::audio::volume": me.defaultMediaAudioVolume(message, body); break; case "media::consumer::close": me.defaultMediaConsumerClose(message, body); break; case "media::consumer::layers::change": this.defaultMediaConsumerLayersChange(message, body); break; case "media::consumer::pause": me.defaultMediaConsumerPause(message, body); break; case "media::consumer::resume": me.defaultMediaConsumerResume(message, body); break; case "media::consumer::score": me.defaultMediaConsumerScore(message, body); break; case "media::data::consumer::close": me.defaultMediaDataConsumerClose(message, body); break; case "media::data::producer::close": me.defaultMediaDataProducerClose(message, body); break; case "media::producer::close": me.defaultMediaProducerClose(message, body); break; case "media::producer::pause": me.defaultMediaProducerPause(message, body); break; case "media::producer::resume": me.defaultMediaProducerResume(message, body); break; case "media::producer::score": me.defaultMediaProducerScore(message, body); break; case "media::transport::close": me.defaultMediaTransportClose(message, body); break; case "media::video::orientation::change": me.defaultMediaVideoOrientationChange(message, body); break; case "platform::reboot": me.defaultPlatformReboot(message, body); break; case "platform::shutdown": me.defaultPlatformShutdown(message, body); break; case "room::broadcast": me.defaultRoomBroadcast(message, body); break; case "room::client::list": me.defaultRoomClientList(message, body); break; case "room::close": me.defaultRoomClose(message, body); break; case "room::create": this.defaultRoomCreate(message, body); break; case "room::enter": me.defaultRoomEnter(message, body); break; case "room::expel": me.defaultRoomExpel(message, body); break; case "room::invite": me.defaultRoomInvite(message, body); break; case "room::leave": me.defaultRoomLeave(message, body); break; case "session::call": me.defaultSessionCall(message, body); break; case "session::close": me.defaultSessionClose(message, body); break; case "session::exchange": me.defaultSessionExchange(message, body); break; case "session::pause": me.defaultSessionPause(message, body); break; case "session::resume": me.defaultSessionResume(message, body); break; } } /** * @param {*} producerId 生产者ID * * @returns 生产者 */ getProducer(producerId) { const me = this; if(me.audioProducer?.id === producerId) { return me.audioProducer; } else if(me.videoProducer?.id === producerId) { return me.videoProducer; } else if(me.dataProducer?.id === producerId) { return me.dataProducer; } else { return null; } } /** * 选择视频文件 */ async getFileVideo() { const input = document.createElement("input"); input.type = "file"; const select = new Promise((resolve, reject) => { input.onchange = (e) => { resolve(input.value); } input.oncancel = (e) => { resolve(null); }; }); input.click(); const file = await select; input.remove(); if(!file) { console.debug("没有选择共享文件"); return; } console.debug("选择文件", file); this.fileVideo = document.createElement("video"); this.fileVideo.loop = true; this.fileVideo.muted = true; this.fileVideo.controls = true; this.fileVideo.src = URL.createObjectURL(input.files[0]); if(config.media.filePreview) { this.fileVideo.style = "position:fixed;top:1rem;left:1rem;width:128px;border:2px solid #FFF;"; } else { this.fileVideo.style.display = "none"; } document.body.appendChild(this.fileVideo); // 开始播放不然不能采集 await this.fileVideo.play(); } /** * 释放视频文件 */ async closeFileVideo() { if(this.fileVideo) { this.fileVideo.remove(); } if(this.fileVideoObjectURL) { URL.revokeObjectURL(this.fileVideoObjectURL); } } /** * @returns 媒体 */ async getStream({ audioEnabled, videoEnabled, }) { const me = this; let stream; if (me.videoSource === "file") { await this.getFileVideo(); stream = me.fileVideo.captureStream(); } else if (me.videoSource === "camera") { console.debug("媒体配置", me.audioConfig, me.videoConfig); stream = await navigator.mediaDevices.getUserMedia({ audio: audioEnabled && me.audioConfig, video: videoEnabled && me.videoConfig, }); } else if (me.videoSource === "screen") { // 音频配置：视频可能没有音频 const audioConfig = { ...me.audioConfig }; // 删除min/max delete audioConfig.sampleSize.min; delete audioConfig.sampleSize.max; delete audioConfig.sampleRate.min; delete audioConfig.sampleRate.max; // 视频配置 const videoConfig = { ...this.videoConfig, ...defaultShareScreenConfig }; // 删除min/max delete videoConfig.width.min; delete videoConfig.width.max; delete videoConfig.height.min; delete videoConfig.height.max; delete videoConfig.frameRate.min; delete videoConfig.frameRate.max; console.debug("媒体配置", audioConfig, videoConfig); stream = await navigator.mediaDevices.getDisplayMedia({ audio: audioEnabled && audioConfig, video: videoEnabled && videoConfig, }); } else { console.warn("不支持的视频来源", me.videoSource); } stream.getAudioTracks().forEach(track => { console.debug( "音频轨道信息", track.getSettings(), track.getCapabilities() ); }); stream.getVideoTracks().forEach(track => { console.debug( "视频轨道信息", track.getSettings(), track.getCapabilities() ); }); return stream; } /** * @returns 音频轨道 */ async getAudioTrack() { const me = this; const stream = await navigator.mediaDevices.getUserMedia({ audio: me.audioConfig, video: false, }); const track = stream.getAudioTracks()[0]; console.debug( "音频轨道信息", track.getSettings(), track.getCapabilities() ); return track; } /** * @returns 视频轨道 */ async getVideoTrack() { let stream; const me = this; if (me.videoSource === "file") { await this.getFileVideo(); stream = me.fileVideo.captureStream(); } else if (me.videoSource === "camera") { stream = await navigator.mediaDevices.getUserMedia({ audio: false, video: me.videoConfig, }); } else if (me.videoSource === "screen") { // 视频配置 const videoConfig = { ...this.videoConfig, ...defaultShareScreenConfig }; // 删除min/max delete videoConfig.width.min; delete videoConfig.width.max; delete videoConfig.height.min; delete videoConfig.height.max; delete videoConfig.frameRate.min; delete videoConfig.frameRate.max; stream = await navigator.mediaDevices.getDisplayMedia({ audio: false, video: videoConfig, }); } else { console.warn("不支持的视频来源", me.videoSource); } const track = stream.getVideoTracks()[0]; console.debug( "视频轨道信息", track.getSettings(), track.getCapabilities() ); return track; } /** * 终端告警信令 * * @param {*} message */ clientAlarm(message) { const me = this; const date = new Date(); const datetime = "" + date.getFullYear() + ((date.getMonth() < 9 ? "0" : "") + (date.getMonth() + 1)) + ((date.getDate() < 10 ? "0" : "") + date.getDate()) + ((date.getHours() < 10 ? "0" : "") + date.getHours()) + ((date.getMinutes() < 10 ? "0" : "") + date.getMinutes()) + ((date.getSeconds() < 10 ? "0" : "") + date.getSeconds()); me.push(protocol.buildMessage("client::alarm", { message, datetime, })); } /** * 终端广播信令 * * @param {*} message 广播信息 * @param {*} clientType 终端类型（可选） */ clientBroadcast(message, clientType) { const me = this; me.push(protocol.buildMessage("client::broadcast", { ...message, clientType, })); } /** * 终端广播信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultClientBroadcast(message, body) { console.debug("终端广播", message); } /** * 关闭终端信令 */ async clientClose() { const me = this; await me.request(protocol.buildMessage("client::close", {})); me.closeAll(); } /** * 终端配置信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultClientConfig(message, body) { const { media, webrtc } = body; const { audio, video } = media; this.audioConfig.sampleSize = { min : media.minSampleSize, ideal: audio.sampleSize, max : media.maxSampleSize, }; this.audioConfig.sampleRate = { min : media.minSampleRate, ideal: audio.sampleRate, max : media.maxSampleRate, }; this.videoConfig.width = { min : media.minWidth, ideal: video.width, max : media.maxWidth, }; this.videoConfig.height = { min : media.minHeight, ideal: video.height, max : media.maxHeight, }; this.videoConfig.frameRate = { min : media.minFrameRate, ideal: video.frameRate, max : media.maxFrameRate, }; this.options = Object.keys(media.videos).map(key => ({ ...media.videos[key], label: key, value: media.videos[key].resolution, })); this.mediaConfig = media; this.webrtcConfig = webrtc; console.debug( "终端媒体配置", this.options, this.audioConfig, this.videoConfig, this.mediaConfig, this.webrtcConfig ); } /** * @returns 媒体服务列表 */ async mediaServerList() { const response = await this.request(protocol.buildMessage("client::list", { clientType: "MEDIA" })); const { body } = response; return body || []; } /** * @returns 媒体终端列表 */ async mediaClientList() { const response = await this.request(protocol.buildMessage("client::list", {})); const { body } = response; return (body || []).filter(v => { return v.clientType === "WEB" || v.clientType === "CAMERA" || v.clientType === "MOBILE"; }); } /** * @param {*} clientType 终端类型（可选） * * @returns 终端列表 */ async clientList(clientType) { const response = await this.request(protocol.buildMessage("client::list", { clientType })); const { body } = response; return body || []; } /** * 终端下线信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultClientOffline(message, body) { console.debug("终端下线", message); } /** * 终端上线信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultClientOnline(message, body) { console.debug("终端上线", message); } /** * 重启终端信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultClientReboot(message, body) { console.info("重启终端", message); location.reload(); } /** * 关闭终端信令 * * @param {*} message 消息 * @param {*} body 消息主体 */ defaultClientShutdown(message, body) { console.info("关闭终端", message); window.close(); } /** * 终端状态信令 * * @param {*} clientId 终端ID * * @returns 终端状态 */ async clientStatus(clientId) { const response = await this.request(protocol.buildMessage("client::status", { clientId })); const { body } = response; return body || {}; } /** * 终端单播信令 * * @param {*} clientId 终端ID * @param {*} message 消息内容 */ clientUnicast(clientId, message) { this.push(protocol.buildMessage("client::unicast", { ...message, to: clientId })); } /** * 终端单播信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultClientUnicast(message, body) { console.debug("终端单播", message); } /** * 响铃信令 * * @param {*} clientId 终端ID * @param {*} enabled 是否响铃 */ async controlBell(clientId, enabled) { return await this.request(protocol.buildMessage("control::bell", { enabled, to: clientId, })); } /** * 响铃信令 * * 注意：自己实现本地响铃 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultControlBell(message, body) { console.debug("响铃", message); this.push(message); } /** * 终端录像信令 * * @param {*} clientId 终端ID * @param {*} enabled 录制状态 */ async controlClientRecord(clientId, enabled) { return await this.request(protocol.buildMessage("control::client::record", { enabled, to: clientId, })); } /** * 终端录像信令 * * 注意：自己实现本地录像（localClientRecord） * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultControlClientReccord(message, body) { console.debug("录像", message); this.push(message); } /** * 配置音频信令 * * @param {*} clientId 终端ID * @param {*} config 音频配置 */ async controlConfigAudio(clientId, config) { return await this.request(protocol.buildMessage("control::config::audio", { ...config, to: clientId })); } /** * 配置音频信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultControlConfigAudio(message, body) { const { sampleSize, sampleRate, } = body; if(sampleSize) { this.audioConfig.sampleSize.ideal = sampleSize; } if(sampleSize) { this.audioConfig.sampleRate.ideal = sampleRate; } console.debug("配置音频", body, this.audioConfig); this.push(message); this.setLocalAudioConfig(); } /** * 配置视频信令 * * @param {*} clientId 终端ID * @param {*} config 视频配置 */ async controlConfigVideo(clientId, config) { return await this.request(protocol.buildMessage("control::config::video", { ...config, to: clientId })); } /** * 配置视频信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultControlConfigVideo(message, body) { const { width, height, frameRate, } = body; if(width) { this.videoConfig.width.ideal = width; } if(height) { this.videoConfig.height.ideal = height; } if(frameRate) { this.videoConfig.frameRate.ideal = frameRate; } console.debug("配置视频", body, this.videoConfig); this.push(message); this.setLocalVideoConfig(); } /** * 拍照信令 * * @param {*} clientId 终端ID */ async controlPhotograph(clientId) { return await this.request(protocol.buildMessage("control::photograph", { to: clientId })); } /** * 拍照信令 * * 注意：自己实现本地拍照（localPhotograph） * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultControlPhotograph(message, body) { console.debug("拍照", message); this.push(message); } /** * 服务端录像信令 * * @param {*} clientId 终端ID * @param {*} enabled 录制状态 */ async controlServerRecord(clientId, enabled) { return await this.request(protocol.buildMessage("control::server::record", { enabled, to : clientId, roomId: this.roomId, })); } /** * 终端唤醒信令 * * @param {*} clientId 终端ID */ async controlWakeup(clientId) { if(clientId === this.clientId) { console.warn("不能自己唤醒自己"); return; } return await this.request(protocol.buildMessage("control::wakeup", { to: clientId })); } /** * 终端唤醒信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultControlWakeup(message, body) { console.debug("终端唤醒", message); this.push(message); } /** * 终端音量信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaAudioVolume(message, body) { const { roomId, volumes } = body; if (volumes && volumes.length > 0) { // 声音 volumes.forEach(v => { const { volume, clientId } = v; if (this.clientId === clientId) { this.setVolume(volume); } else { const remoteClient = this.remoteClients.get(clientId); remoteClient?.setVolume(volume); } }); } else { // 静音 this.setVolume(-127); this.remoteClients.forEach(v => v.setVolume(-127)); } } /** * 消费媒体信令 * * @param {*} producerId 生产者ID */ mediaConsume(producerId) { if(!this.recvTransport) { this.platformError("没有连接接收通道"); return; } this.push(protocol.buildMessage("media::consume", { producerId, roomId: this.roomId, })); } /** * 消费媒体信令 * * 如果需要加密：consumer.rtpReceiver * const receiverStreams = receiver.createEncodedStreams(); * const readableStream = receiverStreams.readable || receiverStreams.readableStream; * const writableStream = receiverStreams.writable || receiverStreams.writableStream; * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultMediaConsume(message, body) { if (!this.audioConsume && !this.videoConsume) { console.debug("没有消费媒体"); return; } const { roomId, clientId, sourceId, streamId, producerId, consumerId, kind, type, appData, rtpParameters, producerPaused, } = body; try { const consumer = await this.recvTransport.consume({ id: consumerId, appData: { ...appData, clientId, sourceId, streamId }, // libwebrtc同步相同来源媒体 streamId: `${clientId}-${appData.videoSource || "taoyao"}`, kind, producerId, rtpParameters, }); consumer.clientId = clientId; consumer.sourceId = sourceId; consumer.streamId = streamId; this.consumers.set(consumer.id, consumer); consumer.on("transportclose", () => { console.debug("消费者关闭（通道关闭）", consumer.id, streamId); consumer.close(); }); consumer.observer.on("close", () => { if(this.consumers.delete(consumer.id)) { console.debug("消费者关闭", consumer.id, streamId); } else { console.debug("消费者关闭（消费者无效）", consumer.id, streamId); } }); const { spatialLayers, temporalLayers } = mediasoupClient.parseScalabilityMode( consumer.rtpParameters.encodings[0].scalabilityMode ); this.push(message); console.debug("添加远程媒体消费者", consumer, spatialLayers, temporalLayers); const track = consumer.track; const remoteClient = this.remoteClients.get(consumer.sourceId); this.callbackTrack(sourceId, track); if ( remoteClient && remoteClient.proxy && remoteClient.proxy.media ) { if (track.kind === "audio") { remoteClient.audioTrack = track; remoteClient.audioConsumer = consumer; } else if (track.kind === "video") { remoteClient.videoTrack = track; remoteClient.videoConsumer = consumer; } else { console.warn("不支持的媒体类型", track); } remoteClient.proxy.media(track, consumer); } else { console.warn("远程终端没有实现代理", consumer.sourceId, remoteClient); } } catch (error) { this.platformError("消费媒体异常", error); } } /** * 关闭消费者信令 * * @param {*} consumerId 消费者ID */ mediaConsumerClose(consumerId) { this.push(protocol.buildMessage("media::consumer::close", { consumerId, roomId: this.roomId, })); } /** * 关闭消费者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaConsumerClose(message, body) { const { consumerId } = body; const consumer = this.consumers.get(consumerId); if(!consumer) { console.debug("关闭消费者（消费者无效）", consumerId); return; } console.debug("关闭消费者", consumerId); consumer.close(); } /** * 消费者空间层和时间层改变信令 * * @param {*} message 信令消息 * @param {*} body 信令主体 */ defaultMediaConsumerLayersChange(message, body) { console.debug("消费者空间层和时间层改变", body); } /** * 暂停消费者信令 * * @param {*} consumerId 消费者ID */ mediaConsumerPause(consumerId) { const consumer = this.consumers.get(consumerId); if(!consumer) { console.debug("暂停消费者（消费者无效）", consumerId); return; } if(consumer.paused) { console.debug("暂停消费者（消费者已经暂停）", consumerId); return; } console.debug("暂停消费者", consumerId); this.push(protocol.buildMessage("media::consumer::pause", { consumerId, roomId: this.roomId, })); } /** * 暂停消费者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaConsumerPause(message, body) { const { consumerId } = body; const consumer = this.consumers.get(consumerId); if (!consumer) { console.debug("暂停消费者（消费者无效）", consumerId); return; } if(consumer.paused) { console.debug("暂停消费者（消费者已经暂停）", consumerId); return; } console.debug("暂停消费者", consumerId); consumer.pause(); } /** * 请求关键帧信令 * * @param {*} consumerId 消费者ID */ mediaConsumerRequestKeyFrame(consumerId) { const consumer = this.consumers.get(consumerId); if(!consumer) { this.platformError("消费者无效"); return; } if(consumer.kind !== "video") { this.platformError("只能请求视频消费者"); return; } this.push(protocol.buildMessage("media::consumer::request::key::frame", { consumerId, roomId: this.roomId, })); } /** * 恢复消费者信令 * * @param {*} consumerId 消费者ID */ mediaConsumerResume(consumerId) { const consumer = this.consumers.get(consumerId); if(!consumer) { console.debug("恢复消费者（消费者无效）", consumerId); return; } if(!consumer.paused) { console.debug("恢复消费者（消费者已经恢复）", consumerId); return; } console.debug("恢复消费者", consumerId); this.push(protocol.buildMessage("media::consumer::resume", { consumerId, roomId: this.roomId, })); } /** * 恢复消费者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaConsumerResume(message, body) { const { consumerId } = body; const consumer = this.consumers.get(consumerId); if (!consumer) { console.debug("恢复消费者（消费者无效）", consumerId); return; } if(!consumer.paused) { console.debug("恢复消费者（消费者已经恢复）", consumerId); return; } console.debug("恢复消费者", consumerId); consumer.resume(); } /** * 媒体消费者评分信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaConsumerScore(message, body) { console.debug("消费者评分", message); } /** * 修改最佳空间层和时间层信令 * * @param {*} consumerId 消费者ID * @param {*} spatialLayer 空间层 * @param {*} temporalLayer 时间层 */ mediaConsumerSetPreferredLayers(consumerId, spatialLayer, temporalLayer) { const consumer = this.consumers.get(consumerId); if(!consumer) { this.platformError("消费者无效"); return; } if(consumer.kind !== "video") { this.platformError("只能修改视频消费者"); return; } this.push(protocol.buildMessage("media::consumer::set::preferred::layers", { consumerId, spatialLayer, temporalLayer, roomId: this.roomId, })); } /** * 设置消费者优先级信令 * * @param {*} consumerId 消费者ID * @param {*} priority 优先级：1~255 */ mediaConsumerSetPriority(consumerId, priority) { const consumer = this.consumers.get(consumerId); if(!consumer) { this.platformError("消费者无效"); return; } this.push(protocol.buildMessage("media::consumer::set::priority", { priority, consumerId, roomId: this.roomId, })); } /** * 查询消费者状态信令 * * @param {*} consumerId 消费者ID */ async mediaConsumerStatus(consumerId) { return await this.request(protocol.buildMessage("media::consumer::status", { consumerId, roomId: this.roomId, })); } /** * 消费数据信令 * * @param {*} producerId 数据生产者ID */ mediaDataConsume(producerId) { if(!this.recvTransport) { this.platformError("没有连接接收通道"); return; } this.push(protocol.buildMessage("media::data::consume", { producerId, roomId: this.roomId, })); } /** * 消费数据信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultMediaDataConsume(message, body) { const { roomId, clientId, sourceId, streamId, producerId, consumerId, label, appData, protocol, sctpStreamParameters, } = body; try { const dataConsumer = await this.recvTransport.consumeData({ id : consumerId, dataProducerId: producerId, label, appData, protocol, sctpStreamParameters, }); this.dataConsumers.set(dataConsumer.id, dataConsumer); dataConsumer.on("open", () => { console.debug("数据消费者打开", dataConsumer.id, streamId); }); dataConsumer.on("transportclose", () => { console.debug("数据消费者关闭（通道关闭）", dataConsumer.id, streamId); dataConsumer.close(); }); // dataConsumer.observer.on("close", fn()) dataConsumer.on("close", () => { if(this.dataConsumers.delete(dataConsumer.id)) { console.debug("数据消费者关闭", dataConsumer.id, streamId); } else { console.debug("数据消费者关闭（数据消费者无效）", dataConsumer.id, streamId); } }); dataConsumer.on("error", (error) => { console.error("数据消费者异常", dataConsumer.id, streamId, error); }); dataConsumer.on("message", (message, ppid) => { console.debug("数据消费者消息", dataConsumer.id, streamId, message.toString("UTF-8"), ppid); }); } catch (error) { this.platformError("消费数据异常", error); } } /** * 关闭数据消费者信令 * * @param {*} consumerId 数据消费者ID */ mediaDataConsumerClose(consumerId) { this.push(protocol.buildMessage("media::data::consumer::close", { consumerId, roomId: this.roomId, })); } /** * 关闭数据消费者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaDataConsumerClose(message, body) { const { consumerId } = body; const dataConsumer = this.dataConsumers.get(consumerId); if (!dataConsumer) { console.debug("关闭数据消费者（数据消费者无效）", consumerId); return; } console.debug("关闭数据消费者", consumerId); dataConsumer.close(); } /** * 查询数据消费者状态信令 * * @param {*} consumerId 消费者ID */ async mediaDataConsumerStatus(consumerId) { return await this.request(protocol.buildMessage("media::data::consumer::status", { consumerId, roomId: this.roomId, })); } /** * 生产数据 */ async produceData() { if(this.dataProducer) { console.debug("已经存在数据生产者"); return; } if(!this.dataProduce) { console.debug("不能生产数据"); return; } this.dataProducer = await this.sendTransport.produceData({ label : "taoyao", ordered : false, priority : "medium", // maxRetransmits: 1, maxPacketLifeTime: 2000, }); this.dataProducer.on("transportclose", () => { console.debug("数据生产者关闭（通道关闭）", this.dataProducer.id); this.dataProducer.close(); }); this.dataProducer.on("open", () => { console.debug("数据生产者打开", this.dataProducer.id); }); this.dataProducer.on("close", () => { console.debug("数据生产者关闭", this.dataProducer.id); this.dataProducer = null; }); this.dataProducer.on("error", (error) => { console.debug("数据生产者异常", this.dataProducer.id, error); }); // this.dataProducer.on("bufferedamountlow", fn(bufferedAmount)); } /** * 关闭数据生产者 */ async closeDataProducer() { this.mediaDataProducerClose(this.dataProducer?.id); } /** * 通过数据生产者发送数据 * * @param {*} data 数据 */ async sendDataProducer(data) { this.dataProducer?.send(data); } /** * 关闭数据生产者信令 * * @param {*} producerId 数据生产者ID */ mediaDataProducerClose(producerId) { this.push(protocol.buildMessage("media::data::producer::close", { producerId, roomId: this.roomId, })); } /** * 关闭数据生产者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaDataProducerClose(message, body) { const { producerId } = body; const producer = this.getProducer(producerId); if(!producer) { console.debug("关闭数据生产者（数据生产者无效）", producerId); return; } console.debug("关闭数据生产者", producerId); producer.close(); } /** * 查询数据生产者状态信令 * * @param {*} producerId 生产者ID */ async mediaDataProducerStatus(producerId) { return await this.request(protocol.buildMessage("media::data::producer::status", { producerId, roomId: this.roomId, })); } /** * 重启ICE信令 */ async mediaIceRestart() { if (this.sendTransport) { const response = await this.request(protocol.buildMessage("media::ice::restart", { roomId : this.roomId, transportId: this.sendTransport.id })); const { iceParameters } = response.body; await this.sendTransport.restartIce({ iceParameters }); } if (this.recvTransport) { const response = await this.request(protocol.buildMessage("media::ice::restart", { roomId : this.roomId, transportId: this.recvTransport.id })); const { iceParameters } = response.body; await this.recvTransport.restartIce({ iceParameters }); } } /** * 生产媒体 * * 如果需要加密：producer.rtpSender * const senderStreams = sender.createEncodedStreams(); * const readableStream = senderStreams.readable || senderStreams.readableStream; * const writableStream = senderStreams.writable || senderStreams.writableStream; * * @returns 所有生产者 */ async mediaProduce(audioTrack, videoTrack) { if(!audioTrack || !videoTrack) { await this.checkDevice(); } await this.mediaConnect(); await this.produceAudio(audioTrack); await this.produceVideo(videoTrack); await this.produceData(); return { dataProducer : this.dataProducer, audioProducer: this.audioProducer, videoProducer: this.videoProducer, } } /** * 连接媒体 */ async mediaConnect() { if(!this.sendTransport) { await this.createSendTransport(); } if(!this.recvTransport) { await this.createRecvTransport(); } } /** * 生产音频 * * @param {*} audioTrack 音频轨道（可以为空自动） */ async produceAudio(audioTrack) { if (this.audioProducer) { console.debug("已经存在音频生产者"); return; } if ( !this.audioProduce || !this.mediasoupDevice.canProduce("audio") ) { console.debug("不能生产音频数媒"); return; } const codecOptions = { opusDtx : true, opusFec : true, opusNack : true, opusStereo : true, }; const track = audioTrack || await this.getAudioTrack(); this.audioTrack = track; this.audioProducer = await this.sendTransport.produce({ track, codecOptions, appData: { videoSource: this.videoSource }, }); this.callbackTrack(this.clientId, track); if (this.proxy && this.proxy.media) { this.proxy.media(track, this.audioProducer); } else { console.warn("终端没有实现服务代理"); } this.audioProducer.on("transportclose", () => { console.debug("关闭音频生产者（通道关闭）", this.audioProducer.id); this.audioProducer.close(); }); this.audioProducer.on("trackended", () => { console.debug("关闭音频生产者（媒体结束）", this.audioProducer.id); this.audioProducer.close(); }); this.audioProducer.observer.on("close", () => { console.debug("关闭音频生产者", this.audioProducer.id); this.audioProducer = null; }); } /** * 关闭音频生产者 */ async closeAudioProducer() { this.mediaProducerClose(this.audioProducer?.id); } /** * 暂停音频生产者 */ async pauseAudioProducer() { this.mediaProducerPause(this.audioProducer?.id); } /** * 恢复音频生产者 */ async resumeAudioProducer() { this.mediaProducerResume(this.audioProducer?.id); } /** * 生产视频 * * @param {*} videoTrack 音频轨道（可以为空自动） */ async produceVideo(videoTrack) { if (this.videoProducer) { console.debug("已经存在视频生产者"); return; } if ( !this.videoProduce || !this.mediasoupDevice.canProduce("video") ) { console.debug("不能生产视频媒体"); return; } const codecOptions = { videoGoogleStartBitrate: 400, videoGoogleMinBitrate : 800, videoGoogleMaxBitrate : 1600, }; let codec; if(this.forceVP8) { codec = this.mediasoupDevice.rtpCapabilities.codecs.find((c) => c.mimeType.toLowerCase() === "video/vp8"); if (codec) { console.debug("强制使用VP8视频编码"); } else { console.debug("不支持VP8视频编码"); } } if (this.forceVP9) { codec = this.mediasoupDevice.rtpCapabilities.codecs.find((c) => c.mimeType.toLowerCase() === "video/vp9"); if (codec) { console.debug("强制使用VP9视频编码"); } else { console.debug("不支持VP9视频编码"); } } if (this.forceH264) { codec = this.mediasoupDevice.rtpCapabilities.codecs.find((c) => c.mimeType.toLowerCase() === "video/h264"); if (codec) { console.debug("强制使用H264视频编码"); } else { console.debug("不支持H264视频编码"); } } let encodings; if (this.useLayers) { const priorityVideoCodec = this.mediasoupDevice.rtpCapabilities.codecs.find((c) => c.kind === "video"); if ((this.forceVP9 && codec) || priorityVideoCodec.mimeType.toLowerCase() === "video/vp9") { encodings = defaultSvcEncodings; } else { encodings = defaultSimulcastEncodings; } } const track = videoTrack || await this.getVideoTrack(); this.videoTrack = track; this.videoProducer = await this.sendTransport.produce({ codec, track, encodings, codecOptions, appData: { videoSource: this.videoSource }, }); this.callbackTrack(this.clientId, track); if (this.proxy && this.proxy.media) { this.proxy.media(track, this.videoProducer); } else { console.warn("终端没有实现服务代理"); } this.videoProducer.on("transportclose", () => { console.debug("关闭视频生产者（通道关闭）", this.videoProducer.id); this.videoProducer.close(); }); this.videoProducer.on("trackended", () => { console.debug("关闭视频生产者（媒体结束）", this.videoProducer.id); this.videoProducer.close(); }); this.videoProducer.observer.on("close", () => { console.debug("关闭视频生产者", this.videoProducer.id); this.videoProducer = null; }); } /** * 关闭视频生产者 */ async closeVideoProducer() { this.mediaProducerClose(this.videoProducer?.id); } /** * 暂停视频生产者 */ async pauseVideoProducer() { this.mediaProducerPause(this.videoProducer?.id); } /** * 恢复视频生产者 */ async resumeVideoProducer() { this.mediaProducerResume(this.videoProducer?.id); } /** * 切换视频来源 * * @param {*} videoSource 视频来源（可以为空） */ async exchangeVideoSource(videoSource) { console.debug("切换视频来源", videoSource, this.videoSource); const old = this.videoSource; if(videoSource) { this.videoSource = videoSource; } else { if(this.videoSource === "file") { this.videoSource = "camera"; } else if(this.videoSource === "camera") { this.videoSource = "screen"; } else if(this.videoSource === "screen") { this.videoSource = "file"; } else { this.videoSource = "camera"; } } await this.updateVideoProducer(); if(old === "file") { this.closeFileVideo(); } } /** * 更新音频轨道 * * @param {*} audioTrack 音频轨道 */ async updateAudioProducer(audioTrack) { if(!this.audioProducer) { console.debug("没有发布音频忽略更新音频轨道"); return; } const track = audioTrack || await this.getAudioTrack(); this.closeMediaTrack(this.audioProducer.track); await this.audioProducer.replaceTrack({ track }); this.callbackTrack(this.clientId, track); if (this.proxy && this.proxy.media) { this.proxy.media(track, this.audioProducer); } else { console.warn("终端没有实现服务代理"); } } /** * 更新音频轨道 * * @param {*} audioTrack 音频轨道 */ async updateAudioSession(audioTrack) { this.sessionClients.forEach(async (v, k) => { // TODO：旧的资源是否需要释放 const localStream = await this.getStream({ audioEnabled: true, videoEnabled: false, }); if(v.localAudioEnabled) { this.closeMediaTrack(v.localAudioSender.track); v.localStream = localStream; v.localAudioTrack = audioTrack || localStream.getAudioTracks()[0]; v.localAudioSender.replaceTrack(v.localAudioTrack); } }); } /** * 更新视频轨道 * * @param {*} 视频轨道 */ async updateVideoProducer(videoTrack) { if(!this.videoProducer) { console.debug("没有发布视频忽略更新视频轨道"); return; } const track = videoTrack || await this.getVideoTrack(); this.closeMediaTrack(this.videoProducer.track); await this.videoProducer.replaceTrack({ track }); this.callbackTrack(this.clientId, track); if (this.proxy && this.proxy.media) { this.proxy.media(track, this.videoProducer); } else { console.warn("终端没有实现服务代理"); } } /** * 更新视频轨道 * * @param {*} videoTrack 视频轨道 */ async updateVideoSession(videoTrack) { this.sessionClients.forEach(async (v, k) => { // TODO：旧的资源是否需要释放 const localStream = await this.getStream({ audioEnabled: false, videoEnabled: true, }); if(v.localVideoEnabled) { this.closeMediaTrack(v.localVideoSender.track); v.localStream = localStream; v.localVideoTrack = videoTrack || localStream.getVideoTracks()[0]; v.localVideoSender.replaceTrack(v.localVideoTrack); } }); } /** * 验证设备 */ async checkDevice() { if ( navigator.mediaDevices && navigator.mediaDevices.getUserMedia && navigator.mediaDevices.enumerateDevices ) { let audioEnabled = false; let videoEnabled = false; (await navigator.mediaDevices.enumerateDevices()).forEach((v) => { console.debug("终端媒体设备", v, v.kind, v.label); switch (v.kind) { case "audioinput": audioEnabled = true; break; case "videoinput": videoEnabled = true; break; default: console.debug("未知设备类型", v.kind, v.label); break; } }); if (!audioEnabled && this.audioProduce) { this.platformError("没有音频媒体设备"); // 强制修改 this.audioProduce = false; } if (!videoEnabled && this.videoProduce) { this.platformError("没有视频媒体设备"); // 强制修改 this.videoProduce = false; } } else { this.platformError("没有媒体权限"); } } /** * 关闭生产者信令 * * @param {*} producerId 生产者ID */ mediaProducerClose(producerId) { this.push(protocol.buildMessage("media::producer::close", { producerId, roomId: this.roomId, })); } /** * 关闭生产者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultMediaProducerClose(message, body) { const { producerId } = body; const producer = this.getProducer(producerId); if(!producer) { console.debug("关闭生产者（生产者无效）", producerId); return; } console.debug("关闭生产者", producerId); producer.close(); } /** * 暂停生产者信令 * * @param {*} producerId 生产者ID */ mediaProducerPause(producerId) { const producer = this.getProducer(producerId); if(!producer) { console.debug("暂停生产者（生产者无效）", producerId); return; } if(producer.paused) { console.debug("暂停生产者（生产者已经暂停）", producerId); return; } console.debug("暂停生产者", producerId); this.push(protocol.buildMessage("media::producer::pause", { producerId, roomId: this.roomId, })); } /** * 暂停生产者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaProducerPause(message, body) { const { producerId } = body; const producer = this.getProducer(producerId); if (!producer) { console.debug("暂停生产者（生产者无效）", producerId); return; } if(producer.paused) { console.debug("暂停生产者（生产者已经暂停）", producerId); return; } console.debug("暂停生产者", producerId); producer.pause(); } /** * 恢复生产者信令 * * @param {*} producerId 生产者ID */ mediaProducerResume(producerId) { const producer = this.getProducer(producerId); if(!producer) { console.debug("恢复生产者（生产者无效）", producerId); return; } if(!producer.paused) { console.debug("恢复生产者（生产者已经恢复）", producerId); return; } console.debug("恢复生产者", producerId); this.push(protocol.buildMessage("media::producer::resume", { producerId, roomId: this.roomId, })); } /** * 恢复生产者信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaProducerResume(message, body) { const { producerId } = body; const producer = this.getProducer(producerId); if (!producer) { console.debug("恢复生产者（生产者无效）", producerId); return; } if(!producer.paused) { console.debug("恢复生产者（生产者已经恢复）", producerId); return; } console.debug("恢复生产者", producerId); producer.resume(); } /** * 媒体生产者评分信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaProducerScore(message, body) { console.debug("生产者评分", message); } /** * 查询生产者状态信令 * * @param {*} producerId 生产者ID */ async mediaProducerStatus(producerId) { return await this.request(protocol.buildMessage("media::producer::status", { producerId, roomId: this.roomId, })); } /** * 关闭通道信令 * * @param {*} transportId 通道ID */ mediaTransportClose(transportId) { console.debug("关闭通道", transportId); this.push(protocol.buildMessage("media::transport::close", { transportId, roomId: this.roomId, })); } /** * 关闭通道信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaTransportClose(message, body) { const { roomId, transportId } = body; if(this.recvTransport && this.recvTransport.id === transportId) { console.debug("关闭接收通道", transportId); this.recvTransport.close(); this.recvTransport = null; } else if(this.sendTransport && this.sendTransport.id === transportId) { console.debug("关闭发送通道", transportId); this.sendTransport.close(); this.sendTransport = null; } else { console.debug("关闭通道无效", roomId, transportId); } } /** * 查询通道状态信令 * * @param {*} transportId 通道ID */ async mediaTransportStatus(transportId) { return await this.request(protocol.buildMessage('media::transport::status', { transportId, roomId: this.roomId, })); } /** * 创建媒体发送通道 */ async createSendTransport() { if ( !this.dataProduce && !this.audioProduce && !this.videoProduce ) { console.debug("没有任何数据生产忽略创建媒体发送通道"); return; } const response = await this.request(protocol.buildMessage("media::transport::webrtc::create", { roomId : this.roomId, forceTcp : this.forceTcp, producing : true, consuming : false, sctpCapabilities: this.dataProduce ? this.mediasoupDevice.sctpCapabilities : undefined, })); const { transportId, iceCandidates, iceParameters, dtlsParameters, sctpParameters, } = response.body; this.sendTransport = await this.mediasoupDevice.createSendTransport({ iceCandidates, iceParameters, sctpParameters, id : transportId, iceServers : [], dtlsParameters: { ...dtlsParameters, role: "auto", }, proprietaryConstraints: { optional: [{ googDscp : true, // googIPv6 : true, // DtlsSrtpKeyAgreement: true, }], }, }); this.sendTransport.on("connect", ({ dtlsParameters }, callback, errback) => { this.request(protocol.buildMessage("media::transport::webrtc::connect", { dtlsParameters, roomId : this.roomId, transportId: this.sendTransport.id, })) .then(callback) .catch(errback); }); this.sendTransport.on("produce", ({ kind, appData, rtpParameters }, callback, errback) => { this.request(protocol.buildMessage("media::produce", { kind, appData, rtpParameters, roomId : this.roomId, transportId: this.sendTransport.id, })) .then((response) => { const { streamId, producerId } = response.body; callback({ id: producerId }); }) .catch(errback); }); this.sendTransport.on("producedata", ({ label, appData, protocol, sctpStreamParameters }, callback, errback) => { this.request(taoyaoProtocol.buildMessage("media::data::produce", { label, appData, protocol, sctpStreamParameters, roomId : this.roomId, transportId: this.sendTransport.id, })) .then((response) => { const { treamId, producerId } = response.body; callback({ id: producerId }); }) .catch(errback); }); } /** * 创建媒体接收通道 */ async createRecvTransport() { if ( !this.dataConsume && !this.audioConsume && !this.videoConsume ) { console.debug("没有任何数据消费忽略创建媒体接收通道"); return; } const response = await this.request(protocol.buildMessage("media::transport::webrtc::create", { roomId : this.roomId, forceTcp : this.forceTcp, producing : false, consuming : true, sctpCapabilities: this.dataProduce ? this.mediasoupDevice.sctpCapabilities : undefined, })); const { transportId, iceCandidates, iceParameters, dtlsParameters, sctpParameters, } = response.body; this.recvTransport = await this.mediasoupDevice.createRecvTransport({ iceCandidates, iceParameters, sctpParameters, id : transportId, iceServers : [], dtlsParameters: { ...dtlsParameters, role: "auto", }, proprietaryConstraints: { optional: [{ googDscp : true, // googIPv6 : true, // DtlsSrtpKeyAgreement: true, }], }, }); this.recvTransport.on("connect", ({ dtlsParameters }, callback, errback) => { this.request(protocol.buildMessage("media::transport::webrtc::connect", { dtlsParameters, roomId : this.roomId, transportId: this.recvTransport.id, })) .then(callback) .catch(errback); }); } /** * 视频方向变化信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultMediaVideoOrientationChange(message, body) { console.debug("视频方向变化", message); } /** * 错误回调 * * @param {*} message 错误消息 * @param {*} error 异常信息 */ platformError(message, error) { if (this.callback) { let callbackMessage; if(message instanceof Object) { callbackMessage = message; } else { callbackMessage = protocol.buildMessage("platform::error", { error, message, }); callbackMessage.code = "9999"; callbackMessage.message = message; } this.callback(callbackMessage, error); } else { if (error) { console.error("发生异常", message, error); } else { console.warn("发生错误", message); } } } /** * 平台异常信令 * * @param {*} message 消息 * @param {*} body 消息主体 */ defaultPlatformError(message, body) { const { code } = message; if (code === "3401") { // 没有授权直接关闭 this.closeAll(); } else { console.warn("平台异常", message); } } /** * 重启平台信令 * * @returns 响应 */ async platformReboot() { return await this.request(protocol.buildMessage("platform::reboot", {})); } /** * 重启平台信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultPlatformReboot(message, body) { console.debug("重启平台", message); } /** * 执行命令信令 * * @param {*} script 命令 * * @returns 响应 */ async platformScript(script) { return await this.request(protocol.buildMessage("platform::script", { script })); } /** * 关闭平台信令 * * @returns 响应 */ async platformShutdown() { return await this.request(protocol.buildMessage("platform::shutdown", {})); } /** * 关闭平台信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultPlatformShutdown(message, body) { console.debug("平台关闭", message); } /** * 房间广播信令 * * @param {*} message 信令消息 */ roomBroadcast(message) { this.push(protocol.buildMessage("room::broadcast", { ...message, roomId : this.roomId, })); } /** * 房间广播信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultRoomBroadcast(message, body) { console.debug("房间广播", message); } /** * 房间终端ID集合信令 * * @param {*} clientId 终端ID * * @returns 房间终端ID集合 */ async roomClientListId(clientId) { const response = await this.request(protocol.buildMessage("room::client::list::id", { roomId : this.roomId, clientId: clientId })); return response.body; } /** * 房间终端列表信令 * * @param {*} roomId 房间ID * * @returns 设备列表 */ async roomClientList(roomId) { const response = await this.request(protocol.buildMessage("room::client::list", { roomId: roomId || this.roomId })); return response.body; } /** * 房间终端列表信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultRoomClientList(message, body) { const { clients } = body; clients.forEach(v => { if (v.clientId === this.clientId) { // 忽略自己 } else { this.remoteClients.set(v.clientId, new RemoteClient(v)); } }); } /** * 关闭房间信令 */ async roomClose() { this.push(protocol.buildMessage("room::close", { roomId: this.roomId, })); } /** * 关闭房间信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultRoomClose(message, body) { const { roomId } = body; if (roomId !== this.roomId) { return; } console.debug("关闭房间", roomId); this.closeRoomMedia(); } /** * 创建房间信令 * * @param {*} room 房间信息 * * @returns 响应消息 */ async roomCreate(room) { if(this.roomId) { this.platformError("终端已经进入房间"); return { code : 9999, message: "终端已经进入房间" }; } console.debug("创建房间", room); const response = await this.request(protocol.buildMessage("room::create", { ...room })); return response.body; } /** * 创建房间信令 * 用于房间重建 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultRoomCreate(message, body) { console.debug("创建房间", message); const { roomId, password } = body; if(this.roomId && roomId === this.roomId) { await this.roomLeave(); await this.roomEnter(roomId, password); await this.mediaProduce(); } } /** * 进入房间信令 * * @param {*} roomId 房间ID * @param {*} password 房间密码 */ async roomEnter(roomId, password) { if(this.roomId) { this.platformError("终端已经进入房间"); return { code : 9999, message: "终端已经进入房间", }; } this.roomId = roomId; let response = await this.request(protocol.buildMessage("media::router::rtp::capabilities", { roomId: this.roomId, })); if(response.code !== SUCCESS_CODE) { this.roomId = null; this.platformError(response); return response; } const routerRtpCapabilities = response.body.rtpCapabilities; this.mediasoupDevice = new mediasoupClient.Device(); await this.mediasoupDevice.load({ routerRtpCapabilities }); response = await this.request(protocol.buildMessage("room::enter", { roomId : roomId, password : password, rtpCapabilities : this.audioConsume || this.videoConsume || this.audioProduce || this.videoProduce ? this.mediasoupDevice.rtpCapabilities : undefined, sctpCapabilities: this.dataConsume || this.dataProduce ? this.mediasoupDevice.sctpCapabilities : undefined, })); if(response.code !== SUCCESS_CODE) { this.roomId = null; this.platformError(response); return response; } return response; } /** * 进入房间信令 * 其他终端进入房间 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultRoomEnter(message, body) { const { status, clientId, } = body; if (clientId === this.clientId) { // 忽略自己 } else if(this.remoteClients.has(clientId)) { console.debug("终端已经进入房间", clientId); } else { console.debug("远程终端进入房间", clientId); this.remoteClients.set(clientId, new RemoteClient(status)); } } /** * 踢出房间信令 * * @param {*} clientId 终端ID */ roomExpel(clientId) { this.push(protocol.buildMessage("room::expel", { roomId: this.roomId, clientId, })); } /** * 踢出房间信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultRoomExpel(message, body) { console.debug("收到提出房间信令", message); await this.roomLeave(); } /** * 邀请终端信令 * * @param {*} clientId 终端ID */ roomInvite(clientId) { this.push(protocol.buildMessage("room::invite", { roomId: this.roomId, clientId, })); } /** * 邀请终端信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultRoomInvite(message, body) { // 默认自动进入：如果需要确认使用回调函数重写 const { roomId, password } = body; // H5只能同时进入一个房间 if(this.roomId) { this.platformError("终端拒绝房间邀请"); return; } console.debug("房间邀请终端", roomId); await this.roomEnter(roomId, password); await this.mediaProduce(); } /** * 离开房间信令 */ async roomLeave() { this.push(protocol.buildMessage("room::leave", { roomId: this.roomId })); await this.closeRoomMedia(); } /** * 离开房间信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ defaultRoomLeave(message, body) { const { clientId } = body; if(clientId === this.clientId) { this.closeRoomMedia(); console.debug("终端离开房间", clientId); } else if(this.remoteClients.has(clientId)) { const remoteClient = this.remoteClients.get(clientId); remoteClient.close(); this.remoteClients.delete(clientId); console.debug("终端离开房间", clientId); } else { console.debug("终端已经离开", clientId); } } /** * 房间列表信令 * * @returns 房间列表 */ async roomList() { const response = await this.request(protocol.buildMessage("room::list")); return response.body; } /** * 房间状态信令 * * @param {*} roomId 房间ID * * @returns 房间状态 */ async roomStatus(roomId) { const response = await this.request(protocol.buildMessage("room::status", { roomId: roomId || this.roomId })); return response.body; } /** * 发起会话信令 * * @param {*} clientId 目标ID * @param {*} audio 打开音频 * @param {*} video 打开视频 */ async sessionCall(clientId, audio = true, video = true) { if (clientId == this.clientId) { this.platformError("不能监控自己"); return; } await this.checkDevice(); const response = await this.request(protocol.buildMessage("session::call", { clientId })); const { code, body, message } = response; if(code !== SUCCESS_CODE) { this.platformError(message); return; } const { name, sessionId } = body; console.debug("发起会话", clientId, sessionId); const session = new Session({ name, clientId, sessionId, audioEnabled: this.audioProduce && audio, videoEnabled: this.videoProduce && video }); this.sessionClients.set(sessionId, session); } /** * 发起会话信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultSessionCall(message, body) { await this.checkDevice(); const { name, audio = true, video = true, clientId, sessionId } = body; console.debug("接收会话", clientId, sessionId, audio, video); const session = new Session({ name, clientId, sessionId, audioEnabled: this.audioProduce && audio, videoEnabled: this.videoProduce && video }); this.sessionClients.set(sessionId, session); await this.buildPeerConnection(session, sessionId); session.peerConnection.createOffer().then(async (description) => { await session.peerConnection.setLocalDescription(description); this.push(protocol.buildMessage("session::exchange", { sdp : description.sdp, type : description.type, sessionId: sessionId })); }); } /** * 关闭媒体信令 * * @param {*} sessionId 会话ID */ async sessionClose(sessionId) { this.push(protocol.buildMessage("session::close", { sessionId })); } /** * 关闭媒体信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultSessionClose(message, body) { const { sessionId } = body; const session = this.sessionClients.get(sessionId); if(session) { console.debug("关闭媒体", sessionId); await session.close(); this.sessionClients.delete(sessionId); } else { console.debug("关闭媒体（会话无效）", sessionId); } } /** * 媒体交换信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultSessionExchange(message, body) { const { type, candidate, sessionId, } = body; const session = this.sessionClients.get(sessionId); if (type === "offer") { await this.buildPeerConnection(session, sessionId); await session.peerConnection.setRemoteDescription(new RTCSessionDescription(body)); session.peerConnection.createAnswer().then(async description => { await session.peerConnection.setLocalDescription(description); this.push(protocol.buildMessage("session::exchange", { sdp : description.sdp, type : description.type, sessionId: sessionId })); }); } else if (type === "answer") { await session.peerConnection.setRemoteDescription(new RTCSessionDescription(body)); } else if (type === "candidate") { await session.addIceCandidate(candidate); } else { console.warn("媒体交换无效类型", body); } } /** * 暂停媒体信令 * * @param {*} sessionId 会话ID * @param {*} type 媒体类型 */ async sessionPause(sessionId, type) { const session = this.sessionClients.get(sessionId); if(session) { console.debug("暂停媒体", type, sessionId); this.push(protocol.buildMessage("session::pause", { type, sessionId })); session.pauseRemote(type); } else { console.debug("暂停媒体（会话无效）", type, sessionId); } } /** * 暂停媒体信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultSessionPause(message, body) { const { type, sessionId } = body; const session = this.sessionClients.get(sessionId); if(session) { console.debug("暂停媒体", type, sessionId); session.pause(type); } else { console.debug("暂停媒体（会话无效）", type, sessionId); } } /** * 恢复媒体信令 * * @param {*} sessionId 会话ID * @param {*} type 媒体类型 */ async sessionResume(sessionId, type) { const session = this.sessionClients.get(sessionId); if(session) { console.debug("恢复媒体", type, sessionId); this.push(protocol.buildMessage("session::resume", { type, sessionId })); session.resumeRemote(type); } else { console.debug("恢复媒体（会话无效）", type, sessionId); } } /** * 恢复媒体信令 * * @param {*} message 信令消息 * @param {*} body 消息主体 */ async defaultSessionResume(message, body) { const { type, sessionId } = body; const session = this.sessionClients.get(sessionId); if(session) { console.debug("恢复媒体", type, sessionId); session.resume(type); } else { console.debug("恢复媒体（会话无效）", type, sessionId); } } /** * 系统信息信令 * * @returns 系统信息 */ async systemInfo() { return await this.request(protocol.buildMessage("system::info", {})); } /** * 重启系统信令 * * @returns 重启系统结果 */ async systemReboot() { return await this.request(protocol.buildMessage("system::reboot", {})); } /** * 关闭系统信令 * * @returns 关闭系统结果 */ async systemShutdown() { return await this.request(protocol.buildMessage("system::shutdown", {})); } /** * @param {*} session 会话 * @param {*} sessionId 会话ID * * @returns PeerConnection */ async buildPeerConnection(session, sessionId) { if(session.peerConnection) { return session.peerConnection; } const peerConnection = new RTCPeerConnection({ "iceServers": this.webrtcConfig.iceServers || defaultRTCPeerConnectionConfig.iceServers }); peerConnection.ontrack = event => { console.debug("会话添加远程媒体轨道", event); const track = event.track; if(track.kind === 'audio') { session.remoteAudioTrack = track; session.remoteAudioEnabled = true; } else if(track.kind === 'video') { session.remoteVideoTrack = track; session.remoteVideoEnabled = true; } else { console.warn("未知媒体类型", track); } this.callbackTrack(session.clientId, track); if(session.proxy && session.proxy.media) { session.proxy.media(track); } else { console.warn("远程会话没有实现代理", session); } }; peerConnection.onicecandidate = event => { console.debug("会话媒体协商", event); this.push(protocol.buildMessage("session::exchange", { type : "candidate", sessionId : sessionId, candidate : event.candidate })); }; peerConnection.onnegotiationneeded = event => { console.debug("会话媒体重新协商", event); // TODO：重连 if(peerConnection.connectionState === "connected") { peerConnection.restartIce(); } } const localStream = await this.getStream({ audioEnabled: true, videoEnabled: true, }); session.localStream = localStream; session.peerConnection = peerConnection; if(session.audioEnabled && localStream.getAudioTracks().length >= 0) { session.localAudioTrack = localStream.getAudioTracks()[0]; if(session.localAudioTrack) { session.localAudioEnabled = true; session.localAudioSender = await session.peerConnection.addTrack(session.localAudioTrack, localStream); } else { session.localAudioEnabled = false; } } else { session.localAudioEnabled = false; } if(session.videoEnabled && localStream.getVideoTracks().length >= 0) { session.localVideoTrack = localStream.getVideoTracks()[0]; if(session.localVideoTrack) { session.localVideoEnabled = true; session.localVideoSender = await session.peerConnection.addTrack(session.localVideoTrack, localStream); } else { session.localVideoEnabled = false; } } else { session.localVideoEnabled = false; } return peerConnection; } /** * 本地截图 * * @param {*} video 视频 */ localPhotograph(video) { const canvas = document.createElement("canvas"); canvas.width = video.videoWidth; canvas.height = video.videoHeight; const context = canvas.getContext("2d"); context.drawImage(video, 0, 0, video.videoWidth, video.videoHeight); const dataURL = canvas.toDataURL("images/png"); const download = document.createElement("a"); download.href = dataURL; download.download = "taoyao.png"; // download.style.display = "none"; // document.body.appendChild(download); download.click(); // 释放资源 canvas.remove(); download.remove(); } /** * 本地录像 * * 'video/webm;codecs=aac,vp8', * 'video/webm;codecs=aac,vp9', * 'video/webm;codecs=aac,h264', * 'video/webm;codecs=pcm,vp8', * 'video/webm;codecs=pcm,vp9', * 'video/webm;codecs=pcm,h264', * 'video/webm;codecs=opus,vp8', * 'video/webm;codecs=opus,vp9', * 'video/webm;codecs=opus,h264', * 'video/mp4;codecs=aac,vp8', * 'video/mp4;codecs=aac,vp9', * 'video/mp4;codecs=aac,h264', * 'video/mp4;codecs=pcm,vp8', * 'video/mp4;codecs=pcm,vp9', * 'video/mp4;codecs=pcm,h264', * 'video/mp4;codecs=opus,vp8', * 'video/mp4;codecs=opus,vp9', * 'video/mp4;codecs=opus,h264', * * MediaRecorder.isTypeSupported(mimeType) * * video.captureStream().getTracks().forEach((v) => stream.addTrack(v)); * * @param {*} audioStream 音频流 * @param {*} videoStream 视频流 * @param {*} enabled 是否录像 */ localClientRecord(audioStream, videoStream, enabled) { const me = this; if (enabled) { if (me.mediaRecorder) { console.debug("本地录像机已经存在"); return; } const stream = new MediaStream(); if(audioStream) { audioStream.getAudioTracks().forEach(track => stream.addTrack(track)); } if(videoStream) { videoStream.getVideoTracks().forEach(track => stream.addTrack(track)); } me.mediaRecorder = new MediaRecorder(stream, { audioBitsPerSecond: 256 * 1000, videoBitsPerSecond: 1600 * 1000, mimeType: 'video/webm;codecs=opus,h264', }); me.mediaRecorder.onstop = (e) => { const blob = new Blob(me.mediaRecorderChunks); const objectURL = URL.createObjectURL(blob); const download = document.createElement("a"); download.href = objectURL; download.download = "taoyao.mp4"; // download.style.display = "none"; // document.body.appendChild(download); download.click(); download.remove(); URL.revokeObjectURL(objectURL); me.mediaRecorderChunks = []; }; me.mediaRecorder.ondataavailable = (e) => { me.mediaRecorderChunks.push(e.data); }; me.mediaRecorder.start(); } else { if (!me.mediaRecorder) { console.debug("本地录像机无效"); return; } me.mediaRecorder.stop(); me.mediaRecorder = null; } } /** * 配置音频 * * @param {*} label 配置 */ setLocalAudioConfig(label) { if(label) { // TODO：更新本地配置 } this.updateAudioProducer(); this.updateAudioSession(); } /** * 配置视频 * * @param {*} label 配置 */ setLocalVideoConfig(label) { const me = this; if(label) { // TODO：更新本地配置 } me.updateVideoProducer(); me.updateVideoSession(); } /** * 配置视频 * * @param {*} label 配置 */ setVideoConfig(clientId, label) { const me = this; if(clientId === me.clientId) { me.setLocalVideoConfig(label); return; } // TODO：更新远程配置 const option = this.options.find(v => v.label === label); if(!option) { console.warn("不支持的视频配置", label, this.options); return; } this.controlConfigVideo( clientId, option, ); } /** * 配置媒体轨道 * 参考连接：https://developer.mozilla.org/en-US/docs/Web/API/MediaTrackSettings * * @param {*} track 媒体轨道 * @param {*} setting 支持属性：navigator.mediaDevices.getSupportedConstraints() */ async setTrack(track, setting) { await track.applyConstraints(Object.assign(track.getSettings(), setting)); } /** * 媒体回调 * * @param {*} clientId 终端ID * @param {*} track 媒体轨道 */ callbackTrack(clientId, track) { const callbackMessage = protocol.buildMessage("media::track", { track, clientId, }); callbackMessage.code = SUCCESS_CODE; callbackMessage.message = SUCCESS_MESSAGE; this.callback(callbackMessage); } /** * 统计设备信息 * * @param {*} clientId 终端ID * * @returns 设备信息统计 */ async getClientStats(clientId) { const stats = {}; if(clientId === this.clientId) { stats.sendTransport = await this.sendTransport.getStats(); stats.recvTransport = await this.recvTransport.getStats(); stats.audioProducer = await this.audioProducer.getStats(); stats.videoProducer = await this.videoProducer.getStats(); } else { const consumers = Array.from(this.consumers.values()); for(const consumer of consumers) { if(clientId === consumer.sourceId) { stats[consumer.kind] = await consumer.getStats(); } } } return stats; } /** * 关闭媒体资源 * * @param {*} mediaStream 媒体资源 */ closeMediaStream(mediaStream) { if(!mediaStream) { return; } mediaStream.getAudioTracks().forEach(oldTrack => { console.debug("关闭音频媒体轨道", oldTrack); oldTrack.stop(); }); mediaStream.getVideoTracks().forEach(oldTrack => { console.debug("关闭视频媒体轨道", oldTrack); oldTrack.stop(); }); } /** * 关闭媒体轨道 * * @param {*} mediaTrack 媒体轨道 */ closeMediaTrack(mediaTrack) { if(!mediaTrack) { return; } console.debug("关闭媒体轨道", mediaTrack); mediaTrack.stop(); } /** * 关闭视频房间媒体 */ async closeRoomMedia() { console.debug("关闭视频房间媒体"); this.roomId = null; await this.close(); await this.closeRoomMediaConsumer(); await this.closeRoomMediaProducer(); await this.closeRoomMediaConnect(); this.closeFileVideo(); } /** * 关闭媒体连接 */ async closeRoomMediaConnect() { if (this.sendTransport) { await this.sendTransport.close(); this.sendTransport = null; } if (this.recvTransport) { await this.recvTransport.close(); this.recvTransport = null; } if(this.mediasoupDevice) { this.mediasoupDevice = null; } } /** * 关闭媒体生产者 */ async closeRoomMediaProducer() { if(this.audioProducer) { await this.audioProducer.close(); this.audioProducer = null; } if(this.videoProducer) { await this.videoProducer.close(); this.videoProducer = null; } if(this.dataProducer) { await this.dataProducer.close(); this.dataProducer = null; } } /** * 关闭媒体消费者 */ async closeRoomMediaConsumer() { this.consumers.forEach(async (consumer, consumerId) => { await consumer.close(); }); this.consumers.clear(); this.dataConsumers.forEach(async (dataConsumer, consumerId) => { await dataConsumer.close(); }); this.dataConsumers.clear(); this.remoteClients.forEach(async (remoteClient, clientId) => { await remoteClient.close(); }); this.remoteClients.clear(); } /** * 关闭视频会话媒体 */ closeSessionMedia() { console.debug("关闭视频会话媒体"); this.sessionClients.forEach((session, sessionId) => { session.close(); console.debug("关闭会话", sessionId); }); this.sessionClients.clear(); this.closeFileVideo(); } /** * 关闭资源 */ closeAll() { if(this.closed) { return; } this.closed = true; this.closeRoomMedia(); this.closeSessionMedia(); signalChannel.close(); } } export { Taoyao };