3161 lines
110 KiB
JavaScript
3161 lines
110 KiB
JavaScript
"use strict";
|
|
|
|
/*
|
|
The MIT License (MIT)
|
|
|
|
Copyright (c) 2016 Meetecho
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining
|
|
a copy of this software and associated documentation files (the "Software"),
|
|
to deal in the Software without restriction, including without limitation
|
|
the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
and/or sell copies of the Software, and to permit persons to whom the
|
|
Software is furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included
|
|
in all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
|
|
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
|
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
|
|
OTHER DEALINGS IN THE SOFTWARE.
|
|
*/
|
|
|
|
// List of sessions
|
|
Janus.sessions = {};
|
|
|
|
Janus.isExtensionEnabled = function() {
|
|
if(navigator.mediaDevices && navigator.mediaDevices.getDisplayMedia) {
|
|
// No need for the extension, getDisplayMedia is supported
|
|
return true;
|
|
}
|
|
if(window.navigator.userAgent.match('Chrome')) {
|
|
let chromever = parseInt(window.navigator.userAgent.match(/Chrome\/(.*) /)[1], 10);
|
|
let maxver = 33;
|
|
if(window.navigator.userAgent.match('Linux'))
|
|
maxver = 35; // "known" crash in chrome 34 and 35 on linux
|
|
if(chromever >= 26 && chromever <= maxver) {
|
|
// Older versions of Chrome don't support this extension-based approach, so lie
|
|
return true;
|
|
}
|
|
return Janus.extension.isInstalled();
|
|
} else {
|
|
// Firefox and others, no need for the extension (but this doesn't mean it will work)
|
|
return true;
|
|
}
|
|
};
|
|
|
|
var defaultExtension = {
|
|
// Screensharing Chrome Extension ID
|
|
extensionId: 'hapfgfdkleiggjjpfpenajgdnfckjpaj',
|
|
isInstalled: function() { return document.querySelector('#janus-extension-installed') !== null; },
|
|
getScreen: function (callback) {
|
|
let pending = window.setTimeout(function () {
|
|
let error = new Error('NavigatorUserMediaError');
|
|
error.name = 'The required Chrome extension is not installed: click <a href="#">here</a> to install it. (NOTE: this will need you to refresh the page)';
|
|
return callback(error);
|
|
}, 1000);
|
|
this.cache[pending] = callback;
|
|
window.postMessage({ type: 'janusGetScreen', id: pending }, '*');
|
|
},
|
|
init: function () {
|
|
let cache = {};
|
|
this.cache = cache;
|
|
// Wait for events from the Chrome Extension
|
|
window.addEventListener('message', function (event) {
|
|
if(event.origin != window.location.origin)
|
|
return;
|
|
if(event.data.type == 'janusGotScreen' && cache[event.data.id]) {
|
|
let callback = cache[event.data.id];
|
|
delete cache[event.data.id];
|
|
if(event.data.sourceId === '') {
|
|
// user canceled
|
|
let error = new Error('NavigatorUserMediaError');
|
|
error.name = 'You cancelled the request for permission, giving up...';
|
|
callback(error);
|
|
} else {
|
|
callback(null, event.data.sourceId);
|
|
}
|
|
} else if(event.data.type == 'janusGetScreenPending') {
|
|
console.log('clearing ', event.data.id);
|
|
window.clearTimeout(event.data.id);
|
|
}
|
|
});
|
|
}
|
|
};
|
|
|
|
Janus.useDefaultDependencies = function (deps) {
|
|
let f = (deps && deps.fetch) || fetch;
|
|
let p = (deps && deps.Promise) || Promise;
|
|
let socketCls = (deps && deps.WebSocket) || WebSocket;
|
|
|
|
return {
|
|
newWebSocket: function(server, proto) { return new socketCls(server, proto); },
|
|
extension: (deps && deps.extension) || defaultExtension,
|
|
isArray: function(arr) { return Array.isArray(arr); },
|
|
webRTCAdapter: (deps && deps.adapter) || adapter,
|
|
httpAPICall: function(url, options) {
|
|
let fetchOptions = {
|
|
method: options.verb,
|
|
headers: {
|
|
'Accept': 'application/json, text/plain, */*'
|
|
},
|
|
cache: 'no-cache'
|
|
};
|
|
if(options.verb === "POST") {
|
|
fetchOptions.headers['Content-Type'] = 'application/json';
|
|
}
|
|
if(typeof options.withCredentials !== 'undefined') {
|
|
fetchOptions.credentials = options.withCredentials === true ? 'include' : (options.withCredentials ? options.withCredentials : 'omit');
|
|
}
|
|
if(options.body) {
|
|
fetchOptions.body = JSON.stringify(options.body);
|
|
}
|
|
|
|
let fetching = f(url, fetchOptions).catch(function(error) {
|
|
return p.reject({message: 'Probably a network error, is the server down?', error: error});
|
|
});
|
|
|
|
/*
|
|
* fetch() does not natively support timeouts.
|
|
* Work around this by starting a timeout manually, and racing it agains the fetch() to see which thing resolves first.
|
|
*/
|
|
|
|
if(options.timeout) {
|
|
let timeout = new p(function(resolve, reject) {
|
|
let timerId = setTimeout(function() {
|
|
clearTimeout(timerId);
|
|
return reject({message: 'Request timed out', timeout: options.timeout});
|
|
}, options.timeout);
|
|
});
|
|
fetching = p.race([fetching, timeout]);
|
|
}
|
|
|
|
fetching.then(function(response) {
|
|
if(response.ok) {
|
|
if(typeof(options.success) === typeof(Janus.noop)) {
|
|
return response.json().then(function(parsed) {
|
|
try {
|
|
options.success(parsed);
|
|
} catch(error) {
|
|
Janus.error('Unhandled httpAPICall success callback error', error);
|
|
}
|
|
}, function(error) {
|
|
return p.reject({message: 'Failed to parse response body', error: error, response: response});
|
|
});
|
|
}
|
|
}
|
|
else {
|
|
return p.reject({message: 'API call failed', response: response});
|
|
}
|
|
}).catch(function(error) {
|
|
if(typeof(options.error) === typeof(Janus.noop)) {
|
|
options.error(error.message || '<< internal error >>', error);
|
|
}
|
|
});
|
|
|
|
return fetching;
|
|
}
|
|
}
|
|
};
|
|
|
|
Janus.useOldDependencies = function (deps) {
|
|
let jq = (deps && deps.jQuery) || jQuery;
|
|
let socketCls = (deps && deps.WebSocket) || WebSocket;
|
|
return {
|
|
newWebSocket: function(server, proto) { return new socketCls(server, proto); },
|
|
isArray: function(arr) { return jq.isArray(arr); },
|
|
extension: (deps && deps.extension) || defaultExtension,
|
|
webRTCAdapter: (deps && deps.adapter) || adapter,
|
|
httpAPICall: function(url, options) {
|
|
let payload = (typeof options.body !== 'undefined') ? {
|
|
contentType: 'application/json',
|
|
data: JSON.stringify(options.body)
|
|
} : {};
|
|
let credentials = (typeof options.withCredentials !== 'undefined') ? {xhrFields: {withCredentials: options.withCredentials}} : {};
|
|
|
|
return jq.ajax(jq.extend(payload, credentials, {
|
|
url: url,
|
|
type: options.verb,
|
|
cache: false,
|
|
dataType: 'json',
|
|
async: options.async,
|
|
timeout: options.timeout,
|
|
success: function(result) {
|
|
if(typeof(options.success) === typeof(Janus.noop)) {
|
|
options.success(result);
|
|
}
|
|
},
|
|
error: function(xhr, status, err) {
|
|
if(typeof(options.error) === typeof(Janus.noop)) {
|
|
options.error(status, err);
|
|
}
|
|
}
|
|
}));
|
|
}
|
|
};
|
|
};
|
|
|
|
// Helper function to convert a deprecated media object to a tracks array
|
|
Janus.mediaToTracks = function(media) {
|
|
let tracks = [];
|
|
if(!media) {
|
|
// Default is bidirectional audio and video, using default devices
|
|
tracks.push({ type: 'audio', capture: true, recv: true });
|
|
tracks.push({ type: 'video', capture: true, recv: true });
|
|
} else {
|
|
if(!media.keepAudio && media.audio !== false && ((typeof media.audio === 'undefined') || media.audio || media.audioSend || media.audioRecv ||
|
|
media.addAudio || media.replaceAudio || media.removeAudio)) {
|
|
// We may need an audio track
|
|
let track = { type: 'audio' };
|
|
if(media.removeAudio) {
|
|
track.remove = true;
|
|
} else {
|
|
if(media.addAudio)
|
|
track.add = true;
|
|
else if(media.replaceAudio)
|
|
track.replace = true;
|
|
// Check if we need to capture an audio device
|
|
if(media.audioSend !== false)
|
|
track.capture = media.audio || true;
|
|
// Check if we need to receive audio
|
|
if(media.audioRecv !== false)
|
|
track.recv = true;
|
|
}
|
|
// Add an audio track if needed
|
|
if(track.remove || track.capture || track.recv)
|
|
tracks.push(track);
|
|
}
|
|
if(!media.keepVideo && media.video !== false && ((typeof media.video === 'undefined') || media.video || media.videoSend || media.videoRecv ||
|
|
media.addVideo || media.replaceVideo || media.removeVideo)) {
|
|
// We may need a video track
|
|
let track = { type: 'video' };
|
|
if(media.removeVideo) {
|
|
track.remove = true;
|
|
} else {
|
|
if(media.addVideo)
|
|
track.add = true;
|
|
else if(media.replaceVideo)
|
|
track.replace = true;
|
|
// Check if we need to capture a video device
|
|
if(media.videoSend !== false) {
|
|
track.capture = media.video || true;
|
|
if(['screen', 'window', 'desktop'].includes(track.capture)) {
|
|
// Change the type to 'screen'
|
|
track.type = 'screen';
|
|
track.capture = { video: {} };
|
|
// Check if there's constraints
|
|
if(media.screenshareFrameRate)
|
|
track.capture.frameRate = media.screenshareFrameRate;
|
|
if(media.screenshareHeight)
|
|
track.capture.height = media.screenshareHeight;
|
|
if(media.screenshareWidth)
|
|
track.capture.width = media.screenshareWidth;
|
|
}
|
|
}
|
|
// Check if we need to receive video
|
|
if(media.videoRecv !== false)
|
|
track.recv = true;
|
|
}
|
|
// Add a video track if needed
|
|
if(track.remove || track.capture || track.recv)
|
|
tracks.push(track);
|
|
}
|
|
if(media.data) {
|
|
// We need a data channel
|
|
tracks.push({ type: 'data' });
|
|
}
|
|
}
|
|
// Done
|
|
return tracks;
|
|
};
|
|
|
|
// Helper function to convert a track object to a set of constraints
|
|
Janus.trackConstraints = function(track) {
|
|
let constraints = {};
|
|
if(!track || !track.capture)
|
|
return constraints;
|
|
if(track.type === 'audio') {
|
|
// Just put the capture part in the constraints
|
|
constraints.audio = track.capture;
|
|
} else if(track.type === 'video') {
|
|
// Check if one of the keywords was passed
|
|
if((track.simulcast || track.svc) && track.capture === true)
|
|
track.capture = 'hires';
|
|
if(track.capture === true || typeof track.capture === 'object') {
|
|
// Use the provided capture object as video constraint
|
|
constraints.video = track.capture;
|
|
} else {
|
|
let width = 0;
|
|
let height = 0;
|
|
if(track.capture === 'lowres') {
|
|
// Small resolution, 4:3
|
|
width = 320;
|
|
height = 240;
|
|
} else if(track.capture === 'lowres-16:9') {
|
|
// Small resolution, 16:9
|
|
width = 320;
|
|
height = 180;
|
|
} else if(track.capture === 'hires' || track.capture === 'hires-16:9' || track.capture === 'hdres') {
|
|
// High(HD) resolution is only 16:9
|
|
width = 1280;
|
|
height = 720;
|
|
} else if(track.capture === 'fhdres') {
|
|
// Full HD resolution is only 16:9
|
|
width = 1920;
|
|
height = 1080;
|
|
} else if(track.capture === '4kres') {
|
|
// 4K resolution is only 16:9
|
|
width = 3840;
|
|
height = 2160;
|
|
} else if(track.capture === 'stdres') {
|
|
// Normal resolution, 4:3
|
|
width = 640;
|
|
height = 480;
|
|
} else if(track.capture === 'stdres-16:9') {
|
|
// Normal resolution, 16:9
|
|
width = 640;
|
|
height = 360;
|
|
} else {
|
|
Janus.log('Default video setting is stdres 4:3');
|
|
width = 640;
|
|
height = 480;
|
|
}
|
|
constraints.video = {
|
|
width: { ideal: width },
|
|
height: { ideal: height }
|
|
};
|
|
}
|
|
} else if(track.type === 'screen') {
|
|
// Use the provided capture object as video constraint
|
|
constraints.video = track.capture;
|
|
}
|
|
return constraints;
|
|
};
|
|
|
|
Janus.noop = function() {};
|
|
|
|
Janus.dataChanDefaultLabel = "JanusDataChannel";
|
|
|
|
// Note: in the future we may want to change this, e.g., as was
|
|
// attempted in https://github.com/meetecho/janus-gateway/issues/1670
|
|
Janus.endOfCandidates = null;
|
|
|
|
// Stop all tracks from a given stream
|
|
Janus.stopAllTracks = function(stream) {
|
|
try {
|
|
// Try a MediaStreamTrack.stop() for each track
|
|
let tracks = stream.getTracks();
|
|
for(let mst of tracks) {
|
|
Janus.log(mst);
|
|
if(mst && mst.dontStop !== true) {
|
|
mst.stop();
|
|
}
|
|
}
|
|
} catch(e) {
|
|
// Do nothing if this fails
|
|
}
|
|
}
|
|
|
|
// Initialization
|
|
Janus.init = function(options) {
|
|
options = options || {};
|
|
options.callback = (typeof options.callback == "function") ? options.callback : Janus.noop;
|
|
if(Janus.initDone) {
|
|
// Already initialized
|
|
options.callback();
|
|
} else {
|
|
if(typeof console.log == "undefined") {
|
|
console.log = function() {};
|
|
}
|
|
// Console logging (all debugging disabled by default)
|
|
Janus.trace = Janus.noop;
|
|
Janus.debug = Janus.noop;
|
|
Janus.vdebug = Janus.noop;
|
|
Janus.log = Janus.noop;
|
|
Janus.warn = Janus.noop;
|
|
Janus.error = Janus.noop;
|
|
if(options.debug === true || options.debug === "all") {
|
|
// Enable all debugging levels
|
|
Janus.trace = console.trace.bind(console);
|
|
Janus.debug = console.debug.bind(console);
|
|
Janus.vdebug = console.debug.bind(console);
|
|
Janus.log = console.log.bind(console);
|
|
Janus.warn = console.warn.bind(console);
|
|
Janus.error = console.error.bind(console);
|
|
} else if(Array.isArray(options.debug)) {
|
|
for(let d of options.debug) {
|
|
switch(d) {
|
|
case "trace":
|
|
Janus.trace = console.trace.bind(console);
|
|
break;
|
|
case "debug":
|
|
Janus.debug = console.debug.bind(console);
|
|
break;
|
|
case "vdebug":
|
|
Janus.vdebug = console.debug.bind(console);
|
|
break;
|
|
case "log":
|
|
Janus.log = console.log.bind(console);
|
|
break;
|
|
case "warn":
|
|
Janus.warn = console.warn.bind(console);
|
|
break;
|
|
case "error":
|
|
Janus.error = console.error.bind(console);
|
|
break;
|
|
default:
|
|
console.error("Unknown debugging option '" + d + "' (supported: 'trace', 'debug', 'vdebug', 'log', warn', 'error')");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Janus.log("Initializing library");
|
|
|
|
let usedDependencies = options.dependencies || Janus.useDefaultDependencies();
|
|
Janus.isArray = usedDependencies.isArray;
|
|
Janus.webRTCAdapter = usedDependencies.webRTCAdapter;
|
|
Janus.httpAPICall = usedDependencies.httpAPICall;
|
|
Janus.newWebSocket = usedDependencies.newWebSocket;
|
|
Janus.extension = usedDependencies.extension;
|
|
Janus.extension.init();
|
|
|
|
// Helper method to enumerate devices
|
|
Janus.listDevices = function(callback, config) {
|
|
callback = (typeof callback == "function") ? callback : Janus.noop;
|
|
if(!config)
|
|
config = { audio: true, video: true };
|
|
if(Janus.isGetUserMediaAvailable()) {
|
|
navigator.mediaDevices.getUserMedia(config)
|
|
.then(function(stream) {
|
|
navigator.mediaDevices.enumerateDevices().then(function(devices) {
|
|
Janus.debug(devices);
|
|
callback(devices);
|
|
// Get rid of the now useless stream
|
|
Janus.stopAllTracks(stream)
|
|
});
|
|
})
|
|
.catch(function(err) {
|
|
Janus.error(err);
|
|
callback([]);
|
|
});
|
|
} else {
|
|
Janus.warn("navigator.mediaDevices unavailable");
|
|
callback([]);
|
|
}
|
|
};
|
|
// Helper methods to attach/reattach a stream to a video element (previously part of adapter.js)
|
|
Janus.attachMediaStream = function(element, stream) {
|
|
try {
|
|
element.srcObject = stream;
|
|
} catch (e) {
|
|
try {
|
|
element.src = URL.createObjectURL(stream);
|
|
} catch (e) {
|
|
Janus.error("Error attaching stream to element", e);
|
|
}
|
|
}
|
|
};
|
|
Janus.reattachMediaStream = function(to, from) {
|
|
try {
|
|
to.srcObject = from.srcObject;
|
|
} catch (e) {
|
|
try {
|
|
to.src = from.src;
|
|
} catch (e) {
|
|
Janus.error("Error reattaching stream to element", e);
|
|
}
|
|
}
|
|
};
|
|
// Detect tab close: make sure we don't loose existing onbeforeunload handlers
|
|
// (note: for iOS we need to subscribe to a different event, 'pagehide', see
|
|
// https://gist.github.com/thehunmonkgroup/6bee8941a49b86be31a787fe8f4b8cfe)
|
|
let iOS = ['iPad', 'iPhone', 'iPod'].indexOf(navigator.platform) >= 0;
|
|
let eventName = iOS ? 'pagehide' : 'beforeunload';
|
|
let oldOBF = window["on" + eventName];
|
|
window.addEventListener(eventName, function() {
|
|
Janus.log("Closing window");
|
|
for(let s in Janus.sessions) {
|
|
if(Janus.sessions[s] && Janus.sessions[s].destroyOnUnload) {
|
|
Janus.log("Destroying session " + s);
|
|
Janus.sessions[s].destroy({unload: true, notifyDestroyed: false});
|
|
}
|
|
}
|
|
if(oldOBF && typeof oldOBF == "function") {
|
|
oldOBF();
|
|
}
|
|
});
|
|
// If this is a Safari Technology Preview, check if VP8 is supported
|
|
Janus.safariVp8 = false;
|
|
if(Janus.webRTCAdapter.browserDetails.browser === 'safari' &&
|
|
Janus.webRTCAdapter.browserDetails.version >= 605) {
|
|
// Let's see if RTCRtpSender.getCapabilities() is there
|
|
if(RTCRtpSender && RTCRtpSender.getCapabilities && RTCRtpSender.getCapabilities("video") &&
|
|
RTCRtpSender.getCapabilities("video").codecs && RTCRtpSender.getCapabilities("video").codecs.length) {
|
|
for(let codec of RTCRtpSender.getCapabilities("video").codecs) {
|
|
if(codec && codec.mimeType && codec.mimeType.toLowerCase() === "video/vp8") {
|
|
Janus.safariVp8 = true;
|
|
break;
|
|
}
|
|
}
|
|
if(Janus.safariVp8) {
|
|
Janus.log("This version of Safari supports VP8");
|
|
} else {
|
|
Janus.warn("This version of Safari does NOT support VP8: if you're using a Technology Preview, " +
|
|
"try enabling the 'WebRTC VP8 codec' setting in the 'Experimental Features' Develop menu");
|
|
}
|
|
} else {
|
|
// We do it in a very ugly way, as there's no alternative...
|
|
// We create a PeerConnection to see if VP8 is in an offer
|
|
let testpc = new RTCPeerConnection({});
|
|
testpc.createOffer({offerToReceiveVideo: true}).then(function(offer) {
|
|
Janus.safariVp8 = offer.sdp.indexOf("VP8") !== -1;
|
|
if(Janus.safariVp8) {
|
|
Janus.log("This version of Safari supports VP8");
|
|
} else {
|
|
Janus.warn("This version of Safari does NOT support VP8: if you're using a Technology Preview, " +
|
|
"try enabling the 'WebRTC VP8 codec' setting in the 'Experimental Features' Develop menu");
|
|
}
|
|
testpc.close();
|
|
testpc = null;
|
|
});
|
|
}
|
|
}
|
|
Janus.initDone = true;
|
|
options.callback();
|
|
}
|
|
};
|
|
|
|
// Helper method to check whether WebRTC is supported by this browser
|
|
Janus.isWebrtcSupported = function() {
|
|
return !!window.RTCPeerConnection;
|
|
};
|
|
// Helper method to check whether devices can be accessed by this browser (e.g., not possible via plain HTTP)
|
|
Janus.isGetUserMediaAvailable = function() {
|
|
return navigator.mediaDevices && navigator.mediaDevices.getUserMedia;
|
|
};
|
|
|
|
// Helper method to create random identifiers (e.g., transaction)
|
|
Janus.randomString = function(len) {
|
|
let charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
|
|
let randomString = '';
|
|
for(let i=0; i<len; i++) {
|
|
let randomPoz = Math.floor(Math.random() * charSet.length);
|
|
randomString += charSet.charAt(randomPoz);
|
|
}
|
|
return randomString;
|
|
};
|
|
|
|
function Janus(gatewayCallbacks) {
|
|
gatewayCallbacks = gatewayCallbacks || {};
|
|
gatewayCallbacks.success = (typeof gatewayCallbacks.success == "function") ? gatewayCallbacks.success : Janus.noop;
|
|
gatewayCallbacks.error = (typeof gatewayCallbacks.error == "function") ? gatewayCallbacks.error : Janus.noop;
|
|
gatewayCallbacks.destroyed = (typeof gatewayCallbacks.destroyed == "function") ? gatewayCallbacks.destroyed : Janus.noop;
|
|
if(!Janus.initDone) {
|
|
gatewayCallbacks.error("Library not initialized");
|
|
return {};
|
|
}
|
|
if(!Janus.isWebrtcSupported()) {
|
|
gatewayCallbacks.error("WebRTC not supported by this browser");
|
|
return {};
|
|
}
|
|
Janus.log("Library initialized: " + Janus.initDone);
|
|
if(!gatewayCallbacks.server) {
|
|
gatewayCallbacks.error("Invalid server url");
|
|
return {};
|
|
}
|
|
let websockets = false;
|
|
let ws = null;
|
|
let wsHandlers = {};
|
|
let wsKeepaliveTimeoutId = null;
|
|
let servers = null;
|
|
let serversIndex = 0;
|
|
let server = gatewayCallbacks.server;
|
|
if(Janus.isArray(server)) {
|
|
Janus.log("Multiple servers provided (" + server.length + "), will use the first that works");
|
|
server = null;
|
|
servers = gatewayCallbacks.server;
|
|
Janus.debug(servers);
|
|
} else {
|
|
if(server.indexOf("ws") === 0) {
|
|
websockets = true;
|
|
Janus.log("Using WebSockets to contact Janus: " + server);
|
|
} else {
|
|
websockets = false;
|
|
Janus.log("Using REST API to contact Janus: " + server);
|
|
}
|
|
}
|
|
let iceServers = gatewayCallbacks.iceServers || [{urls: "stun:stun.l.google.com:19302"}];
|
|
let iceTransportPolicy = gatewayCallbacks.iceTransportPolicy;
|
|
let bundlePolicy = gatewayCallbacks.bundlePolicy;
|
|
// Whether we should enable the withCredentials flag for XHR requests
|
|
let withCredentials = false;
|
|
if(typeof gatewayCallbacks.withCredentials !== 'undefined' && gatewayCallbacks.withCredentials !== null)
|
|
withCredentials = gatewayCallbacks.withCredentials === true;
|
|
// Optional max events
|
|
let maxev = 10;
|
|
if(typeof gatewayCallbacks.max_poll_events !== 'undefined' && gatewayCallbacks.max_poll_events !== null)
|
|
maxev = gatewayCallbacks.max_poll_events;
|
|
if(maxev < 1)
|
|
maxev = 1;
|
|
// Token to use (only if the token based authentication mechanism is enabled)
|
|
let token = null;
|
|
if(typeof gatewayCallbacks.token !== 'undefined' && gatewayCallbacks.token !== null)
|
|
token = gatewayCallbacks.token;
|
|
// API secret to use (only if the shared API secret is enabled)
|
|
let apisecret = null;
|
|
if(typeof gatewayCallbacks.apisecret !== 'undefined' && gatewayCallbacks.apisecret !== null)
|
|
apisecret = gatewayCallbacks.apisecret;
|
|
// Whether we should destroy this session when onbeforeunload is called
|
|
this.destroyOnUnload = true;
|
|
if(typeof gatewayCallbacks.destroyOnUnload !== 'undefined' && gatewayCallbacks.destroyOnUnload !== null)
|
|
this.destroyOnUnload = (gatewayCallbacks.destroyOnUnload === true);
|
|
// Some timeout-related values
|
|
let keepAlivePeriod = 25000;
|
|
if(typeof gatewayCallbacks.keepAlivePeriod !== 'undefined' && gatewayCallbacks.keepAlivePeriod !== null)
|
|
keepAlivePeriod = gatewayCallbacks.keepAlivePeriod;
|
|
if(isNaN(keepAlivePeriod))
|
|
keepAlivePeriod = 25000;
|
|
let longPollTimeout = 60000;
|
|
if(typeof gatewayCallbacks.longPollTimeout !== 'undefined' && gatewayCallbacks.longPollTimeout !== null)
|
|
longPollTimeout = gatewayCallbacks.longPollTimeout;
|
|
if(isNaN(longPollTimeout))
|
|
longPollTimeout = 60000;
|
|
|
|
// overrides for default maxBitrate values for simulcasting
|
|
function getMaxBitrates(simulcastMaxBitrates) {
|
|
let maxBitrates = {
|
|
high: 900000,
|
|
medium: 300000,
|
|
low: 100000,
|
|
};
|
|
|
|
if(typeof simulcastMaxBitrates !== 'undefined' && simulcastMaxBitrates !== null) {
|
|
if(simulcastMaxBitrates.high)
|
|
maxBitrates.high = simulcastMaxBitrates.high;
|
|
if(simulcastMaxBitrates.medium)
|
|
maxBitrates.medium = simulcastMaxBitrates.medium;
|
|
if(simulcastMaxBitrates.low)
|
|
maxBitrates.low = simulcastMaxBitrates.low;
|
|
}
|
|
|
|
return maxBitrates;
|
|
}
|
|
|
|
let connected = false;
|
|
let sessionId = null;
|
|
let pluginHandles = {};
|
|
let that = this;
|
|
let retries = 0;
|
|
let transactions = {};
|
|
createSession(gatewayCallbacks);
|
|
|
|
// Public methods
|
|
this.getServer = function() { return server; };
|
|
this.isConnected = function() { return connected; };
|
|
this.reconnect = function(callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
callbacks["reconnect"] = true;
|
|
createSession(callbacks);
|
|
};
|
|
this.getSessionId = function() { return sessionId; };
|
|
this.getInfo = function(callbacks) { getInfo(callbacks); };
|
|
this.destroy = function(callbacks) { destroySession(callbacks); };
|
|
this.attach = function(callbacks) { createHandle(callbacks); };
|
|
|
|
function eventHandler() {
|
|
if(sessionId == null)
|
|
return;
|
|
Janus.debug('Long poll...');
|
|
if(!connected) {
|
|
Janus.warn("Is the server down? (connected=false)");
|
|
return;
|
|
}
|
|
let longpoll = server + "/" + sessionId + "?rid=" + new Date().getTime();
|
|
if(maxev)
|
|
longpoll = longpoll + "&maxev=" + maxev;
|
|
if(token)
|
|
longpoll = longpoll + "&token=" + encodeURIComponent(token);
|
|
if(apisecret)
|
|
longpoll = longpoll + "&apisecret=" + encodeURIComponent(apisecret);
|
|
Janus.httpAPICall(longpoll, {
|
|
verb: 'GET',
|
|
withCredentials: withCredentials,
|
|
success: handleEvent,
|
|
timeout: longPollTimeout,
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown);
|
|
retries++;
|
|
if(retries > 3) {
|
|
// Did we just lose the server? :-(
|
|
connected = false;
|
|
gatewayCallbacks.error("Lost connection to the server (is it down?)");
|
|
return;
|
|
}
|
|
eventHandler();
|
|
}
|
|
});
|
|
}
|
|
|
|
// Private event handler: this will trigger plugin callbacks, if set
|
|
function handleEvent(json, skipTimeout) {
|
|
retries = 0;
|
|
if(!websockets && typeof sessionId !== 'undefined' && sessionId !== null && skipTimeout !== true)
|
|
eventHandler();
|
|
if(!websockets && Janus.isArray(json)) {
|
|
// We got an array: it means we passed a maxev > 1, iterate on all objects
|
|
for(let i=0; i<json.length; i++) {
|
|
handleEvent(json[i], true);
|
|
}
|
|
return;
|
|
}
|
|
if(json["janus"] === "keepalive") {
|
|
// Nothing happened
|
|
Janus.vdebug("Got a keepalive on session " + sessionId);
|
|
return;
|
|
} else if(json["janus"] === "server_info") {
|
|
// Just info on the Janus instance
|
|
Janus.debug("Got info on the Janus instance");
|
|
Janus.debug(json);
|
|
const transaction = json["transaction"];
|
|
if(transaction) {
|
|
const reportSuccess = transactions[transaction];
|
|
if(reportSuccess)
|
|
reportSuccess(json);
|
|
delete transactions[transaction];
|
|
}
|
|
return;
|
|
} else if(json["janus"] === "ack") {
|
|
// Just an ack, we can probably ignore
|
|
Janus.debug("Got an ack on session " + sessionId);
|
|
Janus.debug(json);
|
|
const transaction = json["transaction"];
|
|
if(transaction) {
|
|
const reportSuccess = transactions[transaction];
|
|
if(reportSuccess)
|
|
reportSuccess(json);
|
|
delete transactions[transaction];
|
|
}
|
|
return;
|
|
} else if(json["janus"] === "success") {
|
|
// Success!
|
|
Janus.debug("Got a success on session " + sessionId);
|
|
Janus.debug(json);
|
|
const transaction = json["transaction"];
|
|
if(transaction) {
|
|
const reportSuccess = transactions[transaction];
|
|
if(reportSuccess)
|
|
reportSuccess(json);
|
|
delete transactions[transaction];
|
|
}
|
|
return;
|
|
} else if(json["janus"] === "trickle") {
|
|
// We got a trickle candidate from Janus
|
|
const sender = json["sender"];
|
|
if(!sender) {
|
|
Janus.warn("Missing sender...");
|
|
return;
|
|
}
|
|
const pluginHandle = pluginHandles[sender];
|
|
if(!pluginHandle) {
|
|
Janus.debug("This handle is not attached to this session");
|
|
return;
|
|
}
|
|
let candidate = json["candidate"];
|
|
Janus.debug("Got a trickled candidate on session " + sessionId);
|
|
Janus.debug(candidate);
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(config.pc && config.remoteSdp) {
|
|
// Add candidate right now
|
|
Janus.debug("Adding remote candidate:", candidate);
|
|
if(!candidate || candidate.completed === true) {
|
|
// end-of-candidates
|
|
config.pc.addIceCandidate(Janus.endOfCandidates);
|
|
} else {
|
|
// New candidate
|
|
config.pc.addIceCandidate(candidate);
|
|
}
|
|
} else {
|
|
// We didn't do setRemoteDescription (trickle got here before the offer?)
|
|
Janus.debug("We didn't do setRemoteDescription (trickle got here before the offer?), caching candidate");
|
|
if(!config.candidates)
|
|
config.candidates = [];
|
|
config.candidates.push(candidate);
|
|
Janus.debug(config.candidates);
|
|
}
|
|
} else if(json["janus"] === "webrtcup") {
|
|
// The PeerConnection with the server is up! Notify this
|
|
Janus.debug("Got a webrtcup event on session " + sessionId);
|
|
Janus.debug(json);
|
|
const sender = json["sender"];
|
|
if(!sender) {
|
|
Janus.warn("Missing sender...");
|
|
return;
|
|
}
|
|
const pluginHandle = pluginHandles[sender];
|
|
if(!pluginHandle) {
|
|
Janus.debug("This handle is not attached to this session");
|
|
return;
|
|
}
|
|
pluginHandle.webrtcState(true);
|
|
return;
|
|
} else if(json["janus"] === "hangup") {
|
|
// A plugin asked the core to hangup a PeerConnection on one of our handles
|
|
Janus.debug("Got a hangup event on session " + sessionId);
|
|
Janus.debug(json);
|
|
const sender = json["sender"];
|
|
if(!sender) {
|
|
Janus.warn("Missing sender...");
|
|
return;
|
|
}
|
|
const pluginHandle = pluginHandles[sender];
|
|
if(!pluginHandle) {
|
|
Janus.debug("This handle is not attached to this session");
|
|
return;
|
|
}
|
|
pluginHandle.webrtcState(false, json["reason"]);
|
|
pluginHandle.hangup();
|
|
} else if(json["janus"] === "detached") {
|
|
// A plugin asked the core to detach one of our handles
|
|
Janus.debug("Got a detached event on session " + sessionId);
|
|
Janus.debug(json);
|
|
const sender = json["sender"];
|
|
if(!sender) {
|
|
Janus.warn("Missing sender...");
|
|
return;
|
|
}
|
|
const pluginHandle = pluginHandles[sender];
|
|
if(!pluginHandle) {
|
|
// Don't warn here because destroyHandle causes this situation.
|
|
return;
|
|
}
|
|
pluginHandle.ondetached();
|
|
pluginHandle.detach();
|
|
} else if(json["janus"] === "media") {
|
|
// Media started/stopped flowing
|
|
Janus.debug("Got a media event on session " + sessionId);
|
|
Janus.debug(json);
|
|
const sender = json["sender"];
|
|
if(!sender) {
|
|
Janus.warn("Missing sender...");
|
|
return;
|
|
}
|
|
const pluginHandle = pluginHandles[sender];
|
|
if(!pluginHandle) {
|
|
Janus.debug("This handle is not attached to this session");
|
|
return;
|
|
}
|
|
pluginHandle.mediaState(json["type"], json["receiving"], json["mid"]);
|
|
} else if(json["janus"] === "slowlink") {
|
|
Janus.debug("Got a slowlink event on session " + sessionId);
|
|
Janus.debug(json);
|
|
// Trouble uplink or downlink
|
|
const sender = json["sender"];
|
|
if(!sender) {
|
|
Janus.warn("Missing sender...");
|
|
return;
|
|
}
|
|
const pluginHandle = pluginHandles[sender];
|
|
if(!pluginHandle) {
|
|
Janus.debug("This handle is not attached to this session");
|
|
return;
|
|
}
|
|
pluginHandle.slowLink(json["uplink"], json["lost"], json["mid"]);
|
|
} else if(json["janus"] === "error") {
|
|
// Oops, something wrong happened
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
Janus.debug(json);
|
|
let transaction = json["transaction"];
|
|
if(transaction) {
|
|
let reportSuccess = transactions[transaction];
|
|
if(reportSuccess) {
|
|
reportSuccess(json);
|
|
}
|
|
delete transactions[transaction];
|
|
}
|
|
return;
|
|
} else if(json["janus"] === "event") {
|
|
Janus.debug("Got a plugin event on session " + sessionId);
|
|
Janus.debug(json);
|
|
const sender = json["sender"];
|
|
if(!sender) {
|
|
Janus.warn("Missing sender...");
|
|
return;
|
|
}
|
|
let plugindata = json["plugindata"];
|
|
if(!plugindata) {
|
|
Janus.warn("Missing plugindata...");
|
|
return;
|
|
}
|
|
Janus.debug(" -- Event is coming from " + sender + " (" + plugindata["plugin"] + ")");
|
|
let data = plugindata["data"];
|
|
Janus.debug(data);
|
|
const pluginHandle = pluginHandles[sender];
|
|
if(!pluginHandle) {
|
|
Janus.warn("This handle is not attached to this session");
|
|
return;
|
|
}
|
|
let jsep = json["jsep"];
|
|
if(jsep) {
|
|
Janus.debug("Handling SDP as well...");
|
|
Janus.debug(jsep);
|
|
}
|
|
let callback = pluginHandle.onmessage;
|
|
if(callback) {
|
|
Janus.debug("Notifying application...");
|
|
// Send to callback specified when attaching plugin handle
|
|
callback(data, jsep);
|
|
} else {
|
|
// Send to generic callback (?)
|
|
Janus.debug("No provided notification callback");
|
|
}
|
|
} else if(json["janus"] === "timeout") {
|
|
Janus.error("Timeout on session " + sessionId);
|
|
Janus.debug(json);
|
|
if(websockets) {
|
|
ws.close(3504, "Gateway timeout");
|
|
}
|
|
return;
|
|
} else {
|
|
Janus.warn("Unknown message/event '" + json["janus"] + "' on session " + sessionId);
|
|
Janus.debug(json);
|
|
}
|
|
}
|
|
|
|
// Private helper to send keep-alive messages on WebSockets
|
|
function keepAlive() {
|
|
if(!server || !websockets || !connected)
|
|
return;
|
|
wsKeepaliveTimeoutId = setTimeout(keepAlive, keepAlivePeriod);
|
|
let request = { "janus": "keepalive", "session_id": sessionId, "transaction": Janus.randomString(12) };
|
|
if(token)
|
|
request["token"] = token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
ws.send(JSON.stringify(request));
|
|
}
|
|
|
|
// Private method to create a session
|
|
function createSession(callbacks) {
|
|
let transaction = Janus.randomString(12);
|
|
let request = { "janus": "create", "transaction": transaction };
|
|
if(callbacks["reconnect"]) {
|
|
// We're reconnecting, claim the session
|
|
connected = false;
|
|
request["janus"] = "claim";
|
|
request["session_id"] = sessionId;
|
|
// If we were using websockets, ignore the old connection
|
|
if(ws) {
|
|
ws.onopen = null;
|
|
ws.onerror = null;
|
|
ws.onclose = null;
|
|
if(wsKeepaliveTimeoutId) {
|
|
clearTimeout(wsKeepaliveTimeoutId);
|
|
wsKeepaliveTimeoutId = null;
|
|
}
|
|
}
|
|
}
|
|
if(token)
|
|
request["token"] = token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
if(!server && Janus.isArray(servers)) {
|
|
// We still need to find a working server from the list we were given
|
|
server = servers[serversIndex];
|
|
if(server.indexOf("ws") === 0) {
|
|
websockets = true;
|
|
Janus.log("Server #" + (serversIndex+1) + ": trying WebSockets to contact Janus (" + server + ")");
|
|
} else {
|
|
websockets = false;
|
|
Janus.log("Server #" + (serversIndex+1) + ": trying REST API to contact Janus (" + server + ")");
|
|
}
|
|
}
|
|
if(websockets) {
|
|
ws = Janus.newWebSocket(server, 'janus-protocol');
|
|
wsHandlers = {
|
|
'error': function() {
|
|
Janus.error("Error connecting to the Janus WebSockets server... " + server);
|
|
if(Janus.isArray(servers) && !callbacks["reconnect"]) {
|
|
serversIndex++;
|
|
if(serversIndex === servers.length) {
|
|
// We tried all the servers the user gave us and they all failed
|
|
callbacks.error("Error connecting to any of the provided Janus servers: Is the server down?");
|
|
return;
|
|
}
|
|
// Let's try the next server
|
|
server = null;
|
|
setTimeout(function() {
|
|
createSession(callbacks);
|
|
}, 200);
|
|
return;
|
|
}
|
|
callbacks.error("Error connecting to the Janus WebSockets server: Is the server down?");
|
|
},
|
|
|
|
'open': function() {
|
|
// We need to be notified about the success
|
|
transactions[transaction] = function(json) {
|
|
Janus.debug(json);
|
|
if(json["janus"] !== "success") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
callbacks.error(json["error"].reason);
|
|
return;
|
|
}
|
|
wsKeepaliveTimeoutId = setTimeout(keepAlive, keepAlivePeriod);
|
|
connected = true;
|
|
sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
|
|
if(callbacks["reconnect"]) {
|
|
Janus.log("Claimed session: " + sessionId);
|
|
} else {
|
|
Janus.log("Created session: " + sessionId);
|
|
}
|
|
Janus.sessions[sessionId] = that;
|
|
callbacks.success();
|
|
};
|
|
ws.send(JSON.stringify(request));
|
|
},
|
|
|
|
'message': function(event) {
|
|
handleEvent(JSON.parse(event.data));
|
|
},
|
|
|
|
'close': function() {
|
|
if(!server || !connected) {
|
|
return;
|
|
}
|
|
connected = false;
|
|
// FIXME What if this is called when the page is closed?
|
|
gatewayCallbacks.error("Lost connection to the server (is it down?)");
|
|
}
|
|
};
|
|
|
|
for(let eventName in wsHandlers) {
|
|
ws.addEventListener(eventName, wsHandlers[eventName]);
|
|
}
|
|
|
|
return;
|
|
}
|
|
Janus.httpAPICall(server, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request,
|
|
success: function(json) {
|
|
Janus.debug(json);
|
|
if(json["janus"] !== "success") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
callbacks.error(json["error"].reason);
|
|
return;
|
|
}
|
|
connected = true;
|
|
sessionId = json["session_id"] ? json["session_id"] : json.data["id"];
|
|
if(callbacks["reconnect"]) {
|
|
Janus.log("Claimed session: " + sessionId);
|
|
} else {
|
|
Janus.log("Created session: " + sessionId);
|
|
}
|
|
Janus.sessions[sessionId] = that;
|
|
eventHandler();
|
|
callbacks.success();
|
|
},
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown); // FIXME
|
|
if(Janus.isArray(servers) && !callbacks["reconnect"]) {
|
|
serversIndex++;
|
|
if(serversIndex === servers.length) {
|
|
// We tried all the servers the user gave us and they all failed
|
|
callbacks.error("Error connecting to any of the provided Janus servers: Is the server down?");
|
|
return;
|
|
}
|
|
// Let's try the next server
|
|
server = null;
|
|
setTimeout(function() { createSession(callbacks); }, 200);
|
|
return;
|
|
}
|
|
if(errorThrown === "")
|
|
callbacks.error(textStatus + ": Is the server down?");
|
|
else if(errorThrown && errorThrown.error)
|
|
callbacks.error(textStatus + ": " + errorThrown.error.message);
|
|
else
|
|
callbacks.error(textStatus + ": " + errorThrown);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Private method to get info on the server
|
|
function getInfo(callbacks) {
|
|
callbacks = callbacks || {};
|
|
// FIXME This method triggers a success even when we fail
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
Janus.log("Getting info on Janus instance");
|
|
if(!connected) {
|
|
Janus.warn("Is the server down? (connected=false)");
|
|
callbacks.error("Is the server down? (connected=false)");
|
|
return;
|
|
}
|
|
// We just need to send an "info" request
|
|
let transaction = Janus.randomString(12);
|
|
let request = { "janus": "info", "transaction": transaction };
|
|
if(token)
|
|
request["token"] = token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
if(websockets) {
|
|
transactions[transaction] = function(json) {
|
|
Janus.log("Server info:");
|
|
Janus.debug(json);
|
|
if(json["janus"] !== "server_info") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
}
|
|
callbacks.success(json);
|
|
}
|
|
ws.send(JSON.stringify(request));
|
|
return;
|
|
}
|
|
Janus.httpAPICall(server, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request,
|
|
success: function(json) {
|
|
Janus.log("Server info:");
|
|
Janus.debug(json);
|
|
if(json["janus"] !== "server_info") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
}
|
|
callbacks.success(json);
|
|
},
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown); // FIXME
|
|
if(errorThrown === "")
|
|
callbacks.error(textStatus + ": Is the server down?");
|
|
else
|
|
callbacks.error(textStatus + ": " + errorThrown);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Private method to destroy a session
|
|
function destroySession(callbacks) {
|
|
callbacks = callbacks || {};
|
|
// FIXME This method triggers a success even when we fail
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
let unload = (callbacks.unload === true);
|
|
let notifyDestroyed = true;
|
|
if(typeof callbacks.notifyDestroyed !== 'undefined' && callbacks.notifyDestroyed !== null)
|
|
notifyDestroyed = (callbacks.notifyDestroyed === true);
|
|
let cleanupHandles = (callbacks.cleanupHandles === true);
|
|
Janus.log("Destroying session " + sessionId + " (unload=" + unload + ")");
|
|
if(!sessionId) {
|
|
Janus.warn("No session to destroy");
|
|
callbacks.success();
|
|
if(notifyDestroyed)
|
|
gatewayCallbacks.destroyed();
|
|
return;
|
|
}
|
|
if(cleanupHandles) {
|
|
for(let handleId in pluginHandles)
|
|
destroyHandle(handleId, { noRequest: true });
|
|
}
|
|
if(!connected) {
|
|
Janus.warn("Is the server down? (connected=false)");
|
|
sessionId = null;
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
// No need to destroy all handles first, Janus will do that itself
|
|
let request = { "janus": "destroy", "transaction": Janus.randomString(12) };
|
|
if(token)
|
|
request["token"] = token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
if(unload) {
|
|
// We're unloading the page: use sendBeacon for HTTP instead,
|
|
// or just close the WebSocket connection if we're using that
|
|
if(websockets) {
|
|
ws.onclose = null;
|
|
ws.close();
|
|
ws = null;
|
|
} else {
|
|
navigator.sendBeacon(server + "/" + sessionId, JSON.stringify(request));
|
|
}
|
|
Janus.log("Destroyed session:");
|
|
sessionId = null;
|
|
connected = false;
|
|
callbacks.success();
|
|
if(notifyDestroyed)
|
|
gatewayCallbacks.destroyed();
|
|
return;
|
|
}
|
|
if(websockets) {
|
|
request["session_id"] = sessionId;
|
|
|
|
let unbindWebSocket = function() {
|
|
for(let eventName in wsHandlers) {
|
|
ws.removeEventListener(eventName, wsHandlers[eventName]);
|
|
}
|
|
ws.removeEventListener('message', onUnbindMessage);
|
|
ws.removeEventListener('error', onUnbindError);
|
|
if(wsKeepaliveTimeoutId) {
|
|
clearTimeout(wsKeepaliveTimeoutId);
|
|
}
|
|
ws.close();
|
|
};
|
|
|
|
let onUnbindMessage = function(event){
|
|
let data = JSON.parse(event.data);
|
|
if(data.session_id == request.session_id && data.transaction == request.transaction) {
|
|
unbindWebSocket();
|
|
callbacks.success();
|
|
if(notifyDestroyed)
|
|
gatewayCallbacks.destroyed();
|
|
}
|
|
};
|
|
let onUnbindError = function() {
|
|
unbindWebSocket();
|
|
callbacks.error("Failed to destroy the server: Is the server down?");
|
|
if(notifyDestroyed)
|
|
gatewayCallbacks.destroyed();
|
|
};
|
|
|
|
ws.addEventListener('message', onUnbindMessage);
|
|
ws.addEventListener('error', onUnbindError);
|
|
|
|
if(ws.readyState === 1) {
|
|
ws.send(JSON.stringify(request));
|
|
} else {
|
|
onUnbindError();
|
|
}
|
|
|
|
return;
|
|
}
|
|
Janus.httpAPICall(server + "/" + sessionId, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request,
|
|
success: function(json) {
|
|
Janus.log("Destroyed session:");
|
|
Janus.debug(json);
|
|
sessionId = null;
|
|
connected = false;
|
|
if(json["janus"] !== "success") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
}
|
|
callbacks.success();
|
|
if(notifyDestroyed)
|
|
gatewayCallbacks.destroyed();
|
|
},
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown); // FIXME
|
|
// Reset everything anyway
|
|
sessionId = null;
|
|
connected = false;
|
|
callbacks.success();
|
|
if(notifyDestroyed)
|
|
gatewayCallbacks.destroyed();
|
|
}
|
|
});
|
|
}
|
|
|
|
// Private method to create a plugin handle
|
|
function createHandle(callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
callbacks.dataChannelOptions = callbacks.dataChannelOptions || { ordered: true };
|
|
callbacks.consentDialog = (typeof callbacks.consentDialog == "function") ? callbacks.consentDialog : Janus.noop;
|
|
callbacks.iceState = (typeof callbacks.iceState == "function") ? callbacks.iceState : Janus.noop;
|
|
callbacks.mediaState = (typeof callbacks.mediaState == "function") ? callbacks.mediaState : Janus.noop;
|
|
callbacks.webrtcState = (typeof callbacks.webrtcState == "function") ? callbacks.webrtcState : Janus.noop;
|
|
callbacks.slowLink = (typeof callbacks.slowLink == "function") ? callbacks.slowLink : Janus.noop;
|
|
callbacks.onmessage = (typeof callbacks.onmessage == "function") ? callbacks.onmessage : Janus.noop;
|
|
callbacks.onlocaltrack = (typeof callbacks.onlocaltrack == "function") ? callbacks.onlocaltrack : Janus.noop;
|
|
callbacks.onremotetrack = (typeof callbacks.onremotetrack == "function") ? callbacks.onremotetrack : Janus.noop;
|
|
callbacks.ondata = (typeof callbacks.ondata == "function") ? callbacks.ondata : Janus.noop;
|
|
callbacks.ondataopen = (typeof callbacks.ondataopen == "function") ? callbacks.ondataopen : Janus.noop;
|
|
callbacks.oncleanup = (typeof callbacks.oncleanup == "function") ? callbacks.oncleanup : Janus.noop;
|
|
callbacks.ondetached = (typeof callbacks.ondetached == "function") ? callbacks.ondetached : Janus.noop;
|
|
if(!connected) {
|
|
Janus.warn("Is the server down? (connected=false)");
|
|
callbacks.error("Is the server down? (connected=false)");
|
|
return;
|
|
}
|
|
let plugin = callbacks.plugin;
|
|
if(!plugin) {
|
|
Janus.error("Invalid plugin");
|
|
callbacks.error("Invalid plugin");
|
|
return;
|
|
}
|
|
let opaqueId = callbacks.opaqueId;
|
|
let loopIndex = callbacks.loopIndex;
|
|
let handleToken = callbacks.token ? callbacks.token : token;
|
|
let transaction = Janus.randomString(12);
|
|
let request = { "janus": "attach", "plugin": plugin, "opaque_id": opaqueId, "loop_index": loopIndex, "transaction": transaction };
|
|
if(handleToken)
|
|
request["token"] = handleToken;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
if(websockets) {
|
|
transactions[transaction] = function(json) {
|
|
Janus.debug(json);
|
|
if(json["janus"] !== "success") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
callbacks.error("Ooops: " + json["error"].code + " " + json["error"].reason);
|
|
return;
|
|
}
|
|
let handleId = json.data["id"];
|
|
Janus.log("Created handle: " + handleId);
|
|
let pluginHandle =
|
|
{
|
|
session : that,
|
|
plugin : plugin,
|
|
id : handleId,
|
|
token : handleToken,
|
|
detached : false,
|
|
webrtcStuff : {
|
|
started : false,
|
|
myStream : null,
|
|
streamExternal : false,
|
|
mySdp : null,
|
|
mediaConstraints : null,
|
|
pc : null,
|
|
dataChannelOptions: callbacks.dataChannelOptions,
|
|
dataChannel : {},
|
|
dtmfSender : null,
|
|
trickle : true,
|
|
iceDone : false,
|
|
bitrate : {}
|
|
},
|
|
getId : function() { return handleId; },
|
|
getPlugin : function() { return plugin; },
|
|
getVolume : function(mid, result) { return getVolume(handleId, mid, true, result); },
|
|
getRemoteVolume : function(mid, result) { return getVolume(handleId, mid, true, result); },
|
|
getLocalVolume : function(mid, result) { return getVolume(handleId, mid, false, result); },
|
|
isAudioMuted : function(mid) { return isMuted(handleId, mid, false); },
|
|
muteAudio : function(mid) { return mute(handleId, mid, false, true); },
|
|
unmuteAudio : function(mid) { return mute(handleId, mid, false, false); },
|
|
isVideoMuted : function(mid) { return isMuted(handleId, mid, true); },
|
|
muteVideo : function(mid) { return mute(handleId, mid, true, true); },
|
|
unmuteVideo : function(mid) { return mute(handleId, mid, true, false); },
|
|
getBitrate : function(mid) { return getBitrate(handleId, mid); },
|
|
setMaxBitrate : function(mid, bitrate) { return setBitrate(handleId, mid, bitrate); },
|
|
send : function(callbacks) { sendMessage(handleId, callbacks); },
|
|
data : function(callbacks) { sendData(handleId, callbacks); },
|
|
dtmf : function(callbacks) { sendDtmf(handleId, callbacks); },
|
|
consentDialog : callbacks.consentDialog,
|
|
iceState : callbacks.iceState,
|
|
mediaState : callbacks.mediaState,
|
|
webrtcState : callbacks.webrtcState,
|
|
slowLink : callbacks.slowLink,
|
|
onmessage : callbacks.onmessage,
|
|
createOffer : function(callbacks) { prepareWebrtc(handleId, true, callbacks); },
|
|
createAnswer : function(callbacks) { prepareWebrtc(handleId, false, callbacks); },
|
|
handleRemoteJsep : function(callbacks) { prepareWebrtcPeer(handleId, callbacks); },
|
|
replaceTracks : function(callbacks) { replaceTracks(handleId, callbacks); },
|
|
getLocalTracks : function() { return getLocalTracks(handleId); },
|
|
getRemoteTracks : function() { return getRemoteTracks(handleId); },
|
|
onlocaltrack : callbacks.onlocaltrack,
|
|
onremotetrack : callbacks.onremotetrack,
|
|
ondata : callbacks.ondata,
|
|
ondataopen : callbacks.ondataopen,
|
|
oncleanup : callbacks.oncleanup,
|
|
ondetached : callbacks.ondetached,
|
|
hangup : function(sendRequest) { cleanupWebrtc(handleId, sendRequest === true); },
|
|
detach : function(callbacks) { destroyHandle(handleId, callbacks); }
|
|
};
|
|
pluginHandles[handleId] = pluginHandle;
|
|
callbacks.success(pluginHandle);
|
|
};
|
|
request["session_id"] = sessionId;
|
|
ws.send(JSON.stringify(request));
|
|
return;
|
|
}
|
|
Janus.httpAPICall(server + "/" + sessionId, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request,
|
|
success: function(json) {
|
|
Janus.debug(json);
|
|
if(json["janus"] !== "success") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
callbacks.error("Ooops: " + json["error"].code + " " + json["error"].reason);
|
|
return;
|
|
}
|
|
let handleId = json.data["id"];
|
|
Janus.log("Created handle: " + handleId);
|
|
let pluginHandle =
|
|
{
|
|
session : that,
|
|
plugin : plugin,
|
|
id : handleId,
|
|
token : handleToken,
|
|
detached : false,
|
|
webrtcStuff : {
|
|
started : false,
|
|
myStream : null,
|
|
streamExternal : false,
|
|
mySdp : null,
|
|
mediaConstraints : null,
|
|
pc : null,
|
|
dataChannelOptions: callbacks.dataChannelOptions,
|
|
dataChannel : {},
|
|
dtmfSender : null,
|
|
trickle : true,
|
|
iceDone : false,
|
|
bitrate: {}
|
|
},
|
|
getId : function() { return handleId; },
|
|
getPlugin : function() { return plugin; },
|
|
getVolume : function(mid, result) { return getVolume(handleId, mid, true, result); },
|
|
getRemoteVolume : function(mid, result) { return getVolume(handleId, mid, true, result); },
|
|
getLocalVolume : function(mid, result) { return getVolume(handleId, mid, false, result); },
|
|
isAudioMuted : function(mid) { return isMuted(handleId, mid, false); },
|
|
muteAudio : function(mid) { return mute(handleId, mid, false, true); },
|
|
unmuteAudio : function(mid) { return mute(handleId, mid, false, false); },
|
|
isVideoMuted : function(mid) { return isMuted(handleId, mid, true); },
|
|
muteVideo : function(mid) { return mute(handleId, mid, true, true); },
|
|
unmuteVideo : function(mid) { return mute(handleId, mid, true, false); },
|
|
getBitrate : function(mid) { return getBitrate(handleId, mid); },
|
|
setMaxBitrate : function(mid, bitrate) { return setBitrate(handleId, mid, bitrate); },
|
|
send : function(callbacks) { sendMessage(handleId, callbacks); },
|
|
data : function(callbacks) { sendData(handleId, callbacks); },
|
|
dtmf : function(callbacks) { sendDtmf(handleId, callbacks); },
|
|
consentDialog : callbacks.consentDialog,
|
|
iceState : callbacks.iceState,
|
|
mediaState : callbacks.mediaState,
|
|
webrtcState : callbacks.webrtcState,
|
|
slowLink : callbacks.slowLink,
|
|
onmessage : callbacks.onmessage,
|
|
createOffer : function(callbacks) { prepareWebrtc(handleId, true, callbacks); },
|
|
createAnswer : function(callbacks) { prepareWebrtc(handleId, false, callbacks); },
|
|
handleRemoteJsep : function(callbacks) { prepareWebrtcPeer(handleId, callbacks); },
|
|
replaceTracks : function(callbacks) { replaceTracks(handleId, callbacks); },
|
|
getLocalTracks : function() { return getLocalTracks(handleId); },
|
|
getRemoteTracks : function() { return getRemoteTracks(handleId); },
|
|
onlocaltrack : callbacks.onlocaltrack,
|
|
onremotetrack : callbacks.onremotetrack,
|
|
ondata : callbacks.ondata,
|
|
ondataopen : callbacks.ondataopen,
|
|
oncleanup : callbacks.oncleanup,
|
|
ondetached : callbacks.ondetached,
|
|
hangup : function(sendRequest) { cleanupWebrtc(handleId, sendRequest === true); },
|
|
detach : function(callbacks) { destroyHandle(handleId, callbacks); }
|
|
}
|
|
pluginHandles[handleId] = pluginHandle;
|
|
callbacks.success(pluginHandle);
|
|
},
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown); // FIXME
|
|
if(errorThrown === "")
|
|
callbacks.error(textStatus + ": Is the server down?");
|
|
else
|
|
callbacks.error(textStatus + ": " + errorThrown);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Private method to send a message
|
|
function sendMessage(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
if(!connected) {
|
|
Janus.warn("Is the server down? (connected=false)");
|
|
callbacks.error("Is the server down? (connected=false)");
|
|
return;
|
|
}
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
callbacks.error("Invalid handle");
|
|
return;
|
|
}
|
|
let message = callbacks.message;
|
|
let jsep = callbacks.jsep;
|
|
let transaction = Janus.randomString(12);
|
|
let request = { "janus": "message", "body": message, "transaction": transaction };
|
|
if(pluginHandle.token)
|
|
request["token"] = pluginHandle.token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
if(jsep) {
|
|
request.jsep = {
|
|
type: jsep.type,
|
|
sdp: jsep.sdp
|
|
};
|
|
if(jsep.e2ee)
|
|
request.jsep.e2ee = true;
|
|
if(jsep.rid_order === "hml" || jsep.rid_order === "lmh")
|
|
request.jsep.rid_order = jsep.rid_order;
|
|
if(jsep.force_relay)
|
|
request.jsep.force_relay = true;
|
|
}
|
|
Janus.debug("Sending message to plugin (handle=" + handleId + "):");
|
|
Janus.debug(request);
|
|
if(websockets) {
|
|
request["session_id"] = sessionId;
|
|
request["handle_id"] = handleId;
|
|
transactions[transaction] = function(json) {
|
|
Janus.debug("Message sent!");
|
|
Janus.debug(json);
|
|
if(json["janus"] === "success") {
|
|
// We got a success, must have been a synchronous transaction
|
|
let plugindata = json["plugindata"];
|
|
if(!plugindata) {
|
|
Janus.warn("Request succeeded, but missing plugindata...");
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
Janus.log("Synchronous transaction successful (" + plugindata["plugin"] + ")");
|
|
let data = plugindata["data"];
|
|
Janus.debug(data);
|
|
callbacks.success(data);
|
|
return;
|
|
} else if(json["janus"] !== "ack") {
|
|
// Not a success and not an ack, must be an error
|
|
if(json["error"]) {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
callbacks.error(json["error"].code + " " + json["error"].reason);
|
|
} else {
|
|
Janus.error("Unknown error"); // FIXME
|
|
callbacks.error("Unknown error");
|
|
}
|
|
return;
|
|
}
|
|
// If we got here, the plugin decided to handle the request asynchronously
|
|
callbacks.success();
|
|
};
|
|
ws.send(JSON.stringify(request));
|
|
return;
|
|
}
|
|
Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request,
|
|
success: function(json) {
|
|
Janus.debug("Message sent!");
|
|
Janus.debug(json);
|
|
if(json["janus"] === "success") {
|
|
// We got a success, must have been a synchronous transaction
|
|
let plugindata = json["plugindata"];
|
|
if(!plugindata) {
|
|
Janus.warn("Request succeeded, but missing plugindata...");
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
Janus.log("Synchronous transaction successful (" + plugindata["plugin"] + ")");
|
|
let data = plugindata["data"];
|
|
Janus.debug(data);
|
|
callbacks.success(data);
|
|
return;
|
|
} else if(json["janus"] !== "ack") {
|
|
// Not a success and not an ack, must be an error
|
|
if(json["error"]) {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
callbacks.error(json["error"].code + " " + json["error"].reason);
|
|
} else {
|
|
Janus.error("Unknown error"); // FIXME
|
|
callbacks.error("Unknown error");
|
|
}
|
|
return;
|
|
}
|
|
// If we got here, the plugin decided to handle the request asynchronously
|
|
callbacks.success();
|
|
},
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown); // FIXME
|
|
callbacks.error(textStatus + ": " + errorThrown);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Private method to send a trickle candidate
|
|
function sendTrickleCandidate(handleId, candidate) {
|
|
if(!connected) {
|
|
Janus.warn("Is the server down? (connected=false)");
|
|
return;
|
|
}
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
return;
|
|
}
|
|
let request = { "janus": "trickle", "candidate": candidate, "transaction": Janus.randomString(12) };
|
|
if(pluginHandle.token)
|
|
request["token"] = pluginHandle.token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
Janus.vdebug("Sending trickle candidate (handle=" + handleId + "):");
|
|
Janus.vdebug(request);
|
|
if(websockets) {
|
|
request["session_id"] = sessionId;
|
|
request["handle_id"] = handleId;
|
|
ws.send(JSON.stringify(request));
|
|
return;
|
|
}
|
|
Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request,
|
|
success: function(json) {
|
|
Janus.vdebug("Candidate sent!");
|
|
Janus.vdebug(json);
|
|
if(json["janus"] !== "ack") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
return;
|
|
}
|
|
},
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown); // FIXME
|
|
}
|
|
});
|
|
}
|
|
|
|
// Private method to create a data channel
|
|
function createDataChannel(handleId, dclabel, dcprotocol, incoming, pendingData) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc) {
|
|
Janus.warn("Invalid PeerConnection");
|
|
return;
|
|
}
|
|
let onDataChannelMessage = function(event) {
|
|
Janus.log('Received message on data channel:', event);
|
|
let label = event.target.label;
|
|
pluginHandle.ondata(event.data, label);
|
|
};
|
|
let onDataChannelStateChange = function(event) {
|
|
Janus.log('Received state change on data channel:', event);
|
|
let label = event.target.label;
|
|
let protocol = event.target.protocol;
|
|
let dcState = config.dataChannel[label] ? config.dataChannel[label].readyState : "null";
|
|
Janus.log('State change on <' + label + '> data channel: ' + dcState);
|
|
if(dcState === 'open') {
|
|
// Any pending messages to send?
|
|
if(config.dataChannel[label].pending && config.dataChannel[label].pending.length > 0) {
|
|
Janus.log("Sending pending messages on <" + label + ">:", config.dataChannel[label].pending.length);
|
|
for(let data of config.dataChannel[label].pending) {
|
|
Janus.log("Sending data on data channel <" + label + ">");
|
|
Janus.debug(data);
|
|
config.dataChannel[label].send(data);
|
|
}
|
|
config.dataChannel[label].pending = [];
|
|
}
|
|
// Notify the open data channel
|
|
pluginHandle.ondataopen(label, protocol);
|
|
}
|
|
};
|
|
let onDataChannelError = function(error) {
|
|
Janus.error('Got error on data channel:', error);
|
|
// TODO
|
|
};
|
|
if(!incoming) {
|
|
// FIXME Add options (ordered, maxRetransmits, etc.)
|
|
let dcoptions = config.dataChannelOptions;
|
|
if(dcprotocol)
|
|
dcoptions.protocol = dcprotocol;
|
|
config.dataChannel[dclabel] = config.pc.createDataChannel(dclabel, dcoptions);
|
|
} else {
|
|
// The channel was created by Janus
|
|
config.dataChannel[dclabel] = incoming;
|
|
}
|
|
config.dataChannel[dclabel].onmessage = onDataChannelMessage;
|
|
config.dataChannel[dclabel].onopen = onDataChannelStateChange;
|
|
config.dataChannel[dclabel].onclose = onDataChannelStateChange;
|
|
config.dataChannel[dclabel].onerror = onDataChannelError;
|
|
config.dataChannel[dclabel].pending = [];
|
|
if(pendingData)
|
|
config.dataChannel[dclabel].pending.push(pendingData);
|
|
}
|
|
|
|
// Private method to send a data channel message
|
|
function sendData(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
callbacks.error("Invalid handle");
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
let data = callbacks.text || callbacks.data;
|
|
if(!data) {
|
|
Janus.warn("Invalid data");
|
|
callbacks.error("Invalid data");
|
|
return;
|
|
}
|
|
let label = callbacks.label ? callbacks.label : Janus.dataChanDefaultLabel;
|
|
if(!config.dataChannel[label]) {
|
|
// Create new data channel and wait for it to open
|
|
createDataChannel(handleId, label, callbacks.protocol, false, data, callbacks.protocol);
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
if(config.dataChannel[label].readyState !== "open") {
|
|
config.dataChannel[label].pending.push(data);
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
Janus.log("Sending data on data channel <" + label + ">");
|
|
Janus.debug(data);
|
|
config.dataChannel[label].send(data);
|
|
callbacks.success();
|
|
}
|
|
|
|
// Private method to send a DTMF tone
|
|
function sendDtmf(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
callbacks.error("Invalid handle");
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.dtmfSender) {
|
|
// Create the DTMF sender the proper way, if possible
|
|
if(config.pc) {
|
|
let senders = config.pc.getSenders();
|
|
let audioSender = senders.find(function(sender) {
|
|
return sender.track && sender.track.kind === 'audio';
|
|
});
|
|
if(!audioSender) {
|
|
Janus.warn("Invalid DTMF configuration (no audio track)");
|
|
callbacks.error("Invalid DTMF configuration (no audio track)");
|
|
return;
|
|
}
|
|
config.dtmfSender = audioSender.dtmf;
|
|
if(config.dtmfSender) {
|
|
Janus.log("Created DTMF Sender");
|
|
config.dtmfSender.ontonechange = function(tone) { Janus.debug("Sent DTMF tone: " + tone.tone); };
|
|
}
|
|
}
|
|
if(!config.dtmfSender) {
|
|
Janus.warn("Invalid DTMF configuration");
|
|
callbacks.error("Invalid DTMF configuration");
|
|
return;
|
|
}
|
|
}
|
|
let dtmf = callbacks.dtmf;
|
|
if(!dtmf) {
|
|
Janus.warn("Invalid DTMF parameters");
|
|
callbacks.error("Invalid DTMF parameters");
|
|
return;
|
|
}
|
|
let tones = dtmf.tones;
|
|
if(!tones) {
|
|
Janus.warn("Invalid DTMF string");
|
|
callbacks.error("Invalid DTMF string");
|
|
return;
|
|
}
|
|
let duration = (typeof dtmf.duration === 'number') ? dtmf.duration : 500; // We choose 500ms as the default duration for a tone
|
|
let gap = (typeof dtmf.gap === 'number') ? dtmf.gap : 50; // We choose 50ms as the default gap between tones
|
|
Janus.debug("Sending DTMF string " + tones + " (duration " + duration + "ms, gap " + gap + "ms)");
|
|
config.dtmfSender.insertDTMF(tones, duration, gap);
|
|
callbacks.success();
|
|
}
|
|
|
|
// Private method to destroy a plugin handle
|
|
function destroyHandle(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
let noRequest = (callbacks.noRequest === true);
|
|
Janus.log("Destroying handle " + handleId + " (only-locally=" + noRequest + ")");
|
|
cleanupWebrtc(handleId);
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || pluginHandle.detached) {
|
|
// Plugin was already detached by Janus, calling detach again will return a handle not found error, so just exit here
|
|
delete pluginHandles[handleId];
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
pluginHandle.detached = true;
|
|
if(noRequest) {
|
|
// We're only removing the handle locally
|
|
delete pluginHandles[handleId];
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
if(!connected) {
|
|
Janus.warn("Is the server down? (connected=false)");
|
|
callbacks.error("Is the server down? (connected=false)");
|
|
return;
|
|
}
|
|
let request = { "janus": "detach", "transaction": Janus.randomString(12) };
|
|
if(pluginHandle.token)
|
|
request["token"] = pluginHandle.token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
if(websockets) {
|
|
request["session_id"] = sessionId;
|
|
request["handle_id"] = handleId;
|
|
ws.send(JSON.stringify(request));
|
|
delete pluginHandles[handleId];
|
|
callbacks.success();
|
|
return;
|
|
}
|
|
Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request,
|
|
success: function(json) {
|
|
Janus.log("Destroyed handle:");
|
|
Janus.debug(json);
|
|
if(json["janus"] !== "success") {
|
|
Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
|
|
}
|
|
delete pluginHandles[handleId];
|
|
callbacks.success();
|
|
},
|
|
error: function(textStatus, errorThrown) {
|
|
Janus.error(textStatus + ":", errorThrown); // FIXME
|
|
// We cleanup anyway
|
|
delete pluginHandles[handleId];
|
|
callbacks.success();
|
|
}
|
|
});
|
|
}
|
|
|
|
// WebRTC stuff
|
|
// Helper function to create a new PeerConnection, if we need one
|
|
function createPeerconnectionIfNeeded(handleId, callbacks) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
throw "Invalid handle";
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(config.pc) {
|
|
// Nothing to do, we have a PeerConnection already
|
|
return;
|
|
}
|
|
let pc_config = {
|
|
iceServers: iceServers,
|
|
iceTransportPolicy: iceTransportPolicy,
|
|
bundlePolicy: bundlePolicy
|
|
};
|
|
pc_config.sdpSemantics = 'unified-plan';
|
|
// Check if a sender or receiver transform has been provided
|
|
let insertableStreams = false;
|
|
if(callbacks.tracks) {
|
|
for(let track of callbacks.tracks) {
|
|
if(track.transforms && (track.transforms.sender || track.transforms.receiver)) {
|
|
insertableStreams = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(RTCRtpSender && (RTCRtpSender.prototype.createEncodedStreams ||
|
|
(RTCRtpSender.prototype.createEncodedAudioStreams &&
|
|
RTCRtpSender.prototype.createEncodedVideoStreams)) && insertableStreams) {
|
|
config.insertableStreams = true;
|
|
pc_config.forceEncodedAudioInsertableStreams = true;
|
|
pc_config.forceEncodedVideoInsertableStreams = true;
|
|
pc_config.encodedInsertableStreams = true;
|
|
}
|
|
Janus.log('Creating PeerConnection');
|
|
config.pc = new RTCPeerConnection(pc_config);
|
|
Janus.debug(config.pc);
|
|
if(config.pc.getStats) { // FIXME
|
|
config.volume = {};
|
|
config.bitrate.value = '0 kbits/sec';
|
|
}
|
|
Janus.log('Preparing local SDP and gathering candidates (trickle=' + config.trickle + ')');
|
|
config.pc.oniceconnectionstatechange = function() {
|
|
if(config.pc)
|
|
pluginHandle.iceState(config.pc.iceConnectionState);
|
|
};
|
|
config.pc.onicecandidate = function(event) {
|
|
if(!event.candidate || (event.candidate.candidate && event.candidate.candidate.indexOf('endOfCandidates') > 0)) {
|
|
Janus.log('End of candidates.');
|
|
config.iceDone = true;
|
|
if(config.trickle === true) {
|
|
// Notify end of candidates
|
|
sendTrickleCandidate(handleId, { completed : true });
|
|
} else {
|
|
// No trickle, time to send the complete SDP (including all candidates)
|
|
sendSDP(handleId, callbacks);
|
|
}
|
|
} else {
|
|
// JSON.stringify doesn't work on some WebRTC objects anymore
|
|
// See https://code.google.com/p/chromium/issues/detail?id=467366
|
|
let candidate = {
|
|
candidate: event.candidate.candidate,
|
|
sdpMid: event.candidate.sdpMid,
|
|
sdpMLineIndex: event.candidate.sdpMLineIndex
|
|
};
|
|
if(config.trickle === true) {
|
|
// Send candidate
|
|
sendTrickleCandidate(handleId, candidate);
|
|
}
|
|
}
|
|
};
|
|
config.pc.ontrack = function(event) {
|
|
Janus.log('Handling Remote Track', event);
|
|
if(!event.streams)
|
|
return;
|
|
if(!event.track)
|
|
return;
|
|
// Notify about the new track event
|
|
let mid = event.transceiver ? event.transceiver.mid : event.track.id;
|
|
try {
|
|
pluginHandle.onremotetrack(event.track, mid, true, { reason: 'created' });
|
|
} catch(e) {
|
|
Janus.error("Error calling onremotetrack", e);
|
|
}
|
|
if(event.track.onended)
|
|
return;
|
|
let trackMutedTimeoutId = null;
|
|
Janus.log('Adding onended callback to track:', event.track);
|
|
event.track.onended = function(ev) {
|
|
Janus.log('Remote track removed:', ev);
|
|
clearTimeout(trackMutedTimeoutId);
|
|
// Notify the application
|
|
let transceivers = config.pc ? config.pc.getTransceivers() : null;
|
|
let transceiver = transceivers ? transceivers.find(
|
|
t => t.receiver.track === ev.target) : null;
|
|
let mid = transceiver ? transceiver.mid : ev.target.id;
|
|
try {
|
|
pluginHandle.onremotetrack(ev.target, mid, false, { reason: 'ended' });
|
|
} catch(e) {
|
|
Janus.error("Error calling onremotetrack on removal", e);
|
|
}
|
|
};
|
|
event.track.onmute = function(ev) {
|
|
Janus.log('Remote track muted:', ev);
|
|
if(!trackMutedTimeoutId) {
|
|
trackMutedTimeoutId = setTimeout(function() {
|
|
Janus.log('Removing remote track');
|
|
// Notify the application the track is gone
|
|
let transceivers = config.pc ? config.pc.getTransceivers() : null;
|
|
let transceiver = transceivers ? transceivers.find(
|
|
t => t.receiver.track === ev.target) : null;
|
|
let mid = transceiver ? transceiver.mid : ev.target.id;
|
|
try {
|
|
pluginHandle.onremotetrack(ev.target, mid, false, { reason: 'mute' } );
|
|
} catch(e) {
|
|
Janus.error("Error calling onremotetrack on mute", e);
|
|
}
|
|
trackMutedTimeoutId = null;
|
|
// Chrome seems to raise mute events only at multiples of 834ms;
|
|
// we set the timeout to three times this value (rounded to 840ms)
|
|
}, 3 * 840);
|
|
}
|
|
};
|
|
event.track.onunmute = function(ev) {
|
|
Janus.log('Remote track flowing again:', ev);
|
|
if(trackMutedTimeoutId != null) {
|
|
clearTimeout(trackMutedTimeoutId);
|
|
trackMutedTimeoutId = null;
|
|
} else {
|
|
try {
|
|
// Notify the application the track is back
|
|
let transceivers = config.pc ? config.pc.getTransceivers() : null;
|
|
let transceiver = transceivers ? transceivers.find(
|
|
t => t.receiver.track === ev.target) : null;
|
|
let mid = transceiver ? transceiver.mid : ev.target.id;
|
|
pluginHandle.onremotetrack(ev.target, mid, true, { reason: 'unmute' });
|
|
} catch(e) {
|
|
Janus.error("Error calling onremotetrack on unmute", e);
|
|
}
|
|
}
|
|
};
|
|
};
|
|
}
|
|
|
|
// Helper function used when creating either an offer or answer: it
|
|
// prepares what needs to be prepared, including creating a new
|
|
// PeerConnection (if needed) and updating the tracks configuration,
|
|
// before invoking the function to actually generate the offer/answer
|
|
async function prepareWebrtc(handleId, offer, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : webrtcError;
|
|
let jsep = callbacks.jsep;
|
|
if(offer && jsep) {
|
|
Janus.error("Provided a JSEP to a createOffer");
|
|
callbacks.error("Provided a JSEP to a createOffer");
|
|
return;
|
|
} else if(!offer && (!jsep || !jsep.type || !jsep.sdp)) {
|
|
Janus.error("A valid JSEP is required for createAnswer");
|
|
callbacks.error("A valid JSEP is required for createAnswer");
|
|
return;
|
|
}
|
|
// If the deprecated media was provided instead of tracks, translate it
|
|
if(callbacks.media && !callbacks.tracks) {
|
|
callbacks.tracks = Janus.mediaToTracks(callbacks.media);
|
|
if(callbacks.simulcast === true || callbacks.simulcast2 === true || callbacks.svc) {
|
|
// Find the video track and add simulcast/SVC info there
|
|
for(let track of callbacks.tracks) {
|
|
if(track.type === 'video') {
|
|
if(callbacks.simulcast === true || callbacks.simulcast2 === true)
|
|
track.simulcast = true;
|
|
else if(callbacks.svc)
|
|
track.svc = callbacks.svc;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Janus.warn('Deprecated media object passed, use tracks instead. Automatically translated to:', callbacks.tracks);
|
|
}
|
|
// Check that callbacks.array is a valid array
|
|
if(callbacks.tracks && !Array.isArray(callbacks.tracks)) {
|
|
Janus.error("Tracks must be an array");
|
|
callbacks.error("Tracks must be an array");
|
|
return;
|
|
}
|
|
// Get the plugin handle
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
callbacks.error("Invalid handle");
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
config.trickle = isTrickleEnabled(callbacks.trickle);
|
|
try {
|
|
// Create a PeerConnection, if needed
|
|
createPeerconnectionIfNeeded(handleId, callbacks);
|
|
if(offer) {
|
|
// Capture devices and setup tracks, if needed
|
|
await captureDevices(handleId, callbacks);
|
|
}
|
|
// Create offer or answer now (depending on the context)
|
|
if(!jsep) {
|
|
let offer = await createOffer(handleId, callbacks);
|
|
callbacks.success(offer);
|
|
} else {
|
|
await config.pc.setRemoteDescription(jsep);
|
|
Janus.log("Remote description accepted!");
|
|
config.remoteSdp = jsep.sdp;
|
|
// Any trickle candidate we cached?
|
|
if(config.candidates && config.candidates.length > 0) {
|
|
for(let i=0; i<config.candidates.length; i++) {
|
|
let candidate = config.candidates[i];
|
|
Janus.debug("Adding remote candidate:", candidate);
|
|
if(!candidate || candidate.completed === true) {
|
|
// end-of-candidates
|
|
config.pc.addIceCandidate(Janus.endOfCandidates);
|
|
} else {
|
|
// New candidate
|
|
config.pc.addIceCandidate(candidate);
|
|
}
|
|
}
|
|
config.candidates = [];
|
|
}
|
|
// Capture devices and setup tracks, if needed
|
|
await captureDevices(handleId, callbacks);
|
|
// Create the answer now
|
|
let answer = await createAnswer(handleId, callbacks);
|
|
callbacks.success(answer);
|
|
}
|
|
} catch(err) {
|
|
Janus.error(err);
|
|
callbacks.error(err);
|
|
}
|
|
}
|
|
|
|
function prepareWebrtcPeer(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : webrtcError;
|
|
callbacks.customizeSdp = (typeof callbacks.customizeSdp == "function") ? callbacks.customizeSdp : Janus.noop;
|
|
let jsep = callbacks.jsep;
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
callbacks.error("Invalid handle");
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(jsep) {
|
|
if(!config.pc) {
|
|
Janus.warn("Wait, no PeerConnection?? if this is an answer, use createAnswer and not handleRemoteJsep");
|
|
callbacks.error("No PeerConnection: if this is an answer, use createAnswer and not handleRemoteJsep");
|
|
return;
|
|
}
|
|
callbacks.customizeSdp(jsep);
|
|
config.pc.setRemoteDescription(jsep)
|
|
.then(function() {
|
|
Janus.log("Remote description accepted!");
|
|
config.remoteSdp = jsep.sdp;
|
|
// Any trickle candidate we cached?
|
|
if(config.candidates && config.candidates.length > 0) {
|
|
for(let i=0; i<config.candidates.length; i++) {
|
|
let candidate = config.candidates[i];
|
|
Janus.debug("Adding remote candidate:", candidate);
|
|
if(!candidate || candidate.completed === true) {
|
|
// end-of-candidates
|
|
config.pc.addIceCandidate(Janus.endOfCandidates);
|
|
} else {
|
|
// New candidate
|
|
config.pc.addIceCandidate(candidate);
|
|
}
|
|
}
|
|
config.candidates = [];
|
|
}
|
|
// Done
|
|
callbacks.success();
|
|
}, callbacks.error);
|
|
} else {
|
|
callbacks.error("Invalid JSEP");
|
|
}
|
|
}
|
|
|
|
async function createOffer(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.customizeSdp = (typeof callbacks.customizeSdp == "function") ? callbacks.customizeSdp : Janus.noop;
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
throw "Invalid handle";
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
Janus.log("Creating offer (iceDone=" + config.iceDone + ")");
|
|
// https://code.google.com/p/webrtc/issues/detail?id=3508
|
|
let mediaConstraints = {};
|
|
let iceRestart = (callbacks.iceRestart === true);
|
|
// If we need an ICE restart, set the related constraint
|
|
if(iceRestart)
|
|
mediaConstraints.iceRestart = true;
|
|
Janus.debug(mediaConstraints);
|
|
let offer = await config.pc.createOffer(mediaConstraints);
|
|
Janus.debug(offer);
|
|
// JSON.stringify doesn't work on some WebRTC objects anymore
|
|
// See https://code.google.com/p/chromium/issues/detail?id=467366
|
|
let jsep = {
|
|
type: 'offer',
|
|
sdp: offer.sdp
|
|
};
|
|
callbacks.customizeSdp(jsep);
|
|
offer.sdp = jsep.sdp;
|
|
Janus.log("Setting local description");
|
|
config.mySdp = {
|
|
type: 'offer',
|
|
sdp: offer.sdp
|
|
};
|
|
await config.pc.setLocalDescription(offer);
|
|
config.mediaConstraints = mediaConstraints;
|
|
if(!config.iceDone && !config.trickle) {
|
|
// FIXME Don't do anything until we have all candidates
|
|
Janus.log("Waiting for all candidates...");
|
|
return null;
|
|
}
|
|
// If transforms are present, notify Janus that the media is end-to-end encrypted
|
|
if(config.insertableStreams)
|
|
offer.e2ee = true;
|
|
return offer;
|
|
}
|
|
|
|
async function createAnswer(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.customizeSdp = (typeof callbacks.customizeSdp == "function") ? callbacks.customizeSdp : Janus.noop;
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
throw "Invalid handle";
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
Janus.log("Creating answer (iceDone=" + config.iceDone + ")");
|
|
let answer = await config.pc.createAnswer();
|
|
Janus.debug(answer);
|
|
// JSON.stringify doesn't work on some WebRTC objects anymore
|
|
// See https://code.google.com/p/chromium/issues/detail?id=467366
|
|
let jsep = {
|
|
type: 'answer',
|
|
sdp: answer.sdp
|
|
};
|
|
callbacks.customizeSdp(jsep);
|
|
answer.sdp = jsep.sdp;
|
|
Janus.log("Setting local description");
|
|
config.mySdp = {
|
|
type: 'answer',
|
|
sdp: answer.sdp
|
|
};
|
|
await config.pc.setLocalDescription(answer);
|
|
if(!config.iceDone && !config.trickle) {
|
|
// FIXME Don't do anything until we have all candidates
|
|
Janus.log("Waiting for all candidates...");
|
|
return null;
|
|
}
|
|
// If transforms are present, notify Janus that the media is end-to-end encrypted
|
|
if(config.insertableStreams)
|
|
answer.e2ee = true;
|
|
return answer;
|
|
}
|
|
|
|
function sendSDP(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle, not sending anything");
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
Janus.log("Sending offer/answer SDP...");
|
|
if(!config.mySdp) {
|
|
Janus.warn("Local SDP instance is invalid, not sending anything...");
|
|
return;
|
|
}
|
|
config.mySdp = {
|
|
type: config.pc.localDescription.type,
|
|
sdp: config.pc.localDescription.sdp
|
|
};
|
|
if(config.trickle === false)
|
|
config.mySdp["trickle"] = false;
|
|
Janus.debug(callbacks);
|
|
config.sdpSent = true;
|
|
callbacks.success(config.mySdp);
|
|
}
|
|
|
|
async function replaceTracks(handleId, callbacks) {
|
|
callbacks = callbacks || {};
|
|
callbacks.success = (typeof callbacks.success == 'function') ? callbacks.success : Janus.noop;
|
|
callbacks.error = (typeof callbacks.error == 'function') ? callbacks.error : Janus.noop;
|
|
// Check that callbacks.array is a valid array
|
|
if(callbacks.tracks && !Array.isArray(callbacks.tracks)) {
|
|
Janus.error('Tracks must be an array');
|
|
callbacks.error('Tracks must be an array');
|
|
return;
|
|
}
|
|
// Add the replace:true if it's missing
|
|
for(let track of callbacks.tracks) {
|
|
if(track.add || (!track.replace && !track.remove))
|
|
track.replace = true;
|
|
}
|
|
try {
|
|
await captureDevices(handleId, callbacks);
|
|
callbacks.success();
|
|
} catch(err) {
|
|
Janus.error(err);
|
|
callbacks.error(err);
|
|
}
|
|
}
|
|
|
|
async function captureDevices(handleId, callbacks) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn('Invalid handle, not sending anything');
|
|
throw 'Invalid handle';
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc) {
|
|
Janus.warn('Invalid PeerConnection');
|
|
throw 'Invalid PeerConnection';
|
|
}
|
|
let tracks = callbacks.tracks;
|
|
if(!tracks || !Array.isArray(tracks) || tracks.length === 0) {
|
|
// Nothing to do
|
|
return;
|
|
}
|
|
let openedConsentDialog = false;
|
|
// Check if we can/should group getUserMedia calls
|
|
let groups = {};
|
|
for(let track of tracks) {
|
|
delete track.gumGroup;
|
|
if(!track.type || !['audio', 'video'].includes(track.type))
|
|
continue;
|
|
if(!track.capture || track.capture instanceof MediaStreamTrack)
|
|
continue;
|
|
let group = track.group ? track.group : 'default';
|
|
if(!groups[group])
|
|
groups[group] = {};
|
|
if(groups[group][track.type])
|
|
continue;
|
|
track.gumGroup = group;
|
|
groups[group][track.type] = track;
|
|
}
|
|
let keys = Object.keys(groups);
|
|
for(let key of keys) {
|
|
let group = groups[key];
|
|
if(!group.audio || !group.video) {
|
|
if(group.audio)
|
|
delete group.audio.gumGroup;
|
|
if(group.video)
|
|
delete group.video.gumGroup;
|
|
delete groups[key];
|
|
}
|
|
}
|
|
let answer = (callbacks.jsep ? true : false);
|
|
for(let track of tracks) {
|
|
if(!track.type) {
|
|
Janus.warn('Missing track type:', track);
|
|
continue;
|
|
}
|
|
if(track.type === 'data') {
|
|
// Easy enough: create a datachannel if we don't have one already
|
|
if(config.pc.ondatachannel) {
|
|
Janus.warn('Data channel exists already, not creating another one');
|
|
continue;
|
|
}
|
|
Janus.log('Creating default data channel');
|
|
createDataChannel(handleId, Janus.dataChanDefaultLabel, null, false);
|
|
config.pc.ondatachannel = function(event) {
|
|
Janus.log('Data channel created by Janus:', event);
|
|
createDataChannel(handleId, event.channel.label, event.channel.protocol, event.channel);
|
|
};
|
|
continue;
|
|
}
|
|
if((typeof track.add === 'undefined' && track.add === null) &&
|
|
(typeof track.remove === 'undefined' && track.remove === null) &&
|
|
(typeof track.replace === 'undefined' && track.replace === null)) {
|
|
// Let's default to 'add'
|
|
track.add = true;
|
|
}
|
|
if((track.add && track.remove) || (track.add && track.remove && track.replace)) {
|
|
Janus.warn('Conflicting actions for track, ignoring:', track);
|
|
continue;
|
|
}
|
|
if(track.add && track.replace) {
|
|
Janus.warn('Both add and replace provided, falling back to replace:', track);
|
|
delete track.add;
|
|
} else if(track.remove && track.replace) {
|
|
Janus.warn('Both remove and replace provided, falling back to remove:', track);
|
|
delete track.replace;
|
|
}
|
|
let kind = track.type;
|
|
if(track.type === 'screen')
|
|
kind = 'video'; // FIXME
|
|
let transceiver = null, sender = null;
|
|
if(track.mid) {
|
|
// Search by mid
|
|
transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.mid === track.mid && t.receiver.track.kind === kind));
|
|
} else {
|
|
// Find the first track of this type
|
|
transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.receiver.track.kind === kind));
|
|
}
|
|
if(track.replace || track.remove) {
|
|
if(!transceiver) {
|
|
Janus.warn("Couldn't find a transceiver for track:", track);
|
|
continue;
|
|
}
|
|
if(!transceiver.sender) {
|
|
Janus.warn('No sender in the transceiver for track:', track);
|
|
continue;
|
|
}
|
|
sender = transceiver.sender;
|
|
}
|
|
if(answer && !transceiver) {
|
|
transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.receiver.track.kind === kind));
|
|
if(!transceiver) {
|
|
Janus.warn("Couldn't find a transceiver for track:", track);
|
|
continue;
|
|
}
|
|
}
|
|
// Capture the new track, if we need to
|
|
let nt = null, trackId = null;
|
|
if(track.remove) {
|
|
Janus.log('Removing track from PeerConnection', track);
|
|
trackId = sender.track ? sender.track.id : null;
|
|
await sender.replaceTrack(null);
|
|
} else if(track.capture) {
|
|
if(track.gumGroup && groups[track.gumGroup] && groups[track.gumGroup].stream) {
|
|
// We did a getUserMedia before already
|
|
let stream = groups[track.gumGroup].stream;
|
|
nt = (track.type === 'audio' ? stream.getAudioTracks()[0] : stream.getVideoTracks()[0]);
|
|
delete groups[track.gumGroup].stream;
|
|
delete groups[track.gumGroup];
|
|
delete track.gumGroup;
|
|
} else if(track.capture instanceof MediaStreamTrack) {
|
|
// An external track was provided, use that
|
|
nt = track.capture;
|
|
} else {
|
|
if(!openedConsentDialog) {
|
|
openedConsentDialog = true;
|
|
pluginHandle.consentDialog(true);
|
|
}
|
|
let constraints = Janus.trackConstraints(track), stream = null;
|
|
if(track.type === 'audio' || track.type === 'video') {
|
|
// Use getUserMedia: check if we need to group audio and video together
|
|
if(track.gumGroup) {
|
|
let otherType = (track.type === 'audio' ? 'video' : 'audio');
|
|
if(groups[track.gumGroup] && groups[track.gumGroup][otherType]) {
|
|
let otherTrack = groups[track.gumGroup][otherType];
|
|
let otherConstraints = Janus.trackConstraints(otherTrack);
|
|
constraints[otherType] = otherConstraints[otherType];
|
|
}
|
|
}
|
|
stream = await navigator.mediaDevices.getUserMedia(constraints);
|
|
if(track.gumGroup && constraints.audio && constraints.video) {
|
|
// We just performed a grouped getUserMedia, keep track of the
|
|
// stream so that we can immediately assign the track later
|
|
groups[track.gumGroup].stream = stream;
|
|
delete track.gumGroup;
|
|
}
|
|
} else {
|
|
// Use getDisplayMedia
|
|
stream = await navigator.mediaDevices.getDisplayMedia(constraints);
|
|
}
|
|
nt = (track.type === 'audio' ? stream.getAudioTracks()[0] : stream.getVideoTracks()[0]);
|
|
}
|
|
if(track.replace) {
|
|
// Replace the track
|
|
await sender.replaceTrack(nt);
|
|
// Update the transceiver direction
|
|
let newDirection = 'sendrecv';
|
|
if(track.recv === false || transceiver.direction === 'inactive' || transceiver.direction === 'sendonly')
|
|
newDirection = 'sendonly';
|
|
if(transceiver.setDirection)
|
|
transceiver.setDirection(newDirection);
|
|
else
|
|
transceiver.direction = newDirection;
|
|
} else {
|
|
// FIXME Add as a new track
|
|
if(!config.myStream)
|
|
config.myStream = new MediaStream();
|
|
if(kind === 'audio' || (!track.simulcast && !track.svc)) {
|
|
sender = config.pc.addTrack(nt, config.myStream);
|
|
transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.sender === sender));
|
|
} else if(track.simulcast) {
|
|
if(Janus.webRTCAdapter.browserDetails.browser !== 'firefox') {
|
|
// Standard RID
|
|
Janus.log('Enabling rid-based simulcasting:', nt);
|
|
let maxBitrates = getMaxBitrates(track.simulcastMaxBitrates);
|
|
transceiver = config.pc.addTransceiver(nt, {
|
|
direction: 'sendrecv',
|
|
streams: [config.myStream],
|
|
sendEncodings: track.sendEncodings || [
|
|
{ rid: 'h', active: true, maxBitrate: maxBitrates.high },
|
|
{ rid: 'm', active: true, maxBitrate: maxBitrates.medium, scaleResolutionDownBy: 2 },
|
|
{ rid: 'l', active: true, maxBitrate: maxBitrates.low, scaleResolutionDownBy: 4 }
|
|
]
|
|
});
|
|
} else {
|
|
// Firefox-based RID, based on https://gist.github.com/voluntas/088bc3cc62094730647b
|
|
Janus.log('Enabling Simulcasting for Firefox (RID)');
|
|
transceiver = config.pc.addTransceiver(nt, {
|
|
direction: 'sendrecv',
|
|
streams: [config.myStream]
|
|
});
|
|
sender = transceiver ? transceiver.sender : null;
|
|
if(sender) {
|
|
let parameters = sender.getParameters();
|
|
if(!parameters)
|
|
parameters = {};
|
|
let maxBitrates = getMaxBitrates(track.simulcastMaxBitrates);
|
|
parameters.encodings = track.sendEncodings || [
|
|
{ rid: 'h', active: true, maxBitrate: maxBitrates.high },
|
|
{ rid: 'm', active: true, maxBitrate: maxBitrates.medium, scaleResolutionDownBy: 2 },
|
|
{ rid: 'l', active: true, maxBitrate: maxBitrates.low, scaleResolutionDownBy: 4 }
|
|
];
|
|
sender.setParameters(parameters);
|
|
}
|
|
}
|
|
} else {
|
|
Janus.log('Enabling SVC (' + track.svc + '):', nt);
|
|
transceiver = config.pc.addTransceiver(nt, {
|
|
direction: 'sendrecv',
|
|
streams: [config.myStream],
|
|
sendEncodings: [
|
|
{ scalabilityMode: track.svc }
|
|
]
|
|
});
|
|
}
|
|
if(!sender)
|
|
sender = transceiver ? transceiver.sender : null;
|
|
// Check if we need to override some settings
|
|
if(track.codec) {
|
|
if(Janus.webRTCAdapter.browserDetails.browser === 'firefox') {
|
|
Janus.warn('setCodecPreferences not supported in Firefox, ignoring codec for track:', track);
|
|
} else if(typeof track.codec !== 'string') {
|
|
Janus.warn('Invalid codec value, ignoring for track:', track);
|
|
} else {
|
|
let mimeType = kind + '/' + track.codec.toLowerCase();
|
|
let codecs = RTCRtpReceiver.getCapabilities(kind).codecs.filter(function(codec) {
|
|
return codec.mimeType.toLowerCase() === mimeType;
|
|
});
|
|
if(!codecs || codecs.length === 0) {
|
|
Janus.warn('Codec not supported in this browser for this track, ignoring:', track);
|
|
} else if(transceiver) {
|
|
try {
|
|
transceiver.setCodecPreferences(codecs);
|
|
} catch(err) {
|
|
Janus.warn('Failed enforcing codec for this ' + kind + ' track:', err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(track.bitrate) {
|
|
// Override maximum bitrate
|
|
if(track.simulcast || track.svc) {
|
|
Janus.warn('Ignoring bitrate for simulcast/SVC track, use sendEncodings for that');
|
|
} else if(isNaN(track.bitrate) || track.bitrate < 0) {
|
|
Janus.warn('Ignoring invalid bitrate for track:', track);
|
|
} else if(sender) {
|
|
let params = sender.getParameters();
|
|
if(!params || !params.encodings || params.encodings.length === 0) {
|
|
Janus.warn('No encodings in the sender parameters, ignoring bitrate for track:', track);
|
|
} else {
|
|
params.encodings[0].maxBitrate = track.bitrate;
|
|
await sender.setParameters(params);
|
|
}
|
|
}
|
|
}
|
|
if(kind === 'video' && track.framerate) {
|
|
// Override maximum framerate
|
|
if(track.simulcast || track.svc) {
|
|
Janus.warn('Ignoring framerate for simulcast/SVC track, use sendEncodings for that');
|
|
} else if(isNaN(track.framerate) || track.framerate < 0) {
|
|
Janus.warn('Ignoring invalid framerate for track:', track);
|
|
} else if(sender) {
|
|
let params = sender.getParameters();
|
|
if(!params || !params.encodings || params.encodings.length === 0) {
|
|
Janus.warn('No encodings in the sender parameters, ignoring framerate for track:', track);
|
|
} else {
|
|
params.encodings[0].maxFramerate = track.framerate;
|
|
await sender.setParameters(params);
|
|
}
|
|
}
|
|
}
|
|
// Check if insertable streams are involved
|
|
if(track.transforms) {
|
|
if(sender && track.transforms.sender) {
|
|
// There's a sender transform, set it on the transceiver sender
|
|
let senderStreams = null;
|
|
if(RTCRtpSender.prototype.createEncodedStreams) {
|
|
senderStreams = sender.createEncodedStreams();
|
|
} else if(RTCRtpSender.prototype.createAudioEncodedStreams || RTCRtpSender.prototype.createEncodedVideoStreams) {
|
|
if(kind === 'audio') {
|
|
senderStreams = sender.createEncodedAudioStreams();
|
|
} else if(kind === 'video') {
|
|
senderStreams = sender.createEncodedVideoStreams();
|
|
}
|
|
}
|
|
if(senderStreams) {
|
|
console.log('Insertable Streams sender transform:', senderStreams);
|
|
if(senderStreams.readableStream && senderStreams.writableStream) {
|
|
senderStreams.readableStream
|
|
.pipeThrough(track.transforms.sender)
|
|
.pipeTo(senderStreams.writableStream);
|
|
} else if(senderStreams.readable && senderStreams.writable) {
|
|
senderStreams.readable
|
|
.pipeThrough(track.transforms.sender)
|
|
.pipeTo(senderStreams.writable);
|
|
}
|
|
}
|
|
}
|
|
if(transceiver && transceiver.receiver && track.transforms.receiver) {
|
|
// There's a receiver transform, set it on the transceiver receiver
|
|
let receiverStreams = null;
|
|
if(RTCRtpReceiver.prototype.createEncodedStreams) {
|
|
receiverStreams = transceiver.receiver.createEncodedStreams();
|
|
} else if(RTCRtpReceiver.prototype.createAudioEncodedStreams || RTCRtpReceiver.prototype.createEncodedVideoStreams) {
|
|
if(kind === 'audio') {
|
|
receiverStreams = transceiver.receiver.createEncodedAudioStreams();
|
|
} else if(kind === 'video') {
|
|
receiverStreams = transceiver.receiver.createEncodedVideoStreams();
|
|
}
|
|
}
|
|
if(receiverStreams) {
|
|
console.log('Insertable Streams receiver transform:', receiverStreams);
|
|
if(receiverStreams.readableStream && receiverStreams.writableStream) {
|
|
receiverStreams.readableStream
|
|
.pipeThrough(track.transforms.receiver)
|
|
.pipeTo(receiverStreams.writableStream);
|
|
} else if(receiverStreams.readable && receiverStreams.writable) {
|
|
receiverStreams.readable
|
|
.pipeThrough(track.transforms.receiver)
|
|
.pipeTo(receiverStreams.writable);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(nt && track.dontStop === true)
|
|
nt.dontStop = true;
|
|
} else if(track.recv && !transceiver) {
|
|
// Maybe a new recvonly track
|
|
transceiver = config.pc.addTransceiver(kind);
|
|
if(transceiver) {
|
|
// Check if we need to override some settings
|
|
if(track.codec) {
|
|
if(Janus.webRTCAdapter.browserDetails.browser === 'firefox') {
|
|
Janus.warn('setCodecPreferences not supported in Firefox, ignoring codec for track:', track);
|
|
} else if(typeof track.codec !== 'string') {
|
|
Janus.warn('Invalid codec value, ignoring for track:', track);
|
|
} else {
|
|
let mimeType = kind + '/' + track.codec.toLowerCase();
|
|
let codecs = RTCRtpReceiver.getCapabilities(kind).codecs.filter(function(codec) {
|
|
return codec.mimeType.toLowerCase() === mimeType;
|
|
});
|
|
if(!codecs || codecs.length === 0) {
|
|
Janus.warn('Codec not supported in this browser for this track, ignoring:', track);
|
|
} else {
|
|
try {
|
|
transceiver.setCodecPreferences(codecs);
|
|
} catch(err) {
|
|
Janus.warn('Failed enforcing codec for this ' + kind + ' track:', err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Check if insertable streams are involved
|
|
if(transceiver.receiver && track.transforms && track.transforms.receiver) {
|
|
// There's a receiver transform, set it on the transceiver receiver
|
|
let receiverStreams = null;
|
|
if(RTCRtpReceiver.prototype.createEncodedStreams) {
|
|
receiverStreams = transceiver.receiver.createEncodedStreams();
|
|
} else if(RTCRtpReceiver.prototype.createAudioEncodedStreams || RTCRtpReceiver.prototype.createEncodedVideoStreams) {
|
|
if(kind === 'audio') {
|
|
receiverStreams = transceiver.receiver.createEncodedAudioStreams();
|
|
} else if(kind === 'video') {
|
|
receiverStreams = transceiver.receiver.createEncodedVideoStreams();
|
|
}
|
|
}
|
|
if(receiverStreams) {
|
|
console.log('Insertable Streams receiver transform:', receiverStreams);
|
|
if(receiverStreams.readableStream && receiverStreams.writableStream) {
|
|
receiverStreams.readableStream
|
|
.pipeThrough(track.transforms.receiver)
|
|
.pipeTo(receiverStreams.writableStream);
|
|
} else if(receiverStreams.readable && receiverStreams.writable) {
|
|
receiverStreams.readable
|
|
.pipeThrough(track.transforms.receiver)
|
|
.pipeTo(receiverStreams.writable);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// Get rid of the old track
|
|
// FIXME We should probably do this *before* capturing the new
|
|
// track, since this prevents, for instance, just changing the
|
|
// resolution of the same webcam we're capturing already (the
|
|
// existing resolution would be returned, or an overconstrained
|
|
// error). On the other end, closing the track before we capture
|
|
// the new device means we'd end up with a period of time where
|
|
// no video is sent (changing device takes some time), and
|
|
// media would be stopped entirely in case capturing the new
|
|
// device results in an error. To keep things simpler, we're
|
|
// doing it after: we can make this configurable in the future.
|
|
if(trackId && config.myStream) {
|
|
let rt = null;
|
|
if(kind === 'audio' && config.myStream.getAudioTracks() && config.myStream.getAudioTracks().length) {
|
|
for(let t of config.myStream.getAudioTracks()) {
|
|
if(t.id === trackId) {
|
|
rt = t;
|
|
Janus.log('Removing audio track:', rt);
|
|
}
|
|
}
|
|
} else if(kind === 'video' && config.myStream.getVideoTracks() && config.myStream.getVideoTracks().length) {
|
|
for(let t of config.myStream.getVideoTracks()) {
|
|
if(t.id === trackId) {
|
|
rt = t;
|
|
Janus.log('Removing video track:', rt);
|
|
}
|
|
}
|
|
}
|
|
if(rt) {
|
|
// Remove the track and notify the application
|
|
try {
|
|
config.myStream.removeTrack(rt);
|
|
pluginHandle.onlocaltrack(rt, false);
|
|
} catch(e) {
|
|
Janus.error("Error calling onlocaltrack on removal for renegotiation", e);
|
|
}
|
|
// Close the old track (unless we've been asked not to)
|
|
if(rt.dontStop !== true) {
|
|
try {
|
|
rt.stop();
|
|
} catch(e) {}
|
|
}
|
|
}
|
|
}
|
|
if(nt) {
|
|
// FIXME Add the new track locally
|
|
config.myStream.addTrack(nt);
|
|
// Notify the application about the new local track, if any
|
|
nt.onended = function(ev) {
|
|
Janus.log('Local track removed:', ev);
|
|
try {
|
|
pluginHandle.onlocaltrack(ev.target, false);
|
|
} catch(e) {
|
|
Janus.error("Error calling onlocaltrack following end", e);
|
|
}
|
|
}
|
|
try {
|
|
pluginHandle.onlocaltrack(nt, true);
|
|
} catch(e) {
|
|
Janus.error("Error calling onlocaltrack for track add", e);
|
|
}
|
|
}
|
|
// Update the direction of the transceiver
|
|
if(transceiver) {
|
|
let curdir = transceiver.direction, newdir = null;
|
|
let send = (nt && transceiver.sender.track),
|
|
recv = (track.recv !== false && transceiver.receiver.track);
|
|
if(send && recv)
|
|
newdir = 'sendrecv';
|
|
else if(send && !recv)
|
|
newdir = 'sendonly';
|
|
else if(!send && recv)
|
|
newdir = 'recvonly';
|
|
else if(!send && !recv)
|
|
newdir = 'inactive';
|
|
if(newdir && newdir !== curdir) {
|
|
Janus.warn('Changing direction of transceiver to ' + newdir + ' (was ' + curdir + ')', track);
|
|
if(transceiver.setDirection)
|
|
transceiver.setDirection(newdir);
|
|
else
|
|
transceiver.direction = newdir;
|
|
}
|
|
}
|
|
}
|
|
if(openedConsentDialog)
|
|
pluginHandle.consentDialog(false);
|
|
}
|
|
|
|
function getLocalTracks(handleId) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn('Invalid handle');
|
|
return null;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc) {
|
|
Janus.warn('Invalid PeerConnection');
|
|
return null;
|
|
}
|
|
let tracks = [];
|
|
let transceivers = config.pc.getTransceivers();
|
|
for(let tr of transceivers) {
|
|
let track = null;
|
|
if(tr.sender && tr.sender.track) {
|
|
track = { mid: tr.mid };
|
|
track.type = tr.sender.track.kind;
|
|
track.id = tr.sender.track.id;
|
|
track.label = tr.sender.track.label;
|
|
}
|
|
if(track)
|
|
tracks.push(track);
|
|
}
|
|
return tracks;
|
|
}
|
|
|
|
function getRemoteTracks(handleId) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn('Invalid handle');
|
|
return null;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc) {
|
|
Janus.warn('Invalid PeerConnection');
|
|
return null;
|
|
}
|
|
let tracks = [];
|
|
let transceivers = config.pc.getTransceivers();
|
|
for(let tr of transceivers) {
|
|
let track = null;
|
|
if(tr.receiver && tr.receiver.track) {
|
|
track = { mid: tr.mid };
|
|
track.type = tr.receiver.track.kind;
|
|
track.id = tr.receiver.track.id;
|
|
track.label = tr.receiver.track.label;
|
|
}
|
|
if(track)
|
|
tracks.push(track);
|
|
}
|
|
return tracks;
|
|
}
|
|
|
|
function getVolume(handleId, mid, remote, result) {
|
|
result = (typeof result == "function") ? result : Janus.noop;
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
result(0);
|
|
return;
|
|
}
|
|
let stream = remote ? "remote" : "local";
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.volume[stream])
|
|
config.volume[stream] = { value: 0 };
|
|
// Start getting the volume, if audioLevel in getStats is supported (apparently
|
|
// they're only available in Chrome/Safari right now: https://webrtc-stats.callstats.io/)
|
|
if(config.pc && config.pc.getStats && (Janus.webRTCAdapter.browserDetails.browser === "chrome" ||
|
|
Janus.webRTCAdapter.browserDetails.browser === "safari")) {
|
|
// Are we interested in a mid in particular?
|
|
let query = config.pc;
|
|
if(mid) {
|
|
let transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.mid === mid && t.receiver.track.kind === "audio"));
|
|
if(!transceiver) {
|
|
Janus.warn("No audio transceiver with mid " + mid);
|
|
result(0);
|
|
return;
|
|
}
|
|
if(remote && !transceiver.receiver) {
|
|
Janus.warn("Remote transceiver track unavailable");
|
|
result(0);
|
|
return;
|
|
} else if(!remote && !transceiver.sender) {
|
|
Janus.warn("Local transceiver track unavailable");
|
|
result(0);
|
|
return;
|
|
}
|
|
query = remote ? transceiver.receiver : transceiver.sender;
|
|
}
|
|
query.getStats()
|
|
.then(function(stats) {
|
|
stats.forEach(function (res) {
|
|
if(!res || res.kind !== "audio")
|
|
return;
|
|
if((remote && !res.remoteSource) || (!remote && res.type !== "media-source"))
|
|
return;
|
|
result(res.audioLevel ? res.audioLevel : 0);
|
|
});
|
|
});
|
|
return config.volume[stream].value;
|
|
} else {
|
|
// audioInputLevel and audioOutputLevel seem only available in Chrome? audioLevel
|
|
// seems to be available on Chrome and Firefox, but they don't seem to work
|
|
Janus.warn("Getting the " + stream + " volume unsupported by browser");
|
|
result(0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
function isMuted(handleId, mid, video) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
return true;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc) {
|
|
Janus.warn("Invalid PeerConnection");
|
|
return true;
|
|
}
|
|
if(!config.myStream) {
|
|
Janus.warn("Invalid local MediaStream");
|
|
return true;
|
|
}
|
|
if(video) {
|
|
// Check video track
|
|
if(!config.myStream.getVideoTracks() || config.myStream.getVideoTracks().length === 0) {
|
|
Janus.warn("No video track");
|
|
return true;
|
|
}
|
|
if(mid) {
|
|
let transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.mid === mid && t.receiver.track.kind === "video"));
|
|
if(!transceiver) {
|
|
Janus.warn("No video transceiver with mid " + mid);
|
|
return true;
|
|
}
|
|
if(!transceiver.sender || !transceiver.sender.track) {
|
|
Janus.warn("No video sender with mid " + mid);
|
|
return true;
|
|
}
|
|
return !transceiver.sender.track.enabled;
|
|
} else {
|
|
return !config.myStream.getVideoTracks()[0].enabled;
|
|
}
|
|
} else {
|
|
// Check audio track
|
|
if(!config.myStream.getAudioTracks() || config.myStream.getAudioTracks().length === 0) {
|
|
Janus.warn("No audio track");
|
|
return true;
|
|
}
|
|
if(mid) {
|
|
let transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.mid === mid && t.receiver.track.kind === "audio"));
|
|
if(!transceiver) {
|
|
Janus.warn("No audio transceiver with mid " + mid);
|
|
return true;
|
|
}
|
|
if(!transceiver.sender || !transceiver.sender.track) {
|
|
Janus.warn("No audio sender with mid " + mid);
|
|
return true;
|
|
}
|
|
return !transceiver.sender.track.enabled;
|
|
} else {
|
|
return !config.myStream.getAudioTracks()[0].enabled;
|
|
}
|
|
}
|
|
}
|
|
|
|
function mute(handleId, mid, video, mute) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
return false;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc) {
|
|
Janus.warn("Invalid PeerConnection");
|
|
return false;
|
|
}
|
|
if(!config.myStream) {
|
|
Janus.warn("Invalid local MediaStream");
|
|
return false;
|
|
}
|
|
if(video) {
|
|
// Mute/unmute video track
|
|
if(!config.myStream.getVideoTracks() || config.myStream.getVideoTracks().length === 0) {
|
|
Janus.warn("No video track");
|
|
return false;
|
|
}
|
|
if(mid) {
|
|
let transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.mid === mid && t.receiver.track.kind === "video"));
|
|
if(!transceiver) {
|
|
Janus.warn("No video transceiver with mid " + mid);
|
|
return false;
|
|
}
|
|
if(!transceiver.sender || !transceiver.sender.track) {
|
|
Janus.warn("No video sender with mid " + mid);
|
|
return false;
|
|
}
|
|
transceiver.sender.track.enabled = mute ? false : true;
|
|
} else {
|
|
for(const videostream of config.myStream.getVideoTracks()) {
|
|
videostream.enabled = !mute
|
|
}
|
|
}
|
|
} else {
|
|
// Mute/unmute audio track
|
|
if(!config.myStream.getAudioTracks() || config.myStream.getAudioTracks().length === 0) {
|
|
Janus.warn("No audio track");
|
|
return false;
|
|
}
|
|
if(mid) {
|
|
let transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.mid === mid && t.receiver.track.kind === "audio"));
|
|
if(!transceiver) {
|
|
Janus.warn("No audio transceiver with mid " + mid);
|
|
return false;
|
|
}
|
|
if(!transceiver.sender || !transceiver.sender.track) {
|
|
Janus.warn("No audio sender with mid " + mid);
|
|
return false;
|
|
}
|
|
transceiver.sender.track.enabled = mute ? false : true;
|
|
} else {
|
|
for(const audiostream of config.myStream.getAudioTracks()) {
|
|
audiostream.enabled = !mute
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function getBitrate(handleId, mid) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn("Invalid handle");
|
|
return "Invalid handle";
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc)
|
|
return "Invalid PeerConnection";
|
|
// Start getting the bitrate, if getStats is supported
|
|
if(config.pc.getStats) {
|
|
let query = config.pc;
|
|
let target = mid ? mid : "default";
|
|
if(mid) {
|
|
let transceiver = config.pc.getTransceivers()
|
|
.find(t => (t.mid === mid && t.receiver.track.kind === "video"));
|
|
if(!transceiver) {
|
|
Janus.warn("No video transceiver with mid " + mid);
|
|
return ("No video transceiver with mid " + mid);
|
|
}
|
|
if(!transceiver.receiver) {
|
|
Janus.warn("No video receiver with mid " + mid);
|
|
return ("No video receiver with mid " + mid);
|
|
}
|
|
query = transceiver.receiver;
|
|
}
|
|
if(!config.bitrate[target]) {
|
|
config.bitrate[target] = {
|
|
timer: null,
|
|
bsnow: null,
|
|
bsbefore: null,
|
|
tsnow: null,
|
|
tsbefore: null,
|
|
value: "0 kbits/sec"
|
|
};
|
|
}
|
|
if(!config.bitrate[target].timer) {
|
|
Janus.log("Starting bitrate timer" + (mid ? (" for mid " + mid) : "") + " (via getStats)");
|
|
config.bitrate[target].timer = setInterval(function() {
|
|
query.getStats()
|
|
.then(function(stats) {
|
|
stats.forEach(function (res) {
|
|
if(!res)
|
|
return;
|
|
let inStats = false;
|
|
// Check if these are statistics on incoming media
|
|
if((res.mediaType === "video" || res.id.toLowerCase().indexOf("video") > -1) &&
|
|
res.type === "inbound-rtp" && res.id.indexOf("rtcp") < 0) {
|
|
// New stats
|
|
inStats = true;
|
|
} else if(res.type == 'ssrc' && res.bytesReceived &&
|
|
(res.googCodecName === "VP8" || res.googCodecName === "")) {
|
|
// Older Chromer versions
|
|
inStats = true;
|
|
}
|
|
// Parse stats now
|
|
if(inStats) {
|
|
config.bitrate[target].bsnow = res.bytesReceived;
|
|
config.bitrate[target].tsnow = res.timestamp;
|
|
if(config.bitrate[target].bsbefore === null || config.bitrate[target].tsbefore === null) {
|
|
// Skip this round
|
|
config.bitrate[target].bsbefore = config.bitrate[target].bsnow;
|
|
config.bitrate[target].tsbefore = config.bitrate[target].tsnow;
|
|
} else {
|
|
// Calculate bitrate
|
|
let timePassed = config.bitrate[target].tsnow - config.bitrate[target].tsbefore;
|
|
if(Janus.webRTCAdapter.browserDetails.browser === "safari")
|
|
timePassed = timePassed/1000; // Apparently the timestamp is in microseconds, in Safari
|
|
let bitRate = Math.round((config.bitrate[target].bsnow - config.bitrate[target].bsbefore) * 8 / timePassed);
|
|
if(Janus.webRTCAdapter.browserDetails.browser === "safari")
|
|
bitRate = parseInt(bitRate/1000);
|
|
config.bitrate[target].value = bitRate + ' kbits/sec';
|
|
//~ Janus.log("Estimated bitrate is " + config.bitrate.value);
|
|
config.bitrate[target].bsbefore = config.bitrate[target].bsnow;
|
|
config.bitrate[target].tsbefore = config.bitrate[target].tsnow;
|
|
}
|
|
}
|
|
});
|
|
});
|
|
}, 1000);
|
|
return "0 kbits/sec"; // We don't have a bitrate value yet
|
|
}
|
|
return config.bitrate[target].value;
|
|
} else {
|
|
Janus.warn("Getting the video bitrate unsupported by browser");
|
|
return "Feature unsupported by browser";
|
|
}
|
|
}
|
|
|
|
function setBitrate(handleId, mid, bitrate) {
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle || !pluginHandle.webrtcStuff) {
|
|
Janus.warn('Invalid handle');
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(!config.pc) {
|
|
Janus.warn('Invalid PeerConnection');
|
|
return;
|
|
}
|
|
let transceiver = config.pc.getTransceivers().find(t => (t.mid === mid));
|
|
if(!transceiver) {
|
|
Janus.warn('No transceiver with mid', mid);
|
|
return;
|
|
}
|
|
if(!transceiver.sender) {
|
|
Janus.warn('No sender for transceiver with mid', mid);
|
|
return;
|
|
}
|
|
let params = transceiver.sender.getParameters();
|
|
if(!params || !params.encodings || params.encodings.length === 0) {
|
|
Janus.warn('No parameters encodings');
|
|
} else if(params.encodings.length > 1) {
|
|
Janus.warn('Ignoring bitrate for simulcast track, use sendEncodings for that');
|
|
} else if(isNaN(bitrate) || bitrate < 0) {
|
|
Janus.warn('Invalid bitrate (must be a positive integer)');
|
|
} else {
|
|
params.encodings[0].maxBitrate = bitrate;
|
|
transceiver.sender.setParameters(params);
|
|
}
|
|
}
|
|
|
|
function webrtcError(error) {
|
|
Janus.error("WebRTC error:", error);
|
|
}
|
|
|
|
function cleanupWebrtc(handleId, hangupRequest) {
|
|
Janus.log("Cleaning WebRTC stuff");
|
|
let pluginHandle = pluginHandles[handleId];
|
|
if(!pluginHandle) {
|
|
// Nothing to clean
|
|
return;
|
|
}
|
|
let config = pluginHandle.webrtcStuff;
|
|
if(config) {
|
|
if(hangupRequest === true) {
|
|
// Send a hangup request (we don't really care about the response)
|
|
let request = { "janus": "hangup", "transaction": Janus.randomString(12) };
|
|
if(pluginHandle.token)
|
|
request["token"] = pluginHandle.token;
|
|
if(apisecret)
|
|
request["apisecret"] = apisecret;
|
|
Janus.debug("Sending hangup request (handle=" + handleId + "):");
|
|
Janus.debug(request);
|
|
if(websockets) {
|
|
request["session_id"] = sessionId;
|
|
request["handle_id"] = handleId;
|
|
ws.send(JSON.stringify(request));
|
|
} else {
|
|
Janus.httpAPICall(server + "/" + sessionId + "/" + handleId, {
|
|
verb: 'POST',
|
|
withCredentials: withCredentials,
|
|
body: request
|
|
});
|
|
}
|
|
}
|
|
// Cleanup stack
|
|
if(config.volume) {
|
|
if(config.volume["local"] && config.volume["local"].timer)
|
|
clearInterval(config.volume["local"].timer);
|
|
if(config.volume["remote"] && config.volume["remote"].timer)
|
|
clearInterval(config.volume["remote"].timer);
|
|
}
|
|
for(let i in config.bitrate) {
|
|
if(config.bitrate[i].timer)
|
|
clearInterval(config.bitrate[i].timer);
|
|
}
|
|
config.bitrate = {};
|
|
if(!config.streamExternal && config.myStream) {
|
|
Janus.log("Stopping local stream tracks");
|
|
Janus.stopAllTracks(config.myStream);
|
|
}
|
|
config.streamExternal = false;
|
|
config.myStream = null;
|
|
// Close PeerConnection
|
|
try {
|
|
config.pc.close();
|
|
} catch(e) {
|
|
// Do nothing
|
|
}
|
|
config.pc = null;
|
|
config.candidates = null;
|
|
config.mySdp = null;
|
|
config.remoteSdp = null;
|
|
config.iceDone = false;
|
|
config.dataChannel = {};
|
|
config.dtmfSender = null;
|
|
config.insertableStreams = false;
|
|
}
|
|
pluginHandle.oncleanup();
|
|
}
|
|
|
|
function isTrickleEnabled(trickle) {
|
|
Janus.debug("isTrickleEnabled:", trickle);
|
|
return (trickle === false) ? false : true;
|
|
}
|
|
}
|