galerija-bot/janus.js

3161 lines
110 KiB
JavaScript
Raw Normal View History

"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;
}
}