File: source/data-transfer.js

  1. /**
  2.  * The current version of DT (Data Transfer) Protocol
  3.  *   that the Skylink SDK is using.
  4.  * @attribute DT_PROTOCOL_VERSION
  5.  * @type String
  6.  * @final
  7.  * @required
  8.  * @component DataTransfer
  9.  * @for Skylink
  10.  * @since 0.5.10
  11.  */
  12. Skylink.prototype.DT_PROTOCOL_VERSION = '0.1.0';
  13.  
  14. /**
  15.  * The fixed delimiter that is used in Skylink to
  16.  *   concat the DataChannel channelName and the actual
  17.  *   transfer ID together based on the transfer ID provided in
  18.  *   {{#crossLink "Skylink/dataTransferState:event"}}dataTransferState{{/crossLink}}.
  19.  * @attribute _TRANSFER_DELIMITER
  20.  * @type String
  21.  * @final
  22.  * @private
  23.  * @component DataTransfer
  24.  * @for Skylink
  25.  * @since 0.5.10
  26.  */
  27. Skylink.prototype._TRANSFER_DELIMITER = '_skylink__';
  28.  
  29. /**
  30.  * The list of Protocol types that is used for transfers and messaging using
  31.  *   the DataChannel connection.
  32.  * @attribute _DC_PROTOCOL_TYPE
  33.  * @type JSON
  34.  * @param {String} WRQ Protocol to initiate a transfer request on the current
  35.  *   DataChannel connection. Data transfer step 1.
  36.  * @param {String} ACK Protocol to accept or reject the transfer request.
  37.  *   Data transfer step 2.
  38.  * @param {String} DATA Actual binary data or string send based on the
  39.  *   <code>ackN</code> in the <code>ACK</code> packet received.
  40.  *   Data transfer step 3. This may not occur is step 2 is rejected.
  41.  * @param {String} CANCEL Protocol to terminate an ongoing transfer.
  42.  *   This data transfer step can happen after step 2 or 3.
  43.  * @param {String} ERROR Protocol that is sent when a transfer occurs an exception
  44.  *   which using causes it to be terminated.
  45.  *   This data transfer step can happen after step 2 or 3.
  46.  * @param {String} MESSAGE Protocol that is used to send P2P message objects
  47.  *   over the DataChannel connection.
  48.  *   This is not related to any data transfer step, but for messaging purposes.
  49.  * @final
  50.  * @private
  51.  * @for Skylink
  52.  * @component DataTransfer
  53.  * @since 0.5.2
  54.  */
  55. Skylink.prototype._DC_PROTOCOL_TYPE = {
  56.   WRQ: 'WRQ',
  57.   ACK: 'ACK',
  58.   ERROR: 'ERROR',
  59.   CANCEL: 'CANCEL',
  60.   MESSAGE: 'MESSAGE'
  61. };
  62.  
  63. /**
  64.  * The list of platforms that Skylink should fallback to use the
  65.  *   {{#crossLink "Skylink/DATA_CHANNEL_TYPE:attr"}}<code>
  66.  *   DATA_CHANNEL_TYPE.MESSAGING</code>{{/crossLink}}
  67.  *   channel for transfers instead of using multi-transfers
  68.  *   due to the lack of support in the platform implementations.
  69.  * @attribute _INTEROP_MULTI_TRANSFERS
  70.  * @type Array
  71.  * @final
  72.  * @private
  73.  * @for Skylink
  74.  * @component DataTransfer
  75.  * @since 0.6.1
  76.  */
  77. Skylink.prototype._INTEROP_MULTI_TRANSFERS = ['Android', 'iOS'];
  78.  
  79. /**
  80.  * The types of data transfers to indicate if the DataChannel is
  81.  *   uploading or downloading the data transfer.
  82.  * @attribute DATA_TRANSFER_TYPE
  83.  * @type JSON
  84.  * @param {String} UPLOAD The DataChannel connection is uploading data packets to
  85.  *   receiving end.
  86.  * @param {String} DOWNLOAD The DataChannel connection is downloading data packets
  87.  *   from sending point.
  88.  * @final
  89.  * @component DataTransfer
  90.  * @for Skylink
  91.  * @since 0.1.0
  92.  */
  93. Skylink.prototype.DATA_TRANSFER_TYPE = {
  94.   UPLOAD: 'upload',
  95.   DOWNLOAD: 'download'
  96. };
  97.  
  98. /**
  99.  * The states of a data transfer in a DataChannel connection.
  100.  * @attribute DATA_TRANSFER_STATE
  101.  * @type JSON
  102.  * @param {String} UPLOAD_REQUEST Request to start a data transfer.
  103.  * @param {String} UPLOAD_STARTED Request to start the data transfer has been accepted
  104.  *   and data transfer is starting to upload data packets to receiving end.
  105.  * @param {String} DOWNLOAD_STARTED Request to start the data transfer has been accepted
  106.  *   and data transfer is starting to receive data packets from sending point.
  107.  * @param {String} REJECTED Request to start a data transfer is rejected.
  108.  * @param {String} UPLOADING The data transfer upload is ongoing with receiving end.
  109.  * @param {String} DOWNLOADING The data transfer download is ongoing with sending point.
  110.  * @param {String} UPLOAD_COMPLETED The data transfer uploaded to receiving end has
  111.  *   been completed successfully.
  112.  * @param {String} DOWNLOAD_COMPLETED The data transfer downloaded from sending point
  113.  *   has been completed successfully.
  114.  * @param {String} CANCEL The ongoing data transfer has cancelled from receiving end
  115.  *   or sending point and has been terminated.
  116.  * @param {String} ERROR The ongoing data transfer has occurred an exception and
  117.  *   has been terminated.
  118.  * @readOnly
  119.  * @component DataTransfer
  120.  * @for Skylink
  121.  * @since 0.4.0
  122.  */
  123. Skylink.prototype.DATA_TRANSFER_STATE = {
  124.   UPLOAD_REQUEST: 'request',
  125.   UPLOAD_STARTED: 'uploadStarted',
  126.   DOWNLOAD_STARTED: 'downloadStarted',
  127.   REJECTED: 'rejected',
  128.   CANCEL: 'cancel',
  129.   ERROR: 'error',
  130.   UPLOADING: 'uploading',
  131.   DOWNLOADING: 'downloading',
  132.   UPLOAD_COMPLETED: 'uploadCompleted',
  133.   DOWNLOAD_COMPLETED: 'downloadCompleted'
  134. };
  135.  
  136. /**
  137.  * Stores the list of ongoing data transfers data packets (chunks) to be sent to receiving end
  138.  *   in a DataChannel connection based on the associated DataChannel ID.
  139.  * @attribute _uploadDataTransfers
  140.  * @param {Array} (#channelName) The ongoing data transfer packets to be sent to
  141.  *   receiving end associated with the DataChannel connection.
  142.  * @param {Blob|String} (#channelName).(#index) The packet index of chunked Blob data object or
  143.  *   dataURL string (base64 binary string) to be sent to received end.
  144.  * @type JSON
  145.  * @private
  146.  * @required
  147.  * @component DataTransfer
  148.  * @for Skylink
  149.  * @since 0.4.1
  150.  */
  151. Skylink.prototype._uploadDataTransfers = {};
  152.  
  153. /**
  154.  * Stores the list of ongoing data transfer state informations that is sent to receiving end
  155.  *   in a DataChannel connection based on the associated DataChannel ID.
  156.  * @attribute _uploadDataSessions
  157.  * @param {JSON} (#channelName) The ongoing data transfer information that is sent
  158.  *   to receiving end associated with the DataChannel connection.
  159.  * @param {String} (#channelName).name The data transfer name.
  160.  * @param {Number} (#channelName).size The expected data size of the
  161.  *   completed data transfer.
  162.  * @param {Boolean} (#channelName).isUpload The flag that indicates if the
  163.  *   transfer is an upload data transfer.
  164.  *   In this case, the value should be <code>true</code>.
  165.  * @param {String} (#channelName).senderPeerId The Peer uploader ID.
  166.  * @param {String} (#channelName).transferId The data transfer ID.
  167.  * @param {Number} (#channelName).percentage The data transfer percentage.
  168.  * @param {Number} (#channelName).timeout The data transfer timeout.
  169.  * @param {Number} (#channelName).chunkSize The data transfer packet (chunk) size.
  170.  * @param {String} (#channelName).dataType The data transfer packet (chunk) data type.
  171.  * @type JSON
  172.  * @private
  173.  * @required
  174.  * @component DataTransfer
  175.  * @for Skylink
  176.  * @since 0.4.1
  177.  */
  178. Skylink.prototype._uploadDataSessions = {};
  179.  
  180. /**
  181.  * Stores the list of ongoing data transfers data packets (chunks) to be received from
  182.  *   sending point in a DataChannel connection based on the associated DataChannel ID.
  183.  * @attribute _downloadDataTransfers
  184.  * @param {Array} (#channelName) The ongoing data transfer packets received
  185.  *   associated with DataChannel.
  186.  * @param {Blob|String} (#channelName).(#index) The packet index of chunked Blob data object or
  187.  *   dataURL string (base64 binary string) received from sending point.
  188.  * @type JSON
  189.  * @private
  190.  * @required
  191.  * @component DataTransfer
  192.  * @for Skylink
  193.  * @since 0.4.1
  194.  */
  195. Skylink.prototype._downloadDataTransfers = {};
  196.  
  197. /**
  198.  * Stores the list of ongoing data transfer state informations that is received from
  199.  *   the sender point in a DataChannel connection based on the associated DataChannel ID.
  200.  * @attribute _downloadDataSessions
  201.  * @param {JSON} (#channelName) The ongoing data transfer information that is sent
  202.  *   to receiving end associated with the DataChannel connection.
  203.  * @param {String} (#channelName).name The data transfer name.
  204.  * @param {Number} (#channelName).size The expected data size of the
  205.  *   completed data transfer.
  206.  * @param {Boolean} (#channelName).isUpload The flag that indicates if the
  207.  *   transfer is an upload data transfer.
  208.  *   In this case, the value should be <code>false</code>.
  209.  * @param {String} (#channelName).senderPeerId The Peer uploader ID.
  210.  * @param {String} (#channelName).transferId The data transfer ID.
  211.  * @param {Number} (#channelName).percentage The data transfer percentage.
  212.  * @param {Number} (#channelName).timeout The data transfer timeout to wait for response
  213.  *   before throwing a timeout error.
  214.  * @param {Number} (#channelName).chunkSize The data transfer packet (chunk) size.
  215.  * @param {String} (#channelName).dataType The data transfer packet (chunk) data type.
  216.  * @type JSON
  217.  * @private
  218.  * @required
  219.  * @component DataTransfer
  220.  * @for Skylink
  221.  * @since 0.4.1
  222.  */
  223. Skylink.prototype._downloadDataSessions = {};
  224.  
  225. /**
  226.  * Stores the list of ongoing data transfer timeouts using the
  227.  *   <code>setTimeout</code> objects for each DataChannel connection transfer.
  228.  * @attribute _dataTransfersTimeout
  229.  * @param {Object} (#channelName) The timeout for the associated DataChannel
  230.  *   connection.
  231.  * @type JSON
  232.  * @private
  233.  * @required
  234.  * @component DataTransfer
  235.  * @for Skylink
  236.  * @since 0.4.1
  237.  */
  238. Skylink.prototype._dataTransfersTimeout = {};
  239.  
  240. /**
  241.  * Sets a waiting timeout for every response sent to DataChannel connection receiving
  242.  *   end. Once the timeout has ended, a timeout error will be thrown and
  243.  *   data transfer will be terminated.
  244.  * @method _setDataChannelTimeout
  245.  * @param {String} peerId The Peer ID associated with the DataChannel connection.
  246.  * @param {Number} timeout The waiting timeout in seconds.
  247.  * @param {Boolean} [isSender=false] The flag thats indicates if the response
  248.  *   is related to a downloading or uploading data transfer.
  249.  * @param {String} channelName The DataChannel connection ID.
  250.  * @private
  251.  * @component DataTransfer
  252.  * @for Skylink
  253.  * @since 0.5.0
  254.  */
  255. Skylink.prototype._setDataChannelTimeout = function(peerId, timeout, isSender, channelName) {
  256.   var self = this;
  257.   if (!self._dataTransfersTimeout[channelName]) {
  258.     self._dataTransfersTimeout[channelName] = null;
  259.   }
  260.   var type = (isSender) ? self.DATA_TRANSFER_TYPE.UPLOAD :
  261.     self.DATA_TRANSFER_TYPE.DOWNLOAD;
  262.  
  263.   self._dataTransfersTimeout[channelName] = setTimeout(function() {
  264.     var name;
  265.     if (self._dataTransfersTimeout[channelName][type]) {
  266.       if (isSender) {
  267.         name = self._uploadDataSessions[channelName].name;
  268.         delete self._uploadDataTransfers[channelName];
  269.         delete self._uploadDataSessions[channelName];
  270.       } else {
  271.         name = self._downloadDataSessions[channelName].name;
  272.         delete self._downloadDataTransfers[channelName];
  273.         delete self._downloadDataSessions[channelName];
  274.       }
  275.  
  276.       self._sendDataChannelMessage(peerId, {
  277.         type: self._DC_PROTOCOL_TYPE.ERROR,
  278.         sender: self._user.sid,
  279.         name: name,
  280.         content: 'Connection Timeout. Longer than ' + timeout +
  281.           ' seconds. Connection is abolished.',
  282.         isUploadError: isSender
  283.       }, channelName);
  284.       // TODO: Find a way to add channel name so it's more specific
  285.       log.error([peerId, 'RTCDataChannel', channelName, 'Failed transfering data:'],
  286.         'Transfer ' + ((isSender) ? 'for': 'from') + ' ' + peerId +
  287.         ' failed. Connection timeout');
  288.       self._clearDataChannelTimeout(peerId, isSender, channelName);
  289.     }
  290.   }, 1000 * timeout);
  291. };
  292.  
  293. /**
  294.  * Stops and clears the waitig timeout for the associated DataChannel connection.
  295.  * @method _clearDataChannelTimeout
  296.  * @param {String} peerId The Peer ID associated with the DataChannel connection.
  297.  * @param {Boolean} [isSender=false] The flag thats indicates if the response
  298.  *   is related to a downloading or uploading data transfer.
  299.  * @param {String} channelName The DataChannel connection ID.
  300.  * @private
  301.  * @component DataTransfer
  302.  * @for Skylink
  303.  * @since 0.5.0
  304.  */
  305. Skylink.prototype._clearDataChannelTimeout = function(peerId, isSender, channelName) {
  306.   if (this._dataTransfersTimeout[channelName]) {
  307.     clearTimeout(this._dataTransfersTimeout[channelName]);
  308.     delete this._dataTransfersTimeout[channelName];
  309.     log.debug([peerId, 'RTCDataChannel', channelName, 'Clear datachannel timeout']);
  310.   } else {
  311.     log.debug([peerId, 'RTCDataChannel', channelName, 'Unable to find timeouts. ' +
  312.       'Not clearing the datachannel timeouts']);
  313.   }
  314. };
  315.  
  316. /**
  317.  * Starts a data transfer with a Peer. If multi-transfer is supported,
  318.  *   Skylink would open a new DataChannel connection with Peer to start
  319.  *   data transfer. If mutli-transfer is not supported in
  320.  *   {{#crossLink "Skylink/_INTEROP_MULTI_TRANSFERS:attr"}}_INTEROP_MULTI_TRANSFERS{{/crossLink}},
  321.  *   the data transfer would start in the {{#crossLink "Skylink/DATA_CHANNEL_TYPE:attr"}}<code>
  322.  *   DATA_CHANNEL_TYPE.MESSAGING</code>{{/crossLink}} channel instead.
  323.  * @method _sendBlobDataToPeer
  324.  * @param {Blob} data The Blob data object to send.
  325.  * @param {JSON} dataInfo The data transfer information.
  326.  * @param {String} dataInfo.transferId The transfer ID of the data transfer.
  327.  * @param {String} dataInfo.name The transfer Blob data object name.
  328.  * @param {Number} [dataInfo.timeout=60] The timeout set to await in seconds
  329.  *   for response from DataChannel connection.
  330.  * @param {Number} dataInfo.size The Blob data binary size expected to be received in the receiving end.
  331.  * @param {Boolean} [dataInfo.isPrivate=false] The flag to indicate if the data transfer is a private
  332.  *   transfer to the Peer directly and not broadcasted to all Peers.
  333.  * @param {String|Array} [targetPeerId=null] The receiving Peer ID. Array is used for
  334.  *   MCU connection where multi-targeted Peers are used. By default, the
  335.  *   value is <code>null</code>, which indicates that the data transfer is requested with all
  336.  *   connected Peers.
  337.  * @return {String} The DataChannel connection ID associated with the transfer. If returned
  338.  *   as <code>null</code> or empty, it indicates an error.
  339.  * @private
  340.  * @component DataTransfer
  341.  * @for Skylink
  342.  * @since 0.5.5
  343.  */
  344. Skylink.prototype._sendBlobDataToPeer = function(data, dataInfo, targetPeerId) {
  345.   var self = this;
  346.   //If there is MCU then directs all messages to MCU
  347.   var targetChannel = targetPeerId;//(self._hasMCU) ? 'MCU' : targetPeerId;
  348.   var targetPeerList = [];
  349.  
  350.   var binarySize = parseInt((dataInfo.size * (4 / 3)).toFixed(), 10);
  351.   var binaryChunkSize = 0;
  352.   var chunkSize = 0;
  353.   var i;
  354.   var hasSend = false;
  355.  
  356.   // move list of peers to targetPeerList
  357.   if (self._hasMCU) {
  358.     if (Array.isArray(targetPeerList)) {
  359.       targetPeerList = targetPeerId;
  360.     } else {
  361.       targetPeerList = [targetPeerId];
  362.     }
  363.     targetPeerId = 'MCU';
  364.   }
  365.  
  366.   if (dataInfo.dataType !== 'blob') {
  367.     // output: 1616
  368.     binaryChunkSize = self._CHUNK_DATAURL_SIZE;
  369.     chunkSize = self._CHUNK_DATAURL_SIZE;
  370.     binarySize = dataInfo.size;
  371.   } else if (window.webrtcDetectedBrowser === 'firefox') {
  372.     // output: 16384
  373.     binaryChunkSize = self._MOZ_CHUNK_FILE_SIZE * (4 / 3);
  374.     chunkSize = self._MOZ_CHUNK_FILE_SIZE;
  375.   } else {
  376.     // output: 65536
  377.     binaryChunkSize = parseInt((self._CHUNK_FILE_SIZE * (4 / 3)).toFixed(), 10);
  378.     chunkSize = self._CHUNK_FILE_SIZE;
  379.   }
  380.  
  381.   var throwTransferErrorFn = function (message) {
  382.     // MCU targetPeerId case - list of peers
  383.     if (self._hasMCU) {
  384.       for (i = 0; i < targetPeerList.length; i++) {
  385.         var peerId = targetPeerList[i];
  386.         self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.ERROR,
  387.           dataInfo.transferId, peerId, {
  388.             name: dataInfo.name,
  389.             size: dataInfo.size,
  390.             percentage: 0,
  391.             data: null,
  392.             dataType: dataInfo.dataType,
  393.             senderPeerId: self._user.sid,
  394.             timeout: dataInfo.timeout,
  395.             isPrivate: dataInfo.isPrivate
  396.           },{
  397.             message: message,
  398.             transferType: self.DATA_TRANSFER_TYPE.UPLOAD
  399.         });
  400.       }
  401.     } else {
  402.       self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.ERROR,
  403.         dataInfo.transferId, targetPeerId, {
  404.           name: dataInfo.name,
  405.           size: dataInfo.size,
  406.           percentage: 0,
  407.           data: null,
  408.           dataType: dataInfo.dataType,
  409.           senderPeerId: self._user.sid,
  410.           timeout: dataInfo.timeout,
  411.           isPrivate: dataInfo.isPrivate
  412.         },{
  413.           message: message,
  414.           transferType: self.DATA_TRANSFER_TYPE.UPLOAD
  415.       });
  416.     }
  417.   };
  418.  
  419.   var startTransferFn = function (targetId, channel) {
  420.     if (!hasSend) {
  421.       hasSend = true;
  422.       var payload = {
  423.         type: self._DC_PROTOCOL_TYPE.WRQ,
  424.         sender: self._user.sid,
  425.         agent: window.webrtcDetectedBrowser,
  426.         version: window.webrtcDetectedVersion,
  427.         name: dataInfo.name,
  428.         size: binarySize,
  429.         dataType: dataInfo.dataType,
  430.         chunkSize: binaryChunkSize,
  431.         timeout: dataInfo.timeout,
  432.         target: self._hasMCU ? 'MCU' : targetPeerId,
  433.         isPrivate: dataInfo.isPrivate
  434.       };
  435.  
  436.       if (self._hasMCU) {
  437.         // if has MCU and is public, do not send individually
  438.         self._sendDataChannelMessage('MCU', payload, channel);
  439.         try {
  440.           var mainChannel = self._dataChannels.MCU.main.label;
  441.           self._setDataChannelTimeout('MCU', dataInfo.timeout, true, mainChannel);
  442.         } catch (error) {
  443.           log.error(['MCU', 'RTCDataChannel', 'MCU', 'Failed setting datachannel ' +
  444.             'timeout for MCU'], error);
  445.         }
  446.       } else {
  447.         // if has MCU and is public, do not send individually
  448.         self._sendDataChannelMessage(targetId, payload, channel);
  449.         self._setDataChannelTimeout(targetId, dataInfo.timeout, true, channel);
  450.       }
  451.  
  452.     }
  453.   };
  454.  
  455.   log.log([targetPeerId, 'RTCDataChannel', targetChannel, 'Chunk size of data:'], {
  456.     chunkSize: chunkSize,
  457.     binaryChunkSize: binaryChunkSize,
  458.     transferId: dataInfo.transferId,
  459.     dataType: dataInfo.dataType
  460.   });
  461.  
  462.  
  463.   var supportMulti = false;
  464.   var peerAgent = (self._peerInformations[targetPeerId] || {}).agent;
  465.  
  466.   if (!peerAgent && !peerAgent.name) {
  467.     log.error([targetPeerId, 'RTCDataChannel', targetChannel, 'Aborting transfer to peer ' +
  468.       'as peer agent information for peer does not exists'], dataInfo);
  469.     throwTransferErrorFn('Peer agent information for peer does not exists');
  470.     return;
  471.   }
  472.  
  473.   if (self._INTEROP_MULTI_TRANSFERS.indexOf(peerAgent.name) === -1) {
  474.  
  475.     targetChannel = targetPeerId + '-' + dataInfo.transferId;
  476.     supportMulti = true;
  477.  
  478.     if (!(self._dataChannels[targetPeerId] || {}).main) {
  479.       log.error([targetPeerId, 'RTCDataChannel', targetChannel,
  480.         'Main datachannel does not exists'], dataInfo);
  481.       throwTransferErrorFn('Main datachannel does not exists');
  482.       return;
  483.  
  484.     } else if (self._dataChannels[targetPeerId].main.readyState !==
  485.       self.DATA_CHANNEL_STATE.OPEN) {
  486.       log.error([targetPeerId, 'RTCDataChannel', targetChannel,
  487.         'Main datachannel is not opened'], {
  488.           transferId: dataInfo.transferId,
  489.           readyState: self._dataChannels[targetPeerId].main.readyState
  490.       });
  491.       throwTransferErrorFn('Main datachannel is not opened');
  492.       return;
  493.     }
  494.  
  495.     self._dataChannels[targetPeerId][targetChannel] =
  496.       self._createDataChannel(targetPeerId, self.DATA_CHANNEL_TYPE.DATA, null, targetChannel);
  497.  
  498.   } else {
  499.     var ongoingTransfer = null;
  500.  
  501.     if (self._uploadDataSessions[targetChannel]) {
  502.       ongoingTransfer = self.DATA_TRANSFER_TYPE.UPLOAD;
  503.     } else if (self._downloadDataSessions[targetChannel]) {
  504.       ongoingTransfer = self.DATA_TRANSFER_TYPE.DOWNLOAD;
  505.     }
  506.  
  507.     if (ongoingTransfer) {
  508.       log.error([targetPeerId, 'RTCDataChannel', targetChannel, 'User have ongoing ' +
  509.         ongoingTransfer + ' transfer session with peer. Unable to send data'], dataInfo);
  510.       throwTransferErrorFn('Another ' + ongoingTransfer +
  511.         ' transfer is ongoing. Unable to send data.');
  512.       return;
  513.     }
  514.   }
  515.  
  516.   if (dataInfo.dataType === 'blob') {
  517.     self._uploadDataTransfers[targetChannel] = self._chunkBlobData(data, chunkSize);
  518.   } else {
  519.     self._uploadDataTransfers[targetChannel] = self._chunkDataURL(data, chunkSize);
  520.   }
  521.  
  522.   self._uploadDataSessions[targetChannel] = {
  523.     name: dataInfo.name,
  524.     size: binarySize,
  525.     isUpload: true,
  526.     senderPeerId: self._user.sid,
  527.     transferId: dataInfo.transferId,
  528.     percentage: 0,
  529.     timeout: dataInfo.timeout,
  530.     chunkSize: chunkSize,
  531.     dataType: dataInfo.dataType,
  532.     isPrivate: dataInfo.isPrivate
  533.   };
  534.  
  535.   if (supportMulti) {
  536.     self._condition('dataChannelState', function () {
  537.       startTransferFn(targetPeerId, targetChannel);
  538.     }, function () {
  539.       return self._dataChannels[targetPeerId][targetChannel].readyState ===
  540.         self.DATA_CHANNEL_STATE.OPEN;
  541.     }, function (state) {
  542.       return state === self.DATA_CHANNEL_STATE.OPEN;
  543.     });
  544.   } else {
  545.     startTransferFn(targetChannel, targetChannel);
  546.   }
  547.  
  548.   return targetChannel;
  549. };
  550.  
  551. /**
  552.  * Routes the data received to the relevant Protocol handler based on the data received.
  553.  * @method _dataChannelProtocolHandler
  554.  * @param {String|Object} data The data received from the DataChannel connection.
  555.  * @param {String} senderPeerId The Peer ID associated with the DataChannel connection.
  556.  * @param {String} channelName The DataChannel connection ID.
  557.  * @param {String} channelType The DataChannel connection functionality type.
  558.  *   [Rel: Skylink.DATA_CHANNEL_TYPE]
  559.  * @private
  560.  * @component DataTransfer
  561.  * @for Skylink
  562.  * @since 0.5.2
  563.  */
  564. Skylink.prototype._dataChannelProtocolHandler = function(dataString, peerId, channelName, channelType) {
  565.   // PROTOCOL ESTABLISHMENT
  566.  
  567.   if (!(this._peerInformations[peerId] || {}).agent) {
  568.     log.error([peerId, 'RTCDataChannel', channelName, 'Peer informations is missing during protocol ' +
  569.       'handling. Dropping packet'], dataString);
  570.     return;
  571.   }
  572.  
  573.   /*var useChannel = channelName;
  574.   var peerAgent = this._peerInformations[peerId].agent.name;
  575.  
  576.   if (channelType === this.DATA_CHANNEL_TYPE.MESSAGING ||
  577.     this._INTEROP_MULTI_TRANSFERS[peerAgent] > -1) {
  578.     useChannel = peerId;
  579.   }*/
  580.  
  581.   if (typeof dataString === 'string') {
  582.     var data = {};
  583.     try {
  584.       data = JSON.parse(dataString);
  585.     } catch (error) {
  586.       log.debug([peerId, 'RTCDataChannel', channelName, 'Received from peer ->'], {
  587.         type: 'DATA',
  588.         data: dataString
  589.       });
  590.       this._DATAProtocolHandler(peerId, dataString,
  591.         this.DATA_TRANSFER_DATA_TYPE.BINARY_STRING, channelName);
  592.       return;
  593.     }
  594.     log.debug([peerId, 'RTCDataChannel', channelName, 'Received from peer ->'], {
  595.       type: data.type,
  596.       data: data
  597.     });
  598.     switch (data.type) {
  599.     case this._DC_PROTOCOL_TYPE.WRQ:
  600.       this._WRQProtocolHandler(peerId, data, channelName);
  601.       break;
  602.     case this._DC_PROTOCOL_TYPE.ACK:
  603.       this._ACKProtocolHandler(peerId, data, channelName);
  604.       break;
  605.     case this._DC_PROTOCOL_TYPE.ERROR:
  606.       this._ERRORProtocolHandler(peerId, data, channelName);
  607.       break;
  608.     case this._DC_PROTOCOL_TYPE.CANCEL:
  609.       this._CANCELProtocolHandler(peerId, data, channelName);
  610.       break;
  611.     case this._DC_PROTOCOL_TYPE.MESSAGE: // Not considered a protocol actually?
  612.       this._MESSAGEProtocolHandler(peerId, data, channelName);
  613.       break;
  614.     default:
  615.       log.error([peerId, 'RTCDataChannel', channelName, 'Unsupported message ->'], {
  616.         type: data.type,
  617.         data: data
  618.       });
  619.     }
  620.   }
  621. };
  622.  
  623. /**
  624.  * Handles the WRQ Protocol request received from the DataChannel connection.
  625.  * @method _WRQProtocolHandler
  626.  * @param {String} senderPeerId The Peer ID associated with the DataChannel connection.
  627.  * @param {JSON} data The data object received from the DataChannel connection.
  628.  *   This should contain the <code>WRQ</code> payload.
  629.  * @param {String} data.agent The sender Peer platform browser or agent name.
  630.  * @param {Number} data.version The sender Peer platform browser or agent version.
  631.  * @param {String} data.name The transfer data object name.
  632.  * @param {Number} data.size The transfer data object expected received size.
  633.  * @param {Number} data.chunkSize The expected data transfer packet (chunk) size.
  634.  * @param {Number} data.timeout The timeout set to await in seconds
  635.  *   for response from DataChannel connection.
  636.  * @param {Boolean} data.isPrivate The flag to indicate if the data transfer is a private
  637.  *   transfer to the Peer connection directly and not broadcasted to all Peers conneciton.
  638.  * @param {String} data.sender The Peer ID of the sender.
  639.  * @param {String} data.type Protocol step <code>"WRQ"</code>.
  640.  * @param {String} channelName The DataChannel connection ID associated with the transfer.
  641.  * @trigger dataTransferState
  642.  * @private
  643.  * @component DataTransfer
  644.  * @for Skylink
  645.  * @since 0.5.2
  646.  */
  647. Skylink.prototype._WRQProtocolHandler = function(peerId, data, channelName) {
  648.   var transferId = channelName + this._TRANSFER_DELIMITER + (new Date()).getTime();
  649.  
  650.   log.log([peerId, 'RTCDataChannel', channelName,
  651.     'Received file request from peer:'], data);
  652.  
  653.   var name = data.name;
  654.   var binarySize = data.size;
  655.   var expectedSize = data.chunkSize;
  656.   var timeout = data.timeout;
  657.  
  658.   this._downloadDataSessions[channelName] = {
  659.     transferId: transferId,
  660.     name: name,
  661.     isUpload: false,
  662.     senderPeerId: peerId,
  663.     size: binarySize,
  664.     percentage: 0,
  665.     dataType: data.dataType,
  666.     ackN: 0,
  667.     receivedSize: 0,
  668.     chunkSize: expectedSize,
  669.     timeout: timeout,
  670.     isPrivate: data.isPrivate
  671.   };
  672.   this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.UPLOAD_REQUEST,
  673.     transferId, peerId, {
  674.       name: name,
  675.       size: binarySize,
  676.       percentage: 0,
  677.       data: null,
  678.       dataType: data.dataType,
  679.       senderPeerId: peerId,
  680.       timeout: timeout,
  681.       isPrivate: data.isPrivate
  682.   });
  683.   this._trigger('incomingDataRequest', transferId, peerId, {
  684.     name: name,
  685.     size: binarySize,
  686.     percentage: 0,
  687.     dataType: data.dataType,
  688.     senderPeerId: peerId,
  689.     timeout: timeout,
  690.     isPrivate: data.isPrivate
  691.   }, false);
  692. };
  693.  
  694. /**
  695.  * Handles the ACK Protocol request received from the DataChannel connection.
  696.  * @method _ACKProtocolHandler
  697.  * @param {String} peerId The Peer ID associated with the DataChannel connection.
  698.  * @param {JSON} data The data object received from the DataChannel connection.
  699.  *   This should contain the <code>ACK</code> payload.
  700.  * @param {Number} data.ackN The ACK response of the current data transfer.
  701.  *   If <code>0</code>, it means that the request has been accepted and the sending Peer
  702.  *   has to send the first data transfer packet (chunk). If it's greater than <code>0</code>,
  703.  *   it means that the previous data transfer packet (chunk) has been received and is expecting
  704.  *   for the next data transfer packet. The number always increment based on the number of data
  705.  *   packets the receiving end has received. If it's <code>-1</code>, it means that the data
  706.  *   transfer request has been rejected and the data transfer will be terminated.
  707.  * @param {String} data.sender The Peer ID of sender.
  708.  * @param {String} data.type Protocol step <code>"ACK"</code>.
  709.  * @param {String} channelName The DataChannel connection ID associated with the transfer.
  710.  * @trigger dataTransferState
  711.  * @private
  712.  * @component DataTransfer
  713.  * @for Skylink
  714.  * @since 0.5.2
  715.  */
  716. Skylink.prototype._ACKProtocolHandler = function(peerId, data, channelName) {
  717.   var self = this;
  718.   var ackN = data.ackN;
  719.   var transferStatus = self._uploadDataSessions[channelName];
  720.  
  721.   if (!transferStatus) {
  722.     log.error([peerId, 'RTCDataChannel', channelName, 'Ignoring data received as ' +
  723.       'upload data transfers is empty'], {
  724.         status: transferStatus,
  725.         data: data
  726.     });
  727.     return;
  728.   }
  729.  
  730.   if (!this._uploadDataTransfers[channelName]) {
  731.     log.error([peerId, 'RTCDataChannel', channelName,
  732.       'Ignoring data received as upload data transfers array is missing'], {
  733.         data: data
  734.     });
  735.     return;
  736.   }
  737.  
  738.   //peerId = (peerId === 'MCU') ? data.sender : peerId;
  739.   var chunksLength = self._uploadDataTransfers[channelName].length;
  740.   var transferId = transferStatus.transferId;
  741.   var timeout = transferStatus.timeout;
  742.  
  743.   self._clearDataChannelTimeout(peerId, true, channelName);
  744.   log.log([peerId, 'RTCDataChannel', channelName, 'ACK stage (' +
  745.     transferStatus.transferId + ') ->'], ackN + ' / ' + chunksLength);
  746.  
  747.   if (ackN > -1) {
  748.     // Still uploading
  749.     if (ackN < chunksLength) {
  750.       var sendDataFn = function (base64BinaryString) {
  751.         var percentage = parseFloat((((ackN + 1) / chunksLength) * 100).toFixed(2), 10);
  752.  
  753.         if (!self._uploadDataSessions[channelName]) {
  754.           log.error([peerId, 'RTCDataChannel', channelName,
  755.             'Failed uploading as data session is empty'], {
  756.               status: transferStatus,
  757.               data: data
  758.           });
  759.           return;
  760.         }
  761.  
  762.         self._uploadDataSessions[channelName].percentage = percentage;
  763.  
  764.         self._sendDataChannelMessage(peerId, base64BinaryString, channelName);
  765.         self._setDataChannelTimeout(peerId, timeout, true, channelName);
  766.  
  767.         // to prevent from firing upload = 100;
  768.         if (percentage !== 100) {
  769.           self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.UPLOADING,
  770.             transferId, peerId, {
  771.               name: transferStatus.name,
  772.               size: transferStatus.size,
  773.               percentage: percentage,
  774.               data: null,
  775.               dataType: transferStatus.dataType,
  776.               senderPeerId: transferStatus.senderPeerId,
  777.               timeout: transferStatus.timeout,
  778.               isPrivate: transferStatus.isPrivate
  779.           });
  780.         }
  781.       };
  782.  
  783.       if (transferStatus.dataType === 'blob') {
  784.         self._blobToBase64(self._uploadDataTransfers[channelName][ackN], sendDataFn);
  785.       } else {
  786.         sendDataFn(self._uploadDataTransfers[channelName][ackN]);
  787.       }
  788.     } else if (ackN === chunksLength) {
  789. 	    log.log([peerId, 'RTCDataChannel', channelName, 'Upload completed (' +
  790.         transferStatus.transferId + ')'], transferStatus);
  791.  
  792.       self._trigger('dataTransferState',
  793.         self.DATA_TRANSFER_STATE.UPLOAD_COMPLETED, transferId, peerId, {
  794.           name: transferStatus.name,
  795.           size: transferStatus.size,
  796.           percentage: 100,
  797.           data: null,
  798.           dataType: transferStatus.dataType,
  799.           senderPeerId: transferStatus.senderPeerId,
  800.           timeout: transferStatus.timeout,
  801.           isPrivate: transferStatus.isPrivate
  802.       });
  803.  
  804.       var blob = null;
  805.  
  806.       if (transferStatus.dataType === 'blob') {
  807.         blob = new Blob(self._uploadDataTransfers[channelName]);
  808.       } else {
  809.         blob = self._assembleDataURL(self._uploadDataTransfers[channelName]);
  810.       }
  811.  
  812.       self._trigger('incomingData', blob, transferId, peerId, {
  813.         name: transferStatus.name,
  814.         size: transferStatus.size,
  815.         percentage: 100,
  816.         dataType: transferStatus.dataType,
  817.         senderPeerId: transferStatus.senderPeerId,
  818.         timeout: transferStatus.timeout,
  819.         isPrivate: transferStatus.isPrivate
  820.       }, true);
  821.       delete self._uploadDataTransfers[channelName];
  822.       delete self._uploadDataSessions[channelName];
  823.  
  824.       // close datachannel after transfer
  825.       if (self._dataChannels[peerId] && self._dataChannels[peerId][channelName]) {
  826.         log.debug([peerId, 'RTCDataChannel', channelName, 'Closing datachannel for upload transfer']);
  827.         self._closeDataChannel(peerId, channelName);
  828.       }
  829.     }
  830.   } else {
  831.     log.debug([peerId, 'RTCDataChannel', channelName, 'Upload rejected (' +
  832.       transferStatus.transferId + ')'], transferStatus);
  833.  
  834.     self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.REJECTED,
  835.       transferId, peerId, {
  836.         name: transferStatus.name, //self._uploadDataSessions[channelName].name,
  837.         size: transferStatus.size, //self._uploadDataSessions[channelName].size,
  838.         percentage: 0,
  839.         data: null,
  840.         dataType: transferStatus.dataType,
  841.         senderPeerId: transferStatus.senderPeerId,
  842.         timeout: transferStatus.timeout,
  843.         isPrivate: transferStatus.isPrivate
  844.     });
  845.     delete self._uploadDataTransfers[channelName];
  846.     delete self._uploadDataSessions[channelName];
  847.  
  848.     // close datachannel if rejected
  849.     if (self._dataChannels[peerId] && self._dataChannels[peerId][channelName]) {
  850.       log.debug([peerId, 'RTCDataChannel', channelName, 'Closing datachannel for upload transfer']);
  851.       self._closeDataChannel(peerId, channelName);
  852.     }
  853.   }
  854. };
  855.  
  856. /**
  857.  * Handles the MESSAGE Protocol request received from the DataChannel connection.
  858.  * @method _MESSAGEProtocolHandler
  859.  * @param {String} peerId The Peer ID associated with the DataChannel connection.
  860.  * @param {JSON} data The data object received from the DataChannel connection.
  861.  *   This should contain the <code>MESSAGE</code> payload.
  862.  * @param {String} data.target The targeted Peer ID to receive the message object.
  863.  * @param {String|JSON} data.data The message object.
  864.  * @param {String} data.sender The Peer ID of the sender.
  865.  * @param {String} data.type Protocol step <code>"MESSAGE"</code>.
  866.  * @param {String} channelName The DataChannel connection ID associated with the transfer.
  867.  * @trigger incomingMessage
  868.  * @private
  869.  * @component DataTransfer
  870.  * @for Skylink
  871.  * @since 0.5.2
  872.  */
  873. Skylink.prototype._MESSAGEProtocolHandler = function(peerId, data, channelName) {
  874.   var targetMid = data.sender;
  875.   log.log([targetMid, 'RTCDataChannel', channelName,
  876.     'Received P2P message from peer:'], data);
  877.   this._trigger('incomingMessage', {
  878.     content: data.data,
  879.     isPrivate: data.isPrivate,
  880.     isDataChannel: true,
  881.     targetPeerId: this._user.sid,
  882.     senderPeerId: targetMid
  883.   }, targetMid, this.getPeerInfo(targetMid), false);
  884. };
  885.  
  886. /**
  887.  * Handles the ERROR Protocol request received from the DataChannel connection.
  888.  * @method _ERRORProtocolHandler
  889.  * @param {String} senderPeerId The Peer ID associated with the DataChannel connection.
  890.  * @param {JSON} data The data object received from the DataChannel connection.
  891.  *   This should contain the <code>ERROR</code> payload.
  892.  * @param {String} data.name The transfer data object name.
  893.  * @param {String} data.content The error message.
  894.  * @param {Boolean} [data.isUploadError=false] The flag thats indicates if the response
  895.  *   is related to a downloading or uploading data transfer.
  896.  * @param {String} data.sender The Peer ID of the sender.
  897.  * @param {String} data.type Protocol step <code>"ERROR"</code>.
  898.  * @param {String} channelName The DataChannel connection ID associated with the transfer.
  899.  * @trigger dataTransferState
  900.  * @private
  901.  * @for Skylink
  902.  * @since 0.5.2
  903.  */
  904. Skylink.prototype._ERRORProtocolHandler = function(peerId, data, channelName) {
  905.   var isUploader = data.isUploadError;
  906.   var transferStatus = (isUploader) ? this._uploadDataSessions[channelName] :
  907.     this._downloadDataSessions[channelName];
  908.  
  909.   if (!transferStatus) {
  910.     log.error([peerId, 'RTCDataChannel', channelName, 'Ignoring data received as ' +
  911.       (isUploader ? 'upload' : 'download') + ' data session is empty'], data);
  912.     return;
  913.   }
  914.  
  915.   var transferId = transferStatus.transferId;
  916.  
  917.   log.error([peerId, 'RTCDataChannel', channelName,
  918.     'Received an error from peer:'], data);
  919.   this._clearDataChannelTimeout(peerId, isUploader, channelName);
  920.   this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.ERROR,
  921.     transferId, peerId, {
  922.       name: transferStatus.name,
  923.       size: transferStatus.size,
  924.       percentage: transferStatus.percentage,
  925.       data: null,
  926.       dataType: transferStatus.dataType,
  927.       senderPeerId: transferStatus.senderPeerId,
  928.       timeout: transferStatus.timeout,
  929.       isPrivate: transferStatus.isPrivate
  930.     }, {
  931.       message: data.content,
  932.       transferType: ((isUploader) ? this.DATA_TRANSFER_TYPE.UPLOAD :
  933.         this.DATA_TRANSFER_TYPE.DOWNLOAD)
  934.   });
  935. };
  936.  
  937. /**
  938.  * Handles the CANCEL Protocol request received from the DataChannel connection.
  939.  * @method _CANCELProtocolHandler
  940.  * @param {String} senderPeerId The Peer ID associated with the DataChannel connection.
  941.  * @param {JSON} data The data object received from the DataChannel connection.
  942.  *   This should contain the <code>CANCEL</code> payload.
  943.  * @param {String} data.name The transfer data object name.
  944.  * @param {String} data.content The reason for termination as a message.
  945.  * @param {String} data.sender The Peer ID of the sender.
  946.  * @param {String} data.type Protocol step <code>"CANCEL"</code>.
  947.  * @param {String} channelName The DataChannel connection ID associated with the transfer.
  948.  * @trigger dataTransferState
  949.  * @private
  950.  * @component DataTransfer
  951.  * @for Skylink
  952.  * @since 0.5.0
  953.  */
  954. Skylink.prototype._CANCELProtocolHandler = function(peerId, data, channelName) {
  955.   var isUpload = !!this._uploadDataSessions[channelName];
  956.   var isDownload = !!this._downloadDataSessions[channelName];
  957.   var transferStatus = (isUpload) ? this._uploadDataSessions[channelName] :
  958.     this._downloadDataSessions[channelName];
  959.  
  960.   if (!transferStatus) {
  961.     log.error([peerId, 'RTCDataChannel', channelName, 'Ignoring data received as ' +
  962.       (isUpload ? 'upload' : 'download') + ' data session is empty'], data);
  963.     return;
  964.   }
  965.  
  966.   var transferId = transferStatus.transferId;
  967.  
  968.   log.log([peerId, 'RTCDataChannel', channelName,
  969.     'Received file transfer cancel request:'], data);
  970.  
  971.   this._clearDataChannelTimeout(peerId, isUpload, channelName);
  972.  
  973.   try {
  974.     if (isUpload) {
  975.       delete this._uploadDataSessions[channelName];
  976.       delete this._uploadDataTransfers[channelName];
  977.     } else {
  978.       delete this._downloadDataSessions[channelName];
  979.       delete this._downloadDataTransfers[channelName];
  980.     }
  981.  
  982.     this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.CANCEL,
  983.       transferId, peerId, {
  984.         name: transferStatus.name,
  985.         size: transferStatus.size,
  986.         data: null,
  987.         dataType: transferStatus.dataType,
  988.         percentage: transferStatus.percentage,
  989.         senderPeerId: transferStatus.senderPeerId,
  990.         timeout: transferStatus.timeout,
  991.         isPrivate: transferStatus.isPrivate
  992.       }, {
  993.         message: data.content,
  994.         transferType: ((isUpload) ? this.DATA_TRANSFER_TYPE.UPLOAD :
  995.           this.DATA_TRANSFER_TYPE.DOWNLOAD)
  996.     });
  997.  
  998.     log.log([peerId, 'RTCDataChannel', channelName,
  999.       'Emptied file transfer session:'], data);
  1000.  
  1001.   } catch (error) {
  1002.     this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.ERROR,
  1003.       transferId, peerId, {
  1004.         name: transferStatus.name,
  1005.         size: transferStatus.size,
  1006.         data: null,
  1007.         dataType: transferStatus.dataType,
  1008.         percentage: transferStatus.percentage,
  1009.         senderPeerId: transferStatus.senderPeerId,
  1010.         timeout: transferStatus.timeout,
  1011.         isPrivate: transferStatus.isPrivate
  1012.       }, {
  1013.         message: 'Failed cancelling data request from peer',
  1014.         transferType: ((isUpload) ? this.DATA_TRANSFER_TYPE.UPLOAD :
  1015.           this.DATA_TRANSFER_TYPE.DOWNLOAD)
  1016.     });
  1017.  
  1018.     log.error([peerId, 'RTCDataChannel', channelName,
  1019.       'Failed emptying file transfer session:'], {
  1020.         data: data,
  1021.         error: error
  1022.     });
  1023.   }
  1024. };
  1025.  
  1026. /**
  1027.  * Handles the DATA Protocol request received from the DataChannel connection.
  1028.  * In this handler, it actually handles and manipulates the received data transfer packet.
  1029.  * @method _DATAProtocolHandler
  1030.  * @param {String} senderPeerId The Peer ID associated with the DataChannel connection.
  1031.  * @param {ArrayBuffer|Blob|String} dataString The data transfer packet (chunk) received.
  1032.  * @param {String} dataType The data transfer packet (chunk) data type received.
  1033.  *   [Rel: Skylink.DATA_TRANSFER_DATA_TYPE]
  1034.  * @param {String} channelName The DataChannel connection ID associated with the transfer.
  1035.  * @trigger dataTransferState
  1036.  * @private
  1037.  * @component DataTransfer
  1038.  * @for Skylink
  1039.  * @since 0.5.5
  1040.  */
  1041. Skylink.prototype._DATAProtocolHandler = function(peerId, dataString, dataType, channelName) {
  1042.   var chunk, error = '';
  1043.   var transferStatus = this._downloadDataSessions[channelName];
  1044.   log.log([peerId, 'RTCDataChannel', channelName,
  1045.     'Received data chunk from peer ->'], {
  1046.       dataType: dataType,
  1047.       data: dataString,
  1048.       type: 'DATA'
  1049.   });
  1050.  
  1051.   if (!transferStatus) {
  1052.     log.error([peerId, 'RTCDataChannel', channelName,
  1053.       'Ignoring data received as download data session is empty'], {
  1054.         dataType: dataType,
  1055.         data: dataString,
  1056.         type: 'DATA'
  1057.     });
  1058.     return;
  1059.   }
  1060.  
  1061.   if (!this._downloadDataTransfers[channelName]) {
  1062.     log.error([peerId, 'RTCDataChannel', channelName,
  1063.       'Ignoring data received as download data transfers array is missing'], {
  1064.         dataType: dataType,
  1065.         data: dataString,
  1066.         type: 'DATA'
  1067.     });
  1068.     return;
  1069.   }
  1070.  
  1071.   var transferId = transferStatus.transferId;
  1072.   var dataTransferType = transferStatus.dataType;
  1073.   var receivedSize = 0;
  1074.  
  1075.   this._clearDataChannelTimeout(peerId, false, channelName);
  1076.  
  1077.   if (dataType === this.DATA_TRANSFER_DATA_TYPE.BINARY_STRING) {
  1078.     if (dataTransferType === 'blob') {
  1079.       chunk = this._base64ToBlob(dataString);
  1080.       receivedSize = (chunk.size * (4 / 3));
  1081.     } else {
  1082.       chunk = dataString;
  1083.       receivedSize = dataString.length;
  1084.     }
  1085.   } else if (dataType === this.DATA_TRANSFER_DATA_TYPE.ARRAY_BUFFER) {
  1086.     chunk = new Blob(dataString);
  1087.   } else if (dataType === this.DATA_TRANSFER_DATA_TYPE.BLOB) {
  1088.     chunk = dataString;
  1089.   } else {
  1090.     error = 'Unhandled data exception: ' + dataType;
  1091.     log.error([peerId, 'RTCDataChannel', channelName, 'Failed downloading data packets:'], {
  1092.       dataType: dataType,
  1093.       data: dataString,
  1094.       type: 'DATA',
  1095.       error: error
  1096.     });
  1097.     this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.ERROR,
  1098.       transferId, peerId, {
  1099.         name: transferStatus.name,
  1100.         size: transferStatus.size,
  1101.         percentage: transferStatus.percentage,
  1102.         data: null,
  1103.         dataType: dataTransferType,
  1104.         senderPeerId: transferStatus.senderPeerId,
  1105.         timeout: transferStatus.timeout,
  1106.         isPrivate: transferStatus.isPrivate
  1107.       }, {
  1108.         message: error,
  1109.         transferType: this.DATA_TRANSFER_TYPE.DOWNLOAD
  1110.     });
  1111.     return;
  1112.   }
  1113.  
  1114.   log.log([peerId, 'RTCDataChannel', channelName,
  1115.     'Received and expected data chunk size (' + receivedSize + ' === ' +
  1116.       transferStatus.chunkSize + ')'], {
  1117.         dataType: dataType,
  1118.         data: dataString,
  1119.         receivedSize: receivedSize,
  1120.         expectedSize: transferStatus.chunkSize,
  1121.         type: 'DATA'
  1122.   });
  1123.  
  1124.   if (transferStatus.chunkSize >= receivedSize) {
  1125.     this._downloadDataTransfers[channelName].push(chunk);
  1126.     transferStatus.ackN += 1;
  1127.     transferStatus.receivedSize += receivedSize;
  1128.     var totalReceivedSize = transferStatus.receivedSize;
  1129.     var percentage = parseFloat(((totalReceivedSize / transferStatus.size) * 100).toFixed(2), 10);
  1130.  
  1131.     this._sendDataChannelMessage(peerId, {
  1132.       type: this._DC_PROTOCOL_TYPE.ACK,
  1133.       sender: this._user.sid,
  1134.       ackN: transferStatus.ackN
  1135.     }, channelName);
  1136.  
  1137.     // update the percentage
  1138.     this._downloadDataSessions[channelName].percentage = percentage;
  1139.  
  1140.     if (transferStatus.chunkSize === receivedSize && percentage < 100) {
  1141.       log.log([peerId, 'RTCDataChannel', channelName,
  1142.         'Transfer in progress ACK n (' + transferStatus.ackN + ')'], {
  1143.           dataType: dataType,
  1144.           data: dataString,
  1145.           ackN: transferStatus.ackN,
  1146.           type: 'DATA'
  1147.       });
  1148.       this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.DOWNLOADING,
  1149.         transferId, peerId, {
  1150.           name: transferStatus.name,
  1151.           size: transferStatus.size,
  1152.           percentage: percentage,
  1153.           data: null,
  1154.           dataType: dataTransferType,
  1155.           senderPeerId: transferStatus.senderPeerId,
  1156.           timeout: transferStatus.timeout,
  1157.           isPrivate: transferStatus.isPrivate
  1158.       });
  1159.       this._setDataChannelTimeout(peerId, transferStatus.timeout, false, channelName);
  1160.  
  1161.       if (!this._downloadDataSessions[channelName]) {
  1162.         log.error([peerId, 'RTCDataChannel', channelName,
  1163.           'Failed downloading as data session is empty'], {
  1164.             dataType: dataType,
  1165.             data: dataString,
  1166.             type: 'DATA'
  1167.         });
  1168.         return;
  1169.       }
  1170.  
  1171.       this._downloadDataSessions[channelName].info = transferStatus;
  1172.  
  1173.     } else {
  1174.       log.log([peerId, 'RTCDataChannel', channelName,
  1175.         'Download complete'], {
  1176.           dataType: dataType,
  1177.           data: dataString,
  1178.           type: 'DATA',
  1179.           transferInfo: transferStatus
  1180.       });
  1181.  
  1182.       var blob = null;
  1183.  
  1184.       if (dataTransferType === 'blob') {
  1185.         blob = new Blob(this._downloadDataTransfers[channelName]);
  1186.       } else {
  1187.         blob = this._assembleDataURL(this._downloadDataTransfers[channelName]);
  1188.       }
  1189.       this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.DOWNLOAD_COMPLETED,
  1190.         transferId, peerId, {
  1191.           name: transferStatus.name,
  1192.           size: transferStatus.size,
  1193.           percentage: 100,
  1194.           data: blob,
  1195.           dataType: dataTransferType,
  1196.           senderPeerId: transferStatus.senderPeerId,
  1197.           timeout: transferStatus.timeout,
  1198.           isPrivate: transferStatus.isPrivate
  1199.       });
  1200.  
  1201.       this._trigger('incomingData', blob, transferId, peerId, {
  1202.         name: transferStatus.name,
  1203.         size: transferStatus.size,
  1204.         percentage: 100,
  1205.         dataType: dataTransferType,
  1206.         senderPeerId: transferStatus.senderPeerId,
  1207.         timeout: transferStatus.timeout,
  1208.         isPrivate: transferStatus.isPrivate
  1209.       }, false);
  1210.  
  1211.       delete this._downloadDataTransfers[channelName];
  1212.       delete this._downloadDataSessions[channelName];
  1213.  
  1214.       log.log([peerId, 'RTCDataChannel', channelName,
  1215.         'Converted to Blob as download'], {
  1216.           dataType: dataType,
  1217.           data: dataString,
  1218.           type: 'DATA',
  1219.           transferInfo: transferStatus
  1220.       });
  1221.  
  1222.       // close datachannel after transfer
  1223.       if (this._dataChannels[peerId] && this._dataChannels[peerId][channelName]) {
  1224.         log.debug([peerId, 'RTCDataChannel', channelName, 'Closing datachannel for download transfer']);
  1225.         this._closeDataChannel(peerId, channelName);
  1226.       }
  1227.     }
  1228.  
  1229.   } else {
  1230.     error = 'Packet not match - [Received]' + receivedSize +
  1231.       ' / [Expected]' + transferStatus.chunkSize;
  1232.  
  1233.     this._trigger('dataTransferState',
  1234.       this.DATA_TRANSFER_STATE.ERROR, transferId, peerId, {
  1235.         name: transferStatus.name,
  1236.         size: transferStatus.size,
  1237.         percentage: transferStatus.percentage,
  1238.         data: null,
  1239.         dataType: dataTransferType,
  1240.         senderPeerId: transferStatus.senderPeerId,
  1241.         timeout: transferStatus.timeout,
  1242.         isPrivate: transferStatus.isPrivate
  1243.       }, {
  1244.         message: error,
  1245.         transferType: this.DATA_TRANSFER_TYPE.DOWNLOAD
  1246.     });
  1247.  
  1248.     log.error([peerId, 'RTCDataChannel', channelName,
  1249.       'Failed downloading data packets:'], {
  1250.         dataType: dataType,
  1251.         data: dataString,
  1252.         type: 'DATA',
  1253.         transferInfo: transferStatus,
  1254.         error: error
  1255.     });
  1256.   }
  1257. };
  1258.  
  1259. /**
  1260.  * Starts a [Blob](https://developer.mozilla.org/en/docs/Web/API/Blob) data transfer
  1261.  *   with Peers using the DataChannel connection.
  1262.  * You can transfer files using the <code>input</code> [fileupload object](
  1263.  *   http://www.w3schools.com/jsref/dom_obj_fileupload.asp) and accessing the receiving
  1264.  *   files using [FileUpload files property](http://www.w3schools.com/jsref/prop_fileupload_files.asp).
  1265.  * The [File](https://developer.mozilla.org/en/docs/Web/API/File) object inherits from
  1266.  *   the Blob interface which is passable in this method as a Blob object.
  1267.  * The receiving Peer have the option to accept or reject the data transfer.
  1268.  * @method sendBlobData
  1269.  * @param {Blob} data The Blob data object to transfer to Peer.
  1270.  * @param {Number} [timeout=60] The waiting timeout in seconds that the DataChannel connection
  1271.  *   data transfer should wait before throwing an exception and terminating the data transfer.
  1272.  * @param {String|Array} [targetPeerId] The array of targeted Peers to transfer the
  1273.  *   data object to. Alternatively, you may provide this parameter as a string to a specific
  1274.  *   targeted Peer to transfer the data object.
  1275.  * @param {Function} [callback] The callback fired after all the data transfers is completed
  1276.  *   successfully or met with an exception. The callback signature is <code>function (error, success)</code>.
  1277.  * @param {JSON} callback.error The error object received in the callback.
  1278.  *   If received as <code>null</code>, it means that there is no errors.
  1279.  * @param {String} [callback.error.state=null] <i>Deprecated</i>. The
  1280.  *   <a href="#event_dataTransferState">dataTransferState</a>
  1281.  *   when the error has occurred. This only triggers for a single targeted Peer data transfer.
  1282.  * @param {Object|String} [callback.error.error=null] <i>Deprecated</i>. The error received when the
  1283.  *   data transfer fails. This only triggers for single targeted Peer data transfer.
  1284.  * @param {String} callback.error.transferId The transfer ID of the failed data transfer.
  1285.  * @param {String} [callback.error.peerId=null] The single targeted Peer ID for the data transfer.
  1286.  *   This only triggers for single targeted Peer data transfer.
  1287.  * @param {Array} callback.error.listOfPeers The list of Peer that the data transfer has been
  1288.  *   initiated with.
  1289.  * @param {Boolean} callback.error.isPrivate The flag to indicate if the data transfer is a private
  1290.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1291.  * @param {JSON} callback.error.transferErrors The list of errors occurred based on per Peer
  1292.  *   basis.
  1293.  * @param {Object|String} callback.error.transferErrors.(#peerId) The error that occurred when having
  1294.  *   a DataChannel connection data transfer with associated Peer.
  1295.  * @param {JSON} callback.error.transferInfo The transfer data object information.
  1296.  * @param {String} [callback.error.transferInfo.name=transferId] The transfer data object name.
  1297.  *   If there is no name based on the Blob given, the name would be the transfer ID.
  1298.  * @param {Number} callback.error.transferInfo.size The transfer data size.
  1299.  * @param {String} callback.error.transferInfo.transferId The data transfer ID.
  1300.  * @param {String} callback.error.transferInfo.dataType The type of data transfer initiated.
  1301.  *   Available types are <code>"dataURL"</code> and <code>"blob"</code>.
  1302.  * @param {String} callback.error.transferInfo.timeout The waiting timeout in seconds that the DataChannel
  1303.  *   connection data transfer should wait before throwing an exception and terminating the data transfer.
  1304.  * @param {Boolean} callback.error.transferInfo.isPrivate The flag to indicate if the data transfer is a private
  1305.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1306.  * @param {JSON} callback.success The success object received in the callback.
  1307.  *   If received as <code>null</code>, it means that there are errors.
  1308.  * @param {String} [callback.success.state=null] <i>Deprecated</i>. The
  1309.  *   <a href="#event_dataTransferState">dataTransferState</a>
  1310.  *   when the data transfer has been completed successfully.
  1311.  *   This only triggers for a single targeted Peer data transfer.
  1312.  * @param {String} callback.success.transferId The transfer ID of the successful data transfer.
  1313.  * @param {String} [callback.success.peerId=null] The single targeted Peer ID for the data transfer.
  1314.  *   This only triggers for single targeted Peer data transfer.
  1315.  * @param {Array} callback.success.listOfPeers The list of Peer that the data transfer has been
  1316.  *   initiated with.
  1317.  * @param {Boolean} callback.success.isPrivate The flag to indicate if the data transfer is a private
  1318.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1319.  * @param {JSON} callback.success.transferInfo The transfer data object information.
  1320.  * @param {String} [callback.success.transferInfo.name=transferId] The transfer data object name.
  1321.  *   If there is no name based on the Blob given, the name would be the transfer ID.
  1322.  * @param {Number} callback.success.transferInfo.size The transfer data size.
  1323.  * @param {String} callback.success.transferInfo.transferId The data transfer ID.
  1324.  * @param {String} callback.success.transferInfo.dataType The type of data transfer initiated.
  1325.  *   Available types are <code>"dataURL"</code> and <code>"blob"</code>.
  1326.  * @param {String} callback.success.transferInfo.timeout The waiting timeout in seconds that the DataChannel
  1327.  *   connection data transfer should wait before throwing an exception and terminating the data transfer.
  1328.  * @param {Boolean} callback.success.transferInfo.isPrivate The flag to indicate if the data transfer is a private
  1329.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1330.  * @example
  1331.  *   // Example 1: Send file to all peers connected
  1332.  *   SkylinkDemo.sendBlobData(file, 67);
  1333.  *
  1334.  *   // Example 2: Send file to individual peer
  1335.  *   SkylinkDemo.sendBlobData(blob, 87, targetPeerId);
  1336.  *
  1337.  *   // Example 3: Send file with callback
  1338.  *   SkylinkDemo.sendBlobData(data,{
  1339.  *      name: data.name,
  1340.  *      size: data.size
  1341.  *    },function(error, success){
  1342.  *     if (error){
  1343.  *       console.error("Error happened. Could not send file", error);
  1344.  *     }
  1345.  *     else{
  1346.  *       console.info("Successfully uploaded file");
  1347.  *     }
  1348.  *   });
  1349.  *
  1350.  * @trigger incomingData, incomingDataRequest, dataTransferState, dataChannelState
  1351.  * @since 0.5.5
  1352.  * @component DataTransfer
  1353.  * @for Skylink
  1354.  */
  1355. Skylink.prototype.sendBlobData = function(data, timeout, targetPeerId, callback) {
  1356.   var listOfPeers = Object.keys(this._peerConnections);
  1357.   var isPrivate = false;
  1358.   var dataInfo = {};
  1359.   var transferId = this._user.sid + this.DATA_TRANSFER_TYPE.UPLOAD +
  1360.     (((new Date()).toISOString().replace(/-/g, '').replace(/:/g, ''))).replace('.', '');
  1361.   // for error case
  1362.   var errorMsg, errorPayload, i, peerId; // for jshint
  1363.   var singleError = null;
  1364.   var transferErrors = {};
  1365.   var stateError = null;
  1366.   var singlePeerId = null;
  1367.  
  1368.   //Shift parameters
  1369.   // timeout
  1370.   if (typeof timeout === 'function') {
  1371.     callback = timeout;
  1372.  
  1373.   } else if (typeof timeout === 'string') {
  1374.     listOfPeers = [timeout];
  1375.     isPrivate = true;
  1376.  
  1377.   } else if (Array.isArray(timeout)) {
  1378.     listOfPeers = timeout;
  1379.     isPrivate = true;
  1380.   }
  1381.  
  1382.   // targetPeerId
  1383.   if (typeof targetPeerId === 'function'){
  1384.     callback = targetPeerId;
  1385.  
  1386.   // data, timeout, target [array], callback
  1387.   } else if(Array.isArray(targetPeerId)) {
  1388.     listOfPeers = targetPeerId;
  1389.     isPrivate = true;
  1390.  
  1391.   // data, timeout, target [string], callback
  1392.   } else if (typeof targetPeerId === 'string') {
  1393.     listOfPeers = [targetPeerId];
  1394.     isPrivate = true;
  1395.   }
  1396.  
  1397.   //state: String, Deprecated. But for consistency purposes. Null if not a single peer
  1398.   //error: Object, Deprecated. But for consistency purposes. Null if not a single peer
  1399.   //transferId: String,
  1400.   //peerId: String, Deprecated. But for consistency purposes. Null if not a single peer
  1401.   //listOfPeers: Array, NEW!!
  1402.   //isPrivate: isPrivate, NEW!!
  1403.   //transferErrors: JSON, NEW!! - Array of errors
  1404.   //transferInfo: JSON The same payload as dataTransferState transferInfo payload
  1405.  
  1406.   // check if it's blob data
  1407.   if (!(typeof data === 'object' && data instanceof Blob)) {
  1408.     errorMsg = 'Provided data is not a Blob data';
  1409.  
  1410.     if (listOfPeers.length === 0) {
  1411.       transferErrors.self = errorMsg;
  1412.  
  1413.     } else {
  1414.       for (i = 0; i < listOfPeers.length; i++) {
  1415.         peerId = listOfPeers[i];
  1416.         transferErrors[peerId] = errorMsg;
  1417.       }
  1418.  
  1419.       // Deprecated but for consistency purposes. Null if not a single peer.
  1420.       if (listOfPeers.length === 1 && isPrivate) {
  1421.         stateError = self.DATA_TRANSFER_STATE.ERROR;
  1422.         singleError = errorMsg;
  1423.         singlePeerId = listOfPeers[0];
  1424.       }
  1425.     }
  1426.  
  1427.     errorPayload = {
  1428.       state: stateError,
  1429.       error: singleError,
  1430.       transferId: transferId,
  1431.       peerId: singlePeerId,
  1432.       listOfPeers: listOfPeers,
  1433.       transferErrors: transferErrors,
  1434.       transferInfo: dataInfo,
  1435.       isPrivate: isPrivate
  1436.     };
  1437.  
  1438.     log.error(errorMsg, errorPayload);
  1439.  
  1440.     if (typeof callback === 'function'){
  1441.       log.log([null, 'RTCDataChannel', null, 'Error occurred. Firing callback ' +
  1442.         'with error -> '],errorPayload);
  1443.       callback(errorPayload, null);
  1444.     }
  1445.     return;
  1446.   }
  1447.  
  1448.   // populate data
  1449.   dataInfo.name = data.name || transferId;
  1450.   dataInfo.size = data.size;
  1451.   dataInfo.timeout = typeof timeout === 'number' ? timeout : 60;
  1452.   dataInfo.transferId = transferId;
  1453.   dataInfo.dataType = 'blob';
  1454.   dataInfo.isPrivate = isPrivate;
  1455.  
  1456.   // check if datachannel is enabled first or not
  1457.   if (!this._enableDataChannel) {
  1458.     errorMsg = 'Unable to send any blob data. Datachannel is disabled';
  1459.  
  1460.     if (listOfPeers.length === 0) {
  1461.       transferErrors.self = errorMsg;
  1462.  
  1463.     } else {
  1464.       for (i = 0; i < listOfPeers.length; i++) {
  1465.         peerId = listOfPeers[i];
  1466.         transferErrors[peerId] = errorMsg;
  1467.       }
  1468.  
  1469.       // Deprecated but for consistency purposes. Null if not a single peer.
  1470.       if (listOfPeers.length === 1 && isPrivate) {
  1471.         stateError = self.DATA_TRANSFER_STATE.ERROR;
  1472.         singleError = errorMsg;
  1473.         singlePeerId = listOfPeers[0];
  1474.       }
  1475.     }
  1476.  
  1477.     errorPayload = {
  1478.       state: stateError,
  1479.       error: singleError,
  1480.       transferId: transferId,
  1481.       peerId: singlePeerId,
  1482.       listOfPeers: listOfPeers,
  1483.       transferErrors: transferErrors,
  1484.       transferInfo: dataInfo,
  1485.       isPrivate: isPrivate
  1486.     };
  1487.  
  1488.     log.error(errorMsg, errorPayload);
  1489.  
  1490.     if (typeof callback === 'function'){
  1491.       log.log([null, 'RTCDataChannel', null, 'Error occurred. Firing callback ' +
  1492.         'with error -> '], errorPayload);
  1493.       callback(errorPayload, null);
  1494.     }
  1495.     return;
  1496.   }
  1497.  
  1498.   this._startDataTransfer(data, dataInfo, listOfPeers, callback);
  1499. };
  1500.  
  1501.  
  1502. /**
  1503.  * Starts the actual data transfers with the array of Peers provided
  1504.  *   and based on the data transfer type to start the DataChannel connection data transfer.
  1505.  * @method _startDataTransfer
  1506.  * @param {Blob|String} data The transfer data object.
  1507.  * @param {JSON} dataInfo The transfer data object information.
  1508.  * @param {String} [dataInfo.name=transferId] The transfer data object name.
  1509.  *   If there is no name based on the Blob given, the name would be the transfer ID.
  1510.  * @param {Number} dataInfo.size The transfer data size.
  1511.  * @param {String} dataInfo.transferId The data transfer ID.
  1512.  * @param {String} dataInfo.dataType The type of data transfer initiated.
  1513.  *   Available types are <code>"dataURL"</code> and <code>"blob"</code>.
  1514.  * @param {String} dataInfo.timeout The waiting timeout in seconds that the DataChannel
  1515.  *   connection data transfer should wait before throwing an exception and terminating the data transfer.
  1516.  * @param {Boolean} dataInfo.isPrivate The flag to indicate if the data transfer is a private
  1517.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1518.  * @param {Array} [listOfPeers] The array of targeted Peer to transfer the
  1519.  *   data object to.
  1520.  * @param {Function} [callback] The callback fired after all the data transfers is completed
  1521.  *   successfully or met with an exception. The callback signature is <code>function (error, success)</code>.
  1522.  * @param {JSON} callback.error The error object received in the callback.
  1523.  *   If received as <code>null</code>, it means that there is no errors.
  1524.  * @param {String} [callback.error.state=null] <i>Deprecated</i>. The
  1525.  *   <a href="#event_dataTransferState">dataTransferState</a>
  1526.  *   when the error has occurred. This only triggers for a single targeted Peer data transfer.
  1527.  * @param {Object|String} [callback.error.error=null] <i>Deprecated</i>. The error received when the
  1528.  *   data transfer fails. This only triggers for single targeted Peer data transfer.
  1529.  * @param {String} callback.error.transferId The transfer ID of the failed data transfer.
  1530.  * @param {String} [callback.error.peerId=null] The single targeted Peer ID for the data transfer.
  1531.  *   This only triggers for single targeted Peer data transfer.
  1532.  * @param {Array} callback.error.listOfPeers The list of Peer that the data transfer has been
  1533.  *   initiated with.
  1534.  * @param {Boolean} callback.error.isPrivate The flag to indicate if the data transfer is a private
  1535.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1536.  * @param {JSON} callback.error.transferErrors The list of errors occurred based on per Peer
  1537.  *   basis.
  1538.  * @param {Object|String} callback.error.transferErrors.(#peerId) The error that occurred when having
  1539.  *   a DataChannel connection data transfer with associated Peer.
  1540.  * @param {JSON} callback.error.transferInfo The transfer data object information.
  1541.  * @param {String} [callback.error.transferInfo.name=transferId] The transfer data object name.
  1542.  *   If there is no name based on the Blob given, the name would be the transfer ID.
  1543.  * @param {Number} callback.error.transferInfo.size The transfer data size.
  1544.  * @param {String} callback.error.transferInfo.transferId The data transfer ID.
  1545.  * @param {String} callback.error.transferInfo.dataType The type of data transfer initiated.
  1546.  *   The received type would be <code>"blob"</code>.
  1547.  * @param {String} callback.error.transferInfo.timeout The waiting timeout in seconds that the DataChannel
  1548.  *   connection data transfer should wait before throwing an exception and terminating the data transfer.
  1549.  * @param {Boolean} callback.error.transferInfo.isPrivate The flag to indicate if the data transfer is a private
  1550.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1551.  * @param {JSON} callback.success The success object received in the callback.
  1552.  *   If received as <code>null</code>, it means that there are errors.
  1553.  * @param {String} [callback.success.state=null] <i>Deprecated</i>. The
  1554.  *   <a href="#event_dataTransferState">dataTransferState</a>
  1555.  *   when the data transfer has been completed successfully.
  1556.  *   This only triggers for a single targeted Peer data transfer.
  1557.  * @param {String} callback.success.transferId The transfer ID of the successful data transfer.
  1558.  * @param {String} [callback.success.peerId=null] The single targeted Peer ID for the data transfer.
  1559.  *   This only triggers for single targeted Peer data transfer.
  1560.  * @param {Array} callback.success.listOfPeers The list of Peer that the data transfer has been
  1561.  *   initiated with.
  1562.  * @param {Boolean} callback.success.isPrivate The flag to indicate if the data transfer is a private
  1563.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1564.  * @param {JSON} callback.success.transferInfo The transfer data object information.
  1565.  * @param {String} [callback.success.transferInfo.name=transferId] The transfer data object name.
  1566.  *   If there is no name based on the Blob given, the name would be the transfer ID.
  1567.  * @param {Number} callback.success.transferInfo.size The transfer data size.
  1568.  * @param {String} callback.success.transferInfo.transferId The data transfer ID.
  1569.  * @param {String} callback.success.transferInfo.dataType The type of data transfer initiated.
  1570.  *   The received type would be <code>"blob"</code>.
  1571.  * @param {String} callback.success.transferInfo.timeout The waiting timeout in seconds that the DataChannel
  1572.  *   connection data transfer should wait before throwing an exception and terminating the data transfer.
  1573.  * @param {Boolean} callback.success.transferInfo.isPrivate The flag to indicate if the data transfer is a private
  1574.  *   transfer to the Peer directly and not broadcasted to all Peers.
  1575.  * @private
  1576.  * @component DataTransfer
  1577.  * @for Skylink
  1578.  * @since 0.6.1
  1579.  */
  1580. Skylink.prototype._startDataTransfer = function(data, dataInfo, listOfPeers, callback) {
  1581.   var self = this;
  1582.   var error = '';
  1583.   var noOfPeersSent = 0;
  1584.   var transferId = dataInfo.transferId;
  1585.   var dataType = dataInfo.dataType;
  1586.   var isPrivate = dataInfo.isPrivate;
  1587.   var i;
  1588.   var peerId;
  1589.  
  1590.   // for callback
  1591.   var listOfPeersTransferState = {};
  1592.   var transferSuccess = true;
  1593.   var listOfPeersTransferErrors = {};
  1594.   var listOfPeersChannels = {};
  1595.   var successfulPeerTransfers = [];
  1596.  
  1597.   var triggerCallbackFn = function () {
  1598.     for (i = 0; i < listOfPeers.length; i++) {
  1599.       var transferPeerId = listOfPeers[i];
  1600.  
  1601.       if (!listOfPeersTransferState[transferPeerId]) {
  1602.         // if error, make as false and break
  1603.         transferSuccess = false;
  1604.         break;
  1605.       }
  1606.     }
  1607.  
  1608.     if (transferSuccess) {
  1609.       log.log([null, 'RTCDataChannel', transferId, 'Firing success callback for data transfer'], dataInfo);
  1610.       // should we even support this? maybe keeping to not break older impl
  1611.       if (listOfPeers.length === 1 && isPrivate) {
  1612.         callback(null,{
  1613.           state: self.DATA_TRANSFER_STATE.UPLOAD_COMPLETED,
  1614.           peerId: listOfPeers[0],
  1615.           listOfPeers: listOfPeers,
  1616.           transferId: transferId,
  1617.           isPrivate: isPrivate, // added new flag to indicate privacy
  1618.           transferInfo: dataInfo
  1619.         });
  1620.       } else {
  1621.         callback(null,{
  1622.           state: null,
  1623.           peerId: null,
  1624.           transferId: transferId,
  1625.           listOfPeers: listOfPeers,
  1626.           isPrivate: isPrivate, // added new flag to indicate privacy
  1627.           transferInfo: dataInfo
  1628.         });
  1629.       }
  1630.     } else {
  1631.       log.log([null, 'RTCDataChannel', transferId, 'Firing failure callback for data transfer'], dataInfo);
  1632.  
  1633.       // should we even support this? maybe keeping to not break older impl
  1634.       if (listOfPeers.length === 1 && isPrivate) {
  1635.         callback({
  1636.           state: self.DATA_TRANSFER_STATE.ERROR,
  1637.           error: listOfPeersTransferErrors[listOfPeers[0]],
  1638.           peerId: listOfPeers[0],
  1639.           transferId: transferId,
  1640.           transferErrors: listOfPeersTransferErrors,
  1641.           transferInfo: dataInfo,
  1642.           isPrivate: isPrivate, // added new flag to indicate privacy
  1643.           listOfPeers: listOfPeers
  1644.         }, null);
  1645.       } else {
  1646.         callback({
  1647.           state: null,
  1648.           peerId: null,
  1649.           error: null,
  1650.           transferId: transferId,
  1651.           listOfPeers: listOfPeers,
  1652.           isPrivate: isPrivate, // added new flag to indicate privacy
  1653.           transferInfo: dataInfo,
  1654.           transferErrors: listOfPeersTransferErrors
  1655.         }, null);
  1656.       }
  1657.     }
  1658.   };
  1659.  
  1660.   for (i = 0; i < listOfPeers.length; i++) {
  1661.     peerId = listOfPeers[i];
  1662.  
  1663.     if (peerId === 'MCU') {
  1664.       continue;
  1665.     }
  1666.  
  1667.     if (self._dataChannels[peerId] && self._dataChannels[peerId].main) {
  1668.       log.log([peerId, 'RTCDataChannel', null, 'Sending blob data ->'], dataInfo);
  1669.  
  1670.       self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.UPLOAD_STARTED,
  1671.         transferId, peerId, {
  1672.           name: dataInfo.name,
  1673.           size: dataInfo.size,
  1674.           percentage: 0,
  1675.           data: data,
  1676.           dataType: dataType,
  1677.           senderPeerId: self._user.sid,
  1678.           timeout: dataInfo.timeout,
  1679.           isPrivate: isPrivate
  1680.       });
  1681.  
  1682.       self._trigger('incomingDataRequest', transferId, peerId, {
  1683.         name: dataInfo.name,
  1684.         size: dataInfo.size,
  1685.         percentage: 0,
  1686.         dataType: dataType,
  1687.         senderPeerId: self._user.sid,
  1688.         timeout: dataInfo.timeout,
  1689.         isPrivate: isPrivate
  1690.       }, true);
  1691.  
  1692.       //if (!self._hasMCU) {
  1693.         listOfPeersChannels[peerId] =
  1694.           self._sendBlobDataToPeer(data, dataInfo, peerId);
  1695.       /*} else {
  1696.         listOfPeersChannels[peerId] = self._dataChannels[peerId].main.label;
  1697.       }*/
  1698.  
  1699.       noOfPeersSent++;
  1700.  
  1701.     } else {
  1702.       error = 'Datachannel does not exist. Unable to start data transfer with peer';
  1703.       log.error([peerId, 'RTCDataChannel', null, error]);
  1704.       listOfPeersTransferErrors[peerId] = error;
  1705.     }
  1706.   }
  1707.  
  1708.   // if has MCU
  1709.   /*if (self._hasMCU) {
  1710.     self._sendBlobDataToPeer(data, dataInfo, listOfPeers, isPrivate, transferId);
  1711.   }*/
  1712.  
  1713.   if (noOfPeersSent === 0) {
  1714.     error = 'Failed sending data as there is no available datachannels to send data';
  1715.  
  1716.     for (i = 0; i < listOfPeers.length; i++) {
  1717.       peerId = listOfPeers[i];
  1718.  
  1719.       self._trigger('dataTransferState', self.DATA_TRANSFER_STATE.ERROR,
  1720.         transferId, peerId, {
  1721.           name: dataInfo.name,
  1722.           size: dataInfo.size,
  1723.           data: null,
  1724.           dataType: dataType,
  1725.           percentage: 0,
  1726.           senderPeerId: self._user.sid,
  1727.           timeout: dataInfo.timeout,
  1728.           isPrivate: isPrivate
  1729.         }, {
  1730.           message: error,
  1731.           transferType: self.DATA_TRANSFER_TYPE.UPLOAD
  1732.       });
  1733.  
  1734.       listOfPeersTransferErrors[peerId] = error;
  1735.     }
  1736.  
  1737.     log.error([null, 'RTCDataChannel', null, error]);
  1738.     self._uploadDataTransfers = [];
  1739.     self._uploadDataSessions = [];
  1740.  
  1741.     transferSuccess = false;
  1742.  
  1743.     if (typeof callback === 'function') {
  1744.       triggerCallbackFn();
  1745.     }
  1746.     return;
  1747.   }
  1748.  
  1749.   if (typeof callback === 'function') {
  1750.     var dataChannelStateFn = function(state, transferringPeerId, errorObj, channelName, channelType){
  1751.       // check if error or closed halfway, if so abort
  1752.       if (state === self.DATA_CHANNEL_STATE.ERROR &&
  1753.         state === self.DATA_CHANNEL_STATE.CLOSED &&
  1754.         listOfPeersChannels[peerId] === channelName) {
  1755.         // if peer has already been inside, ignore
  1756.         if (successfulPeerTransfers.indexOf(transferringPeerId) === -1) {
  1757.           listOfPeersTransferState[transferringPeerId] = false;
  1758.           listOfPeersTransferErrors[transferringPeerId] = errorObj;
  1759.  
  1760.           log.error([transferringPeerId, 'RTCDataChannel', null,
  1761.             'Data channel state has met a failure state for peer (datachannel) ->'], {
  1762.               state: state,
  1763.               error: errorObj
  1764.           });
  1765.         }
  1766.       }
  1767.  
  1768.       if (Object.keys(listOfPeersTransferState).length === listOfPeers.length) {
  1769.         self.off('dataTransferState', dataTransferStateFn);
  1770.         self.off('dataChannelState', dataChannelStateFn);
  1771.  
  1772.         log.log([null, 'RTCDataChannel', transferId,
  1773.           'Transfer states have been gathered completely in dataChannelState'], state);
  1774.  
  1775.         triggerCallbackFn();
  1776.       }
  1777.     };
  1778.  
  1779.     var dataTransferStateFn = function(state, stateTransferId, transferringPeerId, transferInfo, errorObj){
  1780.       // check if transfer is related to this transfer
  1781.       if (stateTransferId === transferId) {
  1782.         // check if state upload has completed
  1783.         if (state === self.DATA_TRANSFER_STATE.UPLOAD_COMPLETED) {
  1784.  
  1785.           log.debug([transferringPeerId, 'RTCDataChannel', stateTransferId,
  1786.             'Data transfer state has met a success state for peer ->'], state);
  1787.  
  1788.           // if peer has already been inside, ignore
  1789.           if (successfulPeerTransfers.indexOf(transferringPeerId) === -1) {
  1790.             listOfPeersTransferState[transferringPeerId] = true;
  1791.           }
  1792.         } else if(state === self.DATA_TRANSFER_STATE.REJECTED ||
  1793.           state === self.DATA_TRANSFER_STATE.CANCEL ||
  1794.           state === self.DATA_TRANSFER_STATE.ERROR) {
  1795.  
  1796.           if (state === self.DATA_TRANSFER_STATE.REJECTED) {
  1797.             errorObj = new Error('Peer has rejected data transfer request');
  1798.           }
  1799.  
  1800.           log.error([transferringPeerId, 'RTCDataChannel', stateTransferId,
  1801.             'Data transfer state has met a failure state for peer ->'], {
  1802.               state: state,
  1803.               error: errorObj
  1804.           });
  1805.  
  1806.           // if peer has already been inside, ignore
  1807.           if (successfulPeerTransfers.indexOf(transferringPeerId) === -1) {
  1808.             listOfPeersTransferState[transferringPeerId] = false;
  1809.             listOfPeersTransferErrors[transferringPeerId] = errorObj;
  1810.           }
  1811.         }
  1812.       }
  1813.  
  1814.       if (Object.keys(listOfPeersTransferState).length === listOfPeers.length) {
  1815.         self.off('dataTransferState', dataTransferStateFn);
  1816.         self.off('dataChannelState', dataChannelStateFn);
  1817.  
  1818.         log.log([null, 'RTCDataChannel', stateTransferId,
  1819.           'Transfer states have been gathered completely in dataTransferState'], state);
  1820.  
  1821.         triggerCallbackFn();
  1822.       }
  1823.     };
  1824.     self.on('dataTransferState', dataTransferStateFn);
  1825.     self.on('dataChannelState', dataChannelStateFn);
  1826.   }
  1827. };
  1828.  
  1829.  
  1830. /**
  1831.  * Responds to a data transfer request by rejecting or accepting
  1832.  *   the data transfer request initiated by a Peer.
  1833.  * @method respondBlobRequest
  1834.  * @param {String} peerId The sender Peer ID.
  1835.  * @param {String} transferId The data transfer ID of the data transfer request
  1836.  *   to accept or reject.
  1837.  * @param {Boolean} [accept=false] The flag that indicates <code>true</code> as a response
  1838.  *   to accept the data transfer and <code>false</code> as a response to reject the
  1839.  *   data transfer request.
  1840.  * @trigger incomingData, dataTransferState
  1841.  * @component DataTransfer
  1842.  * @deprecated Use .acceptDataTransfer()
  1843.  * @for Skylink
  1844.  * @since 0.5.0
  1845.  */
  1846. Skylink.prototype.respondBlobRequest =
  1847. /**
  1848.  * Responds to a data transfer request by rejecting or accepting
  1849.  *   the data transfer request initiated by a Peer.
  1850.  * @method acceptDataTransfer
  1851.  * @param {String} peerId The sender Peer ID.
  1852.  * @param {String} transferId The data transfer ID of the data transfer request
  1853.  *   to accept or reject.
  1854.  * @param {Boolean} [accept=false] The flag that indicates <code>true</code> as a response
  1855.  *   to accept the data transfer and <code>false</code> as a response to reject the
  1856.  *   data transfer request.
  1857.  * @trigger incomingData, dataTransferState
  1858.  * @component DataTransfer
  1859.  * @for Skylink
  1860.  * @since 0.6.1
  1861.  */
  1862. Skylink.prototype.acceptDataTransfer = function (peerId, transferId, accept) {
  1863.  
  1864.   if (typeof transferId !== 'string' && typeof peerId !== 'string') {
  1865.     log.error([peerId, 'RTCDataChannel', null, 'Aborting accept data transfer as ' +
  1866.       'transfer ID and peer ID is not provided'], {
  1867.         accept: accept,
  1868.         peerId: peerId,
  1869.         transferId: transferId
  1870.     });
  1871.     return;
  1872.   }
  1873.  
  1874.   if (transferId.indexOf(this._TRANSFER_DELIMITER) === -1) {
  1875.     log.error([peerId, 'RTCDataChannel', null, 'Aborting accept data transfer as ' +
  1876.       'invalid transfer ID is provided'], {
  1877.         accept: accept,
  1878.         transferId: transferId
  1879.     });
  1880.     return;
  1881.   }
  1882.   var channelName = transferId.split(this._TRANSFER_DELIMITER)[0];
  1883.  
  1884.   if (accept) {
  1885.  
  1886.     log.info([peerId, 'RTCDataChannel', channelName, 'User accepted peer\'s request'], {
  1887.       accept: accept,
  1888.       transferId: transferId
  1889.     });
  1890.  
  1891.     if (!this._peerInformations[peerId] && !this._peerInformations[peerId].agent) {
  1892.       log.error([peerId, 'RTCDataChannel', channelName, 'Aborting accept data transfer as ' +
  1893.         'Peer informations for peer is missing'], {
  1894.           accept: accept,
  1895.           transferId: transferId
  1896.       });
  1897.       return;
  1898.     }
  1899.  
  1900.     this._downloadDataTransfers[channelName] = [];
  1901.  
  1902.     var data = this._downloadDataSessions[channelName];
  1903.     this._sendDataChannelMessage(peerId, {
  1904.       type: this._DC_PROTOCOL_TYPE.ACK,
  1905.       sender: this._user.sid,
  1906.       ackN: 0,
  1907.       agent: window.webrtcDetectedBrowser
  1908.     }, channelName);
  1909.     this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.DOWNLOAD_STARTED,
  1910.       data.transferId, peerId, {
  1911.         name: data.name,
  1912.         size: data.size,
  1913.         data: null,
  1914.         dataType: data.dataType,
  1915.         percentage: 0,
  1916.         senderPeerId: peerId,
  1917.         timeout: data.timeout,
  1918.         isPrivate: data.isPrivate
  1919.     });
  1920.   } else {
  1921.     log.info([peerId, 'RTCDataChannel', channelName, 'User rejected peer\'s request'], {
  1922.       accept: accept,
  1923.       transferId: transferId
  1924.     });
  1925.     this._sendDataChannelMessage(peerId, {
  1926.       type: this._DC_PROTOCOL_TYPE.ACK,
  1927.       sender: this._user.sid,
  1928.       ackN: -1
  1929.     }, channelName);
  1930.     delete this._downloadDataSessions[channelName];
  1931.     delete this._downloadDataTransfers[channelName];
  1932.   }
  1933. };
  1934.  
  1935. /**
  1936.  * Terminates an ongoing DataChannel connection data transfer.
  1937.  * @method cancelBlobTransfer
  1938.  * @param {String} peerId The Peer ID associated with the data transfer.
  1939.  * @param {String} transferId The data transfer ID of the data transfer request
  1940.  *   to terminate the request.
  1941.  * @trigger dataTransferState
  1942.  * @component DataTransfer
  1943.  * @deprecated Use .cancelDataTransfer()
  1944.  * @for Skylink
  1945.  * @since 0.5.7
  1946.  */
  1947. Skylink.prototype.cancelBlobTransfer =
  1948. /**
  1949.  * Terminates an ongoing DataChannel connection data transfer.
  1950.  * @method cancelDataTransfer
  1951.  * @param {String} peerId The Peer ID associated with the data transfer.
  1952.  * @param {String} transferId The data transfer ID of the data transfer request
  1953.  *   to terminate the request.
  1954.  * @trigger dataTransferState
  1955.  * @component DataTransfer
  1956.  * @for Skylink
  1957.  * @since 0.6.1
  1958.  */
  1959. Skylink.prototype.cancelDataTransfer = function (peerId, transferId) {
  1960.   var data;
  1961.  
  1962.   // targetPeerId + '-' + transferId
  1963.   var channelName = peerId + '-' + transferId;
  1964.  
  1965.   if (transferId.indexOf(this._TRANSFER_DELIMITER) > 0) {
  1966.     channelName = transferId.split(this._TRANSFER_DELIMITER)[0];
  1967.   } else {
  1968.  
  1969.     var peerAgent = (this._peerInformations[peerId] || {}).agent;
  1970.  
  1971.     if (!peerAgent && !peerAgent.name) {
  1972.       log.error([peerId, 'RTCDataChannel', null, 'Cancel transfer to peer ' +
  1973.         'failed as peer agent information for peer does not exists'], transferId);
  1974.       return;
  1975.     }
  1976.  
  1977.     if (self._INTEROP_MULTI_TRANSFERS.indexOf(peerAgent.name) > -1) {
  1978.       channelName = peerId;
  1979.     }
  1980.   }
  1981.  
  1982.   if (this._uploadDataSessions[channelName]) {
  1983.     data = this._uploadDataSessions[channelName];
  1984.  
  1985.     delete this._uploadDataSessions[channelName];
  1986.     delete this._uploadDataTransfers[channelName];
  1987.  
  1988.     // send message
  1989.     this._sendDataChannelMessage(peerId, {
  1990.       type: this._DC_PROTOCOL_TYPE.CANCEL,
  1991.       sender: this._user.sid,
  1992.       name: data.name,
  1993.       content: 'Peer cancelled upload transfer'
  1994.     }, channelName);
  1995.  
  1996.     log.debug([peerId, 'RTCDataChannel', channelName,
  1997.       'Cancelling upload data transfers'], transferId);
  1998.  
  1999.   } else if (this._downloadDataSessions[channelName]) {
  2000.     data = this._downloadDataSessions[channelName];
  2001.  
  2002.     delete this._downloadDataSessions[channelName];
  2003.     delete this._downloadDataTransfers[channelName];
  2004.  
  2005.     // send message
  2006.     this._sendDataChannelMessage(peerId, {
  2007.       type: this._DC_PROTOCOL_TYPE.CANCEL,
  2008.       sender: this._user.sid,
  2009.       name: data.name,
  2010.       content: 'Peer cancelled download transfer'
  2011.     }, channelName);
  2012.  
  2013.     log.debug([peerId, 'RTCDataChannel', channelName,
  2014.       'Cancelling download data transfers'], transferId);
  2015.  
  2016.   } else {
  2017.     log.error([peerId, 'RTCDataChannel', null, 'Cancel transfer to peer ' +
  2018.       'failed as transfer session with peer does not exists'], transferId);
  2019.     return;
  2020.   }
  2021.  
  2022.   this._trigger('dataTransferState', this.DATA_TRANSFER_STATE.CANCEL,
  2023.     data.transferId, peerId, {
  2024.       name: data.name,
  2025.       size: data.size,
  2026.       percentage: data.percentage,
  2027.       data: null,
  2028.       dataType: data.dataType,
  2029.       senderPeerId: data.senderPeerId,
  2030.       timeout: data.timeout,
  2031.       isPrivate: data.isPrivate
  2032.   });
  2033. };
  2034.  
  2035. /**
  2036.  * Send a message object or string using the DataChannel connection
  2037.  *   associated with the list of targeted Peers.
  2038.  * The maximum size for the message object would be<code>16Kb</code>.<br>
  2039.  * To send a string length longer than <code>16kb</code>, please considered
  2040.  *   to use {{#crossLink "Skylink/sendURLData:method"}}sendURLData(){{/crossLink}}
  2041.  *   to send longer strings (for that instance base64 binary strings are long).
  2042.  * To send message objects with platform signaling socket connection, see
  2043.  *   {{#crossLink "Skylink/sendMessage:method"}}sendMessage(){{/crossLink}}.
  2044.  * @method sendP2PMessage
  2045.  * @param {String|JSON} message The message object.
  2046.  * @param {String|Array} [targetPeerId] The array of targeted Peers to
  2047.  *   transfer the message object to. Alternatively, you may provide this parameter
  2048.  *   as a string to a specific targeted Peer to transfer the message object.
  2049.  * @example
  2050.  *   // Example 1: Send to all peers
  2051.  *   SkylinkDemo.sendP2PMessage("Hi there! This is from a DataChannel connection!"");
  2052.  *
  2053.  *   // Example 2: Send to specific peer
  2054.  *   SkylinkDemo.sendP2PMessage("Hi there peer! This is from a DataChannel connection!", targetPeerId);
  2055.  * @trigger incomingMessage
  2056.  * @since 0.5.5
  2057.  * @component DataTransfer
  2058.  * @for Skylink
  2059.  */
  2060. Skylink.prototype.sendP2PMessage = function(message, targetPeerId) {
  2061.   var self = this;
  2062.  
  2063.   // check if datachannel is enabled first or not
  2064.   if (!self._enableDataChannel) {
  2065.     log.warn('Unable to send any P2P message. Datachannel is disabled');
  2066.     return;
  2067.   }
  2068.  
  2069.   var listOfPeers = Object.keys(self._dataChannels);
  2070.   var isPrivate = false;
  2071.  
  2072.   //targetPeerId is defined -> private message
  2073.   if (Array.isArray(targetPeerId)) {
  2074.     listOfPeers = targetPeerId;
  2075.     isPrivate = true;
  2076.  
  2077.   } else if (typeof targetPeerId === 'string') {
  2078.     listOfPeers = [targetPeerId];
  2079.     isPrivate = true;
  2080.   }
  2081.  
  2082.   // sending public message to MCU to relay. MCU case only
  2083.   if (self._hasMCU && !isPrivate) {
  2084.     log.log(['MCU', null, null, 'Relaying P2P message to peers']);
  2085.  
  2086.     self._sendDataChannelMessage('MCU', {
  2087.       type: self._DC_PROTOCOL_TYPE.MESSAGE,
  2088.       isPrivate: isPrivate,
  2089.       sender: self._user.sid,
  2090.       target: 'MCU',
  2091.       data: message
  2092.     });
  2093.   }
  2094.  
  2095.   for (var i = 0; i < listOfPeers.length; i++) {
  2096.     var peerId = listOfPeers[i];
  2097.     var useChannel = (self._hasMCU) ? 'MCU' : peerId;
  2098.  
  2099.     // Ignore MCU peer
  2100.     if (peerId === 'MCU') {
  2101.       continue;
  2102.     }
  2103.  
  2104.     if (isPrivate || !self._hasMCU) {
  2105.       if (self._hasMCU) {
  2106.         log.log([peerId, null, useChannel, 'Sending private P2P message to peer']);
  2107.       } else {
  2108.         log.log([peerId, null, useChannel, 'Sending P2P message to peer']);
  2109.       }
  2110.  
  2111.       self._sendDataChannelMessage(useChannel, {
  2112.         type: self._DC_PROTOCOL_TYPE.MESSAGE,
  2113.         isPrivate: isPrivate,
  2114.         sender: self._user.sid,
  2115.         target: peerId,
  2116.         data: message
  2117.       });
  2118.     }
  2119.   }
  2120.  
  2121.   self._trigger('incomingMessage', {
  2122.     content: message,
  2123.     isPrivate: isPrivate,
  2124.     targetPeerId: targetPeerId || null,
  2125.     isDataChannel: true,
  2126.     senderPeerId: self._user.sid
  2127.   }, self._user.sid, self.getPeerInfo(), true);
  2128. };
  2129.  
  2130. /**
  2131.  * Starts a [dataURL](https://developer.mozilla.org/en-US/docs/Web/API/FileReader
  2132.  *   /readAsDataURL) data transfer with Peers using the DataChannel connection.
  2133.  * The receiving Peers have the option to accept or reject the data transfer.
  2134.  * @method sendURLData
  2135.  * @param {String} data The dataURL (base64 binary string) string to transfer to Peers.
  2136.  * @param {Number} [timeout=60] The waiting timeout in seconds that the DataChannel connection
  2137.  *   data transfer should wait before throwing an exception and terminating the data transfer.
  2138.  * @param {String|Array} [targetPeerId] The array of targeted Peers to transfer the
  2139.  *   data object to. Alternatively, you may provide this parameter as a string to a specific
  2140.  *   targeted Peer to transfer the data object.
  2141.  * @param {Function} [callback] The callback fired after all the data transfers is completed
  2142.  *   successfully or met with an exception. The callback signature is <code>function (error, success)</code>.
  2143.  * @param {JSON} callback.error The error object received in the callback.
  2144.  *   If received as <code>null</code>, it means that there is no errors.
  2145.  * @param {String} [callback.error.state=null] <i>Deprecated</i>. The
  2146.  *   <a href="#event_dataTransferState">dataTransferState</a>
  2147.  *   when the error has occurred. This only triggers for a single targeted Peer data transfer.
  2148.  * @param {Object|String} [callback.error.error=null] <i>Deprecated</i>. The error received when the
  2149.  *   data transfer fails. This only triggers for single targeted Peer data transfer.
  2150.  * @param {String} callback.error.transferId The transfer ID of the failed data transfer.
  2151.  * @param {String} [callback.error.peerId=null] The single targeted Peer ID for the data transfer.
  2152.  *   This only triggers for single targeted Peer data transfer.
  2153.  * @param {Array} callback.error.listOfPeers The list of Peer that the data transfer has been
  2154.  *   initiated with.
  2155.  * @param {Boolean} callback.error.isPrivate The flag to indicate if the data transfer is a private
  2156.  *   transfer to the Peer directly and not broadcasted to all Peers.
  2157.  * @param {JSON} callback.error.transferErrors The list of errors occurred based on per Peer
  2158.  *   basis.
  2159.  * @param {Object|String} callback.error.transferErrors.(#peerId) The error that occurred when having
  2160.  *   a DataChannel connection data transfer with associated Peer.
  2161.  * @param {JSON} callback.error.transferInfo The transfer data object information.
  2162.  * @param {String} [callback.error.transferInfo.name=transferId] The data transfer ID.
  2163.  * @param {Number} callback.error.transferInfo.size The transfer data size.
  2164.  * @param {String} callback.error.transferInfo.transferId The data transfer ID.
  2165.  * @param {String} callback.error.transferInfo.dataType The type of data transfer initiated.
  2166.  *   The received type would be <code>"dataURL"</code>.
  2167.  * @param {String} callback.error.transferInfo.timeout The waiting timeout in seconds that the DataChannel
  2168.  *   connection data transfer should wait before throwing an exception and terminating the data transfer.
  2169.  * @param {Boolean} callback.error.transferInfo.isPrivate The flag to indicate if the data transfer is a private
  2170.  *   transfer to the Peer directly and not broadcasted to all Peers.
  2171.  * @param {JSON} callback.success The success object received in the callback.
  2172.  *   If received as <code>null</code>, it means that there are errors.
  2173.  * @param {String} [callback.success.state=null] <i>Deprecated</i>. The
  2174.  *   <a href="#method_dataTransferState">dataTransferState</a>
  2175.  *   when the data transfer has been completed successfully.
  2176.  *   This only triggers for a single targeted Peer data transfer.
  2177.  * @param {String} callback.success.transferId The transfer ID of the successful data transfer.
  2178.  * @param {String} [callback.success.peerId=null] The single targeted Peer ID for the data transfer.
  2179.  *   This only triggers for single targeted Peer data transfer.
  2180.  * @param {Array} callback.success.listOfPeers The list of Peer that the data transfer has been
  2181.  *   initiated with.
  2182.  * @param {Boolean} callback.success.isPrivate The flag to indicate if the data transfer is a private
  2183.  *   transfer to the Peer directly and not broadcasted to all Peers.
  2184.  * @param {JSON} callback.success.transferInfo The transfer data object information.
  2185.  * @param {String} [callback.success.transferInfo.name=transferId] The data transfer ID.
  2186.  * @param {Number} callback.success.transferInfo.size The transfer data size.
  2187.  * @param {String} callback.success.transferInfo.transferId The data transfer ID.
  2188.  * @param {String} callback.success.transferInfo.dataType The type of data transfer initiated.
  2189.  *   The received type would be <code>"dataURL"</code>.
  2190.  * @param {String} callback.success.transferInfo.timeout The waiting timeout in seconds that the DataChannel
  2191.  *   connection data transfer should wait before throwing an exception and terminating the data transfer.
  2192.  * @param {Boolean} callback.success.transferInfo.isPrivate The flag to indicate if the data transfer is a private
  2193.  *   transfer to the Peer directly and not broadcasted to all Peers.
  2194.  * @example
  2195.  *
  2196.  *   // Example 1: Send dataURL to all peers connected
  2197.  *   SkylinkDemo.sendURLData(dataURL, 67);
  2198.  *
  2199.  *   // Example 2: Send dataURL to individual peer
  2200.  *   SkylinkDemo.sendURLData(dataURL, 87, targetPeerId);
  2201.  *
  2202.  *   // Example 3: Send dataURL with callback
  2203.  *   SkylinkDemo.sendURLData(dataURL, 87, function(error, success){
  2204.  *     if (error){
  2205.  *       console.error("Error happened. Could not send dataURL", error);
  2206.  *     }
  2207.  *     else{
  2208.  *       console.info("Successfully sent dataURL");
  2209.  *     }
  2210.  *   });
  2211.  *
  2212.  * @trigger incomingData, incomingDataRequest, dataTransferState, dataChannelState
  2213.  * @since 0.6.1
  2214.  * @component DataTransfer
  2215.  * @for Skylink
  2216.  */
  2217. Skylink.prototype.sendURLData = function(data, timeout, targetPeerId, callback) {
  2218.   var listOfPeers = Object.keys(this._peerConnections);
  2219.   var isPrivate = false;
  2220.   var dataInfo = {};
  2221.   var transferId = this._user.sid + this.DATA_TRANSFER_TYPE.UPLOAD +
  2222.     (((new Date()).toISOString().replace(/-/g, '').replace(/:/g, ''))).replace('.', '');
  2223.   // for error case
  2224.   var errorMsg, errorPayload, i, peerId; // for jshint
  2225.   var singleError = null;
  2226.   var transferErrors = {};
  2227.   var stateError = null;
  2228.   var singlePeerId = null;
  2229.  
  2230.   //Shift parameters
  2231.   // timeout
  2232.   if (typeof timeout === 'function') {
  2233.     callback = timeout;
  2234.  
  2235.   } else if (typeof timeout === 'string') {
  2236.     listOfPeers = [timeout];
  2237.     isPrivate = true;
  2238.  
  2239.   } else if (Array.isArray(timeout)) {
  2240.     listOfPeers = timeout;
  2241.     isPrivate = true;
  2242.   }
  2243.  
  2244.   // targetPeerId
  2245.   if (typeof targetPeerId === 'function'){
  2246.     callback = targetPeerId;
  2247.  
  2248.   // data, timeout, target [array], callback
  2249.   } else if(Array.isArray(targetPeerId)) {
  2250.     listOfPeers = targetPeerId;
  2251.     isPrivate = true;
  2252.  
  2253.   // data, timeout, target [string], callback
  2254.   } else if (typeof targetPeerId === 'string') {
  2255.     listOfPeers = [targetPeerId];
  2256.     isPrivate = true;
  2257.   }
  2258.  
  2259.   //state: String, Deprecated. But for consistency purposes. Null if not a single peer
  2260.   //error: Object, Deprecated. But for consistency purposes. Null if not a single peer
  2261.   //transferId: String,
  2262.   //peerId: String, Deprecated. But for consistency purposes. Null if not a single peer
  2263.   //listOfPeers: Array, NEW!!
  2264.   //isPrivate: isPrivate, NEW!!
  2265.   //transferErrors: JSON, NEW!! - Array of errors
  2266.   //transferInfo: JSON The same payload as dataTransferState transferInfo payload
  2267.  
  2268.   // check if it's blob data
  2269.   if (typeof data !== 'string') {
  2270.     errorMsg = 'Provided data is not a dataURL';
  2271.  
  2272.     if (listOfPeers.length === 0) {
  2273.       transferErrors.self = errorMsg;
  2274.  
  2275.     } else {
  2276.       for (i = 0; i < listOfPeers.length; i++) {
  2277.         peerId = listOfPeers[i];
  2278.         transferErrors[peerId] = errorMsg;
  2279.       }
  2280.  
  2281.       // Deprecated but for consistency purposes. Null if not a single peer.
  2282.       if (listOfPeers.length === 1 && isPrivate) {
  2283.         stateError = self.DATA_TRANSFER_STATE.ERROR;
  2284.         singleError = errorMsg;
  2285.         singlePeerId = listOfPeers[0];
  2286.       }
  2287.     }
  2288.  
  2289.     errorPayload = {
  2290.       state: stateError,
  2291.       error: singleError,
  2292.       transferId: transferId,
  2293.       peerId: singlePeerId,
  2294.       listOfPeers: listOfPeers,
  2295.       transferErrors: transferErrors,
  2296.       transferInfo: dataInfo,
  2297.       isPrivate: isPrivate
  2298.     };
  2299.  
  2300.     log.error(errorMsg, errorPayload);
  2301.  
  2302.     if (typeof callback === 'function'){
  2303.       log.log([null, 'RTCDataChannel', null, 'Error occurred. Firing callback ' +
  2304.         'with error -> '],errorPayload);
  2305.       callback(errorPayload, null);
  2306.     }
  2307.     return;
  2308.   }
  2309.  
  2310.   // populate data
  2311.   dataInfo.name = data.name || transferId;
  2312.   dataInfo.size = data.size || data.length;
  2313.   dataInfo.timeout = typeof timeout === 'number' ? timeout : 60;
  2314.   dataInfo.transferId = transferId;
  2315.   dataInfo.dataType = 'dataURL';
  2316.   dataInfo.isPrivate = isPrivate;
  2317.  
  2318.   // check if datachannel is enabled first or not
  2319.   if (!this._enableDataChannel) {
  2320.     errorMsg = 'Unable to send any dataURL. Datachannel is disabled';
  2321.  
  2322.     if (listOfPeers.length === 0) {
  2323.       transferErrors.self = errorMsg;
  2324.  
  2325.     } else {
  2326.       for (i = 0; i < listOfPeers.length; i++) {
  2327.         peerId = listOfPeers[i];
  2328.         transferErrors[peerId] = errorMsg;
  2329.       }
  2330.  
  2331.       // Deprecated but for consistency purposes. Null if not a single peer.
  2332.       if (listOfPeers.length === 1 && isPrivate) {
  2333.         stateError = self.DATA_TRANSFER_STATE.ERROR;
  2334.         singleError = errorMsg;
  2335.         singlePeerId = listOfPeers[0];
  2336.       }
  2337.     }
  2338.  
  2339.     errorPayload = {
  2340.       state: stateError,
  2341.       error: singleError,
  2342.       transferId: transferId,
  2343.       peerId: singlePeerId,
  2344.       listOfPeers: listOfPeers,
  2345.       transferErrors: transferErrors,
  2346.       transferInfo: dataInfo,
  2347.       isPrivate: isPrivate
  2348.     };
  2349.  
  2350.     log.error(errorMsg, errorPayload);
  2351.  
  2352.     if (typeof callback === 'function'){
  2353.       log.log([null, 'RTCDataChannel', null, 'Error occurred. Firing callback ' +
  2354.         'with error -> '], errorPayload);
  2355.       callback(errorPayload, null);
  2356.     }
  2357.     return;
  2358.   }
  2359.  
  2360.   this._startDataTransfer(data, dataInfo, listOfPeers, callback);
  2361. };
  2362.  
  2363.