summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--js/app/live-video.js44
-rw-r--r--js/lib/janus.nojquery.js2297
2 files changed, 2341 insertions, 0 deletions
diff --git a/js/app/live-video.js b/js/app/live-video.js
new file mode 100644
index 0000000..f39e801
--- /dev/null
+++ b/js/app/live-video.js
@@ -0,0 +1,44 @@
+var websocket_server = null;
+if(window.location.protocol === 'http:')
+ websocket_server = "ws://" + window.location.hostname + "/janus-ws";
+else
+ websocket_server = "wss://" + window.location.hostname + "/janus-ws";
+
+var janus = null;
+var streaming = null;
+
+Janus.init({callback: function() {
+ janus = new Janus(
+ {
+ server: [websocket_server, "/janus"],
+ iceServers: [{url: "turn:turn.homebase.dk", username: "myturn", credential: "notsecure"}],
+ ipv6: false,
+ success: function() {
+ janus.attach(
+ {
+ plugin: "janus.plugin.streaming",
+ opaqueId: "streaming-"+Janus.randomString(12),
+ success: function(pluginHandle) {
+ streaming = pluginHandle;
+ streaming.send({"message": { "request": "watch", id: 1}});
+ },
+ onmessage: function(msg, jsep) {
+ if(jsep !== undefined && jsep !== null) {
+ streaming.createAnswer(
+ {
+ jsep: jsep,
+ media: { audioSend: false, videoSend: false },
+ success: function(jsep) {
+ var body = { "request": "start" };
+ streaming.send({"message": body, "jsep": jsep});
+ },
+ });
+ }
+ },
+ onremotestream: function(stream) {
+ Janus.attachMediaStream(document.getElementById('live-video'), stream);
+ },
+ });
+ },
+ });
+}});
diff --git a/js/lib/janus.nojquery.js b/js/lib/janus.nojquery.js
new file mode 100644
index 0000000..0dfce72
--- /dev/null
+++ b/js/lib/janus.nojquery.js
@@ -0,0 +1,2297 @@
+/*
+ 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 = {};
+
+// Screensharing Chrome Extension ID
+Janus.extensionId = "hapfgfdkleiggjjpfpenajgdnfckjpaj";
+Janus.isExtensionEnabled = function() {
+ if(window.navigator.userAgent.match('Chrome')) {
+ var chromever = parseInt(window.navigator.userAgent.match(/Chrome\/(.*) /)[1], 10);
+ var 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 (document.getElementById('janus-extension-installed') !== null);
+ } else {
+ // Firefox of others, no need for the extension (but this doesn't mean it will work)
+ return true;
+ }
+};
+
+Janus.noop = function() {};
+
+// Initialization
+Janus.init = function(options) {
+ options = options || {};
+ options.callback = (typeof options.callback == "function") ? options.callback : Janus.noop;
+ if(Janus.initDone === true) {
+ // Already initialized
+ options.callback();
+ } else {
+ if(typeof console == "undefined" || 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(var i in options.debug) {
+ var d = options.debug[i];
+ 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");
+ // Helper method to enumerate devices
+ Janus.listDevices = function(callback) {
+ callback = (typeof callback == "function") ? callback : Janus.noop;
+ if(navigator.mediaDevices) {
+ navigator.mediaDevices.getUserMedia({ audio: true, video: true })
+ .then(function(stream) {
+ navigator.mediaDevices.enumerateDevices().then(function(devices) {
+ Janus.debug(devices);
+ callback(devices);
+ // Get rid of the now useless stream
+ try {
+ stream.stop();
+ } catch(e) {}
+ try {
+ var tracks = stream.getTracks();
+ for(var i in tracks) {
+ var mst = tracks[i];
+ if(mst !== null && mst !== undefined)
+ mst.stop();
+ }
+ } catch(e) {}
+ });
+ })
+ .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) {
+ if(adapter.browserDetails.browser === 'chrome') {
+ var chromever = adapter.browserDetails.version;
+ if(chromever >= 43) {
+ element.srcObject = stream;
+ } else if(typeof element.src !== 'undefined') {
+ element.src = URL.createObjectURL(stream);
+ } else {
+ Janus.error("Error attaching stream to element");
+ }
+ } else {
+ element.srcObject = stream;
+ }
+ };
+ Janus.reattachMediaStream = function(to, from) {
+ if(adapter.browserDetails.browser === 'chrome') {
+ var chromever = adapter.browserDetails.version;
+ if(chromever >= 43) {
+ to.srcObject = from.srcObject;
+ } else if(typeof to.src !== 'undefined') {
+ to.src = from.src;
+ }
+ } else {
+ to.srcObject = from.srcObject;
+ }
+ };
+ // Prepare a helper method to send AJAX requests in a syntax similar to jQuery (at least for what we care)
+ Janus.ajax = function(params) {
+ // Check params
+ if(params === null || params === undefined)
+ return;
+ params.success = (typeof params.success == "function") ? params.success : Janus.noop;
+ params.error = (typeof params.error == "function") ? params.error : Janus.noop;
+ // Make sure there's an URL
+ if(params.url === null || params.url === undefined) {
+ Janus.error('Missing url', params.url);
+ params.error(null, -1, 'Missing url');
+ return;
+ }
+ // Validate async
+ params.async = (params.async === null || params.async === undefined) ? true : (params.async === true);
+ Janus.log(params);
+ // IE doesn't even know what WebRTC is, so no polyfill needed
+ var XHR = new XMLHttpRequest();
+ XHR.open(params.type, params.url, params.async);
+ if(params.contentType !== null && params.contentType !== undefined)
+ XHR.setRequestHeader('Content-type', params.contentType);
+ if(params.withCredentials !== null && params.withCredentials !== undefined)
+ XHR.withCredentials = params.withCredentials;
+ if(params.async) {
+ XHR.onreadystatechange = function () {
+ if(XHR.readyState != 4)
+ return;
+ if(XHR.status !== 200) {
+ // Got an error?
+ params.error(XHR, XHR.status !== 0 ? XHR.status : 'error', "");
+ return;
+ }
+ // Got payload
+ params.success(JSON.parse(XHR.responseText));
+ };
+ }
+ try {
+ XHR.send(params.data);
+ if(!params.async) {
+ if(XHR.status !== 200) {
+ // Got an error?
+ params.error(XHR, XHR.status !== 0 ? XHR.status : 'error', "");
+ return;
+ }
+ // Got payload
+ params.success(JSON.parse(XHR.responseText));
+ }
+ } catch(e) {
+ // Something broke up
+ params.error(XHR, 'error', '');
+ };
+ };
+ // Detect tab close: make sure we don't loose existing onbeforeunload handlers
+ var oldOBF = window.onbeforeunload;
+ window.onbeforeunload = function() {
+ Janus.log("Closing window");
+ for(var s in Janus.sessions) {
+ if(Janus.sessions[s] !== null && Janus.sessions[s] !== undefined &&
+ Janus.sessions[s].destroyOnUnload) {
+ Janus.log("Destroying session " + s);
+ Janus.sessions[s].destroy({asyncRequest: false});
+ }
+ }
+ if(oldOBF && typeof oldOBF == "function")
+ oldOBF();
+ }
+ function addJsList(srcArray) {
+ if (!srcArray || !Array.isArray(srcArray) || srcArray.length == 0) {
+ options.callback();
+ }
+ var count = 0;
+ addJs(srcArray[count],next);
+
+ function next() {
+ count++;
+ if (count<srcArray.length) {
+ addJs(srcArray[count],next);
+ }
+ else {
+ options.callback();
+ }
+ }
+ }
+ function addJs(src,done) {
+ try {
+ if(adapter) {
+ // Already loaded
+ Janus.debug(src + " already loaded, skipping");
+ done();
+ return;
+ }
+ } catch(e) {};
+ var oHead = document.getElementsByTagName('head').item(0);
+ var oScript = document.createElement("script");
+ oScript.type = "text/javascript";
+ oScript.src = src;
+ oScript.onload = function() {
+ Janus.log("Library " + src + " loaded");
+ done();
+ }
+ oHead.appendChild(oScript);
+ }
+ Janus.initDone = true;
+ addJsList(["adapter.js"]); // We may need others in the future
+ }
+};
+
+// Helper method to check whether WebRTC is supported by this browser
+Janus.isWebrtcSupported = function() {
+ return window.RTCPeerConnection !== undefined && window.RTCPeerConnection !== null &&
+ navigator.getUserMedia !== undefined && navigator.getUserMedia !== null;
+};
+
+// Helper method to create random identifiers (e.g., transaction)
+Janus.randomString = function(len) {
+ var charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+ var randomString = '';
+ for (var i = 0; i < len; i++) {
+ var randomPoz = Math.floor(Math.random() * charSet.length);
+ randomString += charSet.substring(randomPoz,randomPoz+1);
+ }
+ return randomString;
+}
+
+
+// Janus session object
+function Janus(gatewayCallbacks) {
+ if(Janus.initDone === undefined) {
+ gatewayCallbacks.error("Library not initialized");
+ return {};
+ }
+ if(!Janus.isWebrtcSupported()) {
+ gatewayCallbacks.error("WebRTC not supported by this browser");
+ return {};
+ }
+ Janus.log("Library initialized: " + Janus.initDone);
+ 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(gatewayCallbacks.server === null || gatewayCallbacks.server === undefined) {
+ gatewayCallbacks.error("Invalid gateway url");
+ return {};
+ }
+ var websockets = false;
+ var ws = null;
+ var wsHandlers = {};
+ var wsKeepaliveTimeoutId = null;
+
+ var servers = null, serversIndex = 0;
+ var server = gatewayCallbacks.server;
+ if(Array.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);
+ }
+ }
+ var iceServers = gatewayCallbacks.iceServers;
+ if(iceServers === undefined || iceServers === null)
+ iceServers = [{urls: "stun:stun.l.google.com:19302"}];
+ var iceTransportPolicy = gatewayCallbacks.iceTransportPolicy;
+ // Whether IPv6 candidates should be gathered
+ var ipv6Support = gatewayCallbacks.ipv6;
+ if(ipv6Support === undefined || ipv6Support === null)
+ ipv6Support = false;
+ // Whether we should enable the withCredentials flag for XHR requests
+ var withCredentials = false;
+ if(gatewayCallbacks.withCredentials !== undefined && gatewayCallbacks.withCredentials !== null)
+ withCredentials = gatewayCallbacks.withCredentials === true;
+ // Optional max events
+ var maxev = null;
+ if(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)
+ var token = null;
+ if(gatewayCallbacks.token !== undefined && gatewayCallbacks.token !== null)
+ token = gatewayCallbacks.token;
+ // API secret to use (only if the shared API secret is enabled)
+ var apisecret = null;
+ if(gatewayCallbacks.apisecret !== undefined && gatewayCallbacks.apisecret !== null)
+ apisecret = gatewayCallbacks.apisecret;
+ // Whether we should destroy this session when onbeforeunload is called
+ this.destroyOnUnload = true;
+ if(gatewayCallbacks.destroyOnUnload !== undefined && gatewayCallbacks.destroyOnUnload !== null)
+ this.destroyOnUnload = (gatewayCallbacks.destroyOnUnload === true);
+
+ var connected = false;
+ var sessionId = null;
+ var pluginHandles = {};
+ var that = this;
+ var retries = 0;
+ var transactions = {};
+ createSession(gatewayCallbacks);
+
+ // Public methods
+ this.getServer = function() { return server; };
+ this.isConnected = function() { return connected; };
+ this.getSessionId = function() { return sessionId; };
+ this.destroy = function(callbacks) { destroySession(callbacks, true); };
+ this.attach = function(callbacks) { createHandle(callbacks); };
+
+ function eventHandler() {
+ if(sessionId == null)
+ return;
+ Janus.debug('Long poll...');
+ if(!connected) {
+ Janus.warn("Is the gateway down? (connected=false)");
+ return;
+ }
+ var longpoll = server + "/" + sessionId + "?rid=" + new Date().getTime();
+ if(maxev !== undefined && maxev !== null)
+ longpoll = longpoll + "&maxev=" + maxev;
+ if(token !== null && token !== undefined)
+ longpoll = longpoll + "&token=" + token;
+ if(apisecret !== null && apisecret !== undefined)
+ longpoll = longpoll + "&apisecret=" + apisecret;
+ Janus.ajax({
+ type: 'GET',
+ url: longpoll,
+ withCredentials: withCredentials,
+ cache: false,
+ timeout: 60000, // FIXME
+ success: handleEvent,
+ error: function(XMLHttpRequest, textStatus, errorThrown) {
+ Janus.error(textStatus + ": " + errorThrown);
+ retries++;
+ if(retries > 3) {
+ // Did we just lose the gateway? :-(
+ connected = false;
+ gatewayCallbacks.error("Lost connection to the gateway (is it down?)");
+ return;
+ }
+ eventHandler();
+ },
+ dataType: "json"
+ });
+ }
+
+ // Private event handler: this will trigger plugin callbacks, if set
+ function handleEvent(json) {
+ retries = 0;
+ if(!websockets && sessionId !== undefined && sessionId !== null)
+ setTimeout(eventHandler, 200);
+ if(!websockets && Array.isArray(json)) {
+ // We got an array: it means we passed a maxev > 1, iterate on all objects
+ for(var i=0; i<json.length; i++) {
+ handleEvent(json[i]);
+ }
+ return;
+ }
+ if(json["janus"] === "keepalive") {
+ // Nothing happened
+ Janus.vdebug("Got a keepalive on session " + sessionId);
+ return;
+ } else if(json["janus"] === "ack") {
+ // Just an ack, we can probably ignore
+ Janus.debug("Got an ack on session " + sessionId);
+ Janus.debug(json);
+ var transaction = json["transaction"];
+ if(transaction !== null && transaction !== undefined) {
+ var reportSuccess = transactions[transaction];
+ if(reportSuccess !== null && reportSuccess !== undefined) {
+ reportSuccess(json);
+ }
+ delete transactions[transaction];
+ }
+ return;
+ } else if(json["janus"] === "success") {
+ // Success!
+ Janus.debug("Got a success on session " + sessionId);
+ Janus.debug(json);
+ var transaction = json["transaction"];
+ if(transaction !== null && transaction !== undefined) {
+ var reportSuccess = transactions[transaction];
+ if(reportSuccess !== null && reportSuccess !== undefined) {
+ reportSuccess(json);
+ }
+ delete transactions[transaction];
+ }
+ return;
+ } else if(json["janus"] === "webrtcup") {
+ // The PeerConnection with the gateway is up! Notify this
+ Janus.debug("Got a webrtcup event on session " + sessionId);
+ Janus.debug(json);
+ var sender = json["sender"];
+ if(sender === undefined || sender === null) {
+ Janus.warn("Missing sender...");
+ return;
+ }
+ var pluginHandle = pluginHandles[sender];
+ if(pluginHandle === undefined || pluginHandle === null) {
+ Janus.warn("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);
+ var sender = json["sender"];
+ if(sender === undefined || sender === null) {
+ Janus.warn("Missing sender...");
+ return;
+ }
+ var pluginHandle = pluginHandles[sender];
+ if(pluginHandle === undefined || pluginHandle === null) {
+ Janus.warn("This handle is not attached to this session");
+ return;
+ }
+ pluginHandle.webrtcState(false);
+ 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);
+ var sender = json["sender"];
+ if(sender === undefined || sender === null) {
+ Janus.warn("Missing sender...");
+ return;
+ }
+ var pluginHandle = pluginHandles[sender];
+ if(pluginHandle === undefined || pluginHandle === null) {
+ // 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);
+ var sender = json["sender"];
+ if(sender === undefined || sender === null) {
+ Janus.warn("Missing sender...");
+ return;
+ }
+ var pluginHandle = pluginHandles[sender];
+ if(pluginHandle === undefined || pluginHandle === null) {
+ Janus.warn("This handle is not attached to this session");
+ return;
+ }
+ pluginHandle.mediaState(json["type"], json["receiving"]);
+ } else if(json["janus"] === "slowlink") {
+ Janus.debug("Got a slowlink event on session " + sessionId);
+ Janus.debug(json);
+ // Trouble uplink or downlink
+ var sender = json["sender"];
+ if(sender === undefined || sender === null) {
+ Janus.warn("Missing sender...");
+ return;
+ }
+ var pluginHandle = pluginHandles[sender];
+ if(pluginHandle === undefined || pluginHandle === null) {
+ Janus.warn("This handle is not attached to this session");
+ return;
+ }
+ pluginHandle.slowLink(json["uplink"], json["nacks"]);
+ } else if(json["janus"] === "error") {
+ // Oops, something wrong happened
+ Janus.error("Ooops: " + json["error"].code + " " + json["error"].reason); // FIXME
+ Janus.debug(json);
+ var transaction = json["transaction"];
+ if(transaction !== null && transaction !== undefined) {
+ var reportSuccess = transactions[transaction];
+ if(reportSuccess !== null && reportSuccess !== undefined) {
+ reportSuccess(json);
+ }
+ delete transactions[transaction];
+ }
+ return;
+ } else if(json["janus"] === "event") {
+ Janus.debug("Got a plugin event on session " + sessionId);
+ Janus.debug(json);
+ var sender = json["sender"];
+ if(sender === undefined || sender === null) {
+ Janus.warn("Missing sender...");
+ return;
+ }
+ var plugindata = json["plugindata"];
+ if(plugindata === undefined || plugindata === null) {
+ Janus.warn("Missing plugindata...");
+ return;
+ }
+ Janus.debug(" -- Event is coming from " + sender + " (" + plugindata["plugin"] + ")");
+ var data = plugindata["data"];
+ Janus.debug(data);
+ var pluginHandle = pluginHandles[sender];
+ if(pluginHandle === undefined || pluginHandle === null) {
+ Janus.warn("This handle is not attached to this session");
+ return;
+ }
+ var jsep = json["jsep"];
+ if(jsep !== undefined && jsep !== null) {
+ Janus.debug("Handling SDP as well...");
+ Janus.debug(jsep);
+ }
+ var callback = pluginHandle.onmessage;
+ if(callback !== null && callback !== undefined) {
+ 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 {
+ Janus.warn("Unkown message/event '" + json["janus"] + "' on session " + sessionId);
+ Janus.debug(json);
+ }
+ }
+
+ // Private helper to send keep-alive messages on WebSockets
+ function keepAlive() {
+ if(server === null || !websockets || !connected)
+ return;
+ wsKeepaliveTimeoutId = setTimeout(keepAlive, 30000);
+ var request = { "janus": "keepalive", "session_id": sessionId, "transaction": Janus.randomString(12) };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ request["apisecret"] = apisecret;
+ ws.send(JSON.stringify(request));
+ }
+
+ // Private method to create a session
+ function createSession(callbacks) {
+ var transaction = Janus.randomString(12);
+ var request = { "janus": "create", "transaction": transaction };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ request["apisecret"] = apisecret;
+ if(server === null && Array.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 = new WebSocket(server, 'janus-protocol');
+ wsHandlers = {
+ 'error': function() {
+ Janus.error("Error connecting to the Janus WebSockets server... " + server);
+ if (Array.isArray(servers)) {
+ 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 gateway 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 gateway 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, 30000);
+ connected = true;
+ sessionId = json.data["id"];
+ 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 === null || !connected) {
+ return;
+ }
+ connected = false;
+ // FIXME What if this is called when the page is closed?
+ gatewayCallbacks.error("Lost connection to the gateway (is it down?)");
+ }
+ };
+
+ for(var eventName in wsHandlers) {
+ ws.addEventListener(eventName, wsHandlers[eventName]);
+ }
+
+ return;
+ }
+ Janus.ajax({
+ type: 'POST',
+ url: server,
+ withCredentials: withCredentials,
+ cache: false,
+ contentType: "application/json",
+ data: JSON.stringify(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.data["id"];
+ Janus.log("Created session: " + sessionId);
+ Janus.sessions[sessionId] = that;
+ eventHandler();
+ callbacks.success();
+ },
+ error: function(XMLHttpRequest, textStatus, errorThrown) {
+ Janus.error(textStatus + ": " + errorThrown); // FIXME
+ if(Array.isArray(servers)) {
+ 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 gateway down?");
+ return;
+ }
+ // Let's try the next server
+ server = null;
+ setTimeout(function() { createSession(callbacks); }, 200);
+ return;
+ }
+ if(errorThrown === "")
+ callbacks.error(textStatus + ": Is the gateway down?");
+ else
+ callbacks.error(textStatus + ": " + errorThrown);
+ },
+ dataType: "json"
+ });
+ }
+
+ // 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;
+ var asyncRequest = true;
+ if(callbacks.asyncRequest !== undefined && callbacks.asyncRequest !== null)
+ asyncRequest = (callbacks.asyncRequest === true);
+ Janus.log("Destroying session " + sessionId + " (async=" + asyncRequest + ")");
+ if(!connected) {
+ Janus.warn("Is the gateway down? (connected=false)");
+ callbacks.success();
+ return;
+ }
+ if(sessionId === undefined || sessionId === null) {
+ Janus.warn("No session to destroy");
+ callbacks.success();
+ gatewayCallbacks.destroyed();
+ return;
+ }
+ delete Janus.sessions[sessionId];
+ // Destroy all handles first
+ for(var ph in pluginHandles) {
+ var phv = pluginHandles[ph];
+ Janus.log("Destroying handle " + phv.id + " (" + phv.plugin + ")");
+ destroyHandle(phv.id, {asyncRequest: asyncRequest});
+ }
+ // Ok, go on
+ var request = { "janus": "destroy", "transaction": Janus.randomString(12) };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ request["apisecret"] = apisecret;
+ if(websockets) {
+ request["session_id"] = sessionId;
+
+ var unbindWebSocket = function() {
+ for(var eventName in wsHandlers) {
+ ws.removeEventListener(eventName, wsHandlers[eventName]);
+ }
+ ws.removeEventListener('message', onUnbindMessage);
+ ws.removeEventListener('error', onUnbindError);
+ if(wsKeepaliveTimeoutId) {
+ clearTimeout(wsKeepaliveTimeoutId);
+ }
+ };
+
+ var onUnbindMessage = function(event){
+ var data = JSON.parse(event.data);
+ if(data.session_id == request.session_id && data.transaction == request.transaction) {
+ unbindWebSocket();
+ callbacks.success();
+ gatewayCallbacks.destroyed();
+ }
+ };
+ var onUnbindError = function(event) {
+ unbindWebSocket();
+ callbacks.error("Failed to destroy the gateway: Is the gateway down?");
+ gatewayCallbacks.destroyed();
+ };
+
+ ws.addEventListener('message', onUnbindMessage);
+ ws.addEventListener('error', onUnbindError);
+
+ ws.send(JSON.stringify(request));
+ return;
+ }
+ Janus.ajax({
+ type: 'POST',
+ url: server + "/" + sessionId,
+ async: asyncRequest, // Sometimes we need false here, or destroying in onbeforeunload won't work
+ withCredentials: withCredentials,
+ cache: false,
+ contentType: "application/json",
+ data: JSON.stringify(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();
+ gatewayCallbacks.destroyed();
+ },
+ error: function(XMLHttpRequest, textStatus, errorThrown) {
+ Janus.error(textStatus + ": " + errorThrown); // FIXME
+ // Reset everything anyway
+ sessionId = null;
+ connected = false;
+ callbacks.success();
+ gatewayCallbacks.destroyed();
+ },
+ dataType: "json"
+ });
+ }
+
+ // 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.consentDialog = (typeof callbacks.consentDialog == "function") ? callbacks.consentDialog : 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.onlocalstream = (typeof callbacks.onlocalstream == "function") ? callbacks.onlocalstream : Janus.noop;
+ callbacks.onremotestream = (typeof callbacks.onremotestream == "function") ? callbacks.onremotestream : 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 gateway down? (connected=false)");
+ callbacks.error("Is the gateway down? (connected=false)");
+ return;
+ }
+ var plugin = callbacks.plugin;
+ if(plugin === undefined || plugin === null) {
+ Janus.error("Invalid plugin");
+ callbacks.error("Invalid plugin");
+ return;
+ }
+ var opaqueId = callbacks.opaqueId;
+ var transaction = Janus.randomString(12);
+ var request = { "janus": "attach", "plugin": plugin, "opaque_id": opaqueId, "transaction": transaction };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ 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;
+ }
+ var handleId = json.data["id"];
+ Janus.log("Created handle: " + handleId);
+ var pluginHandle =
+ {
+ session : that,
+ plugin : plugin,
+ id : handleId,
+ webrtcStuff : {
+ started : false,
+ myStream : null,
+ streamExternal : false,
+ remoteStream : null,
+ mySdp : null,
+ pc : null,
+ dataChannel : null,
+ dtmfSender : null,
+ trickle : true,
+ iceDone : false,
+ sdpSent : false,
+ volume : {
+ value : null,
+ timer : null
+ },
+ bitrate : {
+ value : null,
+ bsnow : null,
+ bsbefore : null,
+ tsnow : null,
+ tsbefore : null,
+ timer : null
+ }
+ },
+ getId : function() { return handleId; },
+ getPlugin : function() { return plugin; },
+ getVolume : function() { return getVolume(handleId); },
+ isAudioMuted : function() { return isMuted(handleId, false); },
+ muteAudio : function() { return mute(handleId, false, true); },
+ unmuteAudio : function() { return mute(handleId, false, false); },
+ isVideoMuted : function() { return isMuted(handleId, true); },
+ muteVideo : function() { return mute(handleId, true, true); },
+ unmuteVideo : function() { return mute(handleId, true, false); },
+ getBitrate : function() { return getBitrate(handleId); },
+ send : function(callbacks) { sendMessage(handleId, callbacks); },
+ data : function(callbacks) { sendData(handleId, callbacks); },
+ dtmf : function(callbacks) { sendDtmf(handleId, callbacks); },
+ consentDialog : callbacks.consentDialog,
+ mediaState : callbacks.mediaState,
+ webrtcState : callbacks.webrtcState,
+ slowLink : callbacks.slowLink,
+ onmessage : callbacks.onmessage,
+ createOffer : function(callbacks) { prepareWebrtc(handleId, callbacks); },
+ createAnswer : function(callbacks) { prepareWebrtc(handleId, callbacks); },
+ handleRemoteJsep : function(callbacks) { prepareWebrtcPeer(handleId, callbacks); },
+ onlocalstream : callbacks.onlocalstream,
+ onremotestream : callbacks.onremotestream,
+ 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.ajax({
+ type: 'POST',
+ url: server + "/" + sessionId,
+ withCredentials: withCredentials,
+ cache: false,
+ contentType: "application/json",
+ data: JSON.stringify(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;
+ }
+ var handleId = json.data["id"];
+ Janus.log("Created handle: " + handleId);
+ var pluginHandle =
+ {
+ session : that,
+ plugin : plugin,
+ id : handleId,
+ webrtcStuff : {
+ started : false,
+ myStream : null,
+ streamExternal : false,
+ remoteStream : null,
+ mySdp : null,
+ pc : null,
+ dataChannel : null,
+ dtmfSender : null,
+ trickle : true,
+ iceDone : false,
+ sdpSent : false,
+ volume : {
+ value : null,
+ timer : null
+ },
+ bitrate : {
+ value : null,
+ bsnow : null,
+ bsbefore : null,
+ tsnow : null,
+ tsbefore : null,
+ timer : null
+ }
+ },
+ getId : function() { return handleId; },
+ getPlugin : function() { return plugin; },
+ getVolume : function() { return getVolume(handleId); },
+ isAudioMuted : function() { return isMuted(handleId, false); },
+ muteAudio : function() { return mute(handleId, false, true); },
+ unmuteAudio : function() { return mute(handleId, false, false); },
+ isVideoMuted : function() { return isMuted(handleId, true); },
+ muteVideo : function() { return mute(handleId, true, true); },
+ unmuteVideo : function() { return mute(handleId, true, false); },
+ getBitrate : function() { return getBitrate(handleId); },
+ send : function(callbacks) { sendMessage(handleId, callbacks); },
+ data : function(callbacks) { sendData(handleId, callbacks); },
+ dtmf : function(callbacks) { sendDtmf(handleId, callbacks); },
+ consentDialog : callbacks.consentDialog,
+ mediaState : callbacks.mediaState,
+ webrtcState : callbacks.webrtcState,
+ slowLink : callbacks.slowLink,
+ onmessage : callbacks.onmessage,
+ createOffer : function(callbacks) { prepareWebrtc(handleId, callbacks); },
+ createAnswer : function(callbacks) { prepareWebrtc(handleId, callbacks); },
+ handleRemoteJsep : function(callbacks) { prepareWebrtcPeer(handleId, callbacks); },
+ onlocalstream : callbacks.onlocalstream,
+ onremotestream : callbacks.onremotestream,
+ 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(XMLHttpRequest, textStatus, errorThrown) {
+ Janus.error(textStatus + ": " + errorThrown); // FIXME
+ },
+ dataType: "json"
+ });
+ }
+
+ // 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 gateway down? (connected=false)");
+ callbacks.error("Is the gateway down? (connected=false)");
+ return;
+ }
+ var message = callbacks.message;
+ var jsep = callbacks.jsep;
+ var transaction = Janus.randomString(12);
+ var request = { "janus": "message", "body": message, "transaction": transaction };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ request["apisecret"] = apisecret;
+ if(jsep !== null && jsep !== undefined)
+ request.jsep = jsep;
+ 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
+ var plugindata = json["plugindata"];
+ if(plugindata === undefined || plugindata === null) {
+ Janus.warn("Request succeeded, but missing plugindata...");
+ callbacks.success();
+ return;
+ }
+ Janus.log("Synchronous transaction successful (" + plugindata["plugin"] + ")");
+ var 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"] !== undefined && json["error"] !== null) {
+ 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.ajax({
+ type: 'POST',
+ url: server + "/" + sessionId + "/" + handleId,
+ withCredentials: withCredentials,
+ cache: false,
+ contentType: "application/json",
+ data: JSON.stringify(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
+ var plugindata = json["plugindata"];
+ if(plugindata === undefined || plugindata === null) {
+ Janus.warn("Request succeeded, but missing plugindata...");
+ callbacks.success();
+ return;
+ }
+ Janus.log("Synchronous transaction successful (" + plugindata["plugin"] + ")");
+ var 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"] !== undefined && json["error"] !== null) {
+ 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(XMLHttpRequest, textStatus, errorThrown) {
+ Janus.error(textStatus + ": " + errorThrown); // FIXME
+ callbacks.error(textStatus + ": " + errorThrown);
+ },
+ dataType: "json"
+ });
+ }
+
+ // Private method to send a trickle candidate
+ function sendTrickleCandidate(handleId, candidate) {
+ if(!connected) {
+ Janus.warn("Is the gateway down? (connected=false)");
+ return;
+ }
+ var request = { "janus": "trickle", "candidate": candidate, "transaction": Janus.randomString(12) };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ 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.ajax({
+ type: 'POST',
+ url: server + "/" + sessionId + "/" + handleId,
+ withCredentials: withCredentials,
+ cache: false,
+ contentType: "application/json",
+ data: JSON.stringify(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(XMLHttpRequest, textStatus, errorThrown) {
+ Janus.error(textStatus + ": " + errorThrown); // FIXME
+ },
+ dataType: "json"
+ });
+ }
+
+ // 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;
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ callbacks.error("Invalid handle");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ var text = callbacks.text;
+ if(text === null || text === undefined) {
+ Janus.warn("Invalid text");
+ callbacks.error("Invalid text");
+ return;
+ }
+ Janus.log("Sending string on data channel: " + text);
+ config.dataChannel.send(text);
+ 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;
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ callbacks.error("Invalid handle");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ if(config.dtmfSender === null || config.dtmfSender === undefined) {
+ // Create the DTMF sender, if possible
+ if(config.myStream !== undefined && config.myStream !== null) {
+ var tracks = config.myStream.getAudioTracks();
+ if(tracks !== null && tracks !== undefined && tracks.length > 0) {
+ var local_audio_track = tracks[0];
+ config.dtmfSender = config.pc.createDTMFSender(local_audio_track);
+ Janus.log("Created DTMF Sender");
+ config.dtmfSender.ontonechange = function(tone) { Janus.debug("Sent DTMF tone: " + tone.tone); };
+ }
+ }
+ if(config.dtmfSender === null || config.dtmfSender === undefined) {
+ Janus.warn("Invalid DTMF configuration");
+ callbacks.error("Invalid DTMF configuration");
+ return;
+ }
+ }
+ var dtmf = callbacks.dtmf;
+ if(dtmf === null || dtmf === undefined) {
+ Janus.warn("Invalid DTMF parameters");
+ callbacks.error("Invalid DTMF parameters");
+ return;
+ }
+ var tones = dtmf.tones;
+ if(tones === null || tones === undefined) {
+ Janus.warn("Invalid DTMF string");
+ callbacks.error("Invalid DTMF string");
+ return;
+ }
+ var duration = dtmf.duration;
+ if(duration === null || duration === undefined)
+ duration = 500; // We choose 500ms as the default duration for a tone
+ var gap = dtmf.gap;
+ if(gap === null || gap === undefined)
+ 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);
+ }
+
+ // 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;
+ var asyncRequest = true;
+ if(callbacks.asyncRequest !== undefined && callbacks.asyncRequest !== null)
+ asyncRequest = (callbacks.asyncRequest === true);
+ Janus.log("Destroying handle " + handleId + " (sync=" + asyncRequest + ")");
+ cleanupWebrtc(handleId);
+ if(!connected) {
+ Janus.warn("Is the gateway down? (connected=false)");
+ callbacks.error("Is the gateway down? (connected=false)");
+ return;
+ }
+ var request = { "janus": "detach", "transaction": Janus.randomString(12) };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ 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.ajax({
+ type: 'POST',
+ url: server + "/" + sessionId + "/" + handleId,
+ async: asyncRequest, // Sometimes we need false here, or destroying in onbeforeunload won't work
+ withCredentials: withCredentials,
+ cache: false,
+ contentType: "application/json",
+ data: JSON.stringify(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(XMLHttpRequest, textStatus, errorThrown) {
+ Janus.error(textStatus + ": " + errorThrown); // FIXME
+ // We cleanup anyway
+ delete pluginHandles[handleId];
+ callbacks.success();
+ },
+ dataType: "json"
+ });
+ }
+
+ // WebRTC stuff
+ function streamsDone(handleId, jsep, media, callbacks, stream) {
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ callbacks.error("Invalid handle");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ Janus.debug("streamsDone:", stream);
+ config.myStream = stream;
+ var pc_config = {"iceServers": iceServers, "iceTransportPolicy": iceTransportPolicy};
+ //~ var pc_constraints = {'mandatory': {'MozDontOfferDataChannel':true}};
+ var pc_constraints = {
+ "optional": [{"DtlsSrtpKeyAgreement": true}]
+ };
+ if(ipv6Support === true) {
+ // FIXME This is only supported in Chrome right now
+ // For support in Firefox track this: https://bugzilla.mozilla.org/show_bug.cgi?id=797262
+ pc_constraints.optional.push({"googIPv6":true});
+ }
+ if(adapter.browserDetails.browser === "edge") {
+ // This is Edge, enable BUNDLE explicitly
+ pc_config.bundlePolicy = "max-bundle";
+ }
+ Janus.log("Creating PeerConnection");
+ Janus.debug(pc_constraints);
+ config.pc = new RTCPeerConnection(pc_config, pc_constraints);
+ Janus.debug(config.pc);
+ if(config.pc.getStats) { // FIXME
+ config.volume.value = 0;
+ config.bitrate.value = "0 kbits/sec";
+ }
+ Janus.log("Preparing local SDP and gathering candidates (trickle=" + config.trickle + ")");
+ config.pc.onicecandidate = function(event) {
+ if (event.candidate == null ||
+ (adapter.browserDetails.browser === 'edge' && 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
+ var candidate = {
+ "candidate": event.candidate.candidate,
+ "sdpMid": event.candidate.sdpMid,
+ "sdpMLineIndex": event.candidate.sdpMLineIndex
+ };
+ if(config.trickle === true) {
+ // Send candidate
+ sendTrickleCandidate(handleId, candidate);
+ }
+ }
+ };
+ if(stream !== null && stream !== undefined) {
+ Janus.log('Adding local stream');
+ config.pc.addStream(stream);
+ pluginHandle.onlocalstream(stream);
+ }
+ config.pc.onaddstream = function(remoteStream) {
+ Janus.log("Handling Remote Stream");
+ Janus.debug(remoteStream);
+ config.remoteStream = remoteStream;
+ pluginHandle.onremotestream(remoteStream.stream);
+ };
+ // Any data channel to create?
+ if(isDataEnabled(media)) {
+ Janus.log("Creating data channel");
+ var onDataChannelMessage = function(event) {
+ Janus.log('Received message on data channel: ' + event.data);
+ pluginHandle.ondata(event.data); // FIXME
+ }
+ var onDataChannelStateChange = function() {
+ var dcState = config.dataChannel !== null ? config.dataChannel.readyState : "null";
+ Janus.log('State change on data channel: ' + dcState);
+ if(dcState === 'open') {
+ pluginHandle.ondataopen(); // FIXME
+ }
+ }
+ var onDataChannelError = function(error) {
+ Janus.error('Got error on data channel:', error);
+ // TODO
+ }
+ // Until we implement the proxying of open requests within the Janus core, we open a channel ourselves whatever the case
+ config.dataChannel = config.pc.createDataChannel("JanusDataChannel", {ordered:false}); // FIXME Add options (ordered, maxRetransmits, etc.)
+ config.dataChannel.onmessage = onDataChannelMessage;
+ config.dataChannel.onopen = onDataChannelStateChange;
+ config.dataChannel.onclose = onDataChannelStateChange;
+ config.dataChannel.onerror = onDataChannelError;
+ }
+ // Create offer/answer now
+ if(jsep === null || jsep === undefined) {
+ createOffer(handleId, media, callbacks);
+ } else {
+ if(adapter.browserDetails.browser === "edge") {
+ // This is Edge, add an a=end-of-candidates at the end
+ jsep.sdp += "a=end-of-candidates\r\n";
+ }
+ config.pc.setRemoteDescription(
+ new RTCSessionDescription(jsep),
+ function() {
+ Janus.log("Remote description accepted!");
+ createAnswer(handleId, media, callbacks);
+ }, callbacks.error);
+ }
+ }
+
+ function prepareWebrtc(handleId, callbacks) {
+ callbacks = callbacks || {};
+ callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+ callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : webrtcError;
+ var jsep = callbacks.jsep;
+ var media = callbacks.media;
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ callbacks.error("Invalid handle");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ // Are we updating a session?
+ if(config.pc !== undefined && config.pc !== null) {
+ Janus.log("Updating existing media session");
+ // Create offer/answer now
+ if(jsep === null || jsep === undefined) {
+ createOffer(handleId, media, callbacks);
+ } else {
+ if(adapter.browserDetails.browser === "edge") {
+ // This is Edge, add an a=end-of-candidates at the end
+ jsep.sdp += "a=end-of-candidates\r\n";
+ }
+ config.pc.setRemoteDescription(
+ new RTCSessionDescription(jsep),
+ function() {
+ Janus.log("Remote description accepted!");
+ createAnswer(handleId, media, callbacks);
+ }, callbacks.error);
+ }
+ return;
+ }
+ // Was a MediaStream object passed, or do we need to take care of that?
+ if(callbacks.stream !== null && callbacks.stream !== undefined) {
+ var stream = callbacks.stream;
+ Janus.log("MediaStream provided by the application");
+ Janus.debug(stream);
+ // Skip the getUserMedia part
+ config.streamExternal = true;
+ streamsDone(handleId, jsep, media, callbacks, stream);
+ return;
+ }
+ config.trickle = isTrickleEnabled(callbacks.trickle);
+ if(isAudioSendEnabled(media) || isVideoSendEnabled(media)) {
+ var constraints = { mandatory: {}, optional: []};
+ pluginHandle.consentDialog(true);
+ var audioSupport = isAudioSendEnabled(media);
+ if(audioSupport === true && media != undefined && media != null) {
+ if(typeof media.audio === 'object') {
+ audioSupport = media.audio;
+ }
+ }
+ var videoSupport = isVideoSendEnabled(media);
+ if(videoSupport === true && media != undefined && media != null) {
+ if(media.video && media.video != 'screen' && media.video != 'window') {
+ var width = 0;
+ var height = 0, maxHeight = 0;
+ if(media.video === 'lowres') {
+ // Small resolution, 4:3
+ height = 240;
+ maxHeight = 240;
+ width = 320;
+ } else if(media.video === 'lowres-16:9') {
+ // Small resolution, 16:9
+ height = 180;
+ maxHeight = 180;
+ width = 320;
+ } else if(media.video === 'hires' || media.video === 'hires-16:9' ) {
+ // High resolution is only 16:9
+ height = 720;
+ maxHeight = 720;
+ width = 1280;
+ if(navigator.mozGetUserMedia) {
+ var firefoxVer = parseInt(window.navigator.userAgent.match(/Firefox\/(.*)/)[1], 10);
+ if(firefoxVer < 38) {
+ // Unless this is and old Firefox, which doesn't support it
+ Janus.warn(media.video + " unsupported, falling back to stdres (old Firefox)");
+ height = 480;
+ maxHeight = 480;
+ width = 640;
+ }
+ }
+ } else if(media.video === 'stdres') {
+ // Normal resolution, 4:3
+ height = 480;
+ maxHeight = 480;
+ width = 640;
+ } else if(media.video === 'stdres-16:9') {
+ // Normal resolution, 16:9
+ height = 360;
+ maxHeight = 360;
+ width = 640;
+ } else {
+ Janus.log("Default video setting (" + media.video + ") is stdres 4:3");
+ height = 480;
+ maxHeight = 480;
+ width = 640;
+ }
+ Janus.log("Adding media constraint " + media.video);
+ if(navigator.mozGetUserMedia) {
+ var firefoxVer = parseInt(window.navigator.userAgent.match(/Firefox\/(.*)/)[1], 10);
+ if(firefoxVer < 38) {
+ videoSupport = {
+ 'require': ['height', 'width'],
+ 'height': {'max': maxHeight, 'min': height},
+ 'width': {'max': width, 'min': width}
+ };
+ } else {
+ // http://stackoverflow.com/questions/28282385/webrtc-firefox-constraints/28911694#28911694
+ // https://github.com/meetecho/janus-gateway/pull/246
+ videoSupport = {
+ 'height': {'ideal': height},
+ 'width': {'ideal': width}
+ };
+ }
+ } else {
+ videoSupport = {
+ 'mandatory': {
+ 'maxHeight': maxHeight,
+ 'minHeight': height,
+ 'maxWidth': width,
+ 'minWidth': width
+ },
+ 'optional': []
+ };
+ }
+ if(typeof media.video === 'object') {
+ videoSupport = media.video;
+ }
+ Janus.debug(videoSupport);
+ } else if(media.video === 'screen' || media.video === 'window') {
+ // Not a webcam, but screen capture
+ if(window.location.protocol !== 'https:') {
+ // Screen sharing mandates HTTPS
+ Janus.warn("Screen sharing only works on HTTPS, try the https:// version of this page");
+ pluginHandle.consentDialog(false);
+ callbacks.error("Screen sharing only works on HTTPS, try the https:// version of this page");
+ return;
+ }
+ // We're going to try and use the extension for Chrome 34+, the old approach
+ // for older versions of Chrome, or the experimental support in Firefox 33+
+ var cache = {};
+ function callbackUserMedia (error, stream) {
+ pluginHandle.consentDialog(false);
+ if(error) {
+ callbacks.error({code: error.code, name: error.name, message: error.message});
+ } else {
+ streamsDone(handleId, jsep, media, callbacks, stream);
+ }
+ };
+ function getScreenMedia(constraints, gsmCallback) {
+ Janus.log("Adding media constraint (screen capture)");
+ Janus.debug(constraints);
+ navigator.mediaDevices.getUserMedia(constraints)
+ .then(function(stream) { gsmCallback(null, stream); })
+ .catch(function(error) { pluginHandle.consentDialog(false); gsmCallback(error); });
+ };
+ if(adapter.browserDetails.browser === 'chrome') {
+ var chromever = adapter.browserDetails.version;
+ var maxver = 33;
+ if(window.navigator.userAgent.match('Linux'))
+ maxver = 35; // "known" crash in chrome 34 and 35 on linux
+ if(chromever >= 26 && chromever <= maxver) {
+ // Chrome 26->33 requires some awkward chrome://flags manipulation
+ constraints = {
+ video: {
+ mandatory: {
+ googLeakyBucket: true,
+ maxWidth: window.screen.width,
+ maxHeight: window.screen.height,
+ maxFrameRate: 3,
+ chromeMediaSource: 'screen'
+ }
+ },
+ audio: isAudioSendEnabled(media)
+ };
+ getScreenMedia(constraints, callbackUserMedia);
+ } else {
+ // Chrome 34+ requires an extension
+ var pending = window.setTimeout(
+ function () {
+ 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)';
+ pluginHandle.consentDialog(false);
+ return callbacks.error(error);
+ }, 1000);
+ cache[pending] = [callbackUserMedia, null];
+ window.postMessage({ type: 'janusGetScreen', id: pending }, '*');
+ }
+ } else if (window.navigator.userAgent.match('Firefox')) {
+ var ffver = parseInt(window.navigator.userAgent.match(/Firefox\/(.*)/)[1], 10);
+ if(ffver >= 33) {
+ // Firefox 33+ has experimental support for screen sharing
+ constraints = {
+ video: {
+ mozMediaSource: media.video,
+ mediaSource: media.video
+ },
+ audio: isAudioSendEnabled(media)
+ };
+ getScreenMedia(constraints, function (err, stream) {
+ callbackUserMedia(err, stream);
+ // Workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=1045810
+ if (!err) {
+ var lastTime = stream.currentTime;
+ var polly = window.setInterval(function () {
+ if(!stream)
+ window.clearInterval(polly);
+ if(stream.currentTime == lastTime) {
+ window.clearInterval(polly);
+ if(stream.onended) {
+ stream.onended();
+ }
+ }
+ lastTime = stream.currentTime;
+ }, 500);
+ }
+ });
+ } else {
+ var error = new Error('NavigatorUserMediaError');
+ error.name = 'Your version of Firefox does not support screen sharing, please install Firefox 33 (or more recent versions)';
+ pluginHandle.consentDialog(false);
+ callbacks.error(error);
+ return;
+ }
+ }
+
+ // 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]) {
+ var data = cache[event.data.id];
+ var callback = data[0];
+ delete cache[event.data.id];
+
+ if (event.data.sourceId === '') {
+ // user canceled
+ var error = new Error('NavigatorUserMediaError');
+ error.name = 'You cancelled the request for permission, giving up...';
+ pluginHandle.consentDialog(false);
+ callbacks.error(error);
+ } else {
+ constraints = {
+ audio: isAudioSendEnabled(media),
+ video: {
+ mandatory: {
+ chromeMediaSource: 'desktop',
+ maxWidth: window.screen.width,
+ maxHeight: window.screen.height,
+ maxFrameRate: 3
+ },
+ optional: [
+ {googLeakyBucket: true},
+ {googTemporalLayeredScreencast: true}
+ ]
+ }
+ };
+ constraints.video.mandatory.chromeMediaSourceId = event.data.sourceId;
+ getScreenMedia(constraints, callback);
+ }
+ } else if (event.data.type == 'janusGetScreenPending') {
+ window.clearTimeout(event.data.id);
+ }
+ });
+ return;
+ }
+ }
+ // If we got here, we're not screensharing
+ if(media === null || media === undefined || media.video !== 'screen') {
+ // Check whether all media sources are actually available or not
+ navigator.mediaDevices.enumerateDevices().then(function(devices) {
+ var audioExist = devices.some(function(device) {
+ return device.kind === 'audioinput';
+ }),
+ videoExist = devices.some(function(device) {
+ return device.kind === 'videoinput';
+ });
+
+ // Check whether a missing device is really a problem
+ var audioSend = isAudioSendEnabled(media);
+ var videoSend = isVideoSendEnabled(media);
+ var needAudioDevice = isAudioSendRequired(media);
+ var needVideoDevice = isVideoSendRequired(media);
+ if(audioSend || videoSend || needAudioDevice || needVideoDevice) {
+ // We need to send either audio or video
+ var haveAudioDevice = audioSend ? audioExist : false;
+ var haveVideoDevice = videoSend ? videoExist : false;
+ if(!haveAudioDevice && !haveVideoDevice) {
+ // FIXME Should we really give up, or just assume recvonly for both?
+ pluginHandle.consentDialog(false);
+ callbacks.error('No capture device found');
+ return false;
+ } else if(!haveAudioDevice && needAudioDevice) {
+ pluginHandle.consentDialog(false);
+ callbacks.error('Audio capture is required, but no capture device found');
+ return false;
+ } else if(!haveVideoDevice && needVideoDevice) {
+ pluginHandle.consentDialog(false);
+ callbacks.error('Video capture is required, but no capture device found');
+ return false;
+ }
+ }
+
+ navigator.mediaDevices.getUserMedia({
+ audio: audioExist ? audioSupport : false,
+ video: videoExist ? videoSupport : false
+ })
+ .then(function(stream) { pluginHandle.consentDialog(false); streamsDone(handleId, jsep, media, callbacks, stream); })
+ .catch(function(error) { pluginHandle.consentDialog(false); callbacks.error({code: error.code, name: error.name, message: error.message}); });
+ })
+ .catch(function(error) {
+ pluginHandle.consentDialog(false);
+ callbacks.error('enumerateDevices error', error);
+ });
+ }
+ } else {
+ // No need to do a getUserMedia, create offer/answer right away
+ streamsDone(handleId, jsep, media, callbacks);
+ }
+ }
+
+ 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;
+ var jsep = callbacks.jsep;
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ callbacks.error("Invalid handle");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ if(jsep !== undefined && jsep !== null) {
+ if(config.pc === null) {
+ 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;
+ }
+ if(adapter.browserDetails.browser === "edge") {
+ // This is Edge, add an a=end-of-candidates at the end
+ jsep.sdp += "a=end-of-candidates\r\n";
+ }
+ config.pc.setRemoteDescription(
+ new RTCSessionDescription(jsep),
+ function() {
+ Janus.log("Remote description accepted!");
+ callbacks.success();
+ }, callbacks.error);
+ } else {
+ callbacks.error("Invalid JSEP");
+ }
+ }
+
+ function createOffer(handleId, media, callbacks) {
+ callbacks = callbacks || {};
+ callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+ callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ callbacks.error("Invalid handle");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ Janus.log("Creating offer (iceDone=" + config.iceDone + ")");
+ // https://code.google.com/p/webrtc/issues/detail?id=3508
+ var mediaConstraints = null;
+ if(adapter.browserDetails.browser == "firefox" || adapter.browserDetails.browser == "edge") {
+ mediaConstraints = {
+ 'offerToReceiveAudio':isAudioRecvEnabled(media),
+ 'offerToReceiveVideo':isVideoRecvEnabled(media)
+ };
+ } else {
+ mediaConstraints = {
+ 'mandatory': {
+ 'OfferToReceiveAudio':isAudioRecvEnabled(media),
+ 'OfferToReceiveVideo':isVideoRecvEnabled(media)
+ }
+ };
+ }
+ Janus.debug(mediaConstraints);
+ config.pc.createOffer(
+ function(offer) {
+ Janus.debug(offer);
+ if(config.mySdp === null || config.mySdp === undefined) {
+ Janus.log("Setting local description");
+ config.mySdp = offer.sdp;
+ config.pc.setLocalDescription(offer);
+ }
+ if(!config.iceDone && !config.trickle) {
+ // Don't do anything until we have all candidates
+ Janus.log("Waiting for all candidates...");
+ return;
+ }
+ if(config.sdpSent) {
+ Janus.log("Offer already sent, not sending it again");
+ return;
+ }
+ Janus.log("Offer ready");
+ Janus.debug(callbacks);
+ config.sdpSent = true;
+ // JSON.stringify doesn't work on some WebRTC objects anymore
+ // See https://code.google.com/p/chromium/issues/detail?id=467366
+ var jsep = {
+ "type": offer.type,
+ "sdp": offer.sdp
+ };
+ callbacks.success(jsep);
+ }, callbacks.error, mediaConstraints);
+ }
+
+ function createAnswer(handleId, media, callbacks) {
+ callbacks = callbacks || {};
+ callbacks.success = (typeof callbacks.success == "function") ? callbacks.success : Janus.noop;
+ callbacks.error = (typeof callbacks.error == "function") ? callbacks.error : Janus.noop;
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ callbacks.error("Invalid handle");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ Janus.log("Creating answer (iceDone=" + config.iceDone + ")");
+ var mediaConstraints = null;
+ if(adapter.browserDetails.browser == "firefox" || adapter.browserDetails.browser == "edge") {
+ mediaConstraints = {
+ 'offerToReceiveAudio':isAudioRecvEnabled(media),
+ 'offerToReceiveVideo':isVideoRecvEnabled(media)
+ };
+ } else {
+ mediaConstraints = {
+ 'mandatory': {
+ 'OfferToReceiveAudio':isAudioRecvEnabled(media),
+ 'OfferToReceiveVideo':isVideoRecvEnabled(media)
+ }
+ };
+ }
+ Janus.debug(mediaConstraints);
+ config.pc.createAnswer(
+ function(answer) {
+ Janus.debug(answer);
+ if(config.mySdp === null || config.mySdp === undefined) {
+ Janus.log("Setting local description");
+ config.mySdp = answer.sdp;
+ config.pc.setLocalDescription(answer);
+ }
+ if(!config.iceDone && !config.trickle) {
+ // Don't do anything until we have all candidates
+ Janus.log("Waiting for all candidates...");
+ return;
+ }
+ if(config.sdpSent) { // FIXME badly
+ Janus.log("Answer already sent, not sending it again");
+ return;
+ }
+ config.sdpSent = true;
+ // JSON.stringify doesn't work on some WebRTC objects anymore
+ // See https://code.google.com/p/chromium/issues/detail?id=467366
+ var jsep = {
+ "type": answer.type,
+ "sdp": answer.sdp
+ };
+ callbacks.success(jsep);
+ }, callbacks.error, mediaConstraints);
+ }
+
+ 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;
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle, not sending anything");
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ Janus.log("Sending offer/answer SDP...");
+ if(config.mySdp === null || config.mySdp === undefined) {
+ 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.sdpSent) {
+ Janus.log("Offer/Answer SDP already sent, not sending it again");
+ return;
+ }
+ if(config.trickle === false)
+ config.mySdp["trickle"] = false;
+ Janus.debug(callbacks);
+ config.sdpSent = true;
+ callbacks.success(config.mySdp);
+ }
+
+ function getVolume(handleId) {
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ return 0;
+ }
+ var config = pluginHandle.webrtcStuff;
+ // Start getting the volume, if getStats is supported
+ if(config.pc.getStats && adapter.browserDetails.browser == "chrome") { // FIXME
+ if(config.remoteStream === null || config.remoteStream === undefined) {
+ Janus.warn("Remote stream unavailable");
+ return 0;
+ }
+ // http://webrtc.googlecode.com/svn/trunk/samples/js/demos/html/constraints-and-stats.html
+ if(config.volume.timer === null || config.volume.timer === undefined) {
+ Janus.log("Starting volume monitor");
+ config.volume.timer = setInterval(function() {
+ config.pc.getStats(function(stats) {
+ var results = stats.result();
+ for(var i=0; i<results.length; i++) {
+ var res = results[i];
+ if(res.type == 'ssrc' && res.stat('audioOutputLevel')) {
+ config.volume.value = res.stat('audioOutputLevel');
+ }
+ }
+ });
+ }, 200);
+ return 0; // We don't have a volume to return yet
+ }
+ return config.volume.value;
+ } else {
+ Janus.log("Getting the remote volume unsupported by browser");
+ return 0;
+ }
+ }
+
+ function isMuted(handleId, video) {
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ return true;
+ }
+ var config = pluginHandle.webrtcStuff;
+ if(config.pc === null || config.pc === undefined) {
+ Janus.warn("Invalid PeerConnection");
+ return true;
+ }
+ if(config.myStream === undefined || config.myStream === null) {
+ Janus.warn("Invalid local MediaStream");
+ return true;
+ }
+ if(video) {
+ // Check video track
+ if(config.myStream.getVideoTracks() === null
+ || config.myStream.getVideoTracks() === undefined
+ || config.myStream.getVideoTracks().length === 0) {
+ Janus.warn("No video track");
+ return true;
+ }
+ return !config.myStream.getVideoTracks()[0].enabled;
+ } else {
+ // Check audio track
+ if(config.myStream.getAudioTracks() === null
+ || config.myStream.getAudioTracks() === undefined
+ || config.myStream.getAudioTracks().length === 0) {
+ Janus.warn("No audio track");
+ return true;
+ }
+ return !config.myStream.getAudioTracks()[0].enabled;
+ }
+ }
+
+ function mute(handleId, video, mute) {
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ return false;
+ }
+ var config = pluginHandle.webrtcStuff;
+ if(config.pc === null || config.pc === undefined) {
+ Janus.warn("Invalid PeerConnection");
+ return false;
+ }
+ if(config.myStream === undefined || config.myStream === null) {
+ Janus.warn("Invalid local MediaStream");
+ return false;
+ }
+ if(video) {
+ // Mute/unmute video track
+ if(config.myStream.getVideoTracks() === null
+ || config.myStream.getVideoTracks() === undefined
+ || config.myStream.getVideoTracks().length === 0) {
+ Janus.warn("No video track");
+ return false;
+ }
+ config.myStream.getVideoTracks()[0].enabled = mute ? false : true;
+ return true;
+ } else {
+ // Mute/unmute audio track
+ if(config.myStream.getAudioTracks() === null
+ || config.myStream.getAudioTracks() === undefined
+ || config.myStream.getAudioTracks().length === 0) {
+ Janus.warn("No audio track");
+ return false;
+ }
+ config.myStream.getAudioTracks()[0].enabled = mute ? false : true;
+ return true;
+ }
+ }
+
+ function getBitrate(handleId) {
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined ||
+ pluginHandle.webrtcStuff === null || pluginHandle.webrtcStuff === undefined) {
+ Janus.warn("Invalid handle");
+ return "Invalid handle";
+ }
+ var config = pluginHandle.webrtcStuff;
+ if(config.pc === null || config.pc === undefined)
+ return "Invalid PeerConnection";
+ // Start getting the bitrate, if getStats is supported
+ if(config.pc.getStats && adapter.browserDetails.browser == "chrome") {
+ // Do it the Chrome way
+ if(config.remoteStream === null || config.remoteStream === undefined) {
+ Janus.warn("Remote stream unavailable");
+ return "Remote stream unavailable";
+ }
+ // http://webrtc.googlecode.com/svn/trunk/samples/js/demos/html/constraints-and-stats.html
+ if(config.bitrate.timer === null || config.bitrate.timer === undefined) {
+ Janus.log("Starting bitrate timer (Chrome)");
+ config.bitrate.timer = setInterval(function() {
+ config.pc.getStats(function(stats) {
+ var results = stats.result();
+ for(var i=0; i<results.length; i++) {
+ var res = results[i];
+ if(res.type == 'ssrc' && res.stat('googFrameHeightReceived')) {
+ config.bitrate.bsnow = res.stat('bytesReceived');
+ config.bitrate.tsnow = res.timestamp;
+ if(config.bitrate.bsbefore === null || config.bitrate.tsbefore === null) {
+ // Skip this round
+ config.bitrate.bsbefore = config.bitrate.bsnow;
+ config.bitrate.tsbefore = config.bitrate.tsnow;
+ } else {
+ // Calculate bitrate
+ var bitRate = Math.round((config.bitrate.bsnow - config.bitrate.bsbefore) * 8 / (config.bitrate.tsnow - config.bitrate.tsbefore));
+ config.bitrate.value = bitRate + ' kbits/sec';
+ //~ Janus.log("Estimated bitrate is " + config.bitrate.value);
+ config.bitrate.bsbefore = config.bitrate.bsnow;
+ config.bitrate.tsbefore = config.bitrate.tsnow;
+ }
+ }
+ }
+ });
+ }, 1000);
+ return "0 kbits/sec"; // We don't have a bitrate value yet
+ }
+ return config.bitrate.value;
+ } else if(config.pc.getStats && adapter.browserDetails.browser == "firefox") {
+ // Do it the Firefox way
+ if(config.remoteStream === null || config.remoteStream === undefined
+ || config.remoteStream.stream === null || config.remoteStream.stream === undefined) {
+ Janus.warn("Remote stream unavailable");
+ return "Remote stream unavailable";
+ }
+ var videoTracks = config.remoteStream.stream.getVideoTracks();
+ if(videoTracks === null || videoTracks === undefined || videoTracks.length < 1) {
+ Janus.warn("No video track");
+ return "No video track";
+ }
+ // https://github.com/muaz-khan/getStats/blob/master/getStats.js
+ if(config.bitrate.timer === null || config.bitrate.timer === undefined) {
+ Janus.log("Starting bitrate timer (Firefox)");
+ config.bitrate.timer = setInterval(function() {
+ // We need a helper callback
+ var cb = function(res) {
+ if(res === null || res === undefined ||
+ res.inbound_rtp_video_1 == null || res.inbound_rtp_video_1 == null) {
+ config.bitrate.value = "Missing inbound_rtp_video_1";
+ return;
+ }
+ config.bitrate.bsnow = res.inbound_rtp_video_1.bytesReceived;
+ config.bitrate.tsnow = res.inbound_rtp_video_1.timestamp;
+ if(config.bitrate.bsbefore === null || config.bitrate.tsbefore === null) {
+ // Skip this round
+ config.bitrate.bsbefore = config.bitrate.bsnow;
+ config.bitrate.tsbefore = config.bitrate.tsnow;
+ } else {
+ // Calculate bitrate
+ var bitRate = Math.round((config.bitrate.bsnow - config.bitrate.bsbefore) * 8 / (config.bitrate.tsnow - config.bitrate.tsbefore));
+ config.bitrate.value = bitRate + ' kbits/sec';
+ config.bitrate.bsbefore = config.bitrate.bsnow;
+ config.bitrate.tsbefore = config.bitrate.tsnow;
+ }
+ };
+ // Actually get the stats
+ config.pc.getStats(videoTracks[0], function(stats) {
+ cb(stats);
+ }, cb);
+ }, 1000);
+ return "0 kbits/sec"; // We don't have a bitrate value yet
+ }
+ return config.bitrate.value;
+ } else {
+ Janus.warn("Getting the video bitrate unsupported by browser");
+ return "Feature unsupported by browser";
+ }
+ }
+
+ function webrtcError(error) {
+ Janus.error("WebRTC error:", error);
+ }
+
+ function cleanupWebrtc(handleId, hangupRequest) {
+ Janus.log("Cleaning WebRTC stuff");
+ var pluginHandle = pluginHandles[handleId];
+ if(pluginHandle === null || pluginHandle === undefined) {
+ // Nothing to clean
+ return;
+ }
+ var config = pluginHandle.webrtcStuff;
+ if(config !== null && config !== undefined) {
+ if(hangupRequest === true) {
+ // Send a hangup request (we don't really care about the response)
+ var request = { "janus": "hangup", "transaction": Janus.randomString(12) };
+ if(token !== null && token !== undefined)
+ request["token"] = token;
+ if(apisecret !== null && apisecret !== undefined)
+ 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.ajax({
+ type: 'POST',
+ url: server + "/" + sessionId + "/" + handleId,
+ withCredentials: withCredentials,
+ cache: false,
+ contentType: "application/json",
+ data: JSON.stringify(request),
+ dataType: "json"
+ });
+ }
+ }
+ // Cleanup stack
+ config.remoteStream = null;
+ if(config.volume.timer)
+ clearInterval(config.volume.timer);
+ config.volume.value = null;
+ if(config.bitrate.timer)
+ clearInterval(config.bitrate.timer);
+ config.bitrate.timer = null;
+ config.bitrate.bsnow = null;
+ config.bitrate.bsbefore = null;
+ config.bitrate.tsnow = null;
+ config.bitrate.tsbefore = null;
+ config.bitrate.value = null;
+ try {
+ // Try a MediaStream.stop() first
+ if(!config.streamExternal && config.myStream !== null && config.myStream !== undefined) {
+ Janus.log("Stopping local stream");
+ config.myStream.stop();
+ }
+ } catch(e) {
+ // Do nothing if this fails
+ }
+ try {
+ // Try a MediaStreamTrack.stop() for each track as well
+ if(!config.streamExternal && config.myStream !== null && config.myStream !== undefined) {
+ Janus.log("Stopping local stream tracks");
+ var tracks = config.myStream.getTracks();
+ for(var i in tracks) {
+ var mst = tracks[i];
+ Janus.log(mst);
+ if(mst !== null && mst !== undefined)
+ mst.stop();
+ }
+ }
+ } catch(e) {
+ // Do nothing if this fails
+ }
+ config.streamExternal = false;
+ config.myStream = null;
+ // Close PeerConnection
+ try {
+ config.pc.close();
+ } catch(e) {
+ // Do nothing
+ }
+ config.pc = null;
+ config.mySdp = null;
+ config.iceDone = false;
+ config.sdpSent = false;
+ config.dataChannel = null;
+ config.dtmfSender = null;
+ }
+ pluginHandle.oncleanup();
+ }
+
+ // Helper methods to parse a media object
+ function isAudioSendEnabled(media) {
+ Janus.debug("isAudioSendEnabled:", media);
+ if(media === undefined || media === null)
+ return true; // Default
+ if(media.audio === false)
+ return false; // Generic audio has precedence
+ if(media.audioSend === undefined || media.audioSend === null)
+ return true; // Default
+ return (media.audioSend === true);
+ }
+
+ function isAudioSendRequired(media) {
+ Janus.debug("isAudioSendRequired:", media);
+ if(media === undefined || media === null)
+ return false; // Default
+ if(media.audio === false || media.audioSend === false)
+ return false; // If we're not asking to capture audio, it's not required
+ if(media.failIfNoAudio === undefined || media.failIfNoAudio === null)
+ return false; // Default
+ return (media.failIfNoAudio === true);
+ }
+
+ function isAudioRecvEnabled(media) {
+ Janus.debug("isAudioRecvEnabled:", media);
+ if(media === undefined || media === null)
+ return true; // Default
+ if(media.audio === false)
+ return false; // Generic audio has precedence
+ if(media.audioRecv === undefined || media.audioRecv === null)
+ return true; // Default
+ return (media.audioRecv === true);
+ }
+
+ function isVideoSendEnabled(media) {
+ Janus.debug("isVideoSendEnabled:", media);
+ if(media === undefined || media === null)
+ return true; // Default
+ if(media.video === false)
+ return false; // Generic video has precedence
+ if(media.videoSend === undefined || media.videoSend === null)
+ return true; // Default
+ return (media.videoSend === true);
+ }
+
+ function isVideoSendRequired(media) {
+ Janus.debug("isVideoSendRequired:", media);
+ if(media === undefined || media === null)
+ return false; // Default
+ if(media.video === false || media.videoSend === false)
+ return false; // If we're not asking to capture video, it's not required
+ if(media.failIfNoVideo === undefined || media.failIfNoVideo === null)
+ return false; // Default
+ return (media.failIfNoVideo === true);
+ }
+
+ function isVideoRecvEnabled(media) {
+ Janus.debug("isVideoRecvEnabled:", media);
+ if(media === undefined || media === null)
+ return true; // Default
+ if(media.video === false)
+ return false; // Generic video has precedence
+ if(media.videoRecv === undefined || media.videoRecv === null)
+ return true; // Default
+ return (media.videoRecv === true);
+ }
+
+ function isDataEnabled(media) {
+ Janus.debug("isDataEnabled:", media);
+ if(adapter.browserDetails.browser == "edge") {
+ Janus.warn("Edge doesn't support data channels yet");
+ return false;
+ }
+ if(media === undefined || media === null)
+ return false; // Default
+ return (media.data === true);
+ }
+
+ function isTrickleEnabled(trickle) {
+ Janus.debug("isTrickleEnabled:", trickle);
+ if(trickle === undefined || trickle === null)
+ return true; // Default is true
+ return (trickle === true);
+ }
+};
generated by cgit v1.2.3 (git 2.46.0) at 2024-11-24 03:18:18 +0000