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

1361 lines
43 KiB
JavaScript

'use strict';
// Last time updated: 2017-07-29 4:31:53 PM UTC
// __________________
// DataChannel v1.0.0
// Open-Sourced: https://github.com/muaz-khan/DataChannel
// --------------------------------------------------
// Muaz Khan - www.MuazKhan.com
// MIT License - www.WebRTC-Experiment.com/licence
// --------------------------------------------------
(function() {
window.DataChannel = function(channel, extras) {
if (channel) {
this.automatic = true;
}
this.channel = channel || location.href.replace(/\/|:|#|%|\.|\[|\]/g, '');
extras = extras || {};
var self = this;
var dataConnector;
var fileReceiver;
var textReceiver;
this.onmessage = function(message, userid) {
console.debug(userid, 'sent message:', message);
};
this.channels = {};
this.onopen = function(userid) {
console.debug(userid, 'is connected with you.');
};
this.onclose = function(event) {
console.error('data channel closed:', event);
};
this.onerror = function(event) {
console.error('data channel error:', event);
};
// by default; received file will be auto-saved to disk
this.autoSaveToDisk = true;
this.onFileReceived = function(fileName) {
console.debug('File <', fileName, '> received successfully.');
};
this.onFileSent = function(file) {
console.debug('File <', file.name, '> sent successfully.');
};
this.onFileProgress = function(packets) {
console.debug('<', packets.remaining, '> items remaining.');
};
function prepareInit(callback) {
for (var extra in extras) {
self[extra] = extras[extra];
}
self.direction = self.direction || 'many-to-many';
if (self.userid) {
window.userid = self.userid;
}
if (!self.openSignalingChannel) {
if (typeof self.transmitRoomOnce === 'undefined') {
self.transmitRoomOnce = true;
}
// socket.io over node.js: https://github.com/muaz-khan/WebRTC-Experiment/blob/master/Signaling.md
self.openSignalingChannel = function(config) {
config = config || {};
channel = config.channel || self.channel || 'default-channel';
var socket = new window.Firebase('https://' + (self.firebase || 'webrtc-experiment') + '.firebaseIO.com/' + channel);
socket.channel = channel;
socket.on('child_added', function(data) {
config.onmessage(data.val());
});
socket.send = function(data) {
this.push(data);
};
if (!self.socket) {
self.socket = socket;
}
if (channel !== self.channel || (self.isInitiator && channel === self.channel)) {
socket.onDisconnect().remove();
}
if (config.onopen) {
setTimeout(config.onopen, 1);
}
return socket;
};
if (!window.Firebase) {
var script = document.createElement('script');
script.src = 'https://cdn.webrtc-experiment.com/firebase.js';
script.onload = callback;
document.documentElement.appendChild(script);
} else {
callback();
}
} else {
callback();
}
}
function init() {
if (self.config) {
return;
}
self.config = {
ondatachannel: function(room) {
if (!dataConnector) {
self.room = room;
return;
}
var tempRoom = {
id: room.roomToken,
owner: room.broadcaster
};
if (self.ondatachannel) {
return self.ondatachannel(tempRoom);
}
if (self.joinedARoom) {
return;
}
self.joinedARoom = true;
self.join(tempRoom);
},
onopen: function(userid, _channel) {
self.onopen(userid, _channel);
self.channels[userid] = {
channel: _channel,
send: function(data) {
self.send(data, this.channel);
}
};
},
onmessage: function(data, userid) {
if (IsDataChannelSupported && !data.size) {
data = JSON.parse(data);
}
if (!IsDataChannelSupported) {
if (data.userid === window.userid) {
return;
}
data = data.message;
}
if (data.type === 'text') {
textReceiver.receive(data, self.onmessage, userid);
} else if (typeof data.maxChunks !== 'undefined') {
fileReceiver.receive(data, self);
} else {
self.onmessage(data, userid);
}
},
onclose: function(event) {
var myChannels = self.channels;
var closedChannel = event.currentTarget;
for (var userid in myChannels) {
if (closedChannel === myChannels[userid].channel) {
delete myChannels[userid];
}
}
self.onclose(event);
},
openSignalingChannel: self.openSignalingChannel
};
dataConnector = IsDataChannelSupported ?
new DataConnector(self, self.config) :
new SocketConnector(self.channel, self.config);
fileReceiver = new FileReceiver(self);
textReceiver = new TextReceiver(self);
if (self.room) {
self.config.ondatachannel(self.room);
}
}
this.open = function(_channel) {
self.joinedARoom = true;
if (self.socket) {
self.socket.onDisconnect().remove();
} else {
self.isInitiator = true;
}
if (_channel) {
self.channel = _channel;
}
prepareInit(function() {
init();
if (IsDataChannelSupported) {
dataConnector.createRoom(_channel);
}
});
};
this.connect = function(_channel) {
if (_channel) {
self.channel = _channel;
}
prepareInit(init);
};
// manually join a room
this.join = function(room) {
if (!room.id || !room.owner) {
throw 'Invalid room info passed.';
}
if (!dataConnector) {
init();
}
if (!dataConnector.joinRoom) {
return;
}
dataConnector.joinRoom({
roomToken: room.id,
joinUser: room.owner
});
};
this.send = function(data, _channel) {
if (!data) {
throw 'No file, data or text message to share.';
}
if (typeof data.size !== 'undefined' && typeof data.type !== 'undefined') {
FileSender.send({
file: data,
channel: dataConnector,
onFileSent: function(file) {
self.onFileSent(file);
},
onFileProgress: function(packets, uuid) {
self.onFileProgress(packets, uuid);
},
_channel: _channel,
root: self
});
return;
}
TextSender.send({
text: data,
channel: dataConnector,
_channel: _channel,
root: self
});
};
this.onleave = function(userid) {
console.debug(userid, 'left!');
};
this.leave = this.eject = function(userid) {
dataConnector.leave(userid, self.autoCloseEntireSession);
};
this.openNewSession = function(isOpenNewSession, isNonFirebaseClient) {
if (isOpenNewSession) {
if (self.isNewSessionOpened) {
return;
}
self.isNewSessionOpened = true;
if (!self.joinedARoom) {
self.open();
}
}
if (!isOpenNewSession || isNonFirebaseClient) {
self.connect();
}
if (!isNonFirebaseClient) {
return;
}
// for non-firebase clients
setTimeout(function() {
self.openNewSession(true);
}, 5000);
};
if (typeof this.preferSCTP === 'undefined') {
this.preferSCTP = isFirefox || chromeVersion >= 32 ? true : false;
}
if (typeof this.chunkSize === 'undefined') {
this.chunkSize = isFirefox || chromeVersion >= 32 ? 13 * 1000 : 1000; // 1000 chars for RTP and 13000 chars for SCTP
}
if (typeof this.chunkInterval === 'undefined') {
this.chunkInterval = isFirefox || chromeVersion >= 32 ? 100 : 500; // 500ms for RTP and 100ms for SCTP
}
if (self.automatic) {
if (window.Firebase) {
console.debug('checking presence of the room..');
new window.Firebase('https://' + (extras.firebase || self.firebase || 'muazkh') + '.firebaseIO.com/' + self.channel).once('value', function(data) {
console.debug('room is present?', data.val() !== null);
self.openNewSession(data.val() === null);
});
} else {
self.openNewSession(false, true);
}
}
};
function DataConnector(root, config) {
var self = {};
var that = this;
self.userToken = (root.userid = root.userid || uniqueToken()).toString();
self.sockets = [];
self.socketObjects = {};
var channels = '--';
var isbroadcaster = false;
var isGetNewRoom = true;
var rtcDataChannels = [];
function newPrivateSocket(_config) {
var socketConfig = {
channel: _config.channel,
onmessage: socketResponse,
onopen: function() {
if (isofferer && !peer) {
initPeer();
}
_config.socketIndex = socket.index = self.sockets.length;
self.socketObjects[socketConfig.channel] = socket;
self.sockets[_config.socketIndex] = socket;
}
};
socketConfig.callback = function(_socket) {
socket = _socket;
socketConfig.onopen();
};
var socket = root.openSignalingChannel(socketConfig);
var isofferer = _config.isofferer;
var gotstream;
var inner = {};
var peer;
var peerConfig = {
onICE: function(candidate) {
if (!socket) {
return setTimeout(function() {
peerConfig.onICE(candidate);
}, 2000);
}
socket.send({
userToken: self.userToken,
candidate: {
sdpMLineIndex: candidate.sdpMLineIndex,
candidate: JSON.stringify(candidate.candidate)
}
});
},
onopen: onChannelOpened,
onmessage: function(event) {
config.onmessage(event.data, _config.userid);
},
onclose: config.onclose,
onerror: root.onerror,
preferSCTP: root.preferSCTP
};
function initPeer(offerSDP) {
if (root.direction === 'one-to-one' && window.isFirstConnectionOpened) {
return;
}
if (!offerSDP) {
peerConfig.onOfferSDP = sendsdp;
} else {
peerConfig.offerSDP = offerSDP;
peerConfig.onAnswerSDP = sendsdp;
}
peer = new RTCPeerConnection(peerConfig);
}
function onChannelOpened(channel) {
channel.peer = peer.peer;
rtcDataChannels.push(channel);
config.onopen(_config.userid, channel);
if (root.direction === 'many-to-many' && isbroadcaster && channels.split('--').length > 3 && defaultSocket) {
defaultSocket.send({
newParticipant: socket.channel,
userToken: self.userToken
});
}
window.isFirstConnectionOpened = gotstream = true;
}
function sendsdp(sdp) {
sdp = JSON.stringify(sdp);
var part = parseInt(sdp.length / 3);
var firstPart = sdp.slice(0, part),
secondPart = sdp.slice(part, sdp.length - 1),
thirdPart = '';
if (sdp.length > part + part) {
secondPart = sdp.slice(part, part + part);
thirdPart = sdp.slice(part + part, sdp.length);
}
socket.send({
userToken: self.userToken,
firstPart: firstPart
});
socket.send({
userToken: self.userToken,
secondPart: secondPart
});
socket.send({
userToken: self.userToken,
thirdPart: thirdPart
});
}
function socketResponse(response) {
if (response.userToken === self.userToken) {
return;
}
if (response.firstPart || response.secondPart || response.thirdPart) {
if (response.firstPart) {
// sdp sender's user id passed over "onopen" method
_config.userid = response.userToken;
inner.firstPart = response.firstPart;
if (inner.secondPart && inner.thirdPart) {
selfInvoker();
}
}
if (response.secondPart) {
inner.secondPart = response.secondPart;
if (inner.firstPart && inner.thirdPart) {
selfInvoker();
}
}
if (response.thirdPart) {
inner.thirdPart = response.thirdPart;
if (inner.firstPart && inner.secondPart) {
selfInvoker();
}
}
}
if (response.candidate && !gotstream && peer) {
if (!inner.firstPart || !inner.secondPart || !inner.thirdPart) {
return setTimeout(function() {
socketResponse(response);
}, 400);
}
peer.addICE({
sdpMLineIndex: response.candidate.sdpMLineIndex,
candidate: JSON.parse(response.candidate.candidate)
});
console.debug('ice candidate', response.candidate.candidate);
}
if (response.left) {
if (peer && peer.peer) {
peer.peer.close();
peer.peer = null;
}
if (response.closeEntireSession) {
leaveChannels();
} else if (socket) {
socket.send({
left: true,
userToken: self.userToken
});
socket = null;
}
root.onleave(response.userToken);
}
if (response.playRoleOfBroadcaster) {
setTimeout(function() {
self.roomToken = response.roomToken;
root.open(self.roomToken);
self.sockets = swap(self.sockets);
}, 600);
}
}
var invokedOnce = false;
function selfInvoker() {
if (invokedOnce) {
return;
}
invokedOnce = true;
inner.sdp = JSON.parse(inner.firstPart + inner.secondPart + inner.thirdPart);
if (isofferer) {
peer.addAnswerSDP(inner.sdp);
} else {
initPeer(inner.sdp);
}
console.debug('sdp', inner.sdp.sdp);
}
}
function onNewParticipant(channel) {
if (!channel || channels.indexOf(channel) !== -1 || channel === self.userToken) {
return;
}
channels += channel + '--';
var newChannel = uniqueToken();
newPrivateSocket({
channel: newChannel,
closeSocket: true
});
if (!defaultSocket) {
return;
}
defaultSocket.send({
participant: true,
userToken: self.userToken,
joinUser: channel,
channel: newChannel
});
}
function uniqueToken() {
return (Math.round(Math.random() * 60535) + 5000000).toString();
}
function leaveChannels(channel) {
var alert = {
left: true,
userToken: self.userToken
};
var socket;
// if room initiator is leaving the room; close the entire session
if (isbroadcaster) {
if (root.autoCloseEntireSession) {
alert.closeEntireSession = true;
} else {
self.sockets[0].send({
playRoleOfBroadcaster: true,
userToken: self.userToken,
roomToken: self.roomToken
});
}
}
if (!channel) {
// closing all sockets
var sockets = self.sockets,
length = sockets.length;
for (var i = 0; i < length; i++) {
socket = sockets[i];
if (socket) {
socket.send(alert);
if (self.socketObjects[socket.channel]) {
delete self.socketObjects[socket.channel];
}
delete sockets[i];
}
}
that.left = true;
}
// eject a specific user!
if (channel) {
socket = self.socketObjects[channel];
if (socket) {
socket.send(alert);
if (self.sockets[socket.index]) {
delete self.sockets[socket.index];
}
delete self.socketObjects[channel];
}
}
self.sockets = swap(self.sockets);
}
window.addEventListener('beforeunload', function() {
leaveChannels();
}, false);
window.addEventListener('keydown', function(e) {
if (e.keyCode === 116) {
leaveChannels();
}
}, false);
var defaultSocket = root.openSignalingChannel({
onmessage: function(response) {
if (response.userToken === self.userToken) {
return;
}
if (isGetNewRoom && response.roomToken && response.broadcaster) {
config.ondatachannel(response);
}
if (response.newParticipant) {
onNewParticipant(response.newParticipant);
}
if (response.userToken && response.joinUser === self.userToken && response.participant && channels.indexOf(response.userToken) === -1) {
channels += response.userToken + '--';
console.debug('Data connection is being opened between you and', response.userToken || response.channel);
newPrivateSocket({
isofferer: true,
channel: response.channel || response.userToken,
closeSocket: true
});
}
},
callback: function(socket) {
defaultSocket = socket;
}
});
return {
createRoom: function(roomToken) {
self.roomToken = (roomToken || uniqueToken()).toString();
isbroadcaster = true;
isGetNewRoom = false;
(function transmit() {
if (defaultSocket) {
defaultSocket.send({
roomToken: self.roomToken,
broadcaster: self.userToken
});
}
if (!root.transmitRoomOnce && !that.leaving) {
if (root.direction === 'one-to-one') {
if (!window.isFirstConnectionOpened) {
setTimeout(transmit, 3000);
}
} else {
setTimeout(transmit, 3000);
}
}
})();
},
joinRoom: function(_config) {
self.roomToken = _config.roomToken;
isGetNewRoom = false;
newPrivateSocket({
channel: self.userToken
});
defaultSocket.send({
participant: true,
userToken: self.userToken,
joinUser: _config.joinUser
});
},
send: function(message, _channel) {
var _channels = rtcDataChannels;
var data;
var length = _channels.length;
if (!length) {
return;
}
data = JSON.stringify(message);
if (_channel) {
if (_channel.readyState === 'open') {
_channel.send(data);
}
return;
}
for (var i = 0; i < length; i++) {
if (_channels[i].readyState === 'open') {
_channels[i].send(data);
}
}
},
leave: function(userid, autoCloseEntireSession) {
if (autoCloseEntireSession) {
root.autoCloseEntireSession = true;
}
leaveChannels(userid);
if (!userid) {
self.joinedARoom = isbroadcaster = false;
isGetNewRoom = true;
}
}
};
}
var moz = !!navigator.mozGetUserMedia;
var IsDataChannelSupported = !((moz && !navigator.mozGetUserMedia) || (!moz && !navigator.webkitGetUserMedia));
function getRandomString() {
return (Math.random() * new Date().getTime()).toString(36).replace(/\./g, '-');
}
var userid = getRandomString();
var isMobileDevice = navigator.userAgent.match(/Android|iPhone|iPad|iPod|BlackBerry|IEMobile/i);
var isChrome = !!navigator.webkitGetUserMedia;
var isFirefox = !!navigator.mozGetUserMedia;
var chromeVersion = 50;
if (isChrome) {
chromeVersion = !!navigator.mozGetUserMedia ? 0 : parseInt(navigator.userAgent.match(/Chrom(e|ium)\/([0-9]+)\./)[2]);
}
function swap(arr) {
var swapped = [];
var length = arr.length;
for (var i = 0; i < length; i++) {
if (arr[i]) {
swapped.push(arr[i]);
}
}
return swapped;
}
function listenEventHandler(eventName, eventHandler) {
window.removeEventListener(eventName, eventHandler);
window.addEventListener(eventName, eventHandler, false);
}
// IceServersHandler.js
var IceServersHandler = (function() {
function getIceServers(connection) {
var iceServers = [];
iceServers.push(getSTUNObj('stun:stun.l.google.com:19302'));
iceServers.push(getTURNObj('stun:webrtcweb.com:7788', 'muazkh', 'muazkh')); // coTURN
iceServers.push(getTURNObj('turn:webrtcweb.com:7788', 'muazkh', 'muazkh')); // coTURN
iceServers.push(getTURNObj('turn:webrtcweb.com:8877', 'muazkh', 'muazkh')); // coTURN
iceServers.push(getTURNObj('turns:webrtcweb.com:7788', 'muazkh', 'muazkh')); // coTURN
iceServers.push(getTURNObj('turns:webrtcweb.com:8877', 'muazkh', 'muazkh')); // coTURN
// iceServers.push(getTURNObj('turn:webrtcweb.com:3344', 'muazkh', 'muazkh')); // resiprocate
// iceServers.push(getTURNObj('turn:webrtcweb.com:4433', 'muazkh', 'muazkh')); // resiprocate
// check if restund is still active: http://webrtcweb.com:4050/
iceServers.push(getTURNObj('stun:webrtcweb.com:4455', 'muazkh', 'muazkh')); // restund
iceServers.push(getTURNObj('turn:webrtcweb.com:4455', 'muazkh', 'muazkh')); // restund
iceServers.push(getTURNObj('turn:webrtcweb.com:5544?transport=tcp', 'muazkh', 'muazkh')); // restund
return iceServers;
}
function getSTUNObj(stunStr) {
var urlsParam = 'urls';
if (typeof isPluginRTC !== 'undefined') {
urlsParam = 'url';
}
var obj = {};
obj[urlsParam] = stunStr;
return obj;
}
function getTURNObj(turnStr, username, credential) {
var urlsParam = 'urls';
if (typeof isPluginRTC !== 'undefined') {
urlsParam = 'url';
}
var obj = {
username: username,
credential: credential
};
obj[urlsParam] = turnStr;
return obj;
}
return {
getIceServers: getIceServers
};
})();
function RTCPeerConnection(options) {
var w = window;
var PeerConnection = w.mozRTCPeerConnection || w.webkitRTCPeerConnection;
var SessionDescription = w.mozRTCSessionDescription || w.RTCSessionDescription;
var IceCandidate = w.mozRTCIceCandidate || w.RTCIceCandidate;
var iceServers = {
iceServers: IceServersHandler.getIceServers()
};
var optional = {
optional: []
};
if (!navigator.onLine) {
iceServers = null;
console.warn('No internet connection detected. No STUN/TURN server is used to make sure local/host candidates are used for peers connection.');
}
var peerConnection = new PeerConnection(iceServers, optional);
openOffererChannel();
peerConnection.onicecandidate = onicecandidate;
function onicecandidate(event) {
if (!event.candidate || !peerConnection) {
return;
}
if (options.onICE) {
options.onICE(event.candidate);
}
}
var constraints = options.constraints || {
optional: [],
mandatory: {
OfferToReceiveAudio: false,
OfferToReceiveVideo: false
}
};
function onSdpError(e) {
var message = JSON.stringify(e, null, '\t');
if (message.indexOf('RTP/SAVPF Expects at least 4 fields') !== -1) {
message = 'It seems that you are trying to interop RTP-datachannels with SCTP. It is not supported!';
}
console.error('onSdpError:', message);
}
function onSdpSuccess() {}
function createOffer() {
if (!options.onOfferSDP) {
return;
}
peerConnection.createOffer(function(sessionDescription) {
peerConnection.setLocalDescription(sessionDescription);
options.onOfferSDP(sessionDescription);
}, onSdpError, constraints);
}
function createAnswer() {
if (!options.onAnswerSDP) {
return;
}
options.offerSDP = new SessionDescription(options.offerSDP);
peerConnection.setRemoteDescription(options.offerSDP, onSdpSuccess, onSdpError);
peerConnection.createAnswer(function(sessionDescription) {
peerConnection.setLocalDescription(sessionDescription);
options.onAnswerSDP(sessionDescription);
}, onSdpError, constraints);
}
if (!moz) {
createOffer();
createAnswer();
}
var channel;
function openOffererChannel() {
if (moz && !options.onOfferSDP) {
return;
}
if (!moz && !options.onOfferSDP) {
return;
}
_openOffererChannel();
if (moz) {
createOffer();
}
}
function _openOffererChannel() {
// protocol: 'text/chat', preset: true, stream: 16
// maxRetransmits:0 && ordered:false
var dataChannelDict = {};
console.debug('dataChannelDict', dataChannelDict);
channel = peerConnection.createDataChannel('channel', dataChannelDict);
setChannelEvents();
}
function setChannelEvents() {
channel.onmessage = options.onmessage;
channel.onopen = function() {
options.onopen(channel);
};
channel.onclose = options.onclose;
channel.onerror = options.onerror;
}
if (options.onAnswerSDP && moz && options.onmessage) {
openAnswererChannel();
}
if (!moz && !options.onOfferSDP) {
openAnswererChannel();
}
function openAnswererChannel() {
peerConnection.ondatachannel = function(event) {
channel = event.channel;
setChannelEvents();
};
if (moz) {
createAnswer();
}
}
function useless() {}
return {
addAnswerSDP: function(sdp) {
sdp = new SessionDescription(sdp);
peerConnection.setRemoteDescription(sdp, onSdpSuccess, onSdpError);
},
addICE: function(candidate) {
peerConnection.addIceCandidate(new IceCandidate({
sdpMLineIndex: candidate.sdpMLineIndex,
candidate: candidate.candidate
}));
},
peer: peerConnection,
channel: channel,
sendData: function(message) {
if (!channel) {
return;
}
channel.send(message);
}
};
}
var FileConverter = {
DataURLToBlob: function(dataURL, fileType, callback) {
function processInWebWorker() {
var blob = URL.createObjectURL(new Blob(['function getBlob(_dataURL, _fileType) {var binary = atob(_dataURL.substr(_dataURL.indexOf(",") + 1)),i = binary.length,view = new Uint8Array(i);while (i--) {view[i] = binary.charCodeAt(i);};postMessage(new Blob([view], {type: _fileType}));};this.onmessage = function (e) {var data = JSON.parse(e.data); getBlob(data.dataURL, data.fileType);}'], {
type: 'application/javascript'
}));
var worker = new Worker(blob);
URL.revokeObjectURL(blob);
return worker;
}
if (!!window.Worker && !isMobileDevice) {
var webWorker = processInWebWorker();
webWorker.onmessage = function(event) {
callback(event.data);
};
webWorker.postMessage(JSON.stringify({
dataURL: dataURL,
fileType: fileType
}));
} else {
var binary = atob(dataURL.substr(dataURL.indexOf(',') + 1)),
i = binary.length,
view = new Uint8Array(i);
while (i--) {
view[i] = binary.charCodeAt(i);
}
callback(new Blob([view]));
}
}
};
function FileReceiver(root) {
var content = {};
var packets = {};
var numberOfPackets = {};
function receive(data) {
var uuid = data.uuid;
if (typeof data.packets !== 'undefined') {
numberOfPackets[uuid] = packets[uuid] = parseInt(data.packets);
}
if (root.onFileProgress) {
root.onFileProgress({
remaining: packets[uuid]--,
length: numberOfPackets[uuid],
received: numberOfPackets[uuid] - packets[uuid],
maxChunks: numberOfPackets[uuid],
uuid: uuid,
currentPosition: numberOfPackets[uuid] - packets[uuid]
}, uuid);
}
if (!content[uuid]) {
content[uuid] = [];
}
content[uuid].push(data.message);
if (data.last) {
var dataURL = content[uuid].join('');
FileConverter.DataURLToBlob(dataURL, data.fileType, function(blob) {
blob.uuid = uuid;
blob.name = data.name;
// blob.type = data.fileType;
blob.extra = data.extra || {};
blob.url = (window.URL || window.webkitURL).createObjectURL(blob);
if (root.autoSaveToDisk) {
FileSaver.SaveToDisk(blob.url, data.name);
}
if (root.onFileReceived) {
root.onFileReceived(blob);
}
delete content[uuid];
});
}
}
return {
receive: receive
};
}
var FileSaver = {
SaveToDisk: function(fileUrl, fileName) {
var hyperlink = document.createElement('a');
hyperlink.href = fileUrl;
hyperlink.target = '_blank';
hyperlink.download = fileName || fileUrl;
var mouseEvent = new MouseEvent('click', {
view: window,
bubbles: true,
cancelable: true
});
hyperlink.dispatchEvent(mouseEvent);
(window.URL || window.webkitURL).revokeObjectURL(hyperlink.href);
}
};
var FileSender = {
send: function(config) {
var root = config.root;
var channel = config.channel;
var privateChannel = config._channel;
var file = config.file;
if (!config.file) {
console.error('You must attach/select a file.');
return;
}
// max chunk sending limit on chrome is 64k
// max chunk receiving limit on firefox is 16k
var packetSize = 15 * 1000;
if (root.chunkSize) {
packetSize = root.chunkSize;
}
var textToTransfer = '';
var numberOfPackets = 0;
var packets = 0;
file.uuid = getRandomString();
function processInWebWorker() {
var blob = URL.createObjectURL(new Blob(['function readFile(_file) {postMessage(new FileReaderSync().readAsDataURL(_file));};this.onmessage = function (e) {readFile(e.data);}'], {
type: 'application/javascript'
}));
var worker = new Worker(blob);
URL.revokeObjectURL(blob);
return worker;
}
if (!!window.Worker && !isMobileDevice) {
var webWorker = processInWebWorker();
webWorker.onmessage = function(event) {
onReadAsDataURL(event.data);
};
webWorker.postMessage(file);
} else {
var reader = new FileReader();
reader.onload = function(e) {
onReadAsDataURL(e.target.result);
};
reader.readAsDataURL(file);
}
function onReadAsDataURL(dataURL, text) {
var data = {
type: 'file',
uuid: file.uuid,
maxChunks: numberOfPackets,
currentPosition: numberOfPackets - packets,
name: file.name,
fileType: file.type,
size: file.size
};
if (dataURL) {
text = dataURL;
numberOfPackets = packets = data.packets = parseInt(text.length / packetSize);
file.maxChunks = data.maxChunks = numberOfPackets;
data.currentPosition = numberOfPackets - packets;
if (root.onFileSent) {
root.onFileSent(file);
}
}
if (root.onFileProgress) {
root.onFileProgress({
remaining: packets--,
length: numberOfPackets,
sent: numberOfPackets - packets,
maxChunks: numberOfPackets,
uuid: file.uuid,
currentPosition: numberOfPackets - packets
}, file.uuid);
}
if (text.length > packetSize) {
data.message = text.slice(0, packetSize);
} else {
data.message = text;
data.last = true;
data.name = file.name;
file.url = URL.createObjectURL(file);
root.onFileSent(file, file.uuid);
}
channel.send(data, privateChannel);
textToTransfer = text.slice(data.message.length);
if (textToTransfer.length) {
setTimeout(function() {
onReadAsDataURL(null, textToTransfer);
}, root.chunkInterval || 100);
}
}
}
};
function SocketConnector(_channel, config) {
var socket = config.openSignalingChannel({
channel: _channel,
onopen: config.onopen,
onmessage: config.onmessage,
callback: function(_socket) {
socket = _socket;
}
});
return {
send: function(message) {
if (!socket) {
return;
}
socket.send({
userid: userid,
message: message
});
}
};
}
function TextReceiver() {
var content = {};
function receive(data, onmessage, userid) {
// uuid is used to uniquely identify sending instance
var uuid = data.uuid;
if (!content[uuid]) {
content[uuid] = [];
}
content[uuid].push(data.message);
if (data.last) {
var message = content[uuid].join('');
if (data.isobject) {
message = JSON.parse(message);
}
// latency detection
var receivingTime = new Date().getTime();
var latency = receivingTime - data.sendingTime;
onmessage(message, userid, latency);
delete content[uuid];
}
}
return {
receive: receive
};
}
var TextSender = {
send: function(config) {
var root = config.root;
var channel = config.channel;
var _channel = config._channel;
var initialText = config.text;
var packetSize = root.chunkSize || 1000;
var textToTransfer = '';
var isobject = false;
if (typeof initialText !== 'string') {
isobject = true;
initialText = JSON.stringify(initialText);
}
// uuid is used to uniquely identify sending instance
var uuid = getRandomString();
var sendingTime = new Date().getTime();
sendText(initialText);
function sendText(textMessage, text) {
var data = {
type: 'text',
uuid: uuid,
sendingTime: sendingTime
};
if (textMessage) {
text = textMessage;
data.packets = parseInt(text.length / packetSize);
}
if (text.length > packetSize) {
data.message = text.slice(0, packetSize);
} else {
data.message = text;
data.last = true;
data.isobject = isobject;
}
channel.send(data, _channel);
textToTransfer = text.slice(data.message.length);
if (textToTransfer.length) {
setTimeout(function() {
sendText(null, textToTransfer);
}, root.chunkInterval || 100);
}
}
}
};
})();