/**
* <blockquote class="info">
* Note that this is used only for SDK developer purposes.<br>
* Current version: <code>0.1.0</code>
* </blockquote>
* The value of the current version of the data transfer protocol.
* @attribute DT_PROTOCOL_VERSION
* @type String
* @readOnly
* @for Skylink
* @since 0.5.10
*/
Skylink.prototype.DT_PROTOCOL_VERSION = '0.1.0';
/**
* The list of data transfers directions.
* @attribute DATA_TRANSFER_TYPE
* @param {String} UPLOAD <small>Value <code>"upload"</code></small>
* The value of the data transfer direction when User is uploading data to Peer.
* @param {String} DOWNLOAD <small>Value <code>"download"</code></small>
* The value of the data transfer direction when User is downloading data from Peer.
* @type JSON
* @readOnly
* @for Skylink
* @since 0.1.0
*/
Skylink.prototype.DATA_TRANSFER_TYPE = {
UPLOAD: 'upload',
DOWNLOAD: 'download'
};
/**
* The list of data transfers session types.
* @attribute DATA_TRANSFER_SESSION_TYPE
* @param {String} BLOB <small>Value <code>"blob"</code></small>
* The value of the session type for
* <a href="#method_sendURLData"><code>sendURLData()</code> method</a> data transfer.
* @param {String} DATA_URL <small>Value <code>"dataURL"</code></small>
* The value of the session type for
* <a href="#method_sendBlobData"><code>method_sendBlobData()</code> method</a> data transfer.
* @type JSON
* @readOnly
* @for Skylink
* @since 0.1.0
*/
Skylink.prototype.DATA_TRANSFER_SESSION_TYPE = {
BLOB: 'blob',
DATA_URL: 'dataURL'
};
/**
* The list of data transfer states.
* @attribute DATA_TRANSFER_STATE
* @param {String} UPLOAD_REQUEST <small>Value <code>"request"</code></small>
* The value of the state when receiving an upload data transfer request from Peer to User.
* <small>At this stage, the upload data transfer request from Peer may be accepted or rejected with the
* <a href="#method_acceptDataTransfer"><code>acceptDataTransfer()</code> method</a> invoked by User.</small>
* @parma {String} USER_UPLOAD_REQUEST <small>Value <code>"userRequest"</code></small>
* The value of the state when User sent an upload data transfer request to Peer.
* <small>At this stage, the upload data transfer request to Peer may be accepted or rejected with the
* <a href="#method_acceptDataTransfer"><code>acceptDataTransfer()</code> method</a> invoked by Peer.</small>
* @param {String} UPLOAD_STARTED <small>Value <code>"uploadStarted"</code></small>
* The value of the state when the data transfer request has been accepted
* and data transfer will start uploading data to Peer.
* <small>At this stage, the data transfer may be terminated with the
* <a href="#method_cancelDataTransfer"><code>cancelDataTransfer()</code> method</a>.</small>
* @param {String} DOWNLOAD_STARTED <small>Value <code>"downloadStarted"</code></small>
* The value of the state when the data transfer request has been accepted
* and data transfer will start downloading data from Peer.
* <small>At this stage, the data transfer may be terminated with the
* <a href="#method_cancelDataTransfer"><code>cancelDataTransfer()</code> method</a>.</small>
* @param {String} REJECTED <small>Value <code>"rejected"</code></small>
* The value of the state when upload data transfer request to Peer has been rejected and terminated.
* @param {String} USER_REJECTED <small>Value <code>"userRejected"</code></small>
* The value of the state when User rejected and terminated upload data transfer request from Peer.
* @param {String} UPLOADING <small>Value <code>"uploading"</code></small>
* The value of the state when data transfer is uploading data to Peer.
* @param {String} DOWNLOADING <small>Value <code>"downloading"</code></small>
* The value of the state when data transfer is downloading data from Peer.
* @param {String} UPLOAD_COMPLETED <small>Value <code>"uploadCompleted"</code></small>
* The value of the state when data transfer has uploaded successfully to Peer.
* @param {String} DOWNLOAD_COMPLETED <small>Value <code>"downloadCompleted"</code></small>
* The value of the state when data transfer has downloaded successfully from Peer.
* @param {String} CANCEL <small>Value <code>"cancel"</code></small>
* The value of the state when data transfer has been terminated from / to Peer.
* @param {String} ERROR <small>Value <code>"error"</code></small>
* The value of the state when data transfer has errors and has been terminated from / to Peer.
* @type JSON
* @readOnly
* @for Skylink
* @since 0.4.0
*/
Skylink.prototype.DATA_TRANSFER_STATE = {
UPLOAD_REQUEST: 'request',
UPLOAD_STARTED: 'uploadStarted',
DOWNLOAD_STARTED: 'downloadStarted',
REJECTED: 'rejected',
CANCEL: 'cancel',
ERROR: 'error',
UPLOADING: 'uploading',
DOWNLOADING: 'downloading',
UPLOAD_COMPLETED: 'uploadCompleted',
DOWNLOAD_COMPLETED: 'downloadCompleted',
USER_REJECTED: 'userRejected',
USER_UPLOAD_REQUEST: 'userRequest'
};
/**
* Stores the list of data transfer protocols.
* @attribute _DC_PROTOCOL_TYPE
* @param {String} WRQ The protocol to initiate data transfer.
* @param {String} ACK The protocol to request for data transfer chunk.
* Give <code>-1</code> to reject the request at the beginning and <code>0</code> to accept
* the data transfer request.
* @param {String} CANCEL The protocol to terminate data transfer.
* @param {String} ERROR The protocol when data transfer has errors and has to be terminated.
* @param {String} MESSAGE The protocol that is used to send P2P messages.
* @type JSON
* @readOnly
* @private
* @for Skylink
* @since 0.5.2
*/
Skylink.prototype._DC_PROTOCOL_TYPE = {
WRQ: 'WRQ',
ACK: 'ACK',
ERROR: 'ERROR',
CANCEL: 'CANCEL',
MESSAGE: 'MESSAGE'
};
/**
* Stores the list of agent names supported by the Web for Web only functionalities.
* @attribute _SUPPORTED_WEB_AGENTS
* @type Array
* @readOnly
* @private
* @for Skylink
* @since 0.6.16
*/
Skylink.prototype._SUPPORTED_WEB_AGENTS = ['chrome', 'firefox', 'safari', 'IE', 'edge' ,'opera', 'bowser', 'blink'];
/**
* <blockquote class="info">
* Note that Android, iOS and C++ SDKs do not support simultaneous data transfers.
* </blockquote>
* Function that starts an uploading data transfer from User to Peers.
* @method sendBlobData
* @param {Blob} data The Blob object.
* @param {Number} [timeout=60] The timeout to wait for response from Peer.
* @param {String|Array} [targetPeerId] The target Peer ID to start data transfer with.
* - When provided as an Array, it will start uploading data transfers with all connections
* with all the Peer IDs provided.
* - When not provided, it will start uploading data transfers with all the currently connected Peers in the Room.
* @param {Boolean} [sendChunksAsBinary=false] <blockquote class="info">
* Note that this is currently not supported for MCU enabled Peer connections or Peer connections connecting from
* Android, iOS and Linux SDKs. This would fallback to <code>transferInfo.chunkType</code> to
* <code>BINARY_STRING</code> when MCU is connected. </blockquote> The flag if data transfer
* binary data chunks should not be encoded as Base64 string during data transfers.
* @param {Function} [callback] The callback function fired when request has completed.
* <small>Function parameters signature is <code>function (error, success)</code></small>
* <small>Function request completion is determined by the <a href="#event_dataTransferState">
* <code>dataTransferState</code> event</a> triggering <code>state</code> parameter payload
* as <code>UPLOAD_COMPLETED</code> for all Peers targeted for request success.</small>
* @param {JSON} callback.error The error result in request.
* <small>Defined as <code>null</code> when there are no errors in request</small>
* @param {String} callback.error.transferId The data transfer ID.
* <small>Defined as <code>null</code> when <code>sendBlobData()</code> fails to start data transfer.</small>
* @param {Array} callback.error.listOfPeers The list Peer IDs targeted for the data transfer.
* @param {JSON} callback.error.transferErrors The list of data transfer errors.
* @param {Error|String} callback.error.transferErrors.#peerId The data transfer error associated
* with the Peer ID defined in <code>#peerId</code> property.
* <small>If <code>#peerId</code> value is <code>"self"</code>, it means that it is the error when there
* are no Peer connections to start data transfer with.</small>
* @param {JSON} callback.error.transferInfo The data transfer information.
* <small>Object signature matches the <code>transferInfo</code> parameter payload received in the
* <a href="#event_dataTransferState"><code>dataTransferState</code> event</a> except without the
* <code>percentage</code> and <code>data</code> property.</small>
* @param {JSON} callback.success The success result in request.
* <small>Defined as <code>null</code> when there are errors in request</small>
* @param {String} callback.success.transferId The data transfer ID.
* @param {Array} callback.success.listOfPeers The list Peer IDs targeted for the data transfer.
* @param {JSON} callback.success.transferInfo The data transfer information.
* <small>Object signature matches the <code>transferInfo</code> parameter payload received in the
* <a href="#event_dataTransferState"><code>dataTransferState</code> event</a> except without the
* <code>percentage</code> property and <code>data</code>.</small>
* @trigger <ol class="desc-seq">
* <li>Checks if Peer connection and Datachannel connection are in correct states. <ol>
* <li>If Peer connection or session does not exists: <ol><li><a href="#event_dataTransferState">
* <code>dataTransferState</code> event</a> triggers parameter payload <code>state</code>
* as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li>
* <li>If Peer connection is not stable: <small>The stable state can be checked with <a href="#event_peerConnectionState">
* <code>peerConnectionState</code> event</a> triggering parameter payload <code>state</code> as <code>STABLE</code>
* for Peer.</small> <ol><li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers
* parameter payload <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li>
* <li>If Peer connection messaging Datachannel has not been opened: <small>This can be checked with
* <a href="#event_dataChannelState"><code>dataChannelState</code> event</a> triggering parameter
* payload <code>state</code> as <code>OPEN</code> and <code>channelType</code> as
* <code>MESSAGING</code> for Peer.</small> <ol><li><a href="#event_dataTransferState">
* <code>dataTransferState</code> event</a> triggers parameter payload <code>state</code> as <code>ERROR</code>.</li>
* <li><b>ABORT</b> step and return error.</li></ol></li>
* <li>If MCU is enabled for the App Key provided in <a href="#method_init"><code>init()</code>method</a> and connected: <ol>
* <li>If MCU Peer connection is not stable: <small>The stable state can be checked with <a href="#event_peerConnectionState">
* <code>peerConnectionState</code> event</a> triggering parameter payload <code>state</code> as <code>STABLE</code>
* and <code>peerId</code> value as <code>"MCU"</code> for MCU Peer.</small>
* <ol><li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers
* parameter payload <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li>
* <li>If MCU Peer connection messaging Datachannel has not been opened: <small>This can be checked with
* <a href="#event_dataChannelState"><code>dataChannelState</code> event</a> triggering parameter
* payload <code>state</code> as <code>OPEN</code>, <code>peerId</code> value as <code>"MCU"</code>
* and <code>channelType</code> as <code>MESSAGING</code> for MCU Peer.</small>
* <ol><li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers
* parameter payload <code>state</code> as <code>ERROR</code>.</li>
* <li><b>ABORT</b> step and return error.</li></ol></li></ol></li>
* <li>Checks if should open a new data Datachannel.<ol>
* <li>If Peer supports simultaneous data transfer, open new data Datachannel: <small>If MCU is connected,
* this opens a new data Datachannel with MCU Peer with all the Peers IDs information that supports
* simultaneous data transfers targeted for the data transfer session instead of opening new data Datachannel
* with all Peers targeted for the data transfer session.</small> <ol>
* <li><a href="#event_dataChannelState"><code>dataChannelState</code> event</a> triggers parameter
* payload <code>state</code> as <code>CONNECTING</code> and <code>channelType</code> as <code>DATA</code>.
* <small>Note that there is no timeout to wait for parameter payload <code>state</code> to be
* <code>OPEN</code>.</small></li>
* <li>If Datachannel has been created and opened successfully: <ol>
* <li><a href="#event_dataChannelState"><code>dataChannelState</code> event</a> triggers parameter payload
* <code>state</code> as <code>OPEN</code> and <code>channelType</code> as <code>DATA</code>.</li></ol></li>
* <li>Else: <ol><li><a href="#event_dataChannelState"><code>dataChannelState</code> event</a>
* triggers parameter payload <code>state</code> as <code>CREATE_ERROR</code> and <code>channelType</code> as
* <code>DATA</code>.</li><li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers
* parameter payload <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and
* return error.</li></ol></li></ol></li><li>Else: <small>If MCU is connected,
* this uses the messaging Datachannel with MCU Peer with all the Peers IDs information that supports
* simultaneous data transfers targeted for the data transfer session instead of using the messaging Datachannels
* with all Peers targeted for the data transfer session.</small> <ol><li>If messaging Datachannel connection has a
* data transfer in-progress: <ol><li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and
* return error.</li></ol></li></li></ol></ol></li></ol></li>
* <li>Starts the data transfer to Peer. <ol>
* <li><a href="#event_incomingDataRequest"><code>incomingDataRequest</code> event</a> triggers.</li>
* <li><em>For User only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>USER_UPLOAD_REQUEST</code>.</li>
* <li><em>For Peer only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>UPLOAD_REQUEST</code>.</li>
* <li>Peer invokes <a href="#method_acceptDataTransfer"><code>acceptDataTransfer()</code> method</a>. <ol>
* <li>If parameter <code>accept</code> value is <code>true</code>: <ol>
* <li>User starts upload data transfer to Peer. <ol>
* <li><em>For User only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>UPLOAD_STARTED</code>.</li>
* <li><em>For Peer only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>DOWNLOAD_STARTED</code>.</li></ol></li>
* <li>If Peer / User invokes <a href="#method_cancelDataTransfer"><code>cancelDataTransfer()</code> method</a>: <ol>
* <li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers parameter
* <code>state</code> as <code>CANCEL</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li>
* <li>If data transfer has timeout errors: <ol>
* <li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers parameter
* <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li>
* <li>Checks for Peer connection and Datachannel connection during data transfer: <ol>
* <li>If MCU is enabled for the App Key provided in <a href="#method_init"><code>init()</code>
* method</a> and connected: <ol>
* <li>If MCU Datachannel has closed abruptly during data transfer: <ol>
* <small>This can be checked with <a href="#event_dataChannelState"><code>dataChannelState</code> event</a>
* triggering parameter payload <code>state</code> as <code>CLOSED</code>, <code>peerId</code> value as
* <code>"MCU"</code> and <code>channelType</code> as <code>DATA</code> for targeted Peers that supports simultaneous
* data transfer or <code>MESSAGING</code> for targeted Peers that do not support it.</small> <ol>
* <li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers parameter
* <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li></ol></li>
* <li>If MCU Peer connection has changed from not being stable: <ol>
* <small>This can be checked with <a href="#event_peerConnectionState"><code>peerConnection</code> event</a>
* triggering parameter payload <code>state</code> as not <code>STABLE</code>, <code>peerId</code> value as
* <code>"MCU"</code>.</small> <ol><li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers parameter
* <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li></ol></li>
* <li>If Peer connection has changed from not being stable: <ol>
* <small>This can be checked with <a href="#event_peerConnectionState"><code>peerConnection</code> event</a>
* triggering parameter payload <code>state</code> as not <code>STABLE</code>.</small> <ol>
* <li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers parameter
* <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li></ol></li></ol></li>
* <li>Else: <ol><li>If Datachannel has closed abruptly during data transfer:
* <small>This can be checked with <a href="#event_dataChannelState"><code>dataChannelState</code> event</a>
* triggering parameter payload <code>state</code> as <code>CLOSED</code> and <code>channelType</code>
* as <code>DATA</code> for Peer that supports simultaneous data transfer or <code>MESSAGING</code>
* for Peer that do not support it.</small> <ol>
* <li><a href="#event_dataTransferState"><code>dataTransferState</code> event</a> triggers parameter
* <code>state</code> as <code>ERROR</code>.</li><li><b>ABORT</b> step and return error.</li></ol></li></ol></li></ol></li>
* <li>If data transfer is still progressing: <ol>
* <li><em>For User only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>UPLOADING</code>.</li>
* <li><em>For Peer only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>DOWNLOADING</code>.</li></ol></li>
* <li>If data transfer has completed <ol>
* <li><a href="#event_incomingData"><code>incomingData</code> event</a> triggers.</li>
* <li><em>For User only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>UPLOAD_COMPLETED</code>.</li>
* <li><em>For Peer only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>DOWNLOAD_COMPLETED</code>.</li></ol></li></ol></li>
* <li>If parameter <code>accept</code> value is <code>false</code>: <ol>
* <li><em>For User only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>REJECTED</code>.</li>
* <li><em>For Peer only</em> <a href="#event_dataTransferState"><code>dataTransferState</code> event</a>
* triggers parameter payload <code>state</code> as <code>USER_REJECTED</code>.</li>
* <li><b>ABORT</b> step and return error.</li></ol></li></ol>
* @example
* <body>
* <input type="radio" name="timeout" onchange="setTransferTimeout(0)"> 1s timeout (Default)
* <input type="radio" name="timeout" onchange="setTransferTimeout(120)"> 2s timeout
* <input type="radio" name="timeout" onchange="setTransferTimeout(300)"> 5s timeout
* <hr>
* <input type="file" onchange="uploadFile(this.files[0], this.getAttribute('data'))" data="peerId">
* <input type="file" onchange="uploadFileGroup(this.files[0], this.getAttribute('data').split(',')))" data="peerIdA,peerIdB">
* <input type="file" onchange="uploadFileAll(this.files[0])" data="">
* <script>
* var transferTimeout = 0;
*
* function setTransferTimeout (timeout) {
* transferTimeout = timeout;
* }
*
* // Example 1: Upload data to a Peer
* function uploadFile (file, peerId) {
* var cb = function (error, success) {
* if (error) return;
* console.info("File has been transferred to '" + peerId + "' successfully");
* };
* if (transferTimeout > 0) {
* skylinkDemo.sendBlobData(file, peerId, transferTimeout, cb);
* } else {
* skylinkDemo.sendBlobData(file, peerId, cb);
* }
* }
*
* // Example 2: Upload data to a list of Peers
* function uploadFileGroup (file, peerIds) {
* var cb = function (error, success) {
* var listOfPeers = error ? error.listOfPeers : success.listOfPeers;
* var listOfPeersErrors = error ? error.transferErrors : {};
* for (var i = 0; i < listOfPeers.length; i++) {
* if (listOfPeersErrors[listOfPeers[i]]) {
* console.error("Failed file transfer to '" + listOfPeers[i] + "'");
* } else {
* console.info("File has been transferred to '" + listOfPeers[i] + "' successfully");
* }
* }
* };
* if (transferTimeout > 0) {
* skylinkDemo.sendBlobData(file, peerIds, transferTimeout, cb);
* } else {
* skylinkDemo.sendBlobData(file, peerIds, cb);
* }
* }
*
* // Example 2: Upload data to a list of Peers
* function uploadFileAll (file) {
* var cb = function (error, success) {
* var listOfPeers = error ? error.listOfPeers : success.listOfPeers;
* var listOfPeersErrors = error ? error.transferErrors : {};
* for (var i = 0; i < listOfPeers.length; i++) {
* if (listOfPeersErrors[listOfPeers[i]]) {
* console.error("Failed file transfer to '" + listOfPeers[i] + "'");
* } else {
* console.info("File has been transferred to '" + listOfPeers[i] + "' successfully");
* }
* }
* };
* if (transferTimeout > 0) {
* skylinkDemo.sendBlobData(file, transferTimeout, cb);
* } else {
* skylinkDemo.sendBlobData(file, cb);
* }
* }
* </script>
* </body>
* @for Skylink
* @since 0.5.5
*/
Skylink.prototype.sendBlobData = function(data, timeout, targetPeerId, sendChunksAsBinary, callback) {
var self = this;
var listOfPeers = Object.keys(self._peerConnections);
var transferInfo = {
name: null,
size: null,
chunkSize: self._CHUNK_FILE_SIZE,
chunkType: self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING,
dataType: self.DATA_TRANSFER_SESSION_TYPE.BLOB,
mimeType: null,
direction: self.DATA_TRANSFER_TYPE.UPLOAD,
timeout: 60,
isPrivate: false,
percentage: 0
};
// Function that returns the error emitted before data transfer has started
var emitErrorBeforeDataTransferFn = function (error) {
log.error(error);
if (typeof callback === 'function') {
var transferErrors = {};
if (listOfPeers.length === 0) {
transferErrors.self = new Error(error);
} else {
for (var i = 0; i < listOfPeers.length; i++) {
transferErrors[listOfPeers[i]] = new Error(error);
}
}
callback({
transferId: null,
transferInfo: transferInfo,
listOfPeers: listOfPeers,
transferErrors: transferErrors
}, null);
}
};
// Remove MCU Peer as list of Peers
if (listOfPeers.indexOf('MCU') > -1) {
listOfPeers.splice(listOfPeers.indexOf('MCU'), 1);
}
// sendBlobData(.., timeout)
if (typeof timeout === 'number') {
transferInfo.timeout = timeout;
} else if (Array.isArray(timeout)) {
listOfPeers = timeout;
} else if (timeout && typeof timeout === 'string') {
listOfPeers = [timeout];
} else if (timeout && typeof timeout === 'boolean') {
transferInfo.chunkType = self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER;
transferInfo.chunkSize = self._BINARY_FILE_SIZE;
} else if (typeof timeout === 'function') {
callback = timeout;
}
// sendBlobData(.., .., targetPeerId)
if (Array.isArray(targetPeerId)) {
listOfPeers = targetPeerId;
} else if (targetPeerId && typeof targetPeerId === 'string') {
listOfPeers = [targetPeerId];
} else if (targetPeerId && typeof targetPeerId === 'boolean') {
transferInfo.chunkType = self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER;
transferInfo.chunkSize = self._BINARY_FILE_SIZE;
} else if (typeof targetPeerId === 'function') {
callback = targetPeerId;
}
// sendBlobData(.., .., .., sendChunksAsBinary)
if (sendChunksAsBinary && typeof sendChunksAsBinary === 'boolean') {
transferInfo.chunkType = self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER;
transferInfo.chunkSize = self._BINARY_FILE_SIZE;
} else if (typeof sendChunksAsBinary === 'function') {
callback = sendChunksAsBinary;
}
if (window.webrtcDetectedBrowser === 'firefox' &&
transferInfo.chunkType === self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING) {
transferInfo.chunkSize = self._MOZ_CHUNK_FILE_SIZE;
}
if (self._hasMCU && transferInfo.chunkType === self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER) {
log.warn('Binary data chunks transfer is not yet supported with MCU environment. ' +
'Fallbacking to binary string data chunks transfer.');
transferInfo.chunkType = self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING;
transferInfo.chunkSize = self._CHUNK_FILE_SIZE;
}
// Use BLOB for Firefox
if (transferInfo.chunkType === self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER &&
window.webrtcDetectedBrowser === 'firefox') {
transferInfo.chunkType = self.DATA_TRANSFER_DATA_TYPE.BLOB;
transferInfo.chunkSize = self._MOZ_BINARY_FILE_SIZE;
}
// Start checking if data transfer can start
if (!(data && typeof data === 'object' && data instanceof Blob)) {
emitErrorBeforeDataTransferFn('Provided data is not a Blob data');
return;
}
transferInfo.name = data.name || null;
transferInfo.mimeType = data.type || null;
if (data.size < 1) {
emitErrorBeforeDataTransferFn('Provided data is not a valid Blob data.');
return;
}
transferInfo.size = data.size;
if (!self._user) {
emitErrorBeforeDataTransferFn('Unable to send any blob data. User is not in Room.');
return;
}
if (listOfPeers.length === 0) {
emitErrorBeforeDataTransferFn('Unable to send any blob data. There are no Peers to start data transfer with');
return;
}
if (!self._enableDataChannel) {
emitErrorBeforeDataTransferFn('Unable to send any blob data. Datachannel is disabled');
return;
}
var chunks = self._chunkBlobData(data, transferInfo.chunkSize);
transferInfo.originalSize = transferInfo.size;
if (transferInfo.chunkType === self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING) {
transferInfo.size = 4 * Math.ceil(transferInfo.size / 3);
transferInfo.chunkSize = 4 * Math.ceil(transferInfo.chunkSize / 3);
}
self._startDataTransfer(chunks, transferInfo, listOfPeers, callback);
};
/**
* <blockquote class="info">
* Currently, the Android, iOS and C++ SDKs do not support this type of data transfer session.
* </blockquote>
* Function that starts an uploading string data transfer from User to Peers.
* @method sendURLData
* @param {String} data The data string to transfer to Peer.
* @param {Number} [timeout=60] The timeout to wait for response from Peer.
* @param {String|Array} [targetPeerId] The target Peer ID to start data transfer with.
* - When provided as an Array, it will start uploading data transfers with all connections
* with all the Peer IDs provided.
* - When not provided, it will start uploading data transfers with all the currently connected Peers in the Room.
* @param {Function} [callback] The callback function fired when request has completed.
* <small>Function parameters signature is <code>function (error, success)</code></small>
* <small>Function request completion is determined by the <a href="#event_dataTransferState">
* <code>dataTransferState</code> event</a> triggering <code>state</code> parameter payload
* as <code>UPLOAD_COMPLETED</code> for all Peers targeted for request success.</small>
* @param {JSON} callback.error The error result in request.
* <small>Defined as <code>null</code> when there are no errors in request</small>
* @param {String} callback.error.transferId The data transfer ID.
* <small>Defined as <code>null</code> when <code>sendURLData()</code> fails to start data transfer.</small>
* @param {Array} callback.error.listOfPeers The list Peer IDs targeted for the data transfer.
* @param {JSON} callback.error.transferErrors The list of data transfer errors.
* @param {Error|String} callback.error.transferErrors.#peerId The data transfer error associated
* with the Peer ID defined in <code>#peerId</code> property.
* <small>If <code>#peerId</code> value is <code>"self"</code>, it means that it is the error when there
* are no Peer connections to start data transfer with.</small>
* @param {JSON} callback.error.transferInfo The data transfer information.
* <small>Object signature matches the <code>transferInfo</code> parameter payload received in the
* <a href="#event_dataTransferState"><code>dataTransferState</code> event</a> except without the
* <code>percentage</code> property and <code>data</code>.</small>
* @param {JSON} callback.success The success result in request.
* <small>Defined as <code>null</code> when there are errors in request</small>
* @param {String} callback.success.transferId The data transfer ID.
* @param {Array} callback.success.listOfPeers The list Peer IDs targeted for the data transfer.
* @param {JSON} callback.success.transferInfo The data transfer information.
* <small>Object signature matches the <code>transferInfo</code> parameter payload received in the
* <a href="#event_dataTransferState"><code>dataTransferState</code> event</a> except without the
* <code>percentage</code> property and <code>data</code>.</small>
* @trigger <small>Event sequence follows <a href="#method_sendBlobData">
* <code>sendBlobData()</code> method</a>.</small>
* @example
* <body>
* <input type="radio" name="timeout" onchange="setTransferTimeout(0)"> 1s timeout (Default)
* <input type="radio" name="timeout" onchange="setTransferTimeout(120)"> 2s timeout
* <input type="radio" name="timeout" onchange="setTransferTimeout(300)"> 5s timeout
* <hr>
* <input type="file" onchange="showImage(this.files[0], this.getAttribute('data'))" data="peerId">
* <input type="file" onchange="showImageGroup(this.files[0], this.getAttribute('data').split(',')))" data="peerIdA,peerIdB">
* <input type="file" onchange="showImageAll(this.files[0])" data="">
* <image id="target-1" src="">
* <image id="target-2" src="">
* <image id="target-3" src="">
* <script>
* var transferTimeout = 0;
*
* function setTransferTimeout (timeout) {
* transferTimeout = timeout;
* }
*
* function retrieveImageDataURL(file, cb) {
* var fr = new FileReader();
* fr.onload = function () {
* cb(fr.result);
* };
* fr.readAsDataURL(files[0]);
* }
*
* // Example 1: Send image data URL to a Peer
* function showImage (file, peerId) {
* var cb = function (error, success) {
* if (error) return;
* console.info("Image has been transferred to '" + peerId + "' successfully");
* };
* retrieveImageDataURL(file, function (str) {
* if (transferTimeout > 0) {
* skylinkDemo.sendURLData(str, peerId, transferTimeout, cb);
* } else {
* skylinkDemo.sendURLData(str, peerId, cb);
* }
* document.getElementById("target-1").src = str;
* });
* }
*
* // Example 2: Send image data URL to a list of Peers
* function showImageGroup (file, peerIds) {
* var cb = function (error, success) {
* var listOfPeers = error ? error.listOfPeers : success.listOfPeers;
* var listOfPeersErrors = error ? error.transferErrors : {};
* for (var i = 0; i < listOfPeers.length; i++) {
* if (listOfPeersErrors[listOfPeers[i]]) {
* console.error("Failed image transfer to '" + listOfPeers[i] + "'");
* } else {
* console.info("Image has been transferred to '" + listOfPeers[i] + "' successfully");
* }
* }
* };
* retrieveImageDataURL(file, function (str) {
* if (transferTimeout > 0) {
* skylinkDemo.sendURLData(str, peerIds, transferTimeout, cb);
* } else {
* skylinkDemo.sendURLData(str, peerIds, cb);
* }
* document.getElementById("target-2").src = str;
* });
* }
*
* // Example 2: Send image data URL to a list of Peers
* function uploadFileAll (file) {
* var cb = function (error, success) {
* var listOfPeers = error ? error.listOfPeers : success.listOfPeers;
* var listOfPeersErrors = error ? error.transferErrors : {};
* for (var i = 0; i < listOfPeers.length; i++) {
* if (listOfPeersErrors[listOfPeers[i]]) {
* console.error("Failed image transfer to '" + listOfPeers[i] + "'");
* } else {
* console.info("Image has been transferred to '" + listOfPeers[i] + "' successfully");
* }
* }
* };
* retrieveImageDataURL(file, function (str) {
* if (transferTimeout > 0) {
* skylinkDemo.sendURLData(str, transferTimeout, cb);
* } else {
* skylinkDemo.sendURLData(str, cb);
* }
* document.getElementById("target-3").src = str;
* });
* }
* </script>
* </body>
* @for Skylink
* @since 0.6.1
*/
Skylink.prototype.sendURLData = function(data, timeout, targetPeerId, callback) {
var self = this;
var listOfPeers = Object.keys(self._peerConnections);
var transferInfo = {
name: null,
size: null,
chunkSize: self._CHUNK_FILE_SIZE,
chunkType: self.DATA_TRANSFER_DATA_TYPE.STRING,
dataType: self.DATA_TRANSFER_SESSION_TYPE.DATA_URL,
mimeType: null,
direction: self.DATA_TRANSFER_TYPE.UPLOAD,
timeout: 60,
isPrivate: false,
percentage: 0
};
// Function that returns the error emitted before data transfer has started
var emitErrorBeforeDataTransferFn = function (error) {
log.error(error);
if (typeof callback === 'function') {
var transferErrors = {};
if (listOfPeers.length === 0) {
transferErrors.self = new Error(error);
} else {
for (var i = 0; i < listOfPeers.length; i++) {
transferErrors[listOfPeers[i]] = new Error(error);
}
}
callback({
transferId: null,
transferInfo: transferInfo,
listOfPeers: listOfPeers,
transferErrors: transferErrors
}, null);
}
};
// Remove MCU Peer as list of Peers
if (listOfPeers.indexOf('MCU') > -1) {
listOfPeers.splice(listOfPeers.indexOf('MCU'), 1);
}
// sendURLData(.., timeout)
if (typeof timeout === 'number') {
transferInfo.timeout = timeout;
} else if (Array.isArray(timeout)) {
listOfPeers = timeout;
} else if (timeout && typeof timeout === 'string') {
listOfPeers = [timeout];
} else if (typeof timeout === 'function') {
callback = timeout;
}
// sendURLData(.., .., targetPeerId)
if (Array.isArray(targetPeerId)) {
listOfPeers = targetPeerId;
} else if (targetPeerId && typeof targetPeerId === 'string') {
listOfPeers = [targetPeerId];
} else if (typeof targetPeerId === 'function') {
callback = targetPeerId;
}
// Start checking if data transfer can start
if (!(data && typeof data === 'string')) {
emitErrorBeforeDataTransferFn('Provided data is not a dataURL');
return;
}
transferInfo.size = data.length || data.size;
if (!self._user) {
emitErrorBeforeDataTransferFn('Unable to send any dataURL. User is not in Room.');
return;
}
if (listOfPeers.length === 0) {
emitErrorBeforeDataTransferFn('Unable to send any dataURL. There are no Peers to start data transfer with');
return;
}
if (!self._enableDataChannel) {
emitErrorBeforeDataTransferFn('Unable to send any dataURL. Datachannel is disabled');
return;
}
var chunks = self._chunkDataURL(data, transferInfo.chunkSize);
transferInfo.originalSize = transferInfo.size;
self._startDataTransfer(chunks, transferInfo, listOfPeers, callback);
};
/**
* Function that accepts or rejects an upload data transfer request from Peer to User.
* @method acceptDataTransfer
* @param {String} peerId The Peer ID.
* @param {String} transferId The data transfer ID.
* @param {Boolean} [accept=false] The flag if User accepts the upload data transfer request from Peer.
* @example
* // Example 1: Accept Peer upload data transfer request
* skylinkDemo.on("incomingDataRequest", function (transferId, peerId, transferInfo, isSelf) {
* if (!isSelf) {
* skylinkDemo.acceptDataTransfer(peerId, transferId, true);
* }
* });
*
* // Example 2: Reject Peer upload data transfer request
* skylinkDemo.on("incomingDataRequest", function (transferId, peerId, transferInfo, isSelf) {
* if (!isSelf) {
* skylinkDemo.acceptDataTransfer(peerId, transferId, false);
* }
* });
* @trigger <small>Event sequence follows <a href="#method_sendBlobData">
* <code>sendBlobData()</code> method</a> after <code>acceptDataTransfer()</code> method is invoked.</small>
* @for Skylink
* @since 0.6.1
*/
Skylink.prototype.respondBlobRequest =
Skylink.prototype.acceptDataTransfer = function (peerId, transferId, accept) {
var self = this;
if (typeof transferId !== 'string' && typeof peerId !== 'string') {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting accept data transfer as ' +
'data transfer ID or peer ID is not provided']);
return;
}
if (!self._dataChannels[peerId]) {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting accept data transfer as ' +
'Peer does not have any Datachannel connections']);
return;
}
if (!self._dataTransfers[transferId]) {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting accept data transfer as ' +
'invalid transfer ID is provided']);
return;
}
// Check Datachannel property in _dataChannels[peerId] list
var channelProp = 'main';
if (self._dataChannels[peerId][transferId]) {
channelProp = transferId;
}
if (accept) {
log.debug([peerId, 'RTCDataChannel', transferId, 'Accepted data transfer and starting ...']);
var dataChannelStateCbFn = function (state, evtPeerId, error, cN, cT) {
console.info(evtPeerId, error, cN, cT);
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.ERROR, transferId, peerId,
self._getTransferInfo(transferId, peerId, true, false, false), {
transferType: self.DATA_TRANSFER_TYPE.DOWNLOAD,
message: new Error('Data transfer terminated as Peer Datachannel connection closed abruptly.')
});
};
self.once('dataChannelState', dataChannelStateCbFn, function (state, evtPeerId, error, channelName, channelType) {
if (!(self._dataTransfers[transferId] && self._dataTransfers[transferId].sessions[peerId])) {
self.off('dataChannelState', dataChannelStateCbFn);
return;
}
return evtPeerId === peerId && (channelProp === 'main' ? channelType === self.DATA_CHANNEL_STATE.MESSAGING :
channelName === transferId) && [self.DATA_CHANNEL_STATE.CLOSING, self.DATA_CHANNEL_STATE.CLOSED,
self.DATA_CHANNEL_STATE.ERROR].indexOf(state) > -1;
});
// From here we start detecting as completion for data transfer downloads
self.once('dataTransferState', function () {
if (dataChannelStateCbFn) {
self.off('dataChannelState', dataChannelStateCbFn);
}
delete self._dataTransfers[transferId];
if (self._dataChannels[peerId]) {
if (channelProp === 'main' && self._dataChannels[peerId].main) {
self._dataChannels[peerId].main.transferId = null;
}
if (channelProp === transferId) {
self._closeDataChannel(peerId, transferId);
}
}
}, function (state, evtTransferId, evtPeerId) {
return evtTransferId === transferId && evtPeerId === peerId &&
[self.DATA_TRANSFER_STATE.ERROR, self.DATA_TRANSFER_STATE.CANCEL,
self.DATA_TRANSFER_STATE.DOWNLOAD_COMPLETED].indexOf(state) > -1;
});
// Send ACK protocol to start data transfer
// MCU sends the data transfer from the "P2P" Datachannel
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.ACK,
sender: self._user.sid,
ackN: 0
}, channelProp);
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.DOWNLOAD_STARTED, transferId, peerId,
self._getTransferInfo(transferId, peerId, true, false, false), null);
} else {
log.warn([peerId, 'RTCDataChannel', transferId, 'Rejected data transfer and data transfer request has been aborted']);
// Send ACK protocol to terminate data transfer request
// MCU sends the data transfer from the "P2P" Datachannel
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.ACK,
sender: self._user.sid,
ackN: -1
}, channelProp);
// Insanity check
if (channelProp === 'main' && self._dataChannels[peerId].main) {
self._dataChannels[peerId].main.transferId = null;
}
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.USER_REJECTED, transferId, peerId,
self._getTransferInfo(transferId, peerId, true, false, false), {
message: new Error('Data transfer terminated as User has rejected data transfer request.'),
transferType: self.DATA_TRANSFER_TYPE.DOWNLOAD
});
delete self._dataTransfers[transferId];
}
};
/**
* <blockquote class="info">
* For MCU enabled Peer connections, the cancel data transfer functionality may differ, as it
* will result in all Peers related to the data transfer ID to be terminated.
* </blockquote>
* Function that terminates a currently uploading / downloading data transfer from / to Peer.
* @method cancelDataTransfer
* @param {String} peerId The Peer ID.
* @param {String} transferId The data transfer ID.
* @example
* // Example 1: Cancel Peer data transfer
* var transferSessions = {};
*
* skylinkDemo.on("dataTransferState", function (state, transferId, peerId) {
* if ([skylinkDemo.DATA_TRANSFER_STATE.DOWNLOAD_STARTED,
* skylinkDemo.DATA_TRANSFER_STATE.UPLOAD_STARTED].indexOf(state) > -1) {
* if (!Array.isArray(transferSessions[transferId])) {
* transferSessions[transferId] = [];
* }
* transferSessions[transferId].push(peerId);
* } else {
* transferSessions[transferId].splice(transferSessions[transferId].indexOf(peerId), 1);
* }
* });
*
* function cancelTransfer (peerId, transferId) {
* skylinkDemo.cancelDataTransfer(peerId, transferId);
* }
* @trigger <small>Event sequence follows <a href="#method_sendBlobData">
* <code>sendBlobData()</code> method</a> after <code>cancelDataTransfer()</code> method is invoked.</small>
* @for Skylink
* @since 0.6.1
*/
Skylink.prototype.cancelBlobTransfer =
Skylink.prototype.cancelDataTransfer = function (peerId, transferId) {
var self = this;
if (!(transferId && typeof transferId === 'string')) {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting cancel data transfer as data transfer ID is not provided']);
return;
}
if (!(peerId && typeof peerId === 'string')) {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting cancel data transfer as peer ID is not provided']);
return;
}
if (!self._dataTransfers[transferId]) {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting cancel data transfer as ' +
'data transfer session does not exists.']);
return;
}
log.debug([peerId, 'RTCDataChannel', transferId, 'Canceling data transfer ...']);
/**
* Emit data state event function.
*/
var emitEventFn = function (peers, transferInfoPeerId) {
for (var i = 0; i < peers.length; i++) {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.CANCEL, transferId, peers[i],
self._getTransferInfo(transferId, transferInfoPeerId, false, false, false), {
transferType: self._dataTransfers[transferId].direction,
message: new Error('User cancelled download transfer')
});
}
};
// For uploading from Peer to MCU case of broadcast
if (self._hasMCU && self._dataTransfers[transferId].direction === self.DATA_TRANSFER_TYPE.UPLOAD) {
if (!self._dataChannels.MCU) {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting cancel data transfer as ' +
'Peer does not have any Datachannel connections']);
return;
}
// We abort all data transfers to all Peers if uploading via MCU since it broadcasts to MCU
log.warn([peerId, 'RTCDataChannel', transferId, 'Aborting all data transfers to Peers']);
// If data transfer to MCU broadcast has interop Peers, send to MCU via the "main" Datachannel
if (Object.keys(self._dataTransfers[transferId].peers.main).length > 0) {
self._sendMessageToDataChannel('MCU', {
type: self._DC_PROTOCOL_TYPE.CANCEL,
sender: self._user.sid,
content: 'Peer cancelled download transfer',
name: self._dataTransfers[transferId].name,
ackN: 0
}, 'main');
}
// If data transfer to MCU broadcast has non-interop Peers, send to MCU via the new Datachanel
if (Object.keys(self._dataTransfers[transferId].peers[transferId]).length > 0) {
self._sendMessageToDataChannel('MCU', {
type: self._DC_PROTOCOL_TYPE.CANCEL,
sender: self._user.sid,
content: 'Peer cancelled download transfer',
name: self._dataTransfers[transferId].name,
ackN: 0
}, transferId);
}
emitEventFn(Object.keys(self._dataTransfers[transferId].peers.main).concat(
Object.keys(self._dataTransfers[transferId].peers[transferId])));
} else {
var channelProp = 'main';
if (!self._dataChannels[peerId]) {
log.error([peerId, 'RTCDataChannel', transferId, 'Aborting cancel data transfer as ' +
'Peer does not have any Datachannel connections']);
return;
}
if (self._dataChannels[peerId][transferId]) {
channelProp = transferId;
}
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.CANCEL,
sender: self._user.sid,
content: 'Peer cancelled download transfer',
name: self._dataTransfers[transferId].name,
ackN: 0
}, channelProp);
emitEventFn([peerId], peerId);
}
};
/**
* Function that sends a message to Peers via the Datachannel connection.
* <small>Consider using <a href="#method_sendURLData"><code>sendURLData()</code> method</a> if you are
* sending large strings to Peers.</small>
* @method sendP2PMessage
* @param {String|JSON} message The message.
* @param {String|Array} [targetPeerId] The target Peer ID to send message to.
* - When provided as an Array, it will send the message to only Peers which IDs are in the list.
* - When not provided, it will broadcast the message to all connected Peers with Datachannel connection in the Room.
* @trigger <ol class="desc-seq">
* <li>Sends P2P message to all targeted Peers. <ol>
* <li>If Peer connection Datachannel has not been opened: <small>This can be checked with
* <a href="#event_dataChannelState"><code>dataChannelState</code> event</a>
* triggering parameter payload <code>state</code> as <code>OPEN</code> and
* <code>channelType</code> as <code>MESSAGING</code> for Peer.</small> <ol>
* <li><a href="#event_dataChannelState"><code>dataChannelState</code> event</a> triggers
* parameter payload <code>state</code> as <code>SEND_MESSAGE_ERROR</code>.</li>
* <li><b>ABORT</b> step and return error.</li></ol></li>
* <li><a href="#event_incomingMessage"><code>incomingMessage</code> event</a> triggers
* parameter payload <code>message.isDataChannel</code> value as <code>true</code> and
* <code>isSelf</code> value as <code>true</code>.</li></ol></li></ol>
* @example
* // Example 1: Broadcasting to all Peers
* skylinkDemo.on("dataChannelState", function (state, peerId, error, channelName, channelType) {
* if (state === skylinkDemo.DATA_CHANNEL_STATE.OPEN &&
* channelType === skylinkDemo.DATA_CHANNEL_TYPE.MESSAGING) {
* skylinkDemo.sendP2PMessage("Hi all!");
* }
* });
*
* // Example 2: Sending to specific Peers
* var peersInExclusiveParty = [];
*
* skylinkDemo.on("peerJoined", function (peerId, peerInfo, isSelf) {
* if (isSelf) return;
* if (peerInfo.userData.exclusive) {
* peersInExclusiveParty[peerId] = false;
* }
* });
*
* skylinkDemo.on("dataChannelState", function (state, peerId, error, channelName, channelType) {
* if (state === skylinkDemo.DATA_CHANNEL_STATE.OPEN &&
* channelType === skylinkDemo.DATA_CHANNEL_TYPE.MESSAGING) {
* peersInExclusiveParty[peerId] = true;
* }
* });
*
* function updateExclusivePartyStatus (message) {
* var readyToSend = [];
* for (var p in peersInExclusiveParty) {
* if (peersInExclusiveParty.hasOwnProperty(p)) {
* readyToSend.push(p);
* }
* }
* skylinkDemo.sendP2PMessage(message, readyToSend);
* }
* @for Skylink
* @since 0.5.5
*/
Skylink.prototype.sendP2PMessage = function(message, targetPeerId) {
var listOfPeers = Object.keys(this._dataChannels);
var isPrivate = false;
if (Array.isArray(targetPeerId)) {
listOfPeers = targetPeerId;
isPrivate = true;
} else if (targetPeerId && typeof targetPeerId === 'string') {
listOfPeers = [targetPeerId];
isPrivate = true;
}
if (!this._inRoom || !this._user) {
log.error('Unable to send message as User is not in Room. ->', message);
return;
}
if (!this._enableDataChannel) {
log.error('Unable to send message as User does not have Datachannel enabled. ->', message);
return;
}
// Loop out unwanted Peers
for (var i = 0; i < listOfPeers.length; i++) {
var peerId = listOfPeers[i];
if (!this._dataChannels[peerId]) {
log.error([peerId, 'RTCDataChannel', null, 'Dropping of sending message to Peer as ' +
'Datachannel connection does not exists']);
listOfPeers.splice(i, 1);
i--;
} else if (peerId === 'MCU') {
listOfPeers.splice(i, 1);
i--;
} else if (!this._hasMCU) {
log.debug([peerId, 'RTCDataChannel', null, 'Sending ' + (isPrivate ? 'private' : '') +
' P2P message to Peer']);
this._sendMessageToDataChannel(peerId, {
type: this._DC_PROTOCOL_TYPE.MESSAGE,
isPrivate: isPrivate,
sender: this._user.sid,
target: peerId,
data: message
}, 'main');
}
}
if (listOfPeers.length === 0) {
log.warn('Currently there are no Peers to send P2P message to (unless the message is queued ' +
'and there are Peer connected by then).');
}
if (this._hasMCU) {
log.debug(['MCU', 'RTCDataChannel', null, 'Broadcasting ' + (isPrivate ? 'private' : '') +
' P2P message to Peers']);
this._sendMessageToDataChannel('MCU', {
type: this._DC_PROTOCOL_TYPE.MESSAGE,
isPrivate: isPrivate,
sender: this._user.sid,
target: listOfPeers,
data: message
}, 'main');
}
this._trigger('incomingMessage', {
content: message,
isPrivate: isPrivate,
targetPeerId: targetPeerId || null,
listOfPeers: listOfPeers,
isDataChannel: true,
senderPeerId: this._user.sid
}, this._user.sid, this.getPeerInfo(), true);
};
/**
* Function that starts the data transfer to Peers.
* @method _startDataTransfer
* @private
* @for Skylink
* @since 0.6.1
*/
Skylink.prototype._startDataTransfer = function(chunks, transferInfo, listOfPeers, callback) {
var self = this;
var transferId = self._user.sid + '_' + (new Date()).getTime();
var transferErrors = {};
var transferCompleted = [];
// Polyfill data name to prevent empty fields in WRQ
// TODO: What happens if transfer requires extension?
if (!transferInfo.name) {
transferInfo.name = transferId;
}
self._dataTransfers[transferId] = clone(transferInfo);
self._dataTransfers[transferId].peers = {};
self._dataTransfers[transferId].peers.main = {};
self._dataTransfers[transferId].peers[transferId] = {};
self._dataTransfers[transferId].sessions = {};
self._dataTransfers[transferId].chunks = chunks;
self._dataTransfers[transferId].enforceBSPeers = [];
self._dataTransfers[transferId].enforcedBSInfo = {};
// Check if fallback chunks is required
if ([self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER, self.DATA_TRANSFER_DATA_TYPE.BLOB].indexOf(
transferInfo.chunkType) > -1) {
for (var p = 0; p < listOfPeers.length; p++) {
var agentName = (((self._peerInformations[listOfPeers[p]]) || {}).agent || {}).name || '';
// C++ SDK does not support binary file transfer for now
if (self._SUPPORTED_WEB_AGENTS.indexOf(agentName) === -1) {
self._dataTransfers[transferId].enforceBSPeers.push(listOfPeers[p]);
}
}
if (self._dataTransfers[transferId].enforceBSPeers.length > 0) {
var bsChunkSize = window.webrtcDetectedBrowser === 'firefox' ? self._MOZ_CHUNK_FILE_SIZE : self._CHUNK_FILE_SIZE;
var bsChunks = self._chunkBlobData(new Blob(chunks), bsChunkSize);
self._dataTransfers[transferId].enforceBSInfo = {
chunkSize: 4 * Math.ceil(bsChunkSize / 3),
chunkType: self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING,
size: 4 * Math.ceil(transferInfo.originalSize / 3),
chunks: bsChunks
};
}
}
/**
* Complete Peer function.
*/
var completeFn = function (peerId, error) {
// Ignore if already added.
if (transferCompleted.indexOf(peerId) > -1) {
return;
}
log.debug([peerId, 'RTCDataChannel', transferId, 'Data transfer result. Is errors present? ->'], error);
transferCompleted.push(peerId);
if (error) {
transferErrors[peerId] = new Error(error);
}
if (listOfPeers.length === transferCompleted.length) {
log.log([null, 'RTCDataChannel', transferId, 'Data transfer request completed']);
if (typeof callback === 'function') {
if (Object.keys(transferErrors).length > 0) {
callback({
transferId: transferId,
transferInfo: self._getTransferInfo(transferId, peerId, false, true, false),
transferErrors: transferErrors,
listOfPeers: listOfPeers
}, null);
} else {
callback(null, {
transferId: transferId,
transferInfo: self._getTransferInfo(transferId, peerId, false, true, false),
listOfPeers: listOfPeers
});
}
}
}
};
for (var i = 0; i < listOfPeers.length; i++) {
var MCUInteropStatus = self._startDataTransferToPeer(transferId, listOfPeers[i], completeFn, null, null);
if (typeof MCUInteropStatus === 'boolean') {
if (MCUInteropStatus === true) {
self._dataTransfers[transferId].peers.main[listOfPeers[i]] = true;
} else {
self._dataTransfers[transferId].peers[transferId][listOfPeers[i]] = true;
}
}
}
if (self._hasMCU) {
if (Object.keys(self._dataTransfers[transferId].peers.main).length > 0) {
self._startDataTransferToPeer(transferId, 'MCU', completeFn, 'main',
Object.keys(self._dataTransfers[transferId].peers.main));
}
if (Object.keys(self._dataTransfers[transferId].peers[transferId]).length > 0) {
self._startDataTransferToPeer(transferId, 'MCU', completeFn, transferId,
Object.keys(self._dataTransfers[transferId].peers[transferId]));
}
}
};
/**
* Function that starts or listens the data transfer status to Peer.
* This reacts differently during MCU environment.
* @method _startDataTransferToPeer
* @return {Boolean} Returns a Boolean only during MCU environment which flag indicates if Peer requires interop
* (Use messaging Datachannel connection instead).
* @private
* @since 0.6.16
*/
Skylink.prototype._startDataTransferToPeer = function (transferId, peerId, callback, channelProp, targetPeers) {
var self = this;
var peerConnectionStateCbFn = null;
var dataChannelStateCbFn = null;
/**
* Emit event for Peers function.
*/
var emitEventFn = function (cb) {
var peers = targetPeers || [peerId];
for (var i = 0; i < peers.length; i++) {
cb(peers[i]);
}
};
/**
* Return error and trigger them if failed before or during data transfers function.
*/
var returnErrorBeforeTransferFn = function (error) {
// Replace if it is a MCU Peer errors for clear indication in error message
var updatedError = peerId === 'MCU' ? error.replace(/Peer/g, 'MCU Peer') : error;
emitEventFn(function (evtPeerId) {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.ERROR, transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, true, true, false), {
message: new Error(updatedError),
transferType: self.DATA_TRANSFER_TYPE.UPLOAD
});
});
};
/**
* Send WRQ protocol to start data transfers.
*/
var sendWRQFn = function () {
var size = self._dataTransfers[transferId].size;
var chunkSize = self._dataTransfers[transferId].chunkSize;
var chunkType = self._dataTransfers[transferId].chunkType;
if (self._dataTransfers[transferId].enforceBSPeers.indexOf(peerId) > -1) {
log.warn([peerId, 'RTCDataChannel', transferId,
'Binary data chunks transfer is not yet supported with Peer connecting from ' +
'Android, iOS and C++ SDK. Fallbacking to binary string data chunks transfer.']);
size = self._dataTransfers[transferId].enforceBSInfo.size;
chunkSize = self._dataTransfers[transferId].enforceBSInfo.chunkSize;
chunkType = self._dataTransfers[transferId].enforceBSInfo.chunkType;
}
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.WRQ,
transferId: transferId,
name: self._dataTransfers[transferId].name,
size: size,
originalSize: self._dataTransfers[transferId].originalSize,
dataType: self._dataTransfers[transferId].dataType,
mimeType: self._dataTransfers[transferId].mimeType,
chunkType: chunkType,
chunkSize: chunkSize,
timeout: self._dataTransfers[transferId].timeout,
isPrivate: self._dataTransfers[transferId].isPrivate,
sender: self._user.sid,
agent: window.webrtcDetectedBrowser,
version: window.webrtcDetectedVersion,
target: targetPeers ? targetPeers : peerId
}, channelProp);
emitEventFn(function (evtPeerId) {
self._trigger('incomingDataRequest', transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, false, false, false), true);
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.USER_UPLOAD_REQUEST, transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, true, false, false), null);
});
};
// Listen to data transfer state
if (peerId !== 'MCU') {
var dataTransferStateCbFn = function (state, evtTransferId, evtPeerId, transferInfo, error) {
if (peerConnectionStateCbFn) {
self.off('peerConnectionState', peerConnectionStateCbFn);
}
if (dataChannelStateCbFn) {
self.off('dataChannelState', dataChannelStateCbFn);
}
if (channelProp) {
delete self._dataTransfers[transferId].peers[channelProp][peerId];
}
if (state === self.DATA_TRANSFER_STATE.UPLOAD_COMPLETED) {
callback(peerId, null);
} else {
callback(peerId, error.message.message || error.message.toString());
}
// Handle Peer uploading to MCU case
if (self._hasMCU && self._dataTransfers[transferId].direction === self.DATA_TRANSFER_TYPE.UPLOAD) {
if (!(Object.keys(self._dataTransfers[transferId].peers.main).length === 0 &&
Object.keys(self._dataTransfers[transferId].peers[transferId]).length === 0)) {
return;
}
delete self._dataTransfers[transferId];
} else {
delete self._dataTransfers[transferId].sessions[peerId];
if (Object.keys(self._dataTransfers[transferId].sessions).length === 0) {
delete self._dataTransfers[transferId];
}
}
};
self.once('dataTransferState', dataTransferStateCbFn, function (state, evtTransferId, evtPeerId) {
if (!(self._dataTransfers[transferId] && (self._hasMCU ? (self._dataTransfers[transferId].peers.main[peerId] ||
self._dataTransfers[transferId].peers[transferId][peerId]) : self._dataTransfers[transferId].sessions[peerId]))) {
if (dataTransferStateCbFn) {
self.off('dataTransferState', dataTransferStateCbFn);
}
if (peerConnectionStateCbFn) {
self.off('peerConnectionState', peerConnectionStateCbFn);
}
if (dataChannelStateCbFn) {
self.off('dataChannelState', dataChannelStateCbFn);
}
return;
}
return evtTransferId === transferId && evtPeerId === peerId &&
[self.DATA_TRANSFER_STATE.UPLOAD_COMPLETED, self.DATA_TRANSFER_STATE.ERROR,
self.DATA_TRANSFER_STATE.CANCEL, self.DATA_TRANSFER_STATE.REJECTED].indexOf(state) > -1;
});
}
// When Peer connection does not exists
if (!self._peerConnections[peerId]) {
returnErrorBeforeTransferFn('Unable to start data transfer as Peer connection does not exists.');
return;
}
// When Peer session does not exists
if (!self._peerInformations[peerId]) {
returnErrorBeforeTransferFn('Unable to start data transfer as Peer connection does not exists.');
return;
}
// When Peer connection is not STABLE
if (self._peerConnections[peerId].signalingState !== self.PEER_CONNECTION_STATE.STABLE) {
returnErrorBeforeTransferFn('Unable to start data transfer as Peer connection is not stable.');
return;
}
if (!self._dataTransfers[transferId]) {
returnErrorBeforeTransferFn('Unable to start data transfer as data transfer session is not in order.');
return;
}
if (!(self._dataChannels[peerId] && self._dataChannels[peerId].main)) {
returnErrorBeforeTransferFn('Unable to start data transfer as Peer Datachannel connection does not exists.');
return;
}
if (self._dataChannels[peerId].main.channel.readyState !== self.DATA_CHANNEL_STATE.OPEN) {
returnErrorBeforeTransferFn('Unable to start data transfer as Peer Datachannel connection is not opened.');
return;
}
var agentName = (self._peerInformations[peerId].agent || {}).name || '';
var requireInterop = self._SUPPORTED_WEB_AGENTS.indexOf(agentName) === -1 && agentName !== 'cpp';
// Prevent DATA_URL (or "string" dataType transfers) with Android / iOS / C++ SDKs
if ((requireInterop || agentName === 'cpp') && self._dataTransfers[transferId].dataType === self.DATA_TRANSFER_SESSION_TYPE.DATA_URL) {
returnErrorBeforeTransferFn('Unable to start data transfer as Peer do not support DATA_URL type of data transfers');
return;
}
// Listen to Peer connection state for MCU Peer
if (peerId !== 'MCU' && self._hasMCU) {
channelProp = requireInterop ? 'main' : transferId;
peerConnectionStateCbFn = function () {
returnErrorBeforeTransferFn('Data transfer terminated as Peer connection is not stable.');
};
self.once('peerConnectionState', peerConnectionStateCbFn, function (state, evtPeerId) {
if (!self._dataTransfers[transferId]) {
self.off('peerConnectionState', peerConnectionStateCbFn);
return;
}
return state !== self.PEER_CONNECTION_STATE.STABLE && evtPeerId === peerId;
});
return requireInterop;
}
if (requireInterop || channelProp === 'main') {
// When MCU Datachannel connection has a transfer in-progress
if (self._dataChannels[peerId].main.transferId) {
returnErrorBeforeTransferFn('Unable to start data transfer as Peer Datachannel has a data transfer in-progress.');
return;
}
}
self._dataTransfers[transferId].sessions[peerId] = {
timer: null,
ackN: 0
};
dataChannelStateCbFn = function (state, evtPeerId, error) {
// Prevent from triggering in instances where the ackN === chunks.length
if (self._dataTransfers[transferId].sessions[peerId].ackN >= (self._dataTransfers[transferId].chunks.length - 1)) {
return;
}
if (error) {
returnErrorBeforeTransferFn(error.message || error.toString());
} else {
returnErrorBeforeTransferFn('Data transfer terminated as Peer Datachannel connection closed abruptly.');
}
};
self.once('dataChannelState', dataChannelStateCbFn, function (state, evtPeerId, error, channelName, channelType) {
if (!(self._dataTransfers[transferId] && self._dataTransfers[transferId].sessions[peerId])) {
self.off('dataChannelState', dataChannelStateCbFn);
return;
}
if (evtPeerId === peerId && (channelType === self.DATA_CHANNEL_TYPE.DATA ? channelName === transferId : true)) {
if (state === self.DATA_CHANNEL_STATE.OPEN && channelType === self.DATA_CHANNEL_TYPE.DATA &&
channelName === transferId) {
sendWRQFn();
return false;
}
return [self.DATA_CHANNEL_STATE.CREATE_ERROR, self.DATA_CHANNEL_STATE.ERROR,
self.DATA_CHANNEL_STATE.CLOSING, self.DATA_CHANNEL_STATE.CLOSED].indexOf(state) > -1;
}
});
// Create new Datachannel for Peer to start data transfer
if (!((requireInterop && peerId !== 'MCU') || channelProp === 'main')) {
channelProp = transferId;
self._createDataChannel(peerId, transferId);
} else {
self._dataChannels[peerId].main.transferId = transferId;
sendWRQFn();
}
};
/**
* Function that returns the data transfer session.
* @method _getTransferInfo
* @private
* @for Skylink
* @since 0.6.16
*/
Skylink.prototype._getTransferInfo = function (transferId, peerId, returnDataProp, hidePercentage, returnDataAtStart) {
if (!this._dataTransfers[transferId]) {
return {};
}
var transferInfo = {
name: this._dataTransfers[transferId].name,
size: this._dataTransfers[transferId].size,
dataType: this._dataTransfers[transferId].dataType || this.DATA_TRANSFER_SESSION_TYPE.BLOB,
mimeType: this._dataTransfers[transferId].mimeType || null,
chunkSize: this._dataTransfers[transferId].chunkSize,
chunkType: this._dataTransfers[transferId].chunkType,
timeout: this._dataTransfers[transferId].timeout,
isPrivate: this._dataTransfers[transferId].isPrivate,
direction: this._dataTransfers[transferId].direction
};
if (this._dataTransfers[transferId].originalSize) {
transferInfo.size = this._dataTransfers[transferId].originalSize;
} else if (this._dataTransfers[transferId].chunkType === this.DATA_TRANSFER_DATA_TYPE.BINARY_STRING) {
transferInfo.size = Math.ceil(transferInfo.size * 3 / 4);
}
if (!hidePercentage) {
transferInfo.percentage = 0;
if (!this._dataTransfers[transferId].sessions[peerId]) {
if (returnDataProp) {
transferInfo.data = null;
}
return transferInfo;
}
if (this._dataTransfers[transferId].direction === this.DATA_TRANSFER_TYPE.DOWNLOAD) {
if (this._dataTransfers[transferId].sessions[peerId].receivedSize === this._dataTransfers[transferId].sessions[peerId].size) {
transferInfo.percentage = 100;
} else {
transferInfo.percentage = parseFloat(((this._dataTransfers[transferId].sessions[peerId].receivedSize /
this._dataTransfers[transferId].size) * 100).toFixed(2), 10);
}
} else {
var chunksLength = (this._dataTransfers[transferId].enforceBSPeers.indexOf(peerId) > -1 ?
this._dataTransfers[transferId].enforceBSInfo.chunks.length : this._dataTransfers[transferId].chunks.length);
if (this._dataTransfers[transferId].sessions[peerId].ackN === chunksLength) {
transferInfo.percentage = 100;
} else {
transferInfo.percentage = parseFloat(((this._dataTransfers[transferId].sessions[peerId].ackN /
chunksLength) * 100).toFixed(2), 10);
}
}
if (returnDataProp) {
if (typeof returnDataAtStart !== 'number') {
if (transferInfo.percentage === 100) {
transferInfo.data = this._getTransferData(transferId);
} else {
transferInfo.data = null;
}
} else {
transferInfo.percentage = returnDataAtStart;
if (returnDataAtStart === 0) {
transferInfo.data = this._getTransferData(transferId);
}
}
}
}
return transferInfo;
};
/**
* Function that returns the compiled data transfer data.
* @method _getTransferData
* @private
* @for Skylink
* @since 0.6.16
*/
Skylink.prototype._getTransferData = function (transferId) {
if (!this._dataTransfers[transferId]) {
return null;
}
if (this._dataTransfers[transferId].dataType === this.DATA_TRANSFER_SESSION_TYPE.BLOB) {
var mimeType = {
name: this._dataTransfers[transferId].name
};
if (this._dataTransfers[transferId].mimeType) {
mimeType.type = this._dataTransfers[transferId].mimeType;
}
return new Blob(this._dataTransfers[transferId].chunks, mimeType);
}
return this._dataTransfers[transferId].chunks.join('');
};
/**
* Function that handles the data transfers sessions timeouts.
* @method _handleDataTransferTimeoutForPeer
* @private
* @for Skylink
* @since 0.6.16
*/
Skylink.prototype._handleDataTransferTimeoutForPeer = function (transferId, peerId, setPeerTO) {
var self = this;
if (!(self._dataTransfers[transferId] && self._dataTransfers[transferId].sessions[peerId])) {
log.debug([peerId, 'RTCDataChannel', transferId, 'Data transfer does not exists for Peer. Ignoring timeout.']);
return;
}
log.debug([peerId, 'RTCDataChannel', transferId, 'Clearing data transfer timer for Peer.']);
if (self._dataTransfers[transferId].sessions[peerId].timer) {
clearTimeout(self._dataTransfers[transferId].sessions[peerId].timer);
}
self._dataTransfers[transferId].sessions[peerId].timer = null;
if (setPeerTO) {
log.debug([peerId, 'RTCDataChannel', transferId, 'Setting data transfer timer for Peer.']);
self._dataTransfers[transferId].sessions[peerId].timer = setTimeout(function () {
if (!(self._dataTransfers[transferId] && self._dataTransfers[transferId].sessions[peerId])) {
log.debug([peerId, 'RTCDataChannel', transferId, 'Data transfer already ended for Peer. Ignoring expired timeout.']);
return;
}
if (!self._user) {
log.debug([peerId, 'RTCDataChannel', transferId, 'User is not in Room. Ignoring expired timeout.']);
return;
}
if (!self._dataChannels[peerId]) {
log.debug([peerId, 'RTCDataChannel', transferId, 'Datachannel connection does not exists. Ignoring expired timeout.']);
return;
}
log.error([peerId, 'RTCDataChannel', transferId, 'Data transfer response has timed out.']);
/**
* Emit event for Peers function.
*/
var emitEventFn = function (cb) {
if (peerId === 'MCU') {
var broadcastedPeers = [self._dataTransfers[transferId].peers.main,
self._dataTransfers[transferId].peers[transferId]];
for (var i = 0; i < broadcastedPeers.length; i++) {
// Should not happen but insanity check
if (!broadcastedPeers[i]) {
continue;
}
for (var bcPeerId in broadcastedPeers[i]) {
if (broadcastedPeers[i].hasOwnProperty(bcPeerId) && broadcastedPeers[i][bcPeerId]) {
cb(bcPeerId);
}
}
}
} else {
cb(peerId);
}
};
var errorMsg = 'Connection Timeout. Longer than ' + self._dataTransfers[transferId].timeout +
' seconds. Connection is abolished.';
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.ERROR,
content: errorMsg,
isUploadError: self._dataTransfers[transferId].direction === self.DATA_TRANSFER_TYPE.UPLOAD,
sender: self._user.sid,
name: self._dataTransfers[transferId].name
}, self._dataChannels[peerId][transferId] ? transferId : 'main');
emitEventFn(function (evtPeerId) {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.ERROR, transferId, peerId,
self._getTransferInfo(transferId, peerId, true, false, false), {
transferType: self.DATA_TRANSFER_TYPE.DOWNLOAD,
message: new Error(errorMsg)
});
});
}, self._dataTransfers[transferId].timeout * 1000);
}
};
/**
* Function that handles the data received from Datachannel and
* routes to the relevant data transfer protocol handler.
* @method _processDataChannelData
* @private
* @for Skylink
* @since 0.6.16
*/
Skylink.prototype._processDataChannelData = function(rawData, peerId, channelName, channelType) {
var self = this;
var channelProp = channelType === self.DATA_CHANNEL_TYPE.MESSAGING ? 'main' : channelName;
var transferId = channelProp === 'main' ? self._dataChannels[peerId].main.transferId : channelName;
if (!self._peerConnections[peerId]) {
log.warn([peerId, 'RTCDataChannel', channelName, 'Dropping data received from Peer ' +
'as connection is not present ->'], rawData);
return;
}
if (!(self._dataChannels[peerId] && self._dataChannels[peerId][channelProp])) {
log.warn([peerId, 'RTCDataChannel', channelName, 'Dropping data received from Peer ' +
'as Datachannel connection is not present ->'], rawData);
return;
}
// Expect as string
if (typeof rawData === 'string') {
try {
var protocolData = JSON.parse(rawData);
log.debug([peerId, 'RTCDataChannel', channelProp, 'Received protocol message ->'], protocolData);
// Ignore ACK, ERROR and CANCEL if there is no data transfer session in-progress
if ([self._DC_PROTOCOL_TYPE.ACK, self._DC_PROTOCOL_TYPE.ERROR, self._DC_PROTOCOL_TYPE.CANCEL].indexOf(protocolData.type) > -1 &&
!(transferId && self._dataTransfers[transferId] && self._dataTransfers[transferId].sessions[peerId])) {
log.warn([peerId, 'RTCDataChannel', channelProp, 'Discarded protocol message as data transfer session ' +
'is not present ->'], protocolData);
return;
}
switch (protocolData.type) {
case self._DC_PROTOCOL_TYPE.WRQ:
// Discard iOS bidirectional upload when Datachannel is in-progress for data transfers
if (transferId && self._dataTransfers[transferId] && self._dataTransfers[transferId].sessions[peerId]) {
log.warn([peerId, 'RTCDataChannel', channelProp, 'Rejecting bidirectional data transfer request as ' +
'it is currently not supported in the SDK']);
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.ACK,
ackN: -1,
sender: self._user.sid
}, channelProp);
return;
}
self._WRQProtocolHandler(peerId, protocolData, channelProp);
break;
case self._DC_PROTOCOL_TYPE.ACK:
self._ACKProtocolHandler(peerId, protocolData, channelProp);
break;
case self._DC_PROTOCOL_TYPE.ERROR:
self._ERRORProtocolHandler(peerId, protocolData, channelProp);
break;
case self._DC_PROTOCOL_TYPE.CANCEL:
self._CANCELProtocolHandler(peerId, protocolData, channelProp);
break;
case self._DC_PROTOCOL_TYPE.MESSAGE:
self._MESSAGEProtocolHandler(peerId, protocolData, channelProp);
break;
default:
log.warn([peerId, 'RTCDataChannel', channelProp, 'Discarded unknown protocol message ->'], protocolData);
}
} catch (error) {
if (rawData.indexOf('{') > -1 && rawData.indexOf('}') > 0) {
log.error([peerId, 'RTCDataChannel', channelProp, 'Received error ->'], error);
self._trigger('dataChannelState', self.DATA_CHANNEL_STATE.ERROR, peerId, error, channelName, channelType, null);
throw error;
}
if (!(transferId && self._dataTransfers[transferId] && self._dataTransfers[transferId].sessions[peerId])) {
log.warn([peerId, 'RTCDataChannel', channelProp, 'Discarded data chunk as data transfer session ' +
'is not present ->'], rawData);
return;
}
if (self._dataTransfers[transferId].chunks[self._dataTransfers[transferId].sessions[peerId].ackN]) {
log.warn([peerId, 'RTCDataChannel', transferId, 'Dropping data chunk as it has already been added ->'], rawData);
return;
}
var chunkType = self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING;
if (self._dataTransfers[transferId].dataType === self.DATA_TRANSFER_SESSION_TYPE.DATA_URL) {
log.debug([peerId, 'RTCDataChannel', channelProp, 'Received string data chunk @' +
self._dataTransfers[transferId].sessions[peerId].ackN + ' with size ->'], rawData.length || rawData.size);
self._DATAProtocolHandler(peerId, rawData, self.DATA_TRANSFER_DATA_TYPE.STRING,
rawData.length || rawData.size || 0, channelProp);
} else {
var removeSpaceData = rawData.replace(/\s|\r|\n/g, '');
log.debug([peerId, 'RTCDataChannel', channelProp, 'Received binary string data chunk @' +
self._dataTransfers[transferId].sessions[peerId].ackN + ' with size ->'],
removeSpaceData.length || removeSpaceData.size);
self._DATAProtocolHandler(peerId, self._base64ToBlob(removeSpaceData), self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING,
removeSpaceData.length || removeSpaceData.size || 0, channelProp);
}
}
} else {
if (rawData instanceof Blob) {
log.debug([peerId, 'RTCDataChannel', channelProp, 'Received blob data chunk @' +
self._dataTransfers[transferId].sessions[peerId].ackN + ' with size ->'], rawData.size);
self._DATAProtocolHandler(peerId, rawData, self.DATA_TRANSFER_DATA_TYPE.BLOB, rawData.size, channelProp);
} else {
var byteArray = rawData;
if (rawData.constructor && rawData.constructor.name === 'Array') {
// Need to re-parse on some browsers
byteArray = new Int8Array(rawData);
}
var blob = new Blob([byteArray]);
log.debug([peerId, 'RTCDataChannel', channelProp, 'Received arraybuffer data chunk @' +
self._dataTransfers[transferId].sessions[peerId].ackN + ' with size ->'], blob.size);
self._DATAProtocolHandler(peerId, blob, self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER, blob.size, channelProp);
}
}
};
/**
* Function that handles the "WRQ" data transfer protocol.
* @method _WRQProtocolHandler
* @private
* @for Skylink
* @since 0.5.2
*/
Skylink.prototype._WRQProtocolHandler = function(peerId, data, channelProp) {
var self = this;
var transferId = channelProp === 'main' ? data.transferId || peerId + '_' + (new Date()).getTime() : channelProp;
var senderPeerId = data.sender || peerId;
self._dataTransfers[transferId] = {
name: data.name || transferId,
size: data.size || 0,
chunkSize: data.chunkSize,
originalSize: data.originalSize || 0,
timeout: data.timeout || 60,
isPrivate: !!data.isPrivate,
senderPeerId: data.sender || peerId,
dataType: data.dataType || self.DATA_TRANSFER_SESSION_TYPE.BLOB,
mimeType: data.mimeType || null,
chunkType: data.chunkType || self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING,
direction: self.DATA_TRANSFER_TYPE.DOWNLOAD,
chunks: [],
sessions: {}
};
self._dataChannels[peerId][channelProp].transferId = transferId;
self._dataTransfers[transferId].sessions[peerId] = {
timer: null,
ackN: 0,
receivedSize: 0
};
self._trigger('incomingDataRequest', transferId, senderPeerId,
self._getTransferInfo(transferId, peerId, false, false, false), false);
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.UPLOAD_REQUEST, transferId, senderPeerId,
self._getTransferInfo(transferId, peerId, true, false, false), null);
};
/**
* Function that handles the "ACK" data transfer protocol.
* @method _ACKProtocolHandler
* @private
* @for Skylink
* @since 0.5.2
*/
Skylink.prototype._ACKProtocolHandler = function(peerId, data, channelProp) {
var self = this;
var transferId = channelProp;
var senderPeerId = data.sender || peerId;
if (channelProp === 'main') {
transferId = self._dataChannels[peerId].main.transferId;
}
self._handleDataTransferTimeoutForPeer(transferId, peerId, false);
/**
* Emit event for Peers function.
*/
var emitEventFn = function (cb) {
if (peerId === 'MCU') {
if (!self._dataTransfers[transferId].peers[channelProp]) {
log.warn([peerId, 'RTCDataChannel', channelProp, 'Dropping triggering of ACK event as ' +
'Peers list does not exists']);
return;
}
for (var evtPeerId in self._dataTransfers[transferId].peers[channelProp]) {
if (self._dataTransfers[transferId].peers[channelProp].hasOwnProperty(evtPeerId) &&
self._dataTransfers[transferId].peers[channelProp][evtPeerId]) {
cb(evtPeerId);
}
}
} else {
cb(senderPeerId);
}
};
if (data.ackN > -1) {
if (data.ackN === 0) {
emitEventFn(function (evtPeerId) {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.UPLOAD_STARTED, transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, true, false, 0), null);
});
} else if (self._dataTransfers[transferId].enforceBSPeers.indexOf(peerId) > -1 ?
data.ackN === self._dataTransfers[transferId].enforceBSInfo.chunks.length :
data.ackN === self._dataTransfers[transferId].chunks.length) {
self._dataTransfers[transferId].sessions[peerId].ackN = data.ackN;
emitEventFn(function (evtPeerId) {
self._trigger('incomingData', self._getTransferData(transferId), transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, false, false, false), true);
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.UPLOAD_COMPLETED, transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, true, false, 100), null);
});
if (self._dataChannels[peerId][channelProp]) {
self._dataChannels[peerId][channelProp].transferId = null;
if (channelProp !== 'main') {
self._closeDataChannel(peerId, channelProp);
}
}
return;
}
var uploadFn = function (chunk) {
self._sendMessageToDataChannel(peerId, chunk, channelProp, true);
if (data.ackN < self._dataTransfers[transferId].chunks.length) {
emitEventFn(function (evtPeerId) {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.UPLOADING, transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, true, false, false), null);
});
}
self._handleDataTransferTimeoutForPeer(transferId, peerId, true);
};
self._dataTransfers[transferId].sessions[peerId].ackN = data.ackN;
if (self._dataTransfers[transferId].enforceBSPeers.indexOf(peerId) > -1) {
self._blobToBase64(self._dataTransfers[transferId].enforceBSInfo.chunks[data.ackN], uploadFn);
} else if (self._dataTransfers[transferId].chunkType === self.DATA_TRANSFER_DATA_TYPE.BINARY_STRING) {
self._blobToBase64(self._dataTransfers[transferId].chunks[data.ackN], uploadFn);
} else if (self._dataTransfers[transferId].chunkType === self.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER) {
self._blobToArrayBuffer(self._dataTransfers[transferId].chunks[data.ackN], uploadFn);
} else {
uploadFn(self._dataTransfers[transferId].chunks[data.ackN]);
}
} else {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.REJECTED, transferId, senderPeerId,
self._getTransferInfo(transferId, peerId, true, false, false), {
message: new Error('Data transfer terminated as Peer has rejected data transfer request'),
transferType: self.DATA_TRANSFER_TYPE.UPLOAD
});
}
};
/**
* Function that handles the "MESSAGE" data transfer protocol.
* @method _MESSAGEProtocolHandler
* @private
* @for Skylink
* @since 0.5.2
*/
Skylink.prototype._MESSAGEProtocolHandler = function(peerId, data, channelProp) {
var senderPeerId = data.sender || peerId;
log.log([senderPeerId, 'RTCDataChannel', channelProp, 'Received P2P message from peer:'], data);
this._trigger('incomingMessage', {
content: data.data,
isPrivate: data.isPrivate,
isDataChannel: true,
targetPeerId: this._user.sid,
senderPeerId: senderPeerId
}, senderPeerId, this.getPeerInfo(senderPeerId), false);
};
/**
* Function that handles the "ERROR" data transfer protocol.
* @method _ERRORProtocolHandler
* @private
* @for Skylink
* @since 0.5.2
*/
Skylink.prototype._ERRORProtocolHandler = function(peerId, data, channelProp) {
var self = this;
var transferId = channelProp;
var senderPeerId = data.sender || peerId;
if (channelProp === 'main') {
transferId = self._dataChannels[peerId].main.transferId;
}
self._handleDataTransferTimeoutForPeer(transferId, peerId, false);
/**
* Emit event for Peers function.
*/
var emitEventFn = function (cb) {
if (peerId === 'MCU') {
if (!self._dataTransfers[transferId].peers[channelProp]) {
log.warn([peerId, 'RTCDataChannel', channelProp, 'Dropping triggering of ERROR event as ' +
'Peers list does not exists']);
return;
}
for (var evtPeerId in self._dataTransfers[transferId].peers[channelProp]) {
if (self._dataTransfers[transferId].peers[channelProp].hasOwnProperty(evtPeerId) &&
self._dataTransfers[transferId].peers[channelProp][evtPeerId]) {
cb(evtPeerId);
}
}
} else {
cb(senderPeerId);
}
};
log.error([peerId, 'RTCDataChannel', channelProp, 'Received an error from peer ->'], data);
emitEventFn(function (evtPeerId) {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.ERROR, transferId, evtPeerId,
self._getTransferInfo(transferId, peerID, true, false, false), {
message: new Error(data.content),
transferType: self._dataTransfers[transferId].direction
});
});
};
/**
* Function that handles the "CANCEL" data transfer protocol.
* @method _CANCELProtocolHandler
* @private
* @for Skylink
* @since 0.5.0
*/
Skylink.prototype._CANCELProtocolHandler = function(peerId, data, channelProp) {
var self = this;
var transferId = channelProp;
if (channelProp === 'main') {
transferId = self._dataChannels[peerId].main.transferId;
}
self._handleDataTransferTimeoutForPeer(transferId, peerId, false);
/**
* Emit event for Peers function.
*/
var emitEventFn = function (cb) {
if (peerId === 'MCU') {
if (!self._dataTransfers[transferId].peers[channelProp]) {
log.warn([peerId, 'RTCDataChannel', channelProp, 'Dropping triggering of CANCEL event as ' +
'Peers list does not exists']);
return;
}
for (var evtPeerId in self._dataTransfers[transferId].peers[channelProp]) {
if (self._dataTransfers[transferId].peers[channelProp].hasOwnProperty(evtPeerId) &&
self._dataTransfers[transferId].peers[channelProp][evtPeerId]) {
cb(evtPeerId);
}
}
} else {
cb(peerId);
}
};
log.error([peerId, 'RTCDataChannel', channelProp, 'Received data transfer termination from peer ->'], data);
emitEventFn(function (evtPeerId) {
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.CANCEL, transferId, evtPeerId,
self._getTransferInfo(transferId, peerId, true, false, false), {
message: new Error(data.content || 'Peer has terminated data transfer.'),
transferType: self._dataTransfers[transferId].direction
});
});
};
/**
* Function that handles the data transfer chunk received.
* @method _DATAProtocolHandler
* @private
* @for Skylink
* @since 0.5.5
*/
Skylink.prototype._DATAProtocolHandler = function(peerId, chunk, chunkType, chunkSize, channelProp) {
var self = this;
var transferId = channelProp;
var senderPeerId = peerId;
if (channelProp === 'main') {
transferId = self._dataChannels[peerId].main.transferId;
}
if (self._dataTransfers[transferId].senderPeerId) {
senderPeerId = self._dataTransfers[transferId].senderPeerId;
}
self._handleDataTransferTimeoutForPeer(transferId, peerId, false);
self._dataTransfers[transferId].chunkType = chunkType;
self._dataTransfers[transferId].sessions[peerId].receivedSize += chunkSize;
self._dataTransfers[transferId].chunks[self._dataTransfers[transferId].sessions[peerId].ackN] = chunk;
if (self._dataTransfers[transferId].sessions[peerId].receivedSize >= self._dataTransfers[transferId].size) {
log.log([peerId, 'RTCDataChannel', channelProp, 'Data transfer has been completed. Computed size ->'],
self._dataTransfers[transferId].sessions[peerId].receivedSize);
// Send last ACK to Peer to indicate completion of data transfers
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.ACK,
sender: self._user.sid,
ackN: self._dataTransfers[transferId].sessions[peerId].ackN + 1
}, channelProp);
self._trigger('incomingData', self._getTransferData(transferId), transferId, senderPeerId,
self._getTransferInfo(transferId, peerId, false, false, false), null);
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.DOWNLOAD_COMPLETED, transferId, senderPeerId,
self._getTransferInfo(transferId, peerId, true, false, false), null);
return;
}
self._dataTransfers[transferId].sessions[peerId].ackN += 1;
self._sendMessageToDataChannel(peerId, {
type: self._DC_PROTOCOL_TYPE.ACK,
sender: self._user.sid,
ackN: self._dataTransfers[transferId].sessions[peerId].ackN
}, channelProp);
self._handleDataTransferTimeoutForPeer(transferId, peerId, true);
self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.DOWNLOADING, transferId, senderPeerId,
self._getTransferInfo(transferId, peerId, true, false, false), null);
};