Files
sean 0e8a8b3028
Some checks are pending
deploy-testing / deploy (push) Waiting to run
Initial testing snapshot
2026-11-17 16:15:01 -05:00

748 lines
26 KiB
JavaScript

// Last time updated at Sep 15, 2014, 08:32:23
// Latest file can be found here: https://cdn.webrtc-experiment.com/conversation.js
// Muaz Khan - www.MuazKhan.com
// MIT License - www.WebRTC-Experiment.com/licence
// _______________
// Conversation.js
/*
-. Signaler object added. See below for how to use it.
var signaler = new Signaler();
signaler.on('message', function(message) {
socket.send(message);
});
socket.on('message', function(message) {
signaler.emit('message', message);
});
var user = new User();
signaler.connect(user);
*/
(function() {
window.Signaler = function() {
var signaler = this;
var users = [];
signaler.connect = function(user) {
user.signaler = signaler;
user.emit('--signaler-connected');
users.push(user);
};
signaler.send = function(data) {
signaler.emit('--message', data);
};
signaler.events = {};
signaler.on = function(event, callback) {
signaler.events[event] = callback;
};
signaler.emit = function() {
if (!arguments[0]) throw 'At least one argument is mandatory.';
var internalevent = arguments[0].indexOf('--') == 0;
if (!internalevent) {
if (arguments[0] == 'message') {
var message = arguments[1];
users.forEach(function(user) {
user.onsignalingmessage(message);
});
}
return;
}
if (internalevent) {
arguments[0] = arguments[0].replace('--', '');
}
if (!signaler.events[arguments[0]]) {
var warning = 'Event name "' + arguments[0] + '" doesn\'t exists.';
if (arguments[1]) warning += ' Values: ' + JSON.stringify(arguments[1], null, '\t');
console.warn(warning);
} else signaler.events[arguments[0]](arguments[1], arguments[2], arguments[3], arguments[4]);
};
};
window.User = function(_defaults) {
var user = this;
user.randomstring = function() {
// suggested by @rvulpescu from #154
if (window.crypto && crypto.getRandomValues && navigator.userAgent.indexOf('Safari') == -1) {
var a = window.crypto.getRandomValues(new Uint32Array(3)),
token = '';
for (var i = 0, l = a.length; i < l; i++) {
token += a[i].toString(36);
}
return token;
} else {
return (Math.random() * new Date().getTime()).toString(36).replace(/\./g, '');
}
};
user.defaults = {};
user.username = user.randomstring();
user.status = 'online';
user.openconversationwith = function(targetuser) {
var conversation = new Conversation(user, targetuser);
// check who is online
user.emit('signal', {
whoisonline: true,
responsefor: targetuser
});
};
user.onmessagecallbacks = {};
user.onsignalingmessage = function(message) {
if (message.isrtcmulticonnectioninnermessage && user.onmessagecallbacks[message.channel]) {
return user.onmessagecallbacks[message.channel](message.message);
}
if (message.searchuser) {
if (user.status === 'online') {
user.emit('signal', {
useronline: true,
responsefor: message.sender
});
}
return;
}
if (message.useronline && message.responsefor == user.username) {
user.emit('--search', {
username: message.sender
});
return;
}
if (message.whoisonline && message.responsefor == user.username && user.status == 'online') {
user.emit('--friend-request', {
accept: function() {
if (!user.peers[message.sender]) {
var randomchannel = user.randomstring();
user.emit('signal', {
iamonline: true,
responsefor: message.sender,
randomchannel: randomchannel
});
var conversation = new Conversation(user, message.sender);
conversation.addnewrtcmulticonnectionpeer({
targetuser: message.sender,
channel: randomchannel
});
}
user.emit('signal', {
requestaccepted: true,
sender: user.username,
responsefor: message.sender
});
},
reject: function() {
user.emit('signal', {
requestrejected: true,
sender: user.username,
responsefor: message.sender
});
},
sender: message.sender
});
}
if (message.requestaccepted && message.responsefor == user.username) {
user.emit('--request-status', {
status: 'accepted',
sender: message.sender
});
}
if (message.requestrejected && message.responsefor == user.username) {
user.emit('--request-status', {
status: 'accepted',
sender: message.sender
});
}
if (message.iamonline && message.responsefor == user.username) {
if (!user.peers[message.sender]) {
user.conversations[message.sender].addnewrtcmulticonnectionpeer({
targetuser: message.sender,
channel: message.randomchannel,
isInitiator: true
});
}
}
if (message.sessionDescription && message.responsefor == user.username) {
user.peers[message.sender].join(message.sessionDescription);
}
}
// reference to all RTCMultiConnection peers
user.peers = {
emit: function(eventName, value) {
for (var conversation in user.conversations) {
user.conversations[conversation].emit(eventName, value);
}
},
length: 0
};
// reference to all Conversation objects
user.conversations = {};
// reference to all local media streams
user.localstreams = {};
user.events = {};
user.on = function(event, callback) {
user.events[event] = callback;
};
user.emit = function() {
if (!arguments[0]) throw 'At least one argument is mandatory.';
var internalevent = arguments[0].indexOf('--') == 0;
if (!internalevent) {
if (arguments[0] == 'search') {
user.emit('signal', {
searchuser: arguments[1]
});
}
if (arguments[0] == 'signal') {
var data = arguments[1];
data.sender = user.username;
user.signaler.emit('--message', data);
}
return;
}
if (internalevent) {
arguments[0] = arguments[0].replace('--', '');
if (arguments[0] == 'log' && user.defaults.log == false) return;
}
if (!user.events[arguments[0]]) {
var warning = 'Event name "' + arguments[0] + '" doesn\'t exists.';
if (arguments[1]) warning += ' Values: ' + JSON.stringify(arguments[1], null, '\t');
console.warn(warning);
} else user.events[arguments[0]](arguments[1], arguments[2], arguments[3], arguments[4]);
};
// defaults
user.on('request-status', function(request) {
user.emit('--log', request.sender + ' ' + request.status + ' your request.');
});
user.on('friend-request', function(request) {
request.accept();
});
user.on('signaler-connected', function() {
user.emit('--log', 'Signaling medium is ready for pub/sub.');
});
user.on('log', function(message) {
console.log(message);
});
for (var data in _defaults || {}) {
user.defaults[data] = _defaults[data];
}
if (_defaults) {
user.emit('signaler', 'start');
}
};
function Conversation(user, targetuser) {
var conversation = this;
function sendmessage(data) {
conversation.peer.send(data);
}
function enablemicrophone() {
if (user.localstreams.microphone) return;
conversation.peer.captureUserMedia(function(stream) {
user.localstreams.microphone = stream;
conversation.peer.peers[targetuser].peer.connection.addStream(stream);
conversation.peer.send({
signalingmessage: true,
hasmicrophone: true,
streamavailable: true,
sender: user.username,
type: 'audio'
});
}, {
audio: true
});
}
function enablecamera() {
if (user.localstreams.camera) return;
conversation.peer.captureUserMedia(function(stream) {
user.localstreams.camera = stream;
conversation.peer.peers[targetuser].peer.connection.addStream(stream);
conversation.peer.send({
signalingmessage: true,
hascamera: true,
streamavailable: true,
sender: user.username,
type: 'video'
});
}, {
audio: true,
video: true
});
}
function enablescreen() {
if (user.localstreams.screen) return;
conversation.peer.captureUserMedia(function(stream) {
user.localstreams.screen = stream;
conversation.peer.peers[targetuser].peer.connection.addStream(stream);
conversation.peer.send({
signalingmessage: true,
hasscreen: true,
streamavailable: true,
sender: user.username,
type: 'screen'
});
}, {
screen: true
});
};
conversation.attachie = {
files: {},
messages: {}
};
conversation.addnewrtcmulticonnectionpeer = function(args) {
var connection = new RTCMultiConnection(args.channel);
for (var d in user.defaults) {
if (typeof connection[d] !== 'undefined' /* && typeof connection[d] !== 'function' */ ) {
connection[d] = user.defaults[d];
}
}
// workaround for RTCMultiConnection-v1.8 or older
if (user.defaults.log == false) {
connection.skipLogs();
}
connection.userid = user.username;
// v1.9 and onwards supports "onlog" event.
connection.onlog = function(message) {
user.emit('--log', JSON.stringify(message, null, '\t'));
};
connection.session = {
data: true
};
connection.onopen = function() {
conversation.targetuser = args.targetuser;
user.emit('--conversation-opened', conversation);
};
connection.onmessage = function(event) {
if (event.data.signalingmessage) {
var data = event.data;
if (data.streamavailable) {
data.emit = function(first, second) {
if (first == 'join-with' && second == 'nothing') {
preview();
}
if (first == 'join-with' && second == 'microphone') {
joinwithmicrophone();
}
if (first == 'join-with' && second == 'camera') {
joinwithcamera();
}
if (first == 'join-with' && second == 'screen') {
joinwithscreen();
}
};
function preview() {
connection.send({
signalingmessage: true,
shareoneway: true,
hasmicrophone: !!data.hasmicrophone,
hascamera: !!data.hascamera,
hasscreen: !!data.hasscreen
});
}
function joinwithmicrophone() {
conversation.peer.peers[targetuser].addStream({
audio: true,
oneway: true
});
}
function joinwithcamera() {
conversation.peer.peers[targetuser].addStream({
audio: true,
video: true,
oneway: true
});
}
function joinwithscreen() {
conversation.peer.peers[targetuser].addStream({
screen: true,
oneway: true
});
}
conversation.emit('--media-enabled', event.data);
}
if (data.shareoneway) {
if (data.hasmicrophone) {
if (!user.localstreams.microphone) throw 'You have not allowed microphone.';
connection.renegotiate();
}
if (data.hascamera) {
if (!user.localstreams.camera) throw 'You have not allowed camera.';
connection.renegotiate();
}
if (data.hasscreen) {
if (!user.localstreams.screen) throw 'You have not allowed screen.';
connection.renegotiate();
}
}
if (data.addedfile) {
var filesinfo = data.filesinfo;
if (filesinfo.size && filesinfo.type) {
filesinfo = eventHanlders(filesinfo);
conversation.emit('--add-file', filesinfo);
} else {
for (var file in filesinfo) {
filesinfo[file] = eventHanlders(filesinfo[file]);
conversation.emit('--add-file', filesinfo[file]);
}
}
function eventHanlders(file) {
file.sender = targetuser;
file.download = function() {
conversation.peer.send({
signalingmessage: true,
download: true,
sender: user.username,
file: {
size: file.size,
type: file.type,
name: file.name,
lastModifiedDate: file.lastModifiedDate,
uuid: file.uuid
}
});
};
file.cancel = function() {
conversation.peer.send({
signalingmessage: true,
download: false,
sender: user.username,
file: {
size: file.size,
type: file.type,
name: file.name,
lastModifiedDate: file.lastModifiedDate,
uuid: file.uuid
}
});
};
return file;
}
}
if (data.file) {
if (data.download) {
var file = conversation.attachie.files[data.file.name];
if ((file.item && file.length && file[0] && file[0].lastModifiedDate) || file.forEach) {
Array.prototype.slice.call(file).forEach(function(f) {
conversation.peer.send(f);
});
} else conversation.peer.send(file);
} else {
var file = conversation.attachie.files[data.file.name];
conversation.emit('--file-cancelled', file);
}
}
} else {
event.username = conversation.targetuser;
conversation.emit('--message', event);
}
};
// overriding "openSignalingChannel" method
connection.openSignalingChannel = function(config) {
var channel = config.channel || this.channel;
user.onmessagecallbacks[channel] = config.onmessage;
if (config.onopen) setTimeout(config.onopen, 1000);
// directly returning socket object using "return" statement
return {
send: function(message) {
user.emit('signal', {
message: message,
isrtcmulticonnectioninnermessage: true,
channel: channel
});
},
channel: channel
};
};
// todo: renegotiation doesn't work if trickleIce=false
// need to fix it.
// connection.trickleIce = false;
connection.sdpConstraints.mandatory = {
OfferToReceiveAudio: true,
OfferToReceiveVideo: true
};
connection.autoSaveToDisk = false;
connection.onFileEnd = function(file) {
if (conversation.attachie.files[file.name]) {
conversation.emit('--file-sent', file);
return;
}
file.savetodisk = function(filename) {
connection.saveToDisk(file, filename || file.name || file.type);
};
file.sender = file.userid;
conversation.emit('--file-downloaded', file);
};
connection.onFileProgress = function(chunk) {
var progress = {
percentage: Math.round((chunk.currentPosition / chunk.maxChunks) * 100),
uuid: chunk.uuid,
file: chunk,
sender: chunk.userid
};
if (progress.percentage > 100) progress.percentage = 100;
conversation.emit('--file-progress', progress);
};
connection.onFileStart = function() {};
connection.onstreamid = function(event) {
conversation.emit('--stream-clue', event);
};
connection.onstream = function(event) {
conversation.emit('--stream', event);
};
connection.onstreamended = function(event) {
conversation.emit('--stream-ended', event);
};
if (args.isInitiator) {
connection.open({
dontTransmit: true
});
}
user.peers[args.targetuser] = connection;
user.peers.length++;
connection.onleave = function() {
user.peers.length--;
};
user.emit('signal', {
joinRoom: true,
responsefor: args.targetuser,
sessionDescription: connection.sessionDescription
});
conversation.peer = connection;
}
function addfile(file) {
var filesinfo = {};
// seems array of files
if ((file.item && file.length && file[0] && file[0].lastModifiedDate) || file.forEach) {
Array.prototype.slice.call(file).forEach(function(f) {
if (!f.uuid) f.uuid = user.randomstring();
filesinfo[file.name] = {
size: f.size,
type: f.type,
name: f.name,
lastModifiedDate: f.lastModifiedDate,
uuid: f.uuid
};
conversation.attachie.files[f.name] = f;
});
} else {
if (!file.uuid) file.uuid = user.randomstring();
filesinfo[file.name] = {
size: file.size,
type: file.type,
name: file.name,
lastModifiedDate: file.lastModifiedDate,
uuid: file.uuid
};
conversation.attachie.files[file.name] = file;
}
conversation.peer.send({
addedfile: true,
filesinfo: filesinfo,
signalingmessage: true,
sender: user.username
});
}
// custom events
conversation.events = {};
conversation.on = function(event, callback) {
conversation.events[event] = callback;
};
conversation.emit = function() {
if (!arguments[0]) throw 'At least one argument is mandatory.';
var internalevent = arguments[0].indexOf('--') == 0;
if (!internalevent) {
if (arguments[0] == 'message') {
sendmessage(arguments[1]);
}
if (arguments[0] == 'add-file' && arguments[1]) {
addfile(arguments[1]);
}
if (arguments[0] == 'enable') {
if (arguments[1] == 'microphone') {
enablemicrophone();
}
if (arguments[1] == 'camera') {
enablecamera();
}
if (arguments[1] == 'screen') {
enablescreen();
}
}
if (arguments[0] == 'end') {
conversation.peer.close();
user.emit('--ended');
}
return;
}
if (internalevent) {
arguments[0] = arguments[0].replace('--', '');
}
if (!conversation.events[arguments[0]]) {
var warning = 'Event name "' + arguments[0] + '" doesn\'t exists.';
if (arguments[1]) warning += ' Values: ' + JSON.stringify(arguments[1], null, '\t');
console.warn(warning);
} else conversation.events[arguments[0]](arguments[1], arguments[2], arguments[3], arguments[4]);
};
conversation.on('add-file', function(file) {
file.download();
});
conversation.on('file-downloaded', function(file) {
file.savetodisk();
});
conversation.on('media-enabled', function(media) {
if (media.hasmicrophone) {
media.emit('join-with', 'microphone');
}
if (media.hascamera) {
media.emit('join-with', 'camera');
}
if (media.hasscreen) {
media.emit('join-with', 'nothing');
}
});
conversation.on('stream-clue', function(stream) {
user.emit('--log', 'stream-clue: ' + stream.streamid);
});
conversation.on('stream', function(stream) {
user.emit('--log', 'stream: ' + stream.streamid);
conversation.peer.body.insertBefore(stream.mediaElement, conversation.peer.body.firstChild);
});
conversation.on('stream-ended', function(stream) {
user.emit('--log', 'stream-ended: ' + stream.streamid);
if (stream.mediaElement && stream.mediaElement.parentNode) {
stream.mediaElement.parentNode.removeChild(stream.mediaElement);
}
});
user.conversations[targetuser] = conversation;
}
})();