Merge pull request #184 from jitsi/revert-181-dc_stats

Revert "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;
     });
 
-    this.rtcForwarder.forward(RTCEvents.LASTN_CHANGED,
-        JitsiConferenceEvents.IN_LAST_N_CHANGED);
+    conference.rtc.addListener(RTCEvents.LASTN_CHANGED,
+        function (oldValue, newValue) {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.IN_LAST_N_CHANGED, oldValue, newValue);
+        });
 
-    this.rtcForwarder.forward(RTCEvents.LASTN_ENDPOINT_CHANGED,
-        JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED);
+    conference.rtc.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
+        function (lastNEndpoints, endpointsEnteringLastN) {
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
+                lastNEndpoints, endpointsEnteringLastN);
+        });
 
     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",
-    /**
-     * Indicates that a message from another participant is received on
-     * data channel.
-     */
-    DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED:
-        "conference.datachannel_endpoint_message_received"
+    PARTICIPANT_PROPERTY_CHANGED: "conference.participant_property_changed"
 };
 
 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",
-    /**
-     * Indicates that a message from another participant is received on
-     * data channel.
-     */
-    DATACHANNEL_ENDPOINT_MESSAGE_RECEIVED:
-        "rtc.datachannel_endpoint_message_received"
+    DEVICE_LIST_AVAILABLE: "rtc.device_list_available"
 };
 
 module.exports = RTCEvents;