Implements interfaces for data channel communication

JitsiConference.js

         JitsiConferenceErrors.INCOMPATIBLE_SERVER_VERSIONS);
 };
 
+/**
+ * Sends broadcast message via the datachannels.
+ * @param payload {object} the payload of the message.
+ */
+JitsiConference.prototype.sendDataChannelBroadcast = function (payload) {
+    if(this.rtc) {
+        this.rtc.sendDataChannelBroadcast(payload);
+    }
+}
+
 module.exports = JitsiConference;

JitsiConferenceEventManager.js

  */
 JitsiConferenceEventManager.prototype.setupRTCListeners = function () {
     var conference = this.conference;
+
+    this.rtcForwarder = new EventEmitterForwarder(conference.rtc,
+        this.conference.eventEmitter);
+
     conference.rtc.addListener(RTCEvents.DOMINANTSPEAKER_CHANGED,
         function (id) {
             if(conference.lastDominantSpeaker !== id && conference.room) {
         conference.room.connectionTimes["data.channel.opened"] = now;
     });
 
-    conference.rtc.addListener(RTCEvents.LASTN_CHANGED,
-        function (oldValue, newValue) {
-            conference.eventEmitter.emit(
-                JitsiConferenceEvents.IN_LAST_N_CHANGED, oldValue, newValue);
-        });
+    this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,
+        JitsiConferenceEvents.IN_LAST_N_CHANGED);
 
-    conference.rtc.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
-        function (lastNEndpoints, endpointsEnteringLastN) {
-            conference.eventEmitter.emit(
-                JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
-                lastNEndpoints, endpointsEnteringLastN);
-        });
+    this.rtcForwarder.forward(RTCEvents.LASTN_ENDPOINT_CHANGED,
+        JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED);
 
     conference.rtc.addListener(RTCEvents.AVAILABLE_DEVICES_CHANGED,
         function (devices) {
             conference.room.updateDeviceAvailability(devices);
         });
+
+    this.rtcForwarder.forward(RTCEvents.DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED,
+        JitsiConferenceEvents.DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED);
 };
 
 /**

JitsiConferenceEvents.js

      * Indicates that a the value of a specific property of a specific
      * participant has changed.
      */
-    PARTICIPANT_PROPERTY_CHANGED: "conference.participant_property_changed"
+    PARTICIPANT_PROPERTY_CHANGED: "conference.participant_property_changed",
+    /**
+     * Indicates that a message from another participant is received on
+     * data channel.
+     */
+    DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED:
+        "conference.datachannel_endpoint_message_received"
 };
 
 module.exports = JitsiConferenceEvents;

doc/API.md

         - AVAILABLE_DEVICES_CHANGED - notifies that available participant devices changed (camera or microphone was added or removed) (parameters - id(string), devices(JS object with 2 properties - audio(boolean), video(boolean)))
         - CONNECTION_STATS - New local connection statistics are received. (parameters - stats(object))
         - AUTH_STATUS_CHANGED - notifies that authentication is enabled or disabled, or local user authenticated (logged in). (parameters - isAuthEnabled(boolean), authIdentity(string))
+        - DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED - notifies that a new message
+        from another participant is received on a data channel.
 
     2. connection
         - CONNECTION_FAILED - indicates that the server connection failed.
         - CHROME_EXTENSION_USER_CANCELED - an error which indicates that user canceled screen sharing window selection dialog in jidesha extension for Chrome.
         - CHROME_EXTENSION_INSTALLATION_ERROR - an error which indicates that the jidesha extension for Chrome is failed to install.
         - FIREFOX_EXTENSION_NEEDED - An error which indicates that the jidesha extension for Firefox is needed to proceed with screen sharing, and that it is not installed.
-        
+
 * ```JitsiMeetJS.errorTypes``` - constructors for Error instances that can be produced by library. Are useful for checks like ```error instanceof JitsiMeetJS.errorTypes.JitsiTrackError```. Following Errors are available:
     1. ```JitsiTrackError``` - Error that happened to a JitsiTrack.
-        
+
 * ```JitsiMeetJS.logLevels``` - object with the log levels:
     1. TRACE
     2. DEBUG
 
 JitsiTrackError
 ======
-The object represents error that happened to a JitsiTrack. Is inherited from JavaScript base ```Error``` object, 
+The object represents error that happened to a JitsiTrack. Is inherited from JavaScript base ```Error``` object,
 so ```"name"```, ```"message"``` and ```"stack"``` properties are available. For GUM-related errors,
 exposes additional ```"gum"``` property, which is an object with following properties:
  - error - original GUM error

modules/RTC/DataChannels.js

                     lastNEndpoints, endpointsEnteringLastN, obj);
                 self.eventEmitter.emit(RTCEvents.LASTN_ENDPOINT_CHANGED,
                     lastNEndpoints, endpointsEnteringLastN, obj);
+            } else if("EndpointMessage" === colibriClass) {
+                self.eventEmitter.emit(
+                    RTCEvents.DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED,
+                    obj.msgPayload);
             }
             else {
                 logger.debug("Data channel JSON-formatted message: ", obj);
     var tail = xxx.substring(1);
     var lower = head.toLowerCase() + tail;
     var upper = head.toUpperCase() + tail;
+    logger.log(
+            'sending ' + lower
+                + ' endpoint changed notification to the bridge: ',
+            userResource);
+
+    var jsonObject = {};
+
+    jsonObject.colibriClass = (upper + 'EndpointChangedEvent');
+    jsonObject[lower + "Endpoint"]
+        = (userResource ? userResource : null);
+
+    this.send(jsonObject);
 
     // Notify Videobridge about the specified endpoint change.
     logger.log(lower + ' endpoint changed: ', userResource);
-    this._some(function (dataChannel) {
-        if (dataChannel.readyState == 'open') {
-            logger.log(
-                    'sending ' + lower
-                        + ' endpoint changed notification to the bridge: ',
-                    userResource);
-
-            var jsonObject = {};
-
-            jsonObject.colibriClass = (upper + 'EndpointChangedEvent');
-            jsonObject[lower + "Endpoint"]
-                = (userResource ? userResource : null);
-            try {
-                dataChannel.send(JSON.stringify(jsonObject));
-            } catch (e) {
-                // FIXME: Maybe we should check if the conference is left
-                // before calling _onXXXEndpointChanged method.
-                // FIXME: We should check if we are disposing correctly the
-                // data channels.
-                logger.warn(e);
-            }
 
-            return true;
-        }
-    });
 };
 
 DataChannels.prototype._some = function (callback, thisArg) {
     }
 };
 
+/**
+ * Sends passed object via the first found open datachannel
+ * @param jsonObject {object} the object that will be sent
+ */
+DataChannels.prototype.send = function (jsonObject) {
+    this._some(function (dataChannel) {
+        if (dataChannel.readyState == 'open') {
+            dataChannel.send(JSON.stringify(jsonObject));
+            return true;
+        }
+    });
+}
+
+/**
+ * Sends broadcast message via the datachannels.
+ * @param payload {object} the payload of the message.
+ */
+DataChannels.prototype.sendBroadcastMessage = function (payload) {
+    var jsonObject = {};
+
+    jsonObject.colibriClass = "EndpointMessage";
+    jsonObject.to = "";
+    // following the same format for the payload in order to be able to
+    // recognise the message on the receiving side.
+    jsonObject.msgPayload = {
+        colibriClass: "EndpointMessage",
+        to: "",
+        msgPayload: payload
+    };
+
+    this.send(jsonObject);
+}
+
 module.exports = DataChannels;

modules/RTC/RTC.js

     }
 }
 
+/**
+ * Sends broadcast message via the datachannels.
+ * @param payload {object} the payload of the message.
+ */
+RTC.prototype.sendDataChannelBroadcast = function (payload) {
+    if(this.dataChannels) {
+        this.dataChannels.sendBroadcastMessage(payload);
+    }
+}
+
 module.exports = RTC;

service/RTC/RTCEvents.js

     TRACK_ATTACHED: "rtc.track_attached",
     AUDIO_OUTPUT_DEVICE_CHANGED: "rtc.audio_output_device_changed",
     DEVICE_LIST_CHANGED: "rtc.device_list_changed",
-    DEVICE_LIST_AVAILABLE: "rtc.device_list_available"
+    DEVICE_LIST_AVAILABLE: "rtc.device_list_available",
+    /**
+     * Indicates that a message from another participant is received on
+     * data channel.
+     */
+    DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED:
+        "rtc.datachannel_endpoint_message_received"
 };
 
 module.exports = RTCEvents;