2860 lines
82 KiB
JavaScript
2860 lines
82 KiB
JavaScript
|
|
/*
|
|
* Verto HTML5/Javascript Telephony Signaling and Control Protocol Stack for FreeSWITCH
|
|
* Copyright (C) 2005-2014, Anthony Minessale II <anthm@freeswitch.org>
|
|
*
|
|
* Version: MPL 1.1
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
* http://www.mozilla.org/MPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*
|
|
* The Original Code is Verto HTML5/Javascript Telephony Signaling and Control Protocol Stack for FreeSWITCH
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Anthony Minessale II <anthm@freeswitch.org>
|
|
* Portions created by the Initial Developer are Copyright (C)
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*
|
|
* Anthony Minessale II <anthm@freeswitch.org>
|
|
*
|
|
* jquery.verto.js - Main interface
|
|
*
|
|
*/
|
|
|
|
(function($) {
|
|
var sources = [];
|
|
|
|
var generateGUID = (typeof(window.crypto) !== 'undefined' && typeof(window.crypto.getRandomValues) !== 'undefined') ?
|
|
function() {
|
|
// If we have a cryptographically secure PRNG, use that
|
|
// http://stackoverflow.com/questions/6906916/collisions-when-generating-uuids-in-javascript
|
|
var buf = new Uint16Array(8);
|
|
window.crypto.getRandomValues(buf);
|
|
var S4 = function(num) {
|
|
var ret = num.toString(16);
|
|
while (ret.length < 4) {
|
|
ret = "0" + ret;
|
|
}
|
|
return ret;
|
|
};
|
|
return (S4(buf[0]) + S4(buf[1]) + "-" + S4(buf[2]) + "-" + S4(buf[3]) + "-" + S4(buf[4]) + "-" + S4(buf[5]) + S4(buf[6]) + S4(buf[7]));
|
|
}
|
|
|
|
:
|
|
|
|
function() {
|
|
// Otherwise, just use Math.random
|
|
// http://stackoverflow.com/questions/105034/how-to-create-a-guid-uuid-in-javascript/2117523#2117523
|
|
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
|
|
var r = Math.random() * 16 | 0,
|
|
v = c == 'x' ? r : (r & 0x3 | 0x8);
|
|
return v.toString(16);
|
|
});
|
|
};
|
|
|
|
/// MASTER OBJ
|
|
$.verto = function(options, callbacks) {
|
|
var verto = this;
|
|
|
|
$.verto.saved.push(verto);
|
|
|
|
verto.options = $.extend({
|
|
login: null,
|
|
passwd: null,
|
|
socketUrl: null,
|
|
tag: null,
|
|
localTag: null,
|
|
videoParams: {},
|
|
audioParams: {},
|
|
loginParams: {},
|
|
deviceParams: {onResCheck: null},
|
|
userVariables: {},
|
|
iceServers: false,
|
|
ringSleep: 6000,
|
|
sessid: null
|
|
}, options);
|
|
|
|
if (verto.options.deviceParams.useCamera) {
|
|
$.FSRTC.getValidRes(verto.options.deviceParams.useCamera, verto.options.deviceParams.onResCheck);
|
|
}
|
|
|
|
if (!verto.options.deviceParams.useMic) {
|
|
verto.options.deviceParams.useMic = "any";
|
|
}
|
|
|
|
if (!verto.options.deviceParams.useSpeak) {
|
|
verto.options.deviceParams.useSpeak = "any";
|
|
}
|
|
|
|
if (verto.options.sessid) {
|
|
verto.sessid = verto.options.sessid;
|
|
} else {
|
|
verto.sessid = localStorage.getItem("verto_session_uuid") || generateGUID();
|
|
localStorage.setItem("verto_session_uuid", verto.sessid);
|
|
}
|
|
|
|
verto.dialogs = {};
|
|
verto.callbacks = callbacks || {};
|
|
verto.eventSUBS = {};
|
|
|
|
verto.rpcClient = new $.JsonRpcClient({
|
|
login: verto.options.login,
|
|
passwd: verto.options.passwd,
|
|
socketUrl: verto.options.socketUrl,
|
|
wsFallbackURL: verto.options.wsFallbackURL,
|
|
turnServer: verto.options.turnServer,
|
|
loginParams: verto.options.loginParams,
|
|
userVariables: verto.options.userVariables,
|
|
sessid: verto.sessid,
|
|
onmessage: function(e) {
|
|
return verto.handleMessage(e.eventData);
|
|
},
|
|
onWSConnect: function(o) {
|
|
o.call('login', {});
|
|
},
|
|
onWSLogin: function(success) {
|
|
if (verto.callbacks.onWSLogin) {
|
|
verto.callbacks.onWSLogin(verto, success);
|
|
}
|
|
},
|
|
onWSClose: function(success) {
|
|
if (verto.callbacks.onWSClose) {
|
|
verto.callbacks.onWSClose(verto, success);
|
|
}
|
|
verto.purge();
|
|
}
|
|
});
|
|
|
|
var tag = verto.options.tag;
|
|
if (typeof(tag) === "function") {
|
|
tag = tag();
|
|
}
|
|
|
|
if (verto.options.ringFile && verto.options.tag) {
|
|
verto.ringer = $("#" + tag);
|
|
}
|
|
|
|
verto.rpcClient.call('login', {});
|
|
|
|
};
|
|
|
|
|
|
$.verto.prototype.deviceParams = function(obj) {
|
|
var verto = this;
|
|
|
|
for (var i in obj) {
|
|
verto.options.deviceParams[i] = obj[i];
|
|
}
|
|
|
|
if (obj.useCamera) {
|
|
$.FSRTC.getValidRes(verto.options.deviceParams.useCamera, obj ? obj.onResCheck : undefined);
|
|
}
|
|
};
|
|
|
|
$.verto.prototype.videoParams = function(obj) {
|
|
var verto = this;
|
|
|
|
for (var i in obj) {
|
|
verto.options.videoParams[i] = obj[i];
|
|
}
|
|
};
|
|
|
|
$.verto.prototype.iceServers = function(obj) {
|
|
var verto = this;
|
|
verto.options.iceServers = obj;
|
|
};
|
|
|
|
$.verto.prototype.loginData = function(params) {
|
|
var verto = this;
|
|
verto.options.login = params.login;
|
|
verto.options.passwd = params.passwd;
|
|
verto.rpcClient.loginData(params);
|
|
};
|
|
|
|
$.verto.prototype.logout = function(msg) {
|
|
var verto = this;
|
|
verto.rpcClient.closeSocket();
|
|
if (verto.callbacks.onWSClose) {
|
|
verto.callbacks.onWSClose(verto, false);
|
|
}
|
|
verto.purge();
|
|
};
|
|
|
|
$.verto.prototype.login = function(msg) {
|
|
var verto = this;
|
|
verto.logout();
|
|
verto.rpcClient.call('login', {});
|
|
};
|
|
|
|
$.verto.prototype.message = function(msg) {
|
|
var verto = this;
|
|
var err = 0;
|
|
|
|
if (!msg.to) {
|
|
console.error("Missing To");
|
|
err++;
|
|
}
|
|
|
|
if (!msg.body) {
|
|
console.error("Missing Body");
|
|
err++;
|
|
}
|
|
|
|
if (err) {
|
|
return false;
|
|
}
|
|
|
|
verto.sendMethod("verto.info", {
|
|
msg: msg
|
|
});
|
|
|
|
return true;
|
|
};
|
|
|
|
$.verto.prototype.processReply = function(method, success, e) {
|
|
var verto = this;
|
|
var i;
|
|
|
|
//console.log("Response: " + method, success, e);
|
|
|
|
switch (method) {
|
|
case "verto.subscribe":
|
|
for (i in e.unauthorizedChannels) {
|
|
drop_bad(verto, e.unauthorizedChannels[i]);
|
|
}
|
|
for (i in e.subscribedChannels) {
|
|
mark_ready(verto, e.subscribedChannels[i]);
|
|
}
|
|
|
|
break;
|
|
case "verto.unsubscribe":
|
|
//console.error(e);
|
|
break;
|
|
}
|
|
};
|
|
|
|
$.verto.prototype.sendMethod = function(method, params) {
|
|
var verto = this;
|
|
|
|
verto.rpcClient.call(method, params,
|
|
|
|
function(e) {
|
|
/* Success */
|
|
verto.processReply(method, true, e);
|
|
},
|
|
|
|
function(e) {
|
|
/* Error */
|
|
verto.processReply(method, false, e);
|
|
});
|
|
};
|
|
|
|
function do_sub(verto, channel, obj) {
|
|
|
|
}
|
|
|
|
function drop_bad(verto, channel) {
|
|
console.error("drop unauthorized channel: " + channel);
|
|
delete verto.eventSUBS[channel];
|
|
}
|
|
|
|
function mark_ready(verto, channel) {
|
|
for (var j in verto.eventSUBS[channel]) {
|
|
verto.eventSUBS[channel][j].ready = true;
|
|
console.log("subscribed to channel: " + channel);
|
|
if (verto.eventSUBS[channel][j].readyHandler) {
|
|
verto.eventSUBS[channel][j].readyHandler(verto, channel);
|
|
}
|
|
}
|
|
}
|
|
|
|
var SERNO = 1;
|
|
|
|
function do_subscribe(verto, channel, subChannels, sparams) {
|
|
var params = sparams || {};
|
|
|
|
var local = params.local;
|
|
|
|
var obj = {
|
|
eventChannel: channel,
|
|
userData: params.userData,
|
|
handler: params.handler,
|
|
ready: false,
|
|
readyHandler: params.readyHandler,
|
|
serno: SERNO++
|
|
};
|
|
|
|
var isnew = false;
|
|
|
|
if (!verto.eventSUBS[channel]) {
|
|
verto.eventSUBS[channel] = [];
|
|
subChannels.push(channel);
|
|
isnew = true;
|
|
}
|
|
|
|
verto.eventSUBS[channel].push(obj);
|
|
|
|
if (local) {
|
|
obj.ready = true;
|
|
obj.local = true;
|
|
}
|
|
|
|
if (!isnew && verto.eventSUBS[channel][0].ready) {
|
|
obj.ready = true;
|
|
if (obj.readyHandler) {
|
|
obj.readyHandler(verto, channel);
|
|
}
|
|
}
|
|
|
|
return {
|
|
serno: obj.serno,
|
|
eventChannel: channel
|
|
};
|
|
|
|
}
|
|
|
|
$.verto.prototype.subscribe = function(channel, sparams) {
|
|
var verto = this;
|
|
var r = [];
|
|
var subChannels = [];
|
|
var params = sparams || {};
|
|
|
|
if (typeof(channel) === "string") {
|
|
r.push(do_subscribe(verto, channel, subChannels, params));
|
|
} else {
|
|
for (var i in channel) {
|
|
r.push(do_subscribe(verto, channel, subChannels, params));
|
|
}
|
|
}
|
|
|
|
if (subChannels.length) {
|
|
verto.sendMethod("verto.subscribe", {
|
|
eventChannel: subChannels.length == 1 ? subChannels[0] : subChannels,
|
|
subParams: params.subParams
|
|
});
|
|
}
|
|
|
|
return r;
|
|
};
|
|
|
|
$.verto.prototype.unsubscribe = function(handle) {
|
|
var verto = this;
|
|
var i;
|
|
|
|
if (!handle) {
|
|
for (i in verto.eventSUBS) {
|
|
if (verto.eventSUBS[i]) {
|
|
verto.unsubscribe(verto.eventSUBS[i]);
|
|
}
|
|
}
|
|
} else {
|
|
var unsubChannels = {};
|
|
var sendChannels = [];
|
|
var channel;
|
|
|
|
if (typeof(handle) == "string") {
|
|
delete verto.eventSUBS[handle];
|
|
unsubChannels[handle]++;
|
|
} else {
|
|
for (i in handle) {
|
|
if (typeof(handle[i]) == "string") {
|
|
channel = handle[i];
|
|
delete verto.eventSUBS[channel];
|
|
unsubChannels[channel]++;
|
|
} else {
|
|
var repl = [];
|
|
channel = handle[i].eventChannel;
|
|
|
|
for (var j in verto.eventSUBS[channel]) {
|
|
if (verto.eventSUBS[channel][j].serno == handle[i].serno) {} else {
|
|
repl.push(verto.eventSUBS[channel][j]);
|
|
}
|
|
}
|
|
|
|
verto.eventSUBS[channel] = repl;
|
|
|
|
if (verto.eventSUBS[channel].length === 0) {
|
|
delete verto.eventSUBS[channel];
|
|
unsubChannels[channel]++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var u in unsubChannels) {
|
|
console.log("Sending Unsubscribe for: ", u);
|
|
sendChannels.push(u);
|
|
}
|
|
|
|
if (sendChannels.length) {
|
|
verto.sendMethod("verto.unsubscribe", {
|
|
eventChannel: sendChannels.length == 1 ? sendChannels[0] : sendChannels
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
$.verto.prototype.broadcast = function(channel, params) {
|
|
var verto = this;
|
|
var msg = {
|
|
eventChannel: channel,
|
|
data: {}
|
|
};
|
|
for (var i in params) {
|
|
msg.data[i] = params[i];
|
|
}
|
|
verto.sendMethod("verto.broadcast", msg);
|
|
};
|
|
|
|
$.verto.prototype.purge = function(callID) {
|
|
var verto = this;
|
|
var x = 0;
|
|
var i;
|
|
|
|
for (i in verto.dialogs) {
|
|
if (!x) {
|
|
console.log("purging dialogs");
|
|
}
|
|
x++;
|
|
verto.dialogs[i].setState($.verto.enum.state.purge);
|
|
}
|
|
|
|
for (i in verto.eventSUBS) {
|
|
if (verto.eventSUBS[i]) {
|
|
console.log("purging subscription: " + i);
|
|
delete verto.eventSUBS[i];
|
|
}
|
|
}
|
|
};
|
|
|
|
$.verto.prototype.hangup = function(callID) {
|
|
var verto = this;
|
|
if (callID) {
|
|
var dialog = verto.dialogs[callID];
|
|
|
|
if (dialog) {
|
|
dialog.hangup();
|
|
}
|
|
} else {
|
|
for (var i in verto.dialogs) {
|
|
verto.dialogs[i].hangup();
|
|
}
|
|
}
|
|
};
|
|
|
|
$.verto.prototype.newCall = function(args, callbacks) {
|
|
var verto = this;
|
|
|
|
if (!verto.rpcClient.socketReady()) {
|
|
console.error("Not Connected...");
|
|
return;
|
|
}
|
|
|
|
if (args["useCamera"]) {
|
|
verto.options.deviceParams["useCamera"] = args["useCamera"];
|
|
}
|
|
|
|
var dialog = new $.verto.dialog($.verto.enum.direction.outbound, this, args);
|
|
|
|
dialog.invite();
|
|
|
|
if (callbacks) {
|
|
dialog.callbacks = callbacks;
|
|
}
|
|
|
|
return dialog;
|
|
};
|
|
|
|
$.verto.prototype.handleMessage = function(data) {
|
|
var verto = this;
|
|
|
|
if (!(data && data.method)) {
|
|
console.error("Invalid Data", data);
|
|
return;
|
|
}
|
|
|
|
if (data.params.callID) {
|
|
var dialog = verto.dialogs[data.params.callID];
|
|
|
|
if (data.method === "verto.attach" && dialog) {
|
|
delete dialog.verto.dialogs[dialog.callID];
|
|
dialog.rtc.stop();
|
|
dialog = null;
|
|
}
|
|
|
|
if (dialog) {
|
|
|
|
switch (data.method) {
|
|
case 'verto.bye':
|
|
dialog.hangup(data.params);
|
|
break;
|
|
case 'verto.answer':
|
|
dialog.handleAnswer(data.params);
|
|
break;
|
|
case 'verto.media':
|
|
dialog.handleMedia(data.params);
|
|
break;
|
|
case 'verto.display':
|
|
dialog.handleDisplay(data.params);
|
|
break;
|
|
case 'verto.info':
|
|
dialog.handleInfo(data.params);
|
|
break;
|
|
default:
|
|
console.debug("INVALID METHOD OR NON-EXISTANT CALL REFERENCE IGNORED", dialog, data.method);
|
|
break;
|
|
}
|
|
} else {
|
|
|
|
switch (data.method) {
|
|
case 'verto.attach':
|
|
data.params.attach = true;
|
|
|
|
if (data.params.sdp && data.params.sdp.indexOf("m=video") > 0) {
|
|
data.params.useVideo = true;
|
|
}
|
|
|
|
if (data.params.sdp && data.params.sdp.indexOf("stereo=1") > 0) {
|
|
data.params.useStereo = true;
|
|
}
|
|
|
|
dialog = new $.verto.dialog($.verto.enum.direction.inbound, verto, data.params);
|
|
dialog.setState($.verto.enum.state.recovering);
|
|
|
|
break;
|
|
case 'verto.invite':
|
|
|
|
if (data.params.sdp && data.params.sdp.indexOf("m=video") > 0) {
|
|
data.params.wantVideo = true;
|
|
}
|
|
|
|
if (data.params.sdp && data.params.sdp.indexOf("stereo=1") > 0) {
|
|
data.params.useStereo = true;
|
|
}
|
|
|
|
dialog = new $.verto.dialog($.verto.enum.direction.inbound, verto, data.params);
|
|
break;
|
|
default:
|
|
console.debug("INVALID METHOD OR NON-EXISTANT CALL REFERENCE IGNORED");
|
|
break;
|
|
}
|
|
}
|
|
|
|
return {
|
|
method: data.method
|
|
};
|
|
} else {
|
|
switch (data.method) {
|
|
case 'verto.punt':
|
|
verto.purge();
|
|
verto.logout();
|
|
break;
|
|
case 'verto.event':
|
|
var list = null;
|
|
var key = null;
|
|
|
|
if (data.params) {
|
|
key = data.params.eventChannel;
|
|
}
|
|
|
|
if (key) {
|
|
list = verto.eventSUBS[key];
|
|
|
|
if (!list) {
|
|
list = verto.eventSUBS[key.split(".")[0]];
|
|
}
|
|
}
|
|
|
|
if (!list && key && key === verto.sessid) {
|
|
if (verto.callbacks.onMessage) {
|
|
verto.callbacks.onMessage(verto, null, $.verto.enum.message.pvtEvent, data.params);
|
|
}
|
|
} else if (!list && key && verto.dialogs[key]) {
|
|
verto.dialogs[key].sendMessage($.verto.enum.message.pvtEvent, data.params);
|
|
} else if (!list) {
|
|
if (!key) {
|
|
key = "UNDEFINED";
|
|
}
|
|
console.error("UNSUBBED or invalid EVENT " + key + " IGNORED");
|
|
} else {
|
|
for (var i in list) {
|
|
var sub = list[i];
|
|
|
|
if (!sub || !sub.ready) {
|
|
console.error("invalid EVENT for " + key + " IGNORED");
|
|
} else if (sub.handler) {
|
|
sub.handler(verto, data.params, sub.userData);
|
|
} else if (verto.callbacks.onEvent) {
|
|
verto.callbacks.onEvent(verto, data.params, sub.userData);
|
|
} else {
|
|
console.log("EVENT:", data.params);
|
|
}
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case "verto.info":
|
|
if (verto.callbacks.onMessage) {
|
|
verto.callbacks.onMessage(verto, null, $.verto.enum.message.info, data.params.msg);
|
|
}
|
|
//console.error(data);
|
|
console.debug("MESSAGE from: " + data.params.msg.from, data.params.msg.body);
|
|
|
|
break;
|
|
|
|
case 'verto.clientReady':
|
|
if (verto.callbacks.onMessage) {
|
|
verto.callbacks.onMessage(verto, null, $.verto.enum.message.clientReady, data.params);
|
|
}
|
|
console.debug("CLIENT READY", data.params);
|
|
break;
|
|
|
|
default:
|
|
console.error("INVALID METHOD OR NON-EXISTANT CALL REFERENCE IGNORED", data.method);
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
|
|
var del_array = function(array, name) {
|
|
var r = [];
|
|
var len = array.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
if (array[i] != name) {
|
|
r.push(array[i]);
|
|
}
|
|
}
|
|
|
|
return r;
|
|
};
|
|
|
|
var hashArray = function() {
|
|
var vha = this;
|
|
|
|
var hash = {};
|
|
var array = [];
|
|
|
|
vha.reorder = function(a) {
|
|
array = a;
|
|
var h = hash;
|
|
hash = {};
|
|
|
|
var len = array.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
var key = array[i];
|
|
if (h[key]) {
|
|
hash[key] = h[key];
|
|
delete h[key];
|
|
}
|
|
}
|
|
h = undefined;
|
|
};
|
|
|
|
vha.clear = function() {
|
|
hash = undefined;
|
|
array = undefined;
|
|
hash = {};
|
|
array = [];
|
|
};
|
|
|
|
vha.add = function(name, val, insertAt) {
|
|
var redraw = false;
|
|
|
|
if (!hash[name]) {
|
|
if (insertAt === undefined || insertAt < 0 || insertAt >= array.length) {
|
|
array.push(name);
|
|
} else {
|
|
var x = 0;
|
|
var n = [];
|
|
var len = array.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
if (x++==insertAt) {
|
|
n.push(name);
|
|
}
|
|
n.push(array[i]);
|
|
}
|
|
|
|
array = undefined;
|
|
array = n;
|
|
n = undefined;
|
|
redraw = true;
|
|
}
|
|
}
|
|
|
|
hash[name] = val;
|
|
|
|
return redraw;
|
|
};
|
|
|
|
vha.del = function(name) {
|
|
var r = false;
|
|
|
|
if (hash[name]) {
|
|
array = del_array(array, name);
|
|
delete hash[name];
|
|
r = true;
|
|
} else {
|
|
console.error("can't del nonexistant key " + name);
|
|
}
|
|
|
|
return r;
|
|
};
|
|
|
|
vha.get = function(name) {
|
|
return hash[name];
|
|
};
|
|
|
|
vha.order = function() {
|
|
return array;
|
|
};
|
|
|
|
vha.hash = function() {
|
|
return hash;
|
|
};
|
|
|
|
vha.indexOf = function(name) {
|
|
var len = array.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
if (array[i] == name) {
|
|
return i;
|
|
}
|
|
}
|
|
};
|
|
|
|
vha.arrayLen = function() {
|
|
return array.length;
|
|
};
|
|
|
|
vha.asArray = function() {
|
|
var r = [];
|
|
|
|
var len = array.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
var key = array[i];
|
|
r.push(hash[key]);
|
|
}
|
|
|
|
return r;
|
|
};
|
|
|
|
vha.each = function(cb) {
|
|
var len = array.length;
|
|
|
|
for (var i = 0; i < len; i++) {
|
|
cb(array[i], hash[array[i]]);
|
|
}
|
|
};
|
|
|
|
vha.dump = function(html) {
|
|
var str = "";
|
|
|
|
vha.each(function(name, val) {
|
|
str += "name: " + name + " val: " + JSON.stringify(val) + (html ? "<br>" : "\n");
|
|
});
|
|
|
|
return str;
|
|
};
|
|
|
|
};
|
|
|
|
$.verto.liveArray = function(verto, context, name, config) {
|
|
var la = this;
|
|
var lastSerno = 0;
|
|
var binding = null;
|
|
var user_obj = config.userObj;
|
|
var local = false;
|
|
|
|
// Inherit methods of hashArray
|
|
hashArray.call(la);
|
|
|
|
// Save the hashArray add, del, reorder, clear methods so we can make our own.
|
|
la._add = la.add;
|
|
la._del = la.del;
|
|
la._reorder = la.reorder;
|
|
la._clear = la.clear;
|
|
|
|
la.context = context;
|
|
la.name = name;
|
|
la.user_obj = user_obj;
|
|
|
|
la.verto = verto;
|
|
la.broadcast = function(channel, obj) {
|
|
verto.broadcast(channel, obj);
|
|
};
|
|
la.errs = 0;
|
|
|
|
la.clear = function() {
|
|
la._clear();
|
|
lastSerno = 0;
|
|
|
|
if (la.onChange) {
|
|
la.onChange(la, {
|
|
action: "clear"
|
|
});
|
|
}
|
|
};
|
|
|
|
la.checkSerno = function(serno) {
|
|
if (serno < 0) {
|
|
return true;
|
|
}
|
|
|
|
if (lastSerno > 0 && serno != (lastSerno + 1)) {
|
|
if (la.onErr) {
|
|
la.onErr(la, {
|
|
lastSerno: lastSerno,
|
|
serno: serno
|
|
});
|
|
}
|
|
la.errs++;
|
|
console.debug(la.errs);
|
|
if (la.errs < 3) {
|
|
la.bootstrap(la.user_obj);
|
|
}
|
|
return false;
|
|
} else {
|
|
lastSerno = serno;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
la.reorder = function(serno, a) {
|
|
if (la.checkSerno(serno)) {
|
|
la._reorder(a);
|
|
if (la.onChange) {
|
|
la.onChange(la, {
|
|
serno: serno,
|
|
action: "reorder"
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
la.init = function(serno, val, key, index) {
|
|
if (key === null || key === undefined) {
|
|
key = serno;
|
|
}
|
|
if (la.checkSerno(serno)) {
|
|
if (la.onChange) {
|
|
la.onChange(la, {
|
|
serno: serno,
|
|
action: "init",
|
|
index: index,
|
|
key: key,
|
|
data: val
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
la.bootObj = function(serno, val) {
|
|
if (la.checkSerno(serno)) {
|
|
|
|
//la.clear();
|
|
for (var i in val) {
|
|
la._add(val[i][0], val[i][1]);
|
|
}
|
|
|
|
if (la.onChange) {
|
|
la.onChange(la, {
|
|
serno: serno,
|
|
action: "bootObj",
|
|
data: val,
|
|
redraw: true
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
// @param serno La is the serial number for la particular request.
|
|
// @param key If looking at it as a hash table, la represents the key in the hashArray object where you want to store the val object.
|
|
// @param index If looking at it as an array, la represents the position in the array where you want to store the val object.
|
|
// @param val La is the object you want to store at the key or index location in the hash table / array.
|
|
la.add = function(serno, val, key, index) {
|
|
if (key === null || key === undefined) {
|
|
key = serno;
|
|
}
|
|
if (la.checkSerno(serno)) {
|
|
var redraw = la._add(key, val, index);
|
|
if (la.onChange) {
|
|
la.onChange(la, {
|
|
serno: serno,
|
|
action: "add",
|
|
index: index,
|
|
key: key,
|
|
data: val,
|
|
redraw: redraw
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
la.modify = function(serno, val, key, index) {
|
|
if (key === null || key === undefined) {
|
|
key = serno;
|
|
}
|
|
if (la.checkSerno(serno)) {
|
|
la._add(key, val, index);
|
|
if (la.onChange) {
|
|
la.onChange(la, {
|
|
serno: serno,
|
|
action: "modify",
|
|
key: key,
|
|
data: val,
|
|
index: index
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
la.del = function(serno, key, index) {
|
|
if (key === null || key === undefined) {
|
|
key = serno;
|
|
}
|
|
if (la.checkSerno(serno)) {
|
|
if (index === null || index < 0 || index === undefined) {
|
|
index = la.indexOf(key);
|
|
}
|
|
var ok = la._del(key);
|
|
|
|
if (ok && la.onChange) {
|
|
la.onChange(la, {
|
|
serno: serno,
|
|
action: "del",
|
|
key: key,
|
|
index: index
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
var eventHandler = function(v, e, la) {
|
|
var packet = e.data;
|
|
|
|
//console.error("READ:", packet);
|
|
|
|
if (packet.name != la.name) {
|
|
return;
|
|
}
|
|
|
|
switch (packet.action) {
|
|
|
|
case "init":
|
|
la.init(packet.wireSerno, packet.data, packet.hashKey, packet.arrIndex);
|
|
break;
|
|
|
|
case "bootObj":
|
|
la.bootObj(packet.wireSerno, packet.data);
|
|
break;
|
|
case "add":
|
|
la.add(packet.wireSerno, packet.data, packet.hashKey, packet.arrIndex);
|
|
break;
|
|
|
|
case "modify":
|
|
if (! (packet.arrIndex || packet.hashKey)) {
|
|
console.error("Invalid Packet", packet);
|
|
} else {
|
|
la.modify(packet.wireSerno, packet.data, packet.hashKey, packet.arrIndex);
|
|
}
|
|
break;
|
|
case "del":
|
|
if (! (packet.arrIndex || packet.hashKey)) {
|
|
console.error("Invalid Packet", packet);
|
|
} else {
|
|
la.del(packet.wireSerno, packet.hashKey, packet.arrIndex);
|
|
}
|
|
break;
|
|
|
|
case "clear":
|
|
la.clear();
|
|
break;
|
|
|
|
case "reorder":
|
|
la.reorder(packet.wireSerno, packet.order);
|
|
break;
|
|
|
|
default:
|
|
if (la.checkSerno(packet.wireSerno)) {
|
|
if (la.onChange) {
|
|
la.onChange(la, {
|
|
serno: packet.wireSerno,
|
|
action: packet.action,
|
|
data: packet.data
|
|
});
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
|
|
if (la.context) {
|
|
binding = la.verto.subscribe(la.context, {
|
|
handler: eventHandler,
|
|
userData: la,
|
|
subParams: config.subParams
|
|
});
|
|
}
|
|
|
|
la.destroy = function() {
|
|
la._clear();
|
|
la.verto.unsubscribe(binding);
|
|
};
|
|
|
|
la.sendCommand = function(cmd, obj) {
|
|
var self = la;
|
|
self.broadcast(self.context, {
|
|
liveArray: {
|
|
command: cmd,
|
|
context: self.context,
|
|
name: self.name,
|
|
obj: obj
|
|
}
|
|
});
|
|
};
|
|
|
|
la.bootstrap = function(obj) {
|
|
var self = la;
|
|
la.sendCommand("bootstrap", obj);
|
|
//self.heartbeat();
|
|
};
|
|
|
|
la.changepage = function(obj) {
|
|
var self = la;
|
|
self.clear();
|
|
self.broadcast(self.context, {
|
|
liveArray: {
|
|
command: "changepage",
|
|
context: la.context,
|
|
name: la.name,
|
|
obj: obj
|
|
}
|
|
});
|
|
};
|
|
|
|
la.heartbeat = function(obj) {
|
|
var self = la;
|
|
|
|
var callback = function() {
|
|
self.heartbeat.call(self, obj);
|
|
};
|
|
self.broadcast(self.context, {
|
|
liveArray: {
|
|
command: "heartbeat",
|
|
context: self.context,
|
|
name: self.name,
|
|
obj: obj
|
|
}
|
|
});
|
|
self.hb_pid = setTimeout(callback, 30000);
|
|
};
|
|
|
|
la.bootstrap(la.user_obj);
|
|
};
|
|
|
|
$.verto.liveTable = function(verto, context, name, jq, config) {
|
|
var dt;
|
|
var la = new $.verto.liveArray(verto, context, name, {
|
|
subParams: config.subParams
|
|
});
|
|
var lt = this;
|
|
|
|
lt.liveArray = la;
|
|
lt.dataTable = dt;
|
|
lt.verto = verto;
|
|
|
|
lt.destroy = function() {
|
|
if (dt) {
|
|
dt.fnDestroy();
|
|
}
|
|
if (la) {
|
|
la.destroy();
|
|
}
|
|
|
|
dt = null;
|
|
la = null;
|
|
};
|
|
|
|
la.onErr = function(obj, args) {
|
|
console.error("Error: ", obj, args);
|
|
};
|
|
|
|
/* back compat so jsonstatus can always be enabled */
|
|
function genRow(data) {
|
|
if (typeof(data[4]) === "string" && data[4].indexOf("{") > -1) {
|
|
var tmp = $.parseJSON(data[4]);
|
|
data[4] = tmp.oldStatus;
|
|
data[5] = null;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
function genArray(obj) {
|
|
var data = obj.asArray();
|
|
|
|
for (var i in data) {
|
|
data[i] = genRow(data[i]);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
|
|
la.onChange = function(obj, args) {
|
|
var index = 0;
|
|
var iserr = 0;
|
|
|
|
if (!dt) {
|
|
if (!config.aoColumns) {
|
|
if (args.action != "init") {
|
|
return;
|
|
}
|
|
|
|
config.aoColumns = [];
|
|
|
|
for (var i in args.data) {
|
|
config.aoColumns.push({
|
|
"sTitle": args.data[i]
|
|
});
|
|
}
|
|
}
|
|
|
|
dt = jq.dataTable(config);
|
|
}
|
|
|
|
if (dt && (args.action == "del" || args.action == "modify")) {
|
|
index = args.index;
|
|
|
|
if (index === undefined && args.key) {
|
|
index = la.indexOf(args.key);
|
|
}
|
|
|
|
if (index === undefined) {
|
|
console.error("INVALID PACKET Missing INDEX\n", args);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (config.onChange) {
|
|
config.onChange(obj, args);
|
|
}
|
|
|
|
try {
|
|
switch (args.action) {
|
|
case "bootObj":
|
|
if (!args.data) {
|
|
console.error("missing data");
|
|
return;
|
|
}
|
|
dt.fnClearTable();
|
|
dt.fnAddData(genArray(obj));
|
|
dt.fnAdjustColumnSizing();
|
|
break;
|
|
case "add":
|
|
if (!args.data) {
|
|
console.error("missing data");
|
|
return;
|
|
}
|
|
if (args.redraw > -1) {
|
|
// specific position, more costly
|
|
dt.fnClearTable();
|
|
dt.fnAddData(genArray(obj));
|
|
} else {
|
|
dt.fnAddData(genRow(args.data));
|
|
}
|
|
dt.fnAdjustColumnSizing();
|
|
break;
|
|
case "modify":
|
|
if (!args.data) {
|
|
return;
|
|
}
|
|
//console.debug(args, index);
|
|
dt.fnUpdate(genRow(args.data), index);
|
|
dt.fnAdjustColumnSizing();
|
|
break;
|
|
case "del":
|
|
dt.fnDeleteRow(index);
|
|
dt.fnAdjustColumnSizing();
|
|
break;
|
|
case "clear":
|
|
dt.fnClearTable();
|
|
break;
|
|
case "reorder":
|
|
// specific position, more costly
|
|
dt.fnClearTable();
|
|
dt.fnAddData(genArray(obj));
|
|
break;
|
|
case "hide":
|
|
jq.hide();
|
|
break;
|
|
|
|
case "show":
|
|
jq.show();
|
|
break;
|
|
|
|
}
|
|
} catch(err) {
|
|
console.error("ERROR: " + err);
|
|
iserr++;
|
|
}
|
|
|
|
if (iserr) {
|
|
obj.errs++;
|
|
if (obj.errs < 3) {
|
|
obj.bootstrap(obj.user_obj);
|
|
}
|
|
} else {
|
|
obj.errs = 0;
|
|
}
|
|
|
|
};
|
|
|
|
la.onChange(la, {
|
|
action: "init"
|
|
});
|
|
|
|
};
|
|
|
|
var CONFMAN_SERNO = 1;
|
|
|
|
/*
|
|
Conference Manager without jQuery table.
|
|
*/
|
|
|
|
$.verto.conf = function(verto, params) {
|
|
var conf = this;
|
|
|
|
conf.params = $.extend({
|
|
dialog: null,
|
|
hasVid: false,
|
|
laData: null,
|
|
onBroadcast: null,
|
|
onLaChange: null,
|
|
onLaRow: null
|
|
}, params);
|
|
|
|
conf.verto = verto;
|
|
conf.serno = CONFMAN_SERNO++;
|
|
|
|
createMainModeratorMethods();
|
|
|
|
verto.subscribe(conf.params.laData.modChannel, {
|
|
handler: function(v, e) {
|
|
if (conf.params.onBroadcast) {
|
|
conf.params.onBroadcast(verto, conf, e.data);
|
|
}
|
|
}
|
|
});
|
|
|
|
verto.subscribe(conf.params.laData.infoChannel, {
|
|
handler: function(v, e) {
|
|
if (typeof(conf.params.infoCallback) === "function") {
|
|
conf.params.infoCallback(v,e);
|
|
}
|
|
}
|
|
});
|
|
|
|
verto.subscribe(conf.params.laData.chatChannel, {
|
|
handler: function(v, e) {
|
|
if (typeof(conf.params.chatCallback) === "function") {
|
|
conf.params.chatCallback(v,e);
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
$.verto.conf.prototype.modCommand = function(cmd, id, value) {
|
|
var conf = this;
|
|
|
|
conf.verto.rpcClient.call("verto.broadcast", {
|
|
"eventChannel": conf.params.laData.modChannel,
|
|
"data": {
|
|
"application": "conf-control",
|
|
"command": cmd,
|
|
"id": id,
|
|
"value": value
|
|
}
|
|
});
|
|
};
|
|
|
|
$.verto.conf.prototype.destroy = function() {
|
|
var conf = this;
|
|
|
|
conf.destroyed = true;
|
|
conf.params.onBroadcast(conf.verto, conf, 'destroy');
|
|
|
|
if (conf.params.laData.modChannel) {
|
|
conf.verto.unsubscribe(conf.params.laData.modChannel);
|
|
}
|
|
|
|
if (conf.params.laData.chatChannel) {
|
|
conf.verto.unsubscribe(conf.params.laData.chatChannel);
|
|
}
|
|
|
|
if (conf.params.laData.infoChannel) {
|
|
conf.verto.unsubscribe(conf.params.laData.infoChannel);
|
|
}
|
|
};
|
|
|
|
function createMainModeratorMethods() {
|
|
$.verto.conf.prototype.listVideoLayouts = function() {
|
|
this.modCommand("list-videoLayouts", null, null);
|
|
};
|
|
|
|
$.verto.conf.prototype.play = function(file) {
|
|
this.modCommand("play", null, file);
|
|
};
|
|
|
|
$.verto.conf.prototype.stop = function() {
|
|
this.modCommand("stop", null, "all");
|
|
};
|
|
|
|
$.verto.conf.prototype.deaf = function(memberID) {
|
|
this.modCommand("deaf", parseInt(memberID));
|
|
};
|
|
|
|
$.verto.conf.prototype.undeaf = function(memberID) {
|
|
this.modCommand("undeaf", parseInt(memberID));
|
|
};
|
|
|
|
$.verto.conf.prototype.record = function(file) {
|
|
this.modCommand("recording", null, ["start", file]);
|
|
};
|
|
|
|
$.verto.conf.prototype.stopRecord = function() {
|
|
this.modCommand("recording", null, ["stop", "all"]);
|
|
};
|
|
|
|
$.verto.conf.prototype.snapshot = function(file) {
|
|
if (!this.params.hasVid) {
|
|
throw 'Conference has no video';
|
|
}
|
|
this.modCommand("vid-write-png", null, file);
|
|
};
|
|
|
|
$.verto.conf.prototype.setVideoLayout = function(layout, canvasID) {
|
|
if (!this.params.hasVid) {
|
|
throw 'Conference has no video';
|
|
}
|
|
if (canvasID) {
|
|
this.modCommand("vid-layout", null, [layout, canvasID]);
|
|
} else {
|
|
this.modCommand("vid-layout", null, layout);
|
|
}
|
|
};
|
|
|
|
$.verto.conf.prototype.kick = function(memberID) {
|
|
this.modCommand("kick", parseInt(memberID));
|
|
};
|
|
|
|
$.verto.conf.prototype.muteMic = function(memberID) {
|
|
this.modCommand("tmute", parseInt(memberID));
|
|
};
|
|
|
|
$.verto.conf.prototype.muteVideo = function(memberID) {
|
|
if (!this.params.hasVid) {
|
|
throw 'Conference has no video';
|
|
}
|
|
this.modCommand("tvmute", parseInt(memberID));
|
|
};
|
|
|
|
$.verto.conf.prototype.presenter = function(memberID) {
|
|
if (!this.params.hasVid) {
|
|
throw 'Conference has no video';
|
|
}
|
|
this.modCommand("vid-res-id", parseInt(memberID), "presenter");
|
|
};
|
|
|
|
$.verto.conf.prototype.videoFloor = function(memberID) {
|
|
if (!this.params.hasVid) {
|
|
throw 'Conference has no video';
|
|
}
|
|
this.modCommand("vid-floor", parseInt(memberID), "force");
|
|
};
|
|
|
|
$.verto.conf.prototype.banner = function(memberID, text) {
|
|
if (!this.params.hasVid) {
|
|
throw 'Conference has no video';
|
|
}
|
|
this.modCommand("vid-banner", parseInt(memberID), escape(text));
|
|
};
|
|
|
|
$.verto.conf.prototype.volumeDown = function(memberID) {
|
|
this.modCommand("volume_out", parseInt(memberID), "down");
|
|
};
|
|
|
|
$.verto.conf.prototype.volumeUp = function(memberID) {
|
|
this.modCommand("volume_out", parseInt(memberID), "up");
|
|
};
|
|
|
|
$.verto.conf.prototype.gainDown = function(memberID) {
|
|
this.modCommand("volume_in", parseInt(memberID), "down");
|
|
};
|
|
|
|
$.verto.conf.prototype.gainUp = function(memberID) {
|
|
this.modCommand("volume_in", parseInt(memberID), "up");
|
|
};
|
|
|
|
$.verto.conf.prototype.transfer = function(memberID, exten) {
|
|
this.modCommand("transfer", parseInt(memberID), exten);
|
|
};
|
|
|
|
$.verto.conf.prototype.sendChat = function(message, type) {
|
|
var conf = this;
|
|
conf.verto.rpcClient.call("verto.broadcast", {
|
|
"eventChannel": conf.params.laData.chatChannel,
|
|
"data": {
|
|
"action": "send",
|
|
"message": message,
|
|
"type": type
|
|
}
|
|
});
|
|
};
|
|
|
|
}
|
|
|
|
$.verto.modfuncs = {};
|
|
|
|
$.verto.confMan = function(verto, params) {
|
|
var confMan = this;
|
|
|
|
confMan.params = $.extend({
|
|
tableID: null,
|
|
statusID: null,
|
|
mainModID: null,
|
|
dialog: null,
|
|
hasVid: false,
|
|
laData: null,
|
|
onBroadcast: null,
|
|
onLaChange: null,
|
|
onLaRow: null
|
|
}, params);
|
|
|
|
confMan.verto = verto;
|
|
confMan.serno = CONFMAN_SERNO++;
|
|
confMan.canvasCount = confMan.params.laData.canvasCount;
|
|
|
|
function genMainMod(jq) {
|
|
var play_id = "play_" + confMan.serno;
|
|
var stop_id = "stop_" + confMan.serno;
|
|
var recording_id = "recording_" + confMan.serno;
|
|
var snapshot_id = "snapshot_" + confMan.serno;
|
|
var rec_stop_id = "recording_stop" + confMan.serno;
|
|
var div_id = "confman_" + confMan.serno;
|
|
|
|
var html = "<div id='" + div_id + "'><br>" +
|
|
"<button class='ctlbtn' id='" + play_id + "'>Play</button>" +
|
|
"<button class='ctlbtn' id='" + stop_id + "'>Stop</button>" +
|
|
"<button class='ctlbtn' id='" + recording_id + "'>Record</button>" +
|
|
"<button class='ctlbtn' id='" + rec_stop_id + "'>Record Stop</button>" +
|
|
(confMan.params.hasVid ? "<button class='ctlbtn' id='" + snapshot_id + "'>PNG Snapshot</button>" : "") +
|
|
"<br><br></div>";
|
|
|
|
jq.html(html);
|
|
|
|
$.verto.modfuncs.change_video_layout = function(id, canvas_id) {
|
|
var val = $("#" + id + " option:selected").text();
|
|
if (val !== "none") {
|
|
confMan.modCommand("vid-layout", null, [val, canvas_id]);
|
|
}
|
|
};
|
|
|
|
if (confMan.params.hasVid) {
|
|
for (var j = 0; j < confMan.canvasCount; j++) {
|
|
var vlayout_id = "confman_vid_layout_" + j + "_" + confMan.serno;
|
|
var vlselect_id = "confman_vl_select_" + j + "_" + confMan.serno;
|
|
|
|
|
|
var vlhtml = "<div id='" + vlayout_id + "'><br>" +
|
|
"<b>Video Layout Canvas " + (j+1) +
|
|
"</b> <select onChange='$.verto.modfuncs.change_video_layout(\"" + vlayout_id + "\", \"" + (j+1) + "\")' id='" + vlselect_id + "'></select> " +
|
|
"<br><br></div>";
|
|
jq.append(vlhtml);
|
|
}
|
|
|
|
$("#" + snapshot_id).click(function() {
|
|
var file = prompt("Please enter file name", "");
|
|
if (file) {
|
|
confMan.modCommand("vid-write-png", null, file);
|
|
}
|
|
});
|
|
}
|
|
|
|
$("#" + play_id).click(function() {
|
|
var file = prompt("Please enter file name", "");
|
|
if (file) {
|
|
confMan.modCommand("play", null, file);
|
|
}
|
|
});
|
|
|
|
$("#" + stop_id).click(function() {
|
|
confMan.modCommand("stop", null, "all");
|
|
});
|
|
|
|
$("#" + recording_id).click(function() {
|
|
var file = prompt("Please enter file name", "");
|
|
if (file) {
|
|
confMan.modCommand("recording", null, ["start", file]);
|
|
}
|
|
});
|
|
|
|
$("#" + rec_stop_id).click(function() {
|
|
confMan.modCommand("recording", null, ["stop", "all"]);
|
|
});
|
|
|
|
}
|
|
|
|
function genControls(jq, rowid) {
|
|
var x = parseInt(rowid);
|
|
var kick_id = "kick_" + x;
|
|
var canvas_in_next_id = "canvas_in_next_" + x;
|
|
var canvas_in_prev_id = "canvas_in_prev_" + x;
|
|
var canvas_out_next_id = "canvas_out_next_" + x;
|
|
var canvas_out_prev_id = "canvas_out_prev_" + x;
|
|
|
|
var canvas_in_set_id = "canvas_in_set_" + x;
|
|
var canvas_out_set_id = "canvas_out_set_" + x;
|
|
|
|
var layer_set_id = "layer_set_" + x;
|
|
var layer_next_id = "layer_next_" + x;
|
|
var layer_prev_id = "layer_prev_" + x;
|
|
|
|
var tmute_id = "tmute_" + x;
|
|
var tvmute_id = "tvmute_" + x;
|
|
var vbanner_id = "vbanner_" + x;
|
|
var tvpresenter_id = "tvpresenter_" + x;
|
|
var tvfloor_id = "tvfloor_" + x;
|
|
var box_id = "box_" + x;
|
|
var gainup_id = "gain_in_up" + x;
|
|
var gaindn_id = "gain_in_dn" + x;
|
|
var volup_id = "vol_in_up" + x;
|
|
var voldn_id = "vol_in_dn" + x;
|
|
var transfer_id = "transfer" + x;
|
|
|
|
|
|
var html = "<div id='" + box_id + "'>";
|
|
|
|
html += "<b>General Controls</b><hr noshade>";
|
|
|
|
html += "<button class='ctlbtn' id='" + kick_id + "'>Kick</button>" +
|
|
"<button class='ctlbtn' id='" + tmute_id + "'>Mute</button>" +
|
|
"<button class='ctlbtn' id='" + gainup_id + "'>Gain -</button>" +
|
|
"<button class='ctlbtn' id='" + gaindn_id + "'>Gain +</button>" +
|
|
"<button class='ctlbtn' id='" + voldn_id + "'>Vol -</button>" +
|
|
"<button class='ctlbtn' id='" + volup_id + "'>Vol +</button>" +
|
|
"<button class='ctlbtn' id='" + transfer_id + "'>Transfer</button>";
|
|
|
|
if (confMan.params.hasVid) {
|
|
html += "<br><br><b>Video Controls</b><hr noshade>";
|
|
|
|
|
|
html += "<button class='ctlbtn' id='" + tvmute_id + "'>VMute</button>" +
|
|
"<button class='ctlbtn' id='" + tvpresenter_id + "'>Presenter</button>" +
|
|
"<button class='ctlbtn' id='" + tvfloor_id + "'>Vid Floor</button>" +
|
|
"<button class='ctlbtn' id='" + vbanner_id + "'>Banner</button>";
|
|
|
|
if (confMan.canvasCount > 1) {
|
|
html += "<br><br><b>Canvas Controls</b><hr noshade>" +
|
|
"<button class='ctlbtn' id='" + canvas_in_set_id + "'>Set Input Canvas</button>" +
|
|
"<button class='ctlbtn' id='" + canvas_in_prev_id + "'>Prev Input Canvas</button>" +
|
|
"<button class='ctlbtn' id='" + canvas_in_next_id + "'>Next Input Canvas</button>" +
|
|
|
|
"<br>" +
|
|
|
|
"<button class='ctlbtn' id='" + canvas_out_set_id + "'>Set Watching Canvas</button>" +
|
|
"<button class='ctlbtn' id='" + canvas_out_prev_id + "'>Prev Watching Canvas</button>" +
|
|
"<button class='ctlbtn' id='" + canvas_out_next_id + "'>Next Watching Canvas</button>";
|
|
}
|
|
|
|
html += "<br>" +
|
|
|
|
"<button class='ctlbtn' id='" + layer_set_id + "'>Set Layer</button>" +
|
|
"<button class='ctlbtn' id='" + layer_prev_id + "'>Prev Layer</button>" +
|
|
"<button class='ctlbtn' id='" + layer_next_id + "'>Next Layer</button>" +
|
|
|
|
|
|
|
|
"</div>";
|
|
}
|
|
|
|
jq.html(html);
|
|
|
|
|
|
if (!jq.data("mouse")) {
|
|
$("#" + box_id).hide();
|
|
}
|
|
|
|
jq.mouseover(function(e) {
|
|
jq.data({"mouse": true});
|
|
$("#" + box_id).show();
|
|
});
|
|
|
|
jq.mouseout(function(e) {
|
|
jq.data({"mouse": false});
|
|
$("#" + box_id).hide();
|
|
});
|
|
|
|
$("#" + transfer_id).click(function() {
|
|
var xten = prompt("Enter Extension");
|
|
if (xten) {
|
|
confMan.modCommand("transfer", x, xten);
|
|
}
|
|
});
|
|
|
|
$("#" + kick_id).click(function() {
|
|
confMan.modCommand("kick", x);
|
|
});
|
|
|
|
|
|
$("#" + layer_set_id).click(function() {
|
|
var cid = prompt("Please enter layer ID", "");
|
|
if (cid) {
|
|
confMan.modCommand("vid-layer", x, cid);
|
|
}
|
|
});
|
|
|
|
$("#" + layer_next_id).click(function() {
|
|
confMan.modCommand("vid-layer", x, "next");
|
|
});
|
|
$("#" + layer_prev_id).click(function() {
|
|
confMan.modCommand("vid-layer", x, "prev");
|
|
});
|
|
|
|
$("#" + canvas_in_set_id).click(function() {
|
|
var cid = prompt("Please enter canvas ID", "");
|
|
if (cid) {
|
|
confMan.modCommand("vid-canvas", x, cid);
|
|
}
|
|
});
|
|
|
|
$("#" + canvas_out_set_id).click(function() {
|
|
var cid = prompt("Please enter canvas ID", "");
|
|
if (cid) {
|
|
confMan.modCommand("vid-watching-canvas", x, cid);
|
|
}
|
|
});
|
|
|
|
$("#" + canvas_in_next_id).click(function() {
|
|
confMan.modCommand("vid-canvas", x, "next");
|
|
});
|
|
$("#" + canvas_in_prev_id).click(function() {
|
|
confMan.modCommand("vid-canvas", x, "prev");
|
|
});
|
|
|
|
|
|
$("#" + canvas_out_next_id).click(function() {
|
|
confMan.modCommand("vid-watching-canvas", x, "next");
|
|
});
|
|
$("#" + canvas_out_prev_id).click(function() {
|
|
confMan.modCommand("vid-watching-canvas", x, "prev");
|
|
});
|
|
|
|
$("#" + tmute_id).click(function() {
|
|
confMan.modCommand("tmute", x);
|
|
});
|
|
|
|
if (confMan.params.hasVid) {
|
|
$("#" + tvmute_id).click(function() {
|
|
confMan.modCommand("tvmute", x);
|
|
});
|
|
$("#" + tvpresenter_id).click(function() {
|
|
confMan.modCommand("vid-res-id", x, "presenter");
|
|
});
|
|
$("#" + tvfloor_id).click(function() {
|
|
confMan.modCommand("vid-floor", x, "force");
|
|
});
|
|
$("#" + vbanner_id).click(function() {
|
|
var text = prompt("Please enter text", "");
|
|
if (text) {
|
|
confMan.modCommand("vid-banner", x, escape(text));
|
|
}
|
|
});
|
|
}
|
|
|
|
$("#" + gainup_id).click(function() {
|
|
confMan.modCommand("volume_in", x, "up");
|
|
});
|
|
|
|
$("#" + gaindn_id).click(function() {
|
|
confMan.modCommand("volume_in", x, "down");
|
|
});
|
|
|
|
$("#" + volup_id).click(function() {
|
|
confMan.modCommand("volume_out", x, "up");
|
|
});
|
|
|
|
$("#" + voldn_id).click(function() {
|
|
confMan.modCommand("volume_out", x, "down");
|
|
});
|
|
|
|
return html;
|
|
}
|
|
|
|
var atitle = "";
|
|
var awidth = 0;
|
|
|
|
//$(".jsDataTable").width(confMan.params.hasVid ? "900px" : "800px");
|
|
|
|
verto.subscribe(confMan.params.laData.infoChannel, {
|
|
handler: function(v, e) {
|
|
if (typeof(confMan.params.infoCallback) === "function") {
|
|
confMan.params.infoCallback(v,e);
|
|
}
|
|
}
|
|
});
|
|
|
|
verto.subscribe(confMan.params.laData.chatChannel, {
|
|
handler: function(v, e) {
|
|
if (typeof(confMan.params.chatCallback) === "function") {
|
|
confMan.params.chatCallback(v,e);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (confMan.params.laData.role === "moderator") {
|
|
atitle = "Action";
|
|
awidth = 600;
|
|
|
|
if (confMan.params.mainModID) {
|
|
genMainMod($(confMan.params.mainModID));
|
|
$(confMan.params.displayID).html("Moderator Controls Ready<br><br>");
|
|
} else {
|
|
$(confMan.params.mainModID).html("");
|
|
}
|
|
|
|
verto.subscribe(confMan.params.laData.modChannel, {
|
|
handler: function(v, e) {
|
|
//console.error("MODDATA:", e.data);
|
|
if (confMan.params.onBroadcast) {
|
|
confMan.params.onBroadcast(verto, confMan, e.data);
|
|
}
|
|
|
|
if (e.data["conf-command"] === "list-videoLayouts") {
|
|
for (var j = 0; j < confMan.canvasCount; j++) {
|
|
var vlselect_id = "#confman_vl_select_" + j + "_" + confMan.serno;
|
|
var vlayout_id = "#confman_vid_layout_" + j + "_" + confMan.serno;
|
|
|
|
var x = 0;
|
|
var options;
|
|
|
|
$(vlselect_id).selectmenu({});
|
|
$(vlselect_id).selectmenu("enable");
|
|
$(vlselect_id).empty();
|
|
|
|
$(vlselect_id).append(new Option("Choose a Layout", "none"));
|
|
|
|
if (e.data.responseData) {
|
|
var rdata = [];
|
|
|
|
for (var i in e.data.responseData) {
|
|
rdata.push(e.data.responseData[i].name);
|
|
}
|
|
|
|
options = rdata.sort(function(a, b) {
|
|
var ga = a.substring(0, 6) == "group:" ? true : false;
|
|
var gb = b.substring(0, 6) == "group:" ? true : false;
|
|
|
|
if ((ga || gb) && ga != gb) {
|
|
return ga ? -1 : 1;
|
|
}
|
|
|
|
return ( ( a == b ) ? 0 : ( ( a > b ) ? 1 : -1 ) );
|
|
});
|
|
|
|
for (var i in options) {
|
|
$(vlselect_id).append(new Option(options[i], options[i]));
|
|
x++;
|
|
}
|
|
}
|
|
|
|
if (x) {
|
|
$(vlselect_id).selectmenu('refresh', true);
|
|
} else {
|
|
$(vlayout_id).hide();
|
|
}
|
|
}
|
|
} else {
|
|
|
|
if (!confMan.destroyed && confMan.params.displayID) {
|
|
$(confMan.params.displayID).html(e.data.response + "<br><br>");
|
|
if (confMan.lastTimeout) {
|
|
clearTimeout(confMan.lastTimeout);
|
|
confMan.lastTimeout = 0;
|
|
}
|
|
confMan.lastTimeout = setTimeout(function() { $(confMan.params.displayID).html(confMan.destroyed ? "" : "Moderator Controls Ready<br><br>");}, 4000);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
|
|
if (confMan.params.hasVid) {
|
|
confMan.modCommand("list-videoLayouts", null, null);
|
|
}
|
|
}
|
|
|
|
var row_callback = null;
|
|
|
|
if (confMan.params.laData.role === "moderator") {
|
|
row_callback = function(nRow, aData, iDisplayIndex, iDisplayIndexFull) {
|
|
if (!aData[5]) {
|
|
var $row = $('td:eq(5)', nRow);
|
|
genControls($row, aData);
|
|
|
|
if (confMan.params.onLaRow) {
|
|
confMan.params.onLaRow(verto, confMan, $row, aData);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
confMan.lt = new $.verto.liveTable(verto, confMan.params.laData.laChannel, confMan.params.laData.laName, $(confMan.params.tableID), {
|
|
subParams: {
|
|
callID: confMan.params.dialog ? confMan.params.dialog.callID : null
|
|
},
|
|
|
|
"onChange": function(obj, args) {
|
|
$(confMan.params.statusID).text("Conference Members: " + " (" + obj.arrayLen() + " Total)");
|
|
if (confMan.params.onLaChange) {
|
|
confMan.params.onLaChange(verto, confMan, $.verto.enum.confEvent.laChange, obj, args);
|
|
}
|
|
},
|
|
|
|
"aaData": [],
|
|
"aoColumns": [
|
|
{
|
|
"sTitle": "ID",
|
|
"sWidth": "50"
|
|
},
|
|
{
|
|
"sTitle": "Number",
|
|
"sWidth": "250"
|
|
},
|
|
{
|
|
"sTitle": "Name",
|
|
"sWidth": "250"
|
|
},
|
|
{
|
|
"sTitle": "Codec",
|
|
"sWidth": "100"
|
|
},
|
|
{
|
|
"sTitle": "Status",
|
|
"sWidth": confMan.params.hasVid ? "200px" : "150px"
|
|
},
|
|
{
|
|
"sTitle": atitle,
|
|
"sWidth": awidth,
|
|
}
|
|
],
|
|
"bAutoWidth": true,
|
|
"bDestroy": true,
|
|
"bSort": false,
|
|
"bInfo": false,
|
|
"bFilter": false,
|
|
"bLengthChange": false,
|
|
"bPaginate": false,
|
|
"iDisplayLength": 1400,
|
|
|
|
"oLanguage": {
|
|
"sEmptyTable": "The Conference is Empty....."
|
|
},
|
|
|
|
"fnRowCallback": row_callback
|
|
|
|
});
|
|
};
|
|
|
|
$.verto.confMan.prototype.modCommand = function(cmd, id, value) {
|
|
var confMan = this;
|
|
|
|
confMan.verto.rpcClient.call("verto.broadcast", {
|
|
"eventChannel": confMan.params.laData.modChannel,
|
|
"data": {
|
|
"application": "conf-control",
|
|
"command": cmd,
|
|
"id": id,
|
|
"value": value
|
|
}
|
|
});
|
|
};
|
|
|
|
$.verto.confMan.prototype.sendChat = function(message, type) {
|
|
var confMan = this;
|
|
confMan.verto.rpcClient.call("verto.broadcast", {
|
|
"eventChannel": confMan.params.laData.chatChannel,
|
|
"data": {
|
|
"action": "send",
|
|
"message": message,
|
|
"type": type
|
|
}
|
|
});
|
|
};
|
|
|
|
|
|
$.verto.confMan.prototype.destroy = function() {
|
|
var confMan = this;
|
|
|
|
confMan.destroyed = true;
|
|
|
|
if (confMan.lt) {
|
|
confMan.lt.destroy();
|
|
}
|
|
|
|
if (confMan.params.laData.chatChannel) {
|
|
confMan.verto.unsubscribe(confMan.params.laData.chatChannel);
|
|
}
|
|
|
|
if (confMan.params.laData.modChannel) {
|
|
confMan.verto.unsubscribe(confMan.params.laData.modChannel);
|
|
}
|
|
|
|
if (confMan.params.mainModID) {
|
|
$(confMan.params.mainModID).html("");
|
|
}
|
|
};
|
|
|
|
$.verto.dialog = function(direction, verto, params) {
|
|
var dialog = this;
|
|
|
|
dialog.params = $.extend({
|
|
useVideo: verto.options.useVideo,
|
|
useStereo: verto.options.useStereo,
|
|
screenShare: false,
|
|
useCamera: false,
|
|
useMic: verto.options.deviceParams.useMic,
|
|
useSpeak: verto.options.deviceParams.useSpeak,
|
|
tag: verto.options.tag,
|
|
localTag: verto.options.localTag,
|
|
login: verto.options.login,
|
|
videoParams: verto.options.videoParams
|
|
}, params);
|
|
|
|
|
|
if (!dialog.params.screenShare) {
|
|
dialog.params.useCamera = verto.options.deviceParams.useCamera;
|
|
}
|
|
|
|
dialog.verto = verto;
|
|
dialog.direction = direction;
|
|
dialog.lastState = null;
|
|
dialog.state = dialog.lastState = $.verto.enum.state.new;
|
|
dialog.callbacks = verto.callbacks;
|
|
dialog.answered = false;
|
|
dialog.attach = params.attach || false;
|
|
dialog.screenShare = params.screenShare || false;
|
|
dialog.useCamera = dialog.params.useCamera;
|
|
dialog.useMic = dialog.params.useMic;
|
|
dialog.useSpeak = dialog.params.useSpeak;
|
|
|
|
if (dialog.params.callID) {
|
|
dialog.callID = dialog.params.callID;
|
|
} else {
|
|
dialog.callID = dialog.params.callID = generateGUID();
|
|
}
|
|
|
|
if (typeof(dialog.params.tag) === "function") {
|
|
dialog.params.tag = dialog.params.tag();
|
|
}
|
|
|
|
if (dialog.params.tag) {
|
|
dialog.audioStream = document.getElementById(dialog.params.tag);
|
|
|
|
if (dialog.params.useVideo) {
|
|
dialog.videoStream = dialog.audioStream;
|
|
}
|
|
} //else conjure one TBD
|
|
|
|
if (dialog.params.localTag) {
|
|
dialog.localVideo = document.getElementById(dialog.params.localTag);
|
|
}
|
|
|
|
dialog.verto.dialogs[dialog.callID] = dialog;
|
|
|
|
var RTCcallbacks = {};
|
|
|
|
if (dialog.direction == $.verto.enum.direction.inbound) {
|
|
if (dialog.params.display_direction === "outbound") {
|
|
dialog.params.remote_caller_id_name = dialog.params.caller_id_name;
|
|
dialog.params.remote_caller_id_number = dialog.params.caller_id_number;
|
|
} else {
|
|
dialog.params.remote_caller_id_name = dialog.params.callee_id_name;
|
|
dialog.params.remote_caller_id_number = dialog.params.callee_id_number;
|
|
}
|
|
|
|
if (!dialog.params.remote_caller_id_name) {
|
|
dialog.params.remote_caller_id_name = "Nobody";
|
|
}
|
|
|
|
if (!dialog.params.remote_caller_id_number) {
|
|
dialog.params.remote_caller_id_number = "UNKNOWN";
|
|
}
|
|
|
|
RTCcallbacks.onMessage = function(rtc, msg) {
|
|
console.debug(msg);
|
|
};
|
|
|
|
RTCcallbacks.onAnswerSDP = function(rtc, sdp) {
|
|
console.error("answer sdp", sdp);
|
|
};
|
|
} else {
|
|
dialog.params.remote_caller_id_name = "Outbound Call";
|
|
dialog.params.remote_caller_id_number = dialog.params.destination_number;
|
|
}
|
|
|
|
RTCcallbacks.onICESDP = function(rtc) {
|
|
console.log("RECV " + rtc.type + " SDP", rtc.mediaData.SDP);
|
|
|
|
if (dialog.state == $.verto.enum.state.requesting || dialog.state == $.verto.enum.state.answering || dialog.state == $.verto.enum.state.active) {
|
|
location.reload();
|
|
return;
|
|
}
|
|
|
|
if (rtc.type == "offer") {
|
|
if (dialog.state == $.verto.enum.state.active) {
|
|
dialog.setState($.verto.enum.state.requesting);
|
|
dialog.sendMethod("verto.attach", {
|
|
sdp: rtc.mediaData.SDP
|
|
});
|
|
} else {
|
|
dialog.setState($.verto.enum.state.requesting);
|
|
|
|
dialog.sendMethod("verto.invite", {
|
|
sdp: rtc.mediaData.SDP
|
|
});
|
|
}
|
|
} else { //answer
|
|
dialog.setState($.verto.enum.state.answering);
|
|
|
|
dialog.sendMethod(dialog.attach ? "verto.attach" : "verto.answer", {
|
|
sdp: dialog.rtc.mediaData.SDP
|
|
});
|
|
}
|
|
};
|
|
|
|
RTCcallbacks.onICE = function(rtc) {
|
|
//console.log("cand", rtc.mediaData.candidate);
|
|
if (rtc.type == "offer") {
|
|
console.log("offer", rtc.mediaData.candidate);
|
|
return;
|
|
}
|
|
};
|
|
|
|
RTCcallbacks.onStream = function(rtc, stream) {
|
|
if (dialog.verto.options.permissionCallback &&
|
|
typeof dialog.verto.options.permissionCallback.onGranted === 'function'){
|
|
dialog.verto.options.permissionCallback.onGranted(stream);
|
|
}
|
|
console.log("stream started");
|
|
};
|
|
|
|
RTCcallbacks.onError = function(e) {
|
|
if (dialog.verto.options.permissionCallback &&
|
|
typeof dialog.verto.options.permissionCallback.onDenied === 'function'){
|
|
dialog.verto.options.permissionCallback.onDenied();
|
|
}
|
|
console.error("ERROR:", e);
|
|
dialog.hangup({cause: "Device or Permission Error"});
|
|
};
|
|
|
|
dialog.rtc = new $.FSRTC({
|
|
callbacks: RTCcallbacks,
|
|
localVideo: dialog.screenShare ? null : dialog.localVideo,
|
|
useVideo: dialog.params.useVideo ? dialog.videoStream : null,
|
|
useAudio: dialog.audioStream,
|
|
useStereo: dialog.params.useStereo,
|
|
videoParams: dialog.params.videoParams,
|
|
audioParams: verto.options.audioParams,
|
|
iceServers: verto.options.iceServers,
|
|
screenShare: dialog.screenShare,
|
|
useCamera: dialog.useCamera,
|
|
useMic: dialog.useMic,
|
|
useSpeak: dialog.useSpeak,
|
|
turnServer: verto.options.turnServer
|
|
});
|
|
|
|
dialog.rtc.verto = dialog.verto;
|
|
|
|
if (dialog.direction == $.verto.enum.direction.inbound) {
|
|
if (dialog.attach) {
|
|
dialog.answer();
|
|
} else {
|
|
dialog.ring();
|
|
}
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.invite = function() {
|
|
var dialog = this;
|
|
dialog.rtc.call();
|
|
};
|
|
|
|
$.verto.dialog.prototype.sendMethod = function(method, obj) {
|
|
var dialog = this;
|
|
obj.dialogParams = {};
|
|
|
|
for (var i in dialog.params) {
|
|
if (i == "sdp" && method != "verto.invite" && method != "verto.attach") {
|
|
continue;
|
|
}
|
|
|
|
if ((obj.noDialogParams && i != "callID")) {
|
|
continue;
|
|
}
|
|
|
|
obj.dialogParams[i] = dialog.params[i];
|
|
}
|
|
|
|
delete obj.noDialogParams;
|
|
|
|
dialog.verto.rpcClient.call(method, obj,
|
|
|
|
function(e) {
|
|
/* Success */
|
|
dialog.processReply(method, true, e);
|
|
},
|
|
|
|
function(e) {
|
|
/* Error */
|
|
dialog.processReply(method, false, e);
|
|
});
|
|
};
|
|
|
|
function checkStateChange(oldS, newS) {
|
|
|
|
if (newS == $.verto.enum.state.purge || $.verto.enum.states[oldS.name][newS.name]) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// Attach audio output device to video element using device/sink ID.
|
|
function find_name(id) {
|
|
for (var i in $.verto.audioOutDevices) {
|
|
var source = $.verto.audioOutDevices[i];
|
|
if (source.id === id) {
|
|
return(source.label);
|
|
}
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
$.verto.dialog.prototype.setAudioPlaybackDevice = function(sinkId, callback, arg) {
|
|
var dialog = this;
|
|
var element = dialog.audioStream;
|
|
|
|
if (typeof element.sinkId !== 'undefined') {
|
|
var devname = find_name(sinkId);
|
|
console.info("Dialog: " + dialog.callID + " Setting speaker:", element, devname);
|
|
|
|
element.setSinkId(sinkId)
|
|
.then(function() {
|
|
console.log("Dialog: " + dialog.callID + ' Success, audio output device attached: ' + sinkId);
|
|
if (callback) {
|
|
callback(true, devname, arg);
|
|
}
|
|
})
|
|
.catch(function(error) {
|
|
var errorMessage = error;
|
|
if (error.name === 'SecurityError') {
|
|
errorMessage = "Dialog: " + dialog.callID + ' You need to use HTTPS for selecting audio output ' +
|
|
'device: ' + error;
|
|
}
|
|
if (callback) {
|
|
callback(false, null, arg);
|
|
}
|
|
console.error(errorMessage);
|
|
});
|
|
} else {
|
|
console.warn("Dialog: " + dialog.callID + ' Browser does not support output device selection.');
|
|
if (callback) {
|
|
callback(false, null, arg);
|
|
}
|
|
}
|
|
}
|
|
|
|
$.verto.dialog.prototype.setState = function(state) {
|
|
var dialog = this;
|
|
|
|
if (dialog.state == $.verto.enum.state.ringing) {
|
|
dialog.stopRinging();
|
|
}
|
|
|
|
if (dialog.state == state || !checkStateChange(dialog.state, state)) {
|
|
console.error("Dialog " + dialog.callID + ": INVALID state change from " + dialog.state.name + " to " + state.name);
|
|
dialog.hangup();
|
|
return false;
|
|
}
|
|
|
|
console.log("Dialog " + dialog.callID + ": state change from " + dialog.state.name + " to " + state.name);
|
|
|
|
dialog.lastState = dialog.state;
|
|
dialog.state = state;
|
|
|
|
if (dialog.callbacks.onDialogState) {
|
|
dialog.callbacks.onDialogState(this);
|
|
}
|
|
|
|
switch (dialog.state) {
|
|
|
|
case $.verto.enum.state.early:
|
|
case $.verto.enum.state.active:
|
|
|
|
var speaker = dialog.useSpeak;
|
|
console.info("Using Speaker: ", speaker);
|
|
|
|
if (speaker && speaker !== "any" && speaker !== "none") {
|
|
setTimeout(function() {
|
|
dialog.setAudioPlaybackDevice(speaker);
|
|
}, 500);
|
|
}
|
|
|
|
break;
|
|
|
|
case $.verto.enum.state.trying:
|
|
setTimeout(function() {
|
|
if (dialog.state == $.verto.enum.state.trying) {
|
|
dialog.setState($.verto.enum.state.hangup);
|
|
}
|
|
}, 30000);
|
|
break;
|
|
case $.verto.enum.state.purge:
|
|
dialog.setState($.verto.enum.state.destroy);
|
|
break;
|
|
case $.verto.enum.state.hangup:
|
|
|
|
if (dialog.lastState.val > $.verto.enum.state.requesting.val && dialog.lastState.val < $.verto.enum.state.hangup.val) {
|
|
dialog.sendMethod("verto.bye", {});
|
|
}
|
|
|
|
dialog.setState($.verto.enum.state.destroy);
|
|
break;
|
|
case $.verto.enum.state.destroy:
|
|
|
|
if (typeof(dialog.verto.options.tag) === "function") {
|
|
$('#' + dialog.params.tag).remove();
|
|
}
|
|
|
|
delete dialog.verto.dialogs[dialog.callID];
|
|
if (dialog.params.screenShare) {
|
|
dialog.rtc.stopPeer();
|
|
} else {
|
|
dialog.rtc.stop();
|
|
}
|
|
break;
|
|
}
|
|
|
|
return true;
|
|
};
|
|
|
|
$.verto.dialog.prototype.processReply = function(method, success, e) {
|
|
var dialog = this;
|
|
|
|
//console.log("Response: " + method + " State:" + dialog.state.name, success, e);
|
|
|
|
switch (method) {
|
|
|
|
case "verto.answer":
|
|
case "verto.attach":
|
|
if (success) {
|
|
dialog.setState($.verto.enum.state.active);
|
|
} else {
|
|
dialog.hangup();
|
|
}
|
|
break;
|
|
case "verto.invite":
|
|
if (success) {
|
|
dialog.setState($.verto.enum.state.trying);
|
|
} else {
|
|
dialog.setState($.verto.enum.state.destroy);
|
|
}
|
|
break;
|
|
|
|
case "verto.bye":
|
|
dialog.hangup();
|
|
break;
|
|
|
|
case "verto.modify":
|
|
if (e.holdState) {
|
|
if (e.holdState == "held") {
|
|
if (dialog.state != $.verto.enum.state.held) {
|
|
dialog.setState($.verto.enum.state.held);
|
|
}
|
|
} else if (e.holdState == "active") {
|
|
if (dialog.state != $.verto.enum.state.active) {
|
|
dialog.setState($.verto.enum.state.active);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (success) {}
|
|
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
};
|
|
|
|
$.verto.dialog.prototype.hangup = function(params) {
|
|
var dialog = this;
|
|
|
|
if (params) {
|
|
if (params.causeCode) {
|
|
dialog.causeCode = params.causeCode;
|
|
}
|
|
|
|
if (params.cause) {
|
|
dialog.cause = params.cause;
|
|
}
|
|
}
|
|
|
|
if (!dialog.cause && !dialog.causeCode) {
|
|
dialog.cause = "NORMAL_CLEARING";
|
|
}
|
|
|
|
if (dialog.state.val >= $.verto.enum.state.new.val && dialog.state.val < $.verto.enum.state.hangup.val) {
|
|
dialog.setState($.verto.enum.state.hangup);
|
|
} else if (dialog.state.val < $.verto.enum.state.destroy) {
|
|
dialog.setState($.verto.enum.state.destroy);
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.stopRinging = function() {
|
|
var dialog = this;
|
|
if (dialog.verto.ringer) {
|
|
dialog.verto.ringer.stop();
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.indicateRing = function() {
|
|
var dialog = this;
|
|
|
|
if (dialog.verto.ringer) {
|
|
dialog.verto.ringer.attr("src", dialog.verto.options.ringFile)[0].play();
|
|
|
|
setTimeout(function() {
|
|
dialog.stopRinging();
|
|
if (dialog.state == $.verto.enum.state.ringing) {
|
|
dialog.indicateRing();
|
|
}
|
|
},
|
|
dialog.verto.options.ringSleep);
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.ring = function() {
|
|
var dialog = this;
|
|
|
|
dialog.setState($.verto.enum.state.ringing);
|
|
dialog.indicateRing();
|
|
};
|
|
|
|
$.verto.dialog.prototype.useVideo = function(on) {
|
|
var dialog = this;
|
|
|
|
dialog.params.useVideo = on;
|
|
|
|
if (on) {
|
|
dialog.videoStream = dialog.audioStream;
|
|
} else {
|
|
dialog.videoStream = null;
|
|
}
|
|
|
|
dialog.rtc.useVideo(dialog.videoStream, dialog.localVideo);
|
|
|
|
};
|
|
|
|
$.verto.dialog.prototype.setMute = function(what) {
|
|
var dialog = this;
|
|
return dialog.rtc.setMute(what);
|
|
};
|
|
|
|
$.verto.dialog.prototype.getMute = function() {
|
|
var dialog = this;
|
|
return dialog.rtc.getMute();
|
|
};
|
|
|
|
$.verto.dialog.prototype.setVideoMute = function(what) {
|
|
var dialog = this;
|
|
return dialog.rtc.setVideoMute(what);
|
|
};
|
|
|
|
$.verto.dialog.prototype.getVideoMute = function() {
|
|
var dialog = this;
|
|
return dialog.rtc.getVideoMute();
|
|
};
|
|
|
|
$.verto.dialog.prototype.useStereo = function(on) {
|
|
var dialog = this;
|
|
|
|
dialog.params.useStereo = on;
|
|
dialog.rtc.useStereo(on);
|
|
};
|
|
|
|
$.verto.dialog.prototype.dtmf = function(digits) {
|
|
var dialog = this;
|
|
if (digits) {
|
|
dialog.sendMethod("verto.info", {
|
|
dtmf: digits
|
|
});
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.rtt = function(obj) {
|
|
var dialog = this;
|
|
var pobj = {};
|
|
|
|
if (!obj) {
|
|
return false;
|
|
}
|
|
|
|
pobj.code = obj.code;
|
|
pobj.chars = obj.chars;
|
|
|
|
|
|
if (pobj.chars || pobj.code) {
|
|
dialog.sendMethod("verto.info", {
|
|
txt: obj,
|
|
noDialogParams: true
|
|
});
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.transfer = function(dest, params) {
|
|
var dialog = this;
|
|
if (dest) {
|
|
dialog.sendMethod("verto.modify", {
|
|
action: "transfer",
|
|
destination: dest,
|
|
params: params
|
|
});
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.replace = function(replaceCallID, params) {
|
|
var dialog = this;
|
|
if (replaceCallID) {
|
|
dialog.sendMethod("verto.modify", {
|
|
action: "replace",
|
|
replaceCallID: replaceCallID,
|
|
params: params
|
|
});
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.hold = function(params) {
|
|
var dialog = this;
|
|
|
|
dialog.sendMethod("verto.modify", {
|
|
action: "hold",
|
|
params: params
|
|
});
|
|
};
|
|
|
|
$.verto.dialog.prototype.unhold = function(params) {
|
|
var dialog = this;
|
|
|
|
dialog.sendMethod("verto.modify", {
|
|
action: "unhold",
|
|
params: params
|
|
});
|
|
};
|
|
|
|
$.verto.dialog.prototype.toggleHold = function(params) {
|
|
var dialog = this;
|
|
|
|
dialog.sendMethod("verto.modify", {
|
|
action: "toggleHold",
|
|
params: params
|
|
});
|
|
};
|
|
|
|
$.verto.dialog.prototype.message = function(msg) {
|
|
var dialog = this;
|
|
var err = 0;
|
|
|
|
msg.from = dialog.params.login;
|
|
|
|
if (!msg.to) {
|
|
console.error("Missing To");
|
|
err++;
|
|
}
|
|
|
|
if (!msg.body) {
|
|
console.error("Missing Body");
|
|
err++;
|
|
}
|
|
|
|
if (err) {
|
|
return false;
|
|
}
|
|
|
|
dialog.sendMethod("verto.info", {
|
|
msg: msg
|
|
});
|
|
|
|
return true;
|
|
};
|
|
|
|
$.verto.dialog.prototype.answer = function(params) {
|
|
var dialog = this;
|
|
|
|
if (!dialog.answered) {
|
|
if (!params) {
|
|
params = {};
|
|
}
|
|
|
|
params.sdp = dialog.params.sdp;
|
|
|
|
if (params) {
|
|
if (params.useVideo) {
|
|
dialog.useVideo(true);
|
|
}
|
|
dialog.params.callee_id_name = params.callee_id_name;
|
|
dialog.params.callee_id_number = params.callee_id_number;
|
|
|
|
if (params.useCamera) {
|
|
dialog.useCamera = params.useCamera;
|
|
}
|
|
|
|
if (params.useMic) {
|
|
dialog.useMic = params.useMic;
|
|
}
|
|
|
|
if (params.useSpeak) {
|
|
dialog.useSpeak = params.useSpeak;
|
|
}
|
|
}
|
|
|
|
dialog.rtc.createAnswer(params);
|
|
dialog.answered = true;
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.handleAnswer = function(params) {
|
|
var dialog = this;
|
|
|
|
dialog.gotAnswer = true;
|
|
|
|
if (dialog.state.val >= $.verto.enum.state.active.val) {
|
|
return;
|
|
}
|
|
|
|
if (dialog.state.val >= $.verto.enum.state.early.val) {
|
|
dialog.setState($.verto.enum.state.active);
|
|
} else {
|
|
if (dialog.gotEarly) {
|
|
console.log("Dialog " + dialog.callID + " Got answer while still establishing early media, delaying...");
|
|
} else {
|
|
console.log("Dialog " + dialog.callID + " Answering Channel");
|
|
dialog.rtc.answer(params.sdp, function() {
|
|
dialog.setState($.verto.enum.state.active);
|
|
}, function(e) {
|
|
console.error(e);
|
|
dialog.hangup();
|
|
});
|
|
console.log("Dialog " + dialog.callID + "ANSWER SDP", params.sdp);
|
|
}
|
|
}
|
|
|
|
|
|
};
|
|
|
|
$.verto.dialog.prototype.cidString = function(enc) {
|
|
var dialog = this;
|
|
var party = dialog.params.remote_caller_id_name + (enc ? " <" : " <") + dialog.params.remote_caller_id_number + (enc ? ">" : ">");
|
|
return party;
|
|
};
|
|
|
|
$.verto.dialog.prototype.sendMessage = function(msg, params) {
|
|
var dialog = this;
|
|
|
|
if (dialog.callbacks.onMessage) {
|
|
dialog.callbacks.onMessage(dialog.verto, dialog, msg, params);
|
|
}
|
|
};
|
|
|
|
$.verto.dialog.prototype.handleInfo = function(params) {
|
|
var dialog = this;
|
|
|
|
dialog.sendMessage($.verto.enum.message.info, params);
|
|
|
|
};
|
|
|
|
$.verto.dialog.prototype.handleDisplay = function(params) {
|
|
var dialog = this;
|
|
|
|
if (params.display_name) {
|
|
dialog.params.remote_caller_id_name = params.display_name;
|
|
}
|
|
if (params.display_number) {
|
|
dialog.params.remote_caller_id_number = params.display_number;
|
|
}
|
|
|
|
dialog.sendMessage($.verto.enum.message.display, {});
|
|
};
|
|
|
|
$.verto.dialog.prototype.handleMedia = function(params) {
|
|
var dialog = this;
|
|
|
|
if (dialog.state.val >= $.verto.enum.state.early.val) {
|
|
return;
|
|
}
|
|
|
|
dialog.gotEarly = true;
|
|
|
|
dialog.rtc.answer(params.sdp, function() {
|
|
console.log("Dialog " + dialog.callID + "Establishing early media");
|
|
dialog.setState($.verto.enum.state.early);
|
|
|
|
if (dialog.gotAnswer) {
|
|
console.log("Dialog " + dialog.callID + "Answering Channel");
|
|
dialog.setState($.verto.enum.state.active);
|
|
}
|
|
}, function(e) {
|
|
console.error(e);
|
|
dialog.hangup();
|
|
});
|
|
console.log("Dialog " + dialog.callID + "EARLY SDP", params.sdp);
|
|
};
|
|
|
|
$.verto.ENUM = function(s) {
|
|
var i = 0,
|
|
o = {};
|
|
s.split(" ").map(function(x) {
|
|
o[x] = {
|
|
name: x,
|
|
val: i++
|
|
};
|
|
});
|
|
return Object.freeze(o);
|
|
};
|
|
|
|
$.verto.enum = {};
|
|
|
|
$.verto.enum.states = Object.freeze({
|
|
new: {
|
|
requesting: 1,
|
|
recovering: 1,
|
|
ringing: 1,
|
|
destroy: 1,
|
|
answering: 1,
|
|
hangup: 1
|
|
},
|
|
requesting: {
|
|
trying: 1,
|
|
hangup: 1,
|
|
active: 1
|
|
},
|
|
recovering: {
|
|
answering: 1,
|
|
hangup: 1
|
|
},
|
|
trying: {
|
|
active: 1,
|
|
early: 1,
|
|
hangup: 1
|
|
},
|
|
ringing: {
|
|
answering: 1,
|
|
hangup: 1
|
|
},
|
|
answering: {
|
|
active: 1,
|
|
hangup: 1
|
|
},
|
|
active: {
|
|
answering: 1,
|
|
requesting: 1,
|
|
hangup: 1,
|
|
held: 1
|
|
},
|
|
held: {
|
|
hangup: 1,
|
|
active: 1
|
|
},
|
|
early: {
|
|
hangup: 1,
|
|
active: 1
|
|
},
|
|
hangup: {
|
|
destroy: 1
|
|
},
|
|
destroy: {},
|
|
purge: {
|
|
destroy: 1
|
|
}
|
|
});
|
|
|
|
$.verto.enum.state = $.verto.ENUM("new requesting trying recovering ringing answering early active held hangup destroy purge");
|
|
$.verto.enum.direction = $.verto.ENUM("inbound outbound");
|
|
$.verto.enum.message = $.verto.ENUM("display info pvtEvent clientReady");
|
|
|
|
$.verto.enum = Object.freeze($.verto.enum);
|
|
|
|
$.verto.saved = [];
|
|
|
|
$.verto.unloadJobs = [];
|
|
|
|
var unloadEventName = 'beforeunload';
|
|
// Hacks for Mobile Safari
|
|
var iOS = ['iPad', 'iPhone', 'iPod'].indexOf(navigator.platform) >= 0;
|
|
if (iOS) {
|
|
unloadEventName = 'pagehide';
|
|
}
|
|
|
|
$(window).bind(unloadEventName, function() {
|
|
for (var f in $.verto.unloadJobs) {
|
|
$.verto.unloadJobs[f]();
|
|
}
|
|
|
|
if ($.verto.haltClosure)
|
|
return $.verto.haltClosure();
|
|
|
|
for (var i in $.verto.saved) {
|
|
var verto = $.verto.saved[i];
|
|
if (verto) {
|
|
verto.purge();
|
|
verto.logout();
|
|
}
|
|
}
|
|
|
|
return $.verto.warnOnUnload;
|
|
});
|
|
|
|
$.verto.videoDevices = [];
|
|
$.verto.audioInDevices = [];
|
|
$.verto.audioOutDevices = [];
|
|
|
|
var checkDevices = function(runtime) {
|
|
console.info("enumerating devices");
|
|
var aud_in = [], aud_out = [], vid = [];
|
|
var has_video = 0, has_audio = 0;
|
|
var Xstream;
|
|
|
|
function gotDevices(deviceInfos) {
|
|
// Handles being called several times to update labels. Preserve values.
|
|
for (var i = 0; i !== deviceInfos.length; ++i) {
|
|
var deviceInfo = deviceInfos[i];
|
|
var text = "";
|
|
|
|
console.log(deviceInfo);
|
|
console.log(deviceInfo.kind + ": " + deviceInfo.label + " id = " + deviceInfo.deviceId);
|
|
|
|
if (deviceInfo.kind === 'audioinput') {
|
|
text = deviceInfo.label || 'microphone ' + (aud_in.length + 1);
|
|
aud_in.push({id: deviceInfo.deviceId, kind: "audio_in", label: text});
|
|
} else if (deviceInfo.kind === 'audiooutput') {
|
|
text = deviceInfo.label || 'speaker ' + (aud_out.length + 1);
|
|
aud_out.push({id: deviceInfo.deviceId, kind: "audio_out", label: text});
|
|
} else if (deviceInfo.kind === 'videoinput') {
|
|
text = deviceInfo.label || 'camera ' + (vid.length + 1);
|
|
vid.push({id: deviceInfo.deviceId, kind: "video", label: text});
|
|
} else {
|
|
console.log('Some other kind of source/device: ', deviceInfo);
|
|
}
|
|
}
|
|
|
|
|
|
$.verto.videoDevices = vid;
|
|
$.verto.audioInDevices = aud_in;
|
|
$.verto.audioOutDevices = aud_out;
|
|
|
|
console.info("Audio IN Devices", $.verto.audioInDevices);
|
|
console.info("Audio Out Devices", $.verto.audioOutDevices);
|
|
console.info("Video Devices", $.verto.videoDevices);
|
|
|
|
if (Xstream) {
|
|
Xstream.getTracks().forEach(function(track) {track.stop();});
|
|
}
|
|
|
|
if (runtime) {
|
|
runtime(true);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
function handleError(error) {
|
|
console.log('device enumeration error: ', error);
|
|
if (runtime) runtime(false);
|
|
}
|
|
|
|
|
|
function checkTypes(devs) {
|
|
for (var i = 0; i !== devs.length; ++i) {
|
|
|
|
if (devs[i].kind === 'audioinput') {
|
|
has_audio++;
|
|
} else if (devs[i].kind === 'videoinput') {
|
|
has_video++;
|
|
}
|
|
}
|
|
|
|
navigator.getUserMedia({ audio: (has_audio > 0 ? true : false), video: (has_video > 0 ? true : false)},
|
|
function(stream) {
|
|
Xstream = stream;
|
|
navigator.mediaDevices.enumerateDevices().then(gotDevices).catch(handleError);
|
|
},
|
|
function(err) {
|
|
console.log("The following error occurred: " + err.name);
|
|
}
|
|
);
|
|
}
|
|
|
|
navigator.mediaDevices.enumerateDevices().then(checkTypes).catch(handleError);
|
|
|
|
};
|
|
|
|
$.verto.refreshDevices = function(runtime) {
|
|
checkDevices(runtime);
|
|
}
|
|
|
|
$.verto.init = function(obj, runtime) {
|
|
if (!obj) {
|
|
obj = {};
|
|
}
|
|
|
|
if (!obj.skipPermCheck && !obj.skipDeviceCheck) {
|
|
$.FSRTC.checkPerms(function(status) {
|
|
checkDevices(runtime);
|
|
}, true, true);
|
|
} else if (obj.skipPermCheck && !obj.skipDeviceCheck) {
|
|
checkDevices(runtime);
|
|
} else if (!obj.skipPermCheck && obj.skipDeviceCheck) {
|
|
$.FSRTC.checkPerms(function(status) {
|
|
runtime(status);
|
|
}, true, true);
|
|
} else {
|
|
runtime(null);
|
|
}
|
|
|
|
}
|
|
|
|
$.verto.genUUID = function () {
|
|
return generateGUID();
|
|
}
|
|
|
|
|
|
})(jQuery);
|