bigbluebutton-Github/bigbluebutton-client/resources/prod/lib/verto_extension.js

var callback = function(message){console.log(message);}; // holds the user's callback for a global scope
callbacks = {};
var callICEConnected = false;
var callPurposefullyEnded = false; // used to determine whether the user ended the call or the call was ended from somewhere else outside
var callTimeout = null; // function that will run if there is no call established
var toDisplayDisconnectCallback = true; // if a call is dropped only display the error the first time
var wasCallSuccessful = false; // when the websocket connection is closed this determines whether a call was ever successfully established
webcamStream = "webcamStream";
window[webcamStream] = null;
verto = null;
videoTag = null;

// receives either a string variable holding the name of an actionscript
// registered callback, or a javascript function object.
// The function will return either the function if it is a javascript Function
// or if it is an actionscript string it will return a javascript Function
// that when invokved will invoke the actionscript registered callback
// and passes along parameters
function normalizeCallback(callback) {
	if (typeof callback == "function") {
		return callback;
	} else {
		return function(args) {
			document.getElementById("BigBlueButton")[callback](args);
		};
	}
}

// save a copy of the hangup function registered for the verto object
var oldHangup = $.verto.prototype.hangup;
// overwrite the verto hangup handler with my own handler
$.verto.prototype.hangup = function(callID, userCallback) {
	console.log("call state callbacks - bye");
	if (userCallback) {
		callback = userCallback;
	}
	callActive = false;

	if (cur_call) {
		console.log('call ended ' + cur_call.audioStream.currentTime); // the duration of the call
		if (callPurposefullyEnded === true) { // the user ended the call themself
			callback({'status':'ended'});
		} else {
			callback({'status':'failed', 'errorcode': 1005}); // Call ended unexpectedly
		}
		clearTimeout(callTimeout);
		cur_call = null;
	} else {
		console.log('bye event already received');
	}
	// call the original hangup procedure
	return oldHangup.apply(this, arguments);
}

// main entry point to making a verto call
callIntoConference_verto = function(voiceBridge, conferenceUsername, conferenceIdNumber, userCallback, videoTag, options, vertoServerCredentials) {
	window.videoTag = videoTag;
	// stores the user's callback in the global scope
	if (userCallback) {
		callback = userCallback;
	}
	if(!isLoggedIntoVerto()) { // start the verto log in procedure
		// runs when a web socket is disconnected
		callbacks.onWSClose = function(v, success) {
			if(wasCallSuccessful) { // a call was established through the websocket
				if(toDisplayDisconnectCallback) { // will only display the error the first time
					// the connection was dropped in an already established call
					console.log("websocket disconnected");
					callback({'status':'failed', 'errorcode': 1001}); // WebSocket disconnected
					toDisplayDisconnectCallback = false;
				}
			} else {
				// this callback was triggered and a call was never successfully established
				console.log("websocket connection could not be established");
				callback({'status':'failed', 'errorcode': 1002}); // Could not make a WebSocket connection
			}
		}
		// runs when the websocket is successfully created
		callbacks.onWSLogin = function(v, success) {
			cur_call = null;
			ringing = false;
			console.log("Inside onWSLogin");

			if (success) {
				console.log("starting call");
				toDisplayDisconnectCallback = true; // yes, display an error if the socket closes
				wasCallSuccessful = true; // yes, a call was successfully established through the websocket
				webrtc_call_verto(voiceBridge, conferenceUsername, conferenceIdNumber, callback, options);
			} else {
				callback({'status':'failed', 'errorcode': '10XX'}); // eror logging verto into freeswitch
			}
		}
		// set up verto
		// $.verto.init({}, init(videoTag));
		init(videoTag, vertoServerCredentials);
	} else {
		console.log("already logged into verto, going straight to making a call");
		webrtc_call_verto(voiceBridge, conferenceUsername, conferenceIdNumber, callback, options);
	}
}

checkSupport = function(callback) {
	if(!isWebRTCAvailable_verto()) {
		callback({'status': 'failed', 'errorcode': 1003}); // Browser version not supported
	}

	if (!navigator.getUserMedia) {
		navigator.getUserMedia = navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia || navigator.msGetUserMedia;
	}

	if (!navigator.getUserMedia){
		callback({'status': 'failed', 'errorcode': '10XX'}); // getUserMedia not supported in this browser
	}
}

configStuns = function(callbacks, callback, videoTag, vertoServerCredentials) {
	console.log("Fetching STUN/TURN server info for Verto initialization");
	var stunsConfig = {};
	$.ajax({
		dataType: 'json',
		url: '/bigbluebutton/api/stuns/'
	}).done(function(data) {
		console.log("ajax request done");
		console.log(data);
		if(data['response'] && data.response.returncode == "FAILED") {
			console.error(data.response.message);
			callback({'status':'failed', 'errorcode': data.response.message});
			return;
		}
		stunsConfig['stunServers'] = ( data['stunServers'] ? data['stunServers'].map(function(data) {
			return {'url': data['url']};
		}) : [] );
		stunsConfig['turnServers'] = ( data['turnServers'] ? data['turnServers'].map(function(data) {
			return {
				'urls': data['url'],
				'username': data['username'],
				'credential': data['password']
			};
		}) : [] );
		stunsConfig = stunsConfig['stunServers'].concat(stunsConfig['turnServers']);
		console.log("success got stun data, making verto");
		makeVerto(callbacks, stunsConfig, videoTag, vertoServerCredentials);
	}).fail(function(data, textStatus, errorThrown) {
		// BBBLog.error("Could not fetch stun/turn servers", {error: textStatus, user: callerIdName, voiceBridge: conferenceVoiceBridge});
		callback({'status':'failed', 'errorcode': 1009});
		return;
	});
}

docall_verto = function(extension, conferenceUsername, conferenceIdNumber, callbacks, options) {
	console.log(extension + ", " + conferenceUsername + ", " + conferenceIdNumber);

	if (cur_call) { // only allow for one call
		console.log("Quitting: Call already in progress");
		return;
	}

	//
	// if (verto) {
	// 	verto.videoParams({
	// 		"minWidth": selectedVideoConstraints.constraints.minWidth,
	// 		"minHeight": selectedVideoConstraints.constraints.minHeight,
	// 		"maxWidth": selectedVideoConstraints.constraints.maxWidth,
	// 		"maxHeight": selectedVideoConstraints.constraints.maxHeight,
	// 		"minFrameRate": selectedVideoConstraints.constraints.minFrameRate,
	// 		"vertoBestFrameRate": selectedVideoConstraints.constraints.vertoBestFrameRate
	// 	});
	// }
	//

	outgoingBandwidth = "default";
	incomingBandwidth = "default";
	var useVideo = useCamera = useMic = false;
	if(options.watchOnly) {
		window.watchOnly = true;
		window.listenOnly = false;
		window.joinAudio = false;
		useVideo = true;
		useCamera = false;
		useMic = false;
	} else if(options.listenOnly) {
		window.listenOnly = true;
		window.watchOnly = false;
		window.joinAudio = false;
		useVideo = false;
		useCamera = 'none';
		useMic = 'none';
	} else if(options.joinAudio) {
		window.joinAudio = true;
		window.watchOnly = false;
		window.listenOnly = false;
		useVideo = false;
		useCamera = 'none';
		useMic = 'any';
	}

	cur_call = verto.newCall({
		destination_number: extension,
		caller_id_name: conferenceUsername,
		caller_id_number: conferenceIdNumber,
		outgoingBandwidth: outgoingBandwidth,
		incomingBandwidth: incomingBandwidth,
		useStereo: true,
		useVideo: useVideo,
		useCamera: useCamera,
		useMic: useMic,
		dedEnc: false,
		mirrorInput: false
	});

	if (callbacks != null) { // add user supplied callbacks to the current call
		cur_call.rtc.options.callbacks = $.extend(cur_call.rtc.options.callbacks, callbacks);
	}
}

// check if logged into verto by seeing if there is a ready websocket connection
function isLoggedIntoVerto() {
	return (verto != null ? (ref = verto.rpcClient) != null ? ref.socketReady() : void 0 : void 0);
}

// overwrite and substitute my own init function
init = function(videoTag, vertoServerCredentials) {
	videoTag = window.videoTag;
	cur_call = null;
	share_call = null;
	incomingBandwidth = "default";
	configStuns(callbacks, callback, videoTag, vertoServerCredentials);
}

// checks whether Google Chrome or Firefox have the WebRTCPeerConnection object
function isWebRTCAvailable_verto() {
	return (typeof window.webkitRTCPeerConnection !== 'undefined' || typeof window.mozRTCPeerConnection !== 'undefined');
}

// exit point for conference
function leaveWebRTCVoiceConference_verto() {
	console.log("Leaving the voice conference");
	webrtc_hangup_verto();
}

function make_call_verto(voiceBridge, conferenceUsername, conferenceIdNumber, userCallback, server, recall, options) {
	if (userCallback) {
		callback = userCallback;
	}
	callPurposefullyEnded = false;

	// after 15 seconds if a call hasn't been established display error, hangup and logout of verto
	callTimeout = setTimeout(function() {
		console.log('Ten seconds without updates sending timeout code');
		callback({'status':'failed', 'errorcode': 1006}); // Failure on call
		if (verto != null) {
			verto.hangup();
			verto.logout();
			verto = null;
		}
		cur_call = null;
	}, 10000*1.5);

	var myRTCCallbacks = {
		onError: function(vertoErrorObject, errorMessage) {
			console.error("custom callback: onError");
			console.error(vertoErrorObject);
			console.error("ERROR:");
			console.error(errorMessage);
			if(errorMessage.name === "PermissionDeniedError") { // user denied access to media peripherals
				console.error("User denied permission/access to hardware");
				console.error("getUserMedia: failure - ", errorMessage);
				callback({'status': 'mediafail', 'cause': errorMessage});
			}
			cur_call.hangup({cause: "Device or Permission Error"});
			clearTimeout(callTimeout);
		},
		onICEComplete: function(self, candidate) { // ICE candidate negotiation is complete
			console.log("custom callback: onICEComplete");
			console.log('Received ICE status changed to completed');
			if (callICEConnected === false) {
				callICEConnected = true;
				if (callActive === true) {
					callback({'status':'started'});
				}
				clearTimeout(callTimeout);
			}
		},
		onStream: function(rtc, stream) { // call has been established
			console.log("getUserMicMedia: success");
			callback({'status':'mediasuccess'});
			console.log("custom callback: stream started");
			callActive = true;
			console.log('BigBlueButton call accepted');

			if (callICEConnected === true) {
				callback({'status':'started'});
			} else {
				callback({'status':'waitingforice'});
			}
			clearTimeout(callTimeout);
		}
	};

	if(isLoggedIntoVerto()) {
		console.log("Verto is logged into FreeSWITCH, socket is available, making call");
		callICEConnected = false;

		docall_verto(voiceBridge, conferenceUsername, conferenceIdNumber, myRTCCallbacks, options);

		if(recall === false) {
			console.log('call connecting');
			callback({'status': 'connecting'});
		} else {
			console.log('call connecting again');
		}

		callback({'status':'mediarequest'});
	} else {
		console.error("Verto is NOT logged into FreeSWITCH, socket is NOT available, abandoning call request");
	}
}

function makeVerto(callbacks, stunsConfig, videoTag, vertoServerCredentials) {
	var vertoPort = vertoServerCredentials.vertoPort;
	var hostName = vertoServerCredentials.hostName;
	var socketUrl = "wss://" + hostName + ":" + vertoPort;
	var login = vertoServerCredentials.login;
	var password = vertoServerCredentials.password;
	var minWidth = "640";
	var minHeight = "480";
	var maxWidth = "1920";
	var maxHeight = "1080";

	console.log("stuns info is");
	console.log(stunsConfig);
	// debugger;
	verto = new $.verto({
		login: login,
		passwd: password,
		socketUrl: socketUrl,
		tag: videoTag,
		ringFile: "sounds/bell_ring2.wav",
		loginParams: {foo: true, bar: "yes"},
		useVideo: false,
		useCamera: false,
		iceServers: stunsConfig, // use user supplied stun configuration
		// iceServers: true, // use stun, use default verto configuration
	}, callbacks);
}

var RTCPeerConnectionCallbacks = {
	iceFailed: function(e) {
		console.log('received ice negotiation failed');
		callback({'status':'failed', 'errorcode': 1007}); // Failure on call
		//
		// TODO unless I do this, the call only lasts for a few seconds.
		// When I comment out the lines below, it works fine indefinitely
		// Anton Georgiev Dec 10 2015
		//
		//cur_call = null;
		//verto.hangup();
		//verto = null;
		//clearTimeout(callTimeout);
	}
};
this.RTCPeerConnectionCallbacks = RTCPeerConnectionCallbacks;

window.verto_afterStreamPublish = function() {}

function webrtc_call_verto(voiceBridge, conferenceUsername, conferenceIdNumber, userCallback, options) {
	if (userCallback) {
		callback = userCallback;
	}
	console.log("webrtc_call\n"+voiceBridge + ", " + conferenceUsername + ", " + conferenceIdNumber + ", " + callback);

	if(!isWebRTCAvailable()) {
		callback({'status': 'failed', 'errorcode': 1003}); // Browser version not supported
		return;
	}

	var server = window.document.location.hostname;
	console.log("user " + conferenceUsername + " calling to " +	voiceBridge);
	if (isLoggedIntoVerto()) {
		make_call_verto(voiceBridge, conferenceUsername, conferenceIdNumber, callback, "", false, options);
	}
}

function webrtc_hangup_verto(userCallback) {
	if (userCallback) {
		callback = userCallback;
	}
	callPurposefullyEnded = true;
	console.log("Hanging up current session");
	if(verto) {
		verto.hangup(false, callback);
	}
}