feat(DataChannel): add support for WebSockets in addition to data channels

Some browsers may not support data channels (hi there, Edge!) and sometimes it
may not be desirable for other reasons.

JitsiConference.js

  * "Math.random() < forceJVB121Ratio" will determine whether a 2 people
  * conference should be moved to the JVB instead of P2P. The decision is made on
  * the responder side, after ICE succeeds on the P2P connection.
+ * @param {*} [options.config.openBridgeChannel] Which kind of communication to
+ * open with the videobridge. Values can be "datachannel", "websocket", true
+ * (treat it as "datachannel"), undefined (treat it as "datachannel") and false
+ * (don't open any channel).
  * @constructor
  *
  * FIXME Make all methods which are called from lib-internal classes
 
     this.getLocalTracks().forEach(track => this.onLocalTrackRemoved(track));
 
-    this.rtc.closeAllDataChannels();
+    this.rtc.closeBridgeChannel();
     if (this.statistics) {
         this.statistics.dispose();
     }
         GlobalOnErrorHandler.callErrorHandler(error);
     }
 
-    this.rtc.initializeDataChannels(jingleSession.peerconnection);
-
     // Add local tracks to the session
     try {
         jingleSession.acceptOffer(
                 if (this.isP2PActive() && this.jvbJingleSession) {
                     this._suspendMediaTransferForJvbConnection();
                 }
+
+                // Open a channel with the videobridge.
+                this._setBridgeChannel();
             },
             error => {
                 GlobalOnErrorHandler.callErrorHandler(error);
     }
 };
 
+/**
+ * Sets the BridgeChannel.
+ */
+JitsiConference.prototype._setBridgeChannel = function() {
+    const jingleSession = this.jvbJingleSession;
+    const wsUrl = jingleSession.bridgeWebSocketUrl;
+    let bridgeChannelType;
+
+    switch (this.options.config.openBridgeChannel) {
+    case 'datachannel':
+    case true:
+    case undefined:
+        bridgeChannelType = 'datachannel';
+        break;
+    case 'websocket':
+        bridgeChannelType = 'websocket';
+        break;
+    }
+
+    if (bridgeChannelType === 'datachannel'
+        && !RTCBrowserType.supportsDataChannels()) {
+        bridgeChannelType = 'websocket';
+    }
+
+    if (bridgeChannelType === 'datachannel') {
+        this.rtc.initializeBridgeChannel(jingleSession.peerconnection, null);
+    } else if (bridgeChannelType === 'websocket' && wsUrl) {
+        this.rtc.initializeBridgeChannel(null, wsUrl);
+    }
+};
+
 /**
  * Rejects incoming Jingle call with 'security-error'. Method should be used to
  * reject calls initiated by unauthorised entities.
  * @throws NetworkError or InvalidStateError or Error if the operation fails.
  */
 JitsiConference.prototype.sendEndpointMessage = function(to, payload) {
-    this.rtc.sendDataChannelMessage(to, payload);
+    this.rtc.sendChannelMessage(to, payload);
 };
 
 /**

JitsiConferenceEventManager.js

 
     chatRoom.addListener(XMPPEvents.ICE_RESTARTING, jingleSession => {
         if (!jingleSession.isP2P) {
-            // All data channels have to be closed, before ICE restart
-            // otherwise Chrome will not trigger "opened" event for the channel
-            // established with the new bridge
-            conference.rtc.closeAllDataChannels();
+            // If using DataChannel as bridge channel, it must be closed
+            // before ICE restart, otherwise Chrome will not trigger "opened"
+            // event for the channel established with the new bridge.
+            // TODO: This may be bypassed when using a WebSocket as bridge
+            // channel.
+            conference.rtc.closeBridgeChannel();
         }
 
         // else: there are no DataChannels in P2P session (at least for now)

doc/API.md

 4. initJitsiConference(name, options) - creates new ```JitsiConference``` object.
     - name - the name of the conference
     - options - JS object with configuration options for the conference. You can change the following properties there:
-        1. openSctp - boolean property. Enables/disables datachannel support. **NOTE: we recommend to set that option to true**
+        1. openBridgeChannel - Enables/disables bridge channel. Values can be "datachannel", "websocket", true (treat it as "datachannel"), undefined (treat it as "datachannel") and false (don't open any channel). **NOTE: we recommend to set that option to true**
         2. recordingType - the type of recording to be used
         3. jirecon
         4. callStatsID - callstats credentials

doc/example/example.js

 };
 
 const confOptions = {
-    openSctp: true
+    openBridgeChannel: true
 };
 
 let connection = null;

modules/RTC/BridgeChannel.js

+import { getLogger } from 'jitsi-meet-logger';
+
+import RTCEvents from '../../service/RTC/RTCEvents';
+import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
+
+const logger = getLogger(__filename);
+
+/**
+ * Handles a WebRTC RTCPeerConnection or a WebSocket instance to communicate
+ * with the videobridge.
+ */
+export default class BridgeChannel {
+    /**
+     * Binds "ondatachannel" event listener on the given RTCPeerConnection
+     * instance, or creates a WebSocket connection with the videobridge.
+     * At least one of both, peerconnection or wsUrl parameters, must be
+     * given.
+     * @param {RTCPeerConnection} [peerconnection] WebRTC peer connection
+     * instance.
+     * @param {string} [wsUrl] WebSocket URL.
+     * @param {EventEmitter} eventEmitter EventEmitter instance.
+     */
+    constructor(peerconnection, wsUrl, emitter) {
+        if (!peerconnection && !wsUrl) {
+            throw new TypeError(
+                'At least peerconnection or wsUrl must be given');
+        } else if (peerconnection && wsUrl) {
+            throw new TypeError(
+                'Just one of peerconnection or wsUrl must be given');
+        }
+
+        if (peerconnection) {
+            logger.debug('constructor() with peerconnection');
+        } else {
+            logger.debug(`constructor() with wsUrl:"${wsUrl}"`);
+        }
+
+        // The underlying WebRTC RTCDataChannel or WebSocket instance.
+        // @type {RTCDataChannel|WebSocket}
+        this._channel = null;
+
+        // @type {EventEmitter}
+        this._eventEmitter = emitter;
+
+        // Whether a RTCDataChannel or WebSocket is internally used.
+        // @type {string} "datachannel" / "websocket"
+        this._mode = null;
+
+        // If a RTCPeerConnection is given, listen for new RTCDataChannel
+        // event.
+        if (peerconnection) {
+            peerconnection.ondatachannel = event => {
+                // NOTE: We assume that the "onDataChannel" event just fires
+                // once.
+
+                const datachannel = event.channel;
+
+                // Handle the RTCDataChannel.
+                this._handleChannel(datachannel);
+                this._mode = 'datachannel';
+            };
+
+        // Otherwise create a WebSocket connection.
+        } else if (wsUrl) {
+            // Create a WebSocket instance.
+            const ws = new WebSocket(wsUrl);
+
+            // Handle the WebSocket.
+            this._handleChannel(ws);
+            this._mode = 'websocket';
+        }
+    }
+
+    /**
+     * The channel mode.
+     * @return {string} "datachannel" or "websocket" (or null if not yet set).
+     */
+    get mode() {
+        return this._mode;
+    }
+
+    /**
+     * Closes the currently opened channel.
+     */
+    close() {
+        if (this._channel) {
+            try {
+                this._channel.close();
+            } catch (error) {} // eslint-disable-line no-empty
+
+            this._channel = null;
+        }
+    }
+
+    /**
+     * Whether there is an underlying RTCDataChannel or WebSocket and it's
+     * open.
+     * @return {boolean}
+     */
+    isOpen() {
+        return this._channel && (this._channel.readyState === 'open'
+            || this._channel.readyState === WebSocket.OPEN);
+    }
+
+    /**
+     * Sends message via the channel.
+     * @param {string} to The id of the endpoint that should receive the
+     * message. If "" the message will be sent to all participants.
+     * @param  {object} payload The payload of the message.
+     * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+     * {@link https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send})
+     * or from WebSocket#send or Error with "No opened channel" message.
+     */
+    sendMessage(to, payload) {
+        this._send({
+            colibriClass: 'EndpointMessage',
+            msgPayload: payload,
+            to
+        });
+    }
+
+    /**
+     * Sends a "lastN value changed" message via the channel.
+     * @param {number} value The new value for lastN. -1 means unlimited.
+     */
+    sendSetLastNMessage(value) {
+        const jsonObject = {
+            colibriClass: 'LastNChangedEvent',
+            lastN: value
+        };
+
+        this._send(jsonObject);
+        logger.log(`Channel lastN set to: ${value}`);
+    }
+
+    /**
+     * Sends a "pinned endpoint changed" message via the channel.
+     * @param {string} endpointId The id of the pinned endpoint.
+     * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+     * {@link https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send})
+     * or from WebSocket#send or Error with "No opened channel" message.
+     */
+    sendPinnedEndpointMessage(endpointId) {
+        logger.log(
+            'sending pinned changed notification to the bridge for endpoint ',
+            endpointId);
+
+        this._send({
+            colibriClass: 'PinnedEndpointChangedEvent',
+            pinnedEndpoint: endpointId || null
+        });
+    }
+
+    /**
+     * Sends a "selected endpoint changed" message via the channel.
+     * @param {string} endpointId The id of the selected endpoint.
+     * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+     * {@link https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send})
+     * or from WebSocket#send or Error with "No opened channel" message.
+     */
+    sendSelectedEndpointMessage(endpointId) {
+        logger.log(
+            'sending selected changed notification to the bridge for endpoint ',
+            endpointId);
+
+        this._send({
+            colibriClass: 'SelectedEndpointChangedEvent',
+            selectedEndpoint: endpointId || null
+        });
+    }
+
+    /**
+     * Set events on the given RTCDataChannel or WebSocket instance.
+     */
+    _handleChannel(channel) {
+        const emitter = this._eventEmitter;
+
+        channel.onopen = () => {
+            logger.info('Channel opened by the Videobridge!', channel);
+
+            // Code sample for sending string and/or binary data.
+            // Sends string message to the bridge:
+            //     channel.send("Hello bridge!");
+            // Sends 12 bytes binary message to the bridge:
+            //     channel.send(new ArrayBuffer(12));
+
+            emitter.emit(RTCEvents.DATA_CHANNEL_OPEN);
+        };
+
+        channel.onerror = error => {
+            logger.error('Channel error:', error, channel);
+        };
+
+        channel.onmessage = ({ data }) => {
+            // JSON object.
+            let obj;
+
+            try {
+                obj = JSON.parse(data);
+            } catch (error) {
+                GlobalOnErrorHandler.callErrorHandler(error);
+                logger.error(
+                    'Failed to parse channel message as JSON: ',
+                    data, channel, error);
+
+                return;
+            }
+
+            const colibriClass = obj.colibriClass;
+
+            switch (colibriClass) {
+            case 'DominantSpeakerEndpointChangeEvent': {
+                // Endpoint ID from the Videobridge.
+                const dominantSpeakerEndpoint = obj.dominantSpeakerEndpoint;
+
+                logger.info(
+                    'Channel new dominant speaker event: ',
+                    dominantSpeakerEndpoint);
+                emitter.emit(
+                    RTCEvents.DOMINANT_SPEAKER_CHANGED,
+                    dominantSpeakerEndpoint);
+                break;
+            }
+            case 'EndpointConnectivityStatusChangeEvent': {
+                const endpoint = obj.endpoint;
+                const isActive = obj.active === 'true';
+
+                logger.info(
+                    `Endpoint connection status changed: ${endpoint} active ? ${
+                        isActive}`);
+                emitter.emit(RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
+                    endpoint, isActive);
+
+                break;
+            }
+            case 'EndpointMessage': {
+                emitter.emit(
+                    RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from,
+                    obj.msgPayload);
+
+                break;
+            }
+            case 'LastNEndpointsChangeEvent': {
+                // The new/latest list of last-n endpoint IDs.
+                const lastNEndpoints = obj.lastNEndpoints;
+
+                logger.info('Channel new last-n event: ',
+                    lastNEndpoints, obj);
+                emitter.emit(RTCEvents.LASTN_ENDPOINT_CHANGED,
+                    lastNEndpoints, obj);
+
+                break;
+            }
+            default: {
+                logger.debug('Channel JSON-formatted message: ', obj);
+
+                // The received message appears to be appropriately formatted
+                // (i.e. is a JSON object which assigns a value to the
+                // mandatory property colibriClass) so don't just swallow it,
+                // expose it to public consumption.
+                emitter.emit(`rtc.datachannel.${colibriClass}`, obj);
+            }
+            }
+        };
+
+        channel.onclose = () => {
+            logger.info('Channel closed', channel);
+
+            // Remove the channel.
+            this._channel = null;
+        };
+
+        // Store the channel.
+        this._channel = channel;
+    }
+
+    /**
+     * Sends passed object via the channel.
+     * @param {object} jsonObject The object that will be sent.
+     * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
+     * {@link https://developer.mozilla.org/docs/Web/API/RTCDataChannel/send})
+     * or from WebSocket#send or Error with "No opened channel" message.
+     */
+    _send(jsonObject) {
+        const channel = this._channel;
+
+        if (!this.isOpen()) {
+            throw new Error('No opened channel');
+        }
+
+        channel.send(JSON.stringify(jsonObject));
+    }
+}

modules/RTC/DataChannels.js

-// cache datachannels to avoid garbage collection
-// https://code.google.com/p/chromium/issues/detail?id=405545
-
-const logger = require('jitsi-meet-logger').getLogger(__filename);
-const RTCEvents = require('../../service/RTC/RTCEvents');
-const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
-
-/**
- * Binds "ondatachannel" event listener to given PeerConnection instance.
- * @param peerConnection WebRTC peer connection instance.
- */
-function DataChannels(peerConnection, emitter) {
-    peerConnection.ondatachannel = this.onDataChannel.bind(this);
-    this.eventEmitter = emitter;
-
-    this._dataChannels = [];
-
-    // Sample code for opening new data channel from Jitsi Meet to the bridge.
-    // Although it's not a requirement to open separate channels from both
-    // bridge and peer as single channel can be used for sending and receiving
-    // data. So either channel opened by the bridge or the one opened here is
-    // enough for communication with the bridge.
-    /* var dataChannelOptions =
-     {
-     reliable: true
-     };
-     var dataChannel
-     = peerConnection.createDataChannel("myChannel", dataChannelOptions);
-
-     // Can be used only when is in open state
-     dataChannel.onopen = function ()
-     {
-     dataChannel.send("My channel !!!");
-     };
-     dataChannel.onmessage = function (event)
-     {
-     var msgData = event.data;
-     logger.info("Got My Data Channel Message:", msgData, dataChannel);
-     };*/
-}
-
-/**
- * Callback triggered by PeerConnection when new data channel is opened
- * on the bridge.
- * @param event the event info object.
- */
-DataChannels.prototype.onDataChannel = function(event) {
-    const dataChannel = event.channel;
-    const self = this;
-
-    dataChannel.onopen = function() {
-        logger.info('Data channel opened by the Videobridge!');
-
-        // Code sample for sending string and/or binary data
-        // Sends String message to the bridge
-        // dataChannel.send("Hello bridge!");
-        // Sends 12 bytes binary message to the bridge
-        // dataChannel.send(new ArrayBuffer(12));
-
-        self.eventEmitter.emit(RTCEvents.DATA_CHANNEL_OPEN);
-    };
-
-    dataChannel.onerror = function(error) {
-        // FIXME: this one seems to be generated a bit too often right now
-        // so we are temporarily commenting it before we have more clarity
-        // on which of the errors we absolutely need to report
-        // GlobalOnErrorHandler.callErrorHandler(
-        //        new Error("Data Channel Error:" + error));
-        logger.error('Data Channel Error:', error, dataChannel);
-    };
-
-    dataChannel.onmessage = function({ data }) {
-        // JSON
-        let obj;
-
-        try {
-            obj = JSON.parse(data);
-        } catch (e) {
-            GlobalOnErrorHandler.callErrorHandler(e);
-            logger.error(
-                'Failed to parse data channel message as JSON: ',
-                data,
-                dataChannel,
-                e);
-        }
-        if ((typeof obj !== 'undefined') && (obj !== null)) {
-            const colibriClass = obj.colibriClass;
-
-            if (colibriClass === 'DominantSpeakerEndpointChangeEvent') {
-                // Endpoint ID from the Videobridge.
-                const dominantSpeakerEndpoint = obj.dominantSpeakerEndpoint;
-
-                logger.info(
-                    'Data channel new dominant speaker event: ',
-                    dominantSpeakerEndpoint);
-                self.eventEmitter.emit(RTCEvents.DOMINANT_SPEAKER_CHANGED,
-                  dominantSpeakerEndpoint);
-            } else if (colibriClass === 'LastNEndpointsChangeEvent') {
-                // The new/latest list of last-n endpoint IDs.
-                const lastNEndpoints = obj.lastNEndpoints;
-
-                logger.info('Data channel new last-n event: ',
-                    lastNEndpoints, obj);
-                self.eventEmitter.emit(RTCEvents.LASTN_ENDPOINT_CHANGED,
-                    lastNEndpoints, obj);
-            } else if (colibriClass === 'EndpointMessage') {
-                self.eventEmitter.emit(
-                    RTCEvents.ENDPOINT_MESSAGE_RECEIVED, obj.from,
-                    obj.msgPayload);
-            } else if (colibriClass
-                    === 'EndpointConnectivityStatusChangeEvent') {
-                const endpoint = obj.endpoint;
-                const isActive = obj.active === 'true';
-
-                logger.info(
-                    `Endpoint connection status changed: ${endpoint} active ? ${
-                        isActive}`);
-                self.eventEmitter.emit(RTCEvents.ENDPOINT_CONN_STATUS_CHANGED,
-                    endpoint, isActive);
-            } else {
-                logger.debug('Data channel JSON-formatted message: ', obj);
-
-                // The received message appears to be appropriately formatted
-                // (i.e. is a JSON object which assigns a value to the mandatory
-                // property colibriClass) so don't just swallow it, expose it to
-                // public consumption.
-                self.eventEmitter.emit(`rtc.datachannel.${colibriClass}`, obj);
-            }
-        }
-    };
-
-    dataChannel.onclose = function() {
-        logger.info('The Data Channel closed', dataChannel);
-        const idx = self._dataChannels.indexOf(dataChannel);
-
-        if (idx > -1) {
-            self._dataChannels = self._dataChannels.splice(idx, 1);
-        }
-    };
-    this._dataChannels.push(dataChannel);
-};
-
-/**
- * Closes all currently opened data channels.
- */
-DataChannels.prototype.closeAllChannels = function() {
-    this._dataChannels.forEach(dc => {
-        // the DC will be removed from the array on 'onclose' event
-        dc.close();
-    });
-};
-
-/**
- * Sends a "selected endpoint changed" message via the data channel.
- * @param endpointId {string} the id of the selected endpoint
- * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
- * or Error with "No opened data channels found!" message.
- */
-DataChannels.prototype.sendSelectedEndpointMessage = function(endpointId) {
-    this._onXXXEndpointChanged('selected', endpointId);
-};
-
-/**
- * Sends a "pinned endpoint changed" message via the data channel.
- * @param endpointId {string} the id of the pinned endpoint
- * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
- * or Error with "No opened data channels found!" message.
- */
-DataChannels.prototype.sendPinnedEndpointMessage = function(endpointId) {
-    this._onXXXEndpointChanged('pinned', endpointId);
-};
-
-/**
- * Notifies Videobridge about a change in the value of a specific
- * endpoint-related property such as selected endpoint and pinned endpoint.
- *
- * @param xxx the name of the endpoint-related property whose value changed
- * @param userResource the new value of the endpoint-related property after the
- * change
- * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
- * or Error with "No opened data channels found!" message.
- */
-DataChannels.prototype._onXXXEndpointChanged = function(xxx, userResource) {
-    // Derive the correct words from xxx such as selected and Selected, pinned
-    // and Pinned.
-    const head = xxx.charAt(0);
-    const tail = xxx.substring(1);
-    const lower = head.toLowerCase() + tail;
-    const upper = head.toUpperCase() + tail;
-
-    logger.log(
-            `sending ${lower} endpoint changed notification to the bridge: `,
-            userResource);
-
-    const 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);
-};
-
-DataChannels.prototype._some = function(callback, thisArg) {
-    const dataChannels = this._dataChannels;
-
-    if (dataChannels && dataChannels.length !== 0) {
-        if (thisArg) {
-            return dataChannels.some(callback, thisArg);
-        }
-
-        return dataChannels.some(callback);
-
-    }
-
-    return false;
-
-};
-
-/**
- * Sends passed object via the first found open datachannel
- * @param jsonObject {object} the object that will be sent
- * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
- * or Error with "No opened data channels found!" message.
- */
-DataChannels.prototype.send = function(jsonObject) {
-    if (!this._some(dataChannel => {
-        if (dataChannel.readyState === 'open') {
-            dataChannel.send(JSON.stringify(jsonObject));
-
-            return true;
-        }
-    })) {
-        throw new Error('No opened data channels found!');
-    }
-};
-
-/**
- * Sends message via the datachannels.
- * @param to {string} the id of the endpoint that should receive the message.
- * If "" the message will be sent to all participants.
- * @param payload {object} the payload of the message.
- * @throws NetworkError or InvalidStateError from RTCDataChannel#send (@see
- * {@link https://developer.mozilla.org/en-US/docs/Web/API/RTCDataChannel/send})
- * or Error with "No opened data channels found!" message.
- */
-DataChannels.prototype.sendDataChannelMessage = function(to, payload) {
-    this.send({
-        colibriClass: 'EndpointMessage',
-        to,
-        msgPayload: payload
-    });
-};
-
-/**
- * Sends a "lastN value changed" message via the data channel.
- * @param value {int} The new value for lastN. -1 means unlimited.
- */
-DataChannels.prototype.sendSetLastNMessage = function(value) {
-    const jsonObject = {
-        colibriClass: 'LastNChangedEvent',
-        lastN: value
-    };
-
-    this.send(jsonObject);
-    logger.log(`Channel lastN set to: ${value}`);
-};
-
-module.exports = DataChannels;

modules/RTC/RTC.js

 
 import { getLogger } from 'jitsi-meet-logger';
 
-import DataChannels from './DataChannels';
+import BridgeChannel from './BridgeChannel';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import JitsiLocalTrack from './JitsiLocalTrack';
 
         this.options = options;
 
-        // A flag whether we had received that the data channel had opened
-        // we can get this flag out of sync if for some reason data channel got
-        // closed from server, a desired behaviour so we can see errors when
-        // this happen
-        this.dataChannelsOpen = false;
+        // BridgeChannel instance.
+        // @private
+        // @type {BridgeChannel}
+        this._channel = null;
+
+        // A flag whether we had received that the channel had opened we can
+        // get this flag out of sync if for some reason channel got closed
+        // from server, a desired behaviour so we can see errors when this
+        // happen.
+        // @private
+        // @type {boolean}
+        this._channelOpen = false;
 
         /**
          * The value specified to the last invocation of setLastN before the
-         * data channels completed opening. If non-null, the value will be sent
-         * through a data channel (once) as soon as it opens and will then be
+         * channel completed opening. If non-null, the value will be sent
+         * through a channel (once) as soon as it opens and will then be
          * discarded.
-         *
          * @private
          * @type {number}
          */
 
         /**
          * Defines the last N endpoints list. It can be null or an array once
-         * initialised with a datachannel last N event.
+         * initialised with a channel last N event.
          * @type {Array<string>|null}
          * @private
          */
 
     /**
      * Creates the local MediaStreams.
-     * @param {Object} [options] optional parameters
-     * @param {Array} options.devices the devices that will be requested
-     * @param {string} options.resolution resolution constraints
-     * @param {bool} options.dontCreateJitsiTrack if <tt>true</tt> objects with
-     * the following structure {stream: the Media Stream, type: "audio" or
-     * "video", videoType: "camera" or "desktop"} will be returned trough the
-     * Promise, otherwise JitsiTrack objects will be returned.
+     * @param {object} [options] Optional parameters.
+     * @param {array} options.devices The devices that will be requested.
+     * @param {string} options.resolution Resolution constraints.
+     * @param {bool} options.dontCreateJitsiTrack If <tt>true</tt> objects with
+     *     the following structure {stream: the Media Stream, type: "audio" or
+     *     "video", videoType: "camera" or "desktop"} will be returned trough
+     *     the Promise, otherwise JitsiTrack objects will be returned.
      * @param {string} options.cameraDeviceId
      * @param {string} options.micDeviceId
      * @returns {*} Promise object that will receive the new JitsiTracks
     }
 
     /**
-     * Initializes the data channels of this instance.
-     * @param peerconnection the associated PeerConnection.
-     */
-    initializeDataChannels(peerconnection) {
-        if (this.options.config.openSctp) {
-            this.dataChannels = new DataChannels(peerconnection,
-                this.eventEmitter);
-
-            this._dataChannelOpenListener = () => {
-                // mark that dataChannel is opened
-                this.dataChannelsOpen = true;
-
-                // when the data channel becomes available, tell the bridge
-                // about video selections so that it can do adaptive simulcast,
-                // we want the notification to trigger even if userJid
-                // is undefined, or null.
-                try {
-                    this.dataChannels.sendPinnedEndpointMessage(
-                        this._pinnedEndpoint);
-                    this.dataChannels.sendSelectedEndpointMessage(
-                        this._selectedEndpoint);
-                } catch (error) {
-                    GlobalOnErrorHandler.callErrorHandler(error);
-                    logger.error(
-                        `Cannot send selected(${this._selectedEndpoint})`
-                        + `pinned(${this._pinnedEndpoint}) endpoint message.`,
-                        error);
-                }
-
-                this.removeListener(RTCEvents.DATA_CHANNEL_OPEN,
-                    this._dataChannelOpenListener);
-                this._dataChannelOpenListener = null;
-
-                // If setLastN was invoked before the data channels completed
-                // opening, apply the specified value now that the data channels
-                // are open. NOTE that -1 is the default value assumed by both
-                // RTC module and the JVB.
-                if (this._lastN !== -1) {
-                    this.dataChannels.sendSetLastNMessage(this._lastN);
-                }
-            };
-            this.addListener(RTCEvents.DATA_CHANNEL_OPEN,
-                this._dataChannelOpenListener);
-
-            // Add Last N change listener.
-            this.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
-                this._lastNChangeListener);
-        }
+     * Initializes the bridge channel of this instance.
+     * At least one of both, peerconnection or wsUrl parameters, must be
+     * given.
+     * @param {RTCPeerConnection} [peerconnection] WebRTC peer connection
+     * instance.
+     * @param {string} [wsUrl] WebSocket URL.
+     */
+    initializeBridgeChannel(peerconnection, wsUrl) {
+        this._channel = new BridgeChannel(
+            peerconnection, wsUrl, this.eventEmitter);
+
+        this._channelOpenListener = () => {
+            // Mark that channel as opened.
+            this._channelOpen = true;
+
+            // When the channel becomes available, tell the bridge about
+            // video selections so that it can do adaptive simulcast,
+            // we want the notification to trigger even if userJid
+            // is undefined, or null.
+            try {
+                this._channel.sendPinnedEndpointMessage(
+                    this._pinnedEndpoint);
+                this._channel.sendSelectedEndpointMessage(
+                    this._selectedEndpoint);
+            } catch (error) {
+                GlobalOnErrorHandler.callErrorHandler(error);
+                logger.error(
+                    `Cannot send selected(${this._selectedEndpoint})`
+                    + `pinned(${this._pinnedEndpoint}) endpoint message.`,
+                    error);
+            }
+
+            this.removeListener(RTCEvents.DATA_CHANNEL_OPEN,
+                this._channelOpenListener);
+            this._channelOpenListener = null;
+
+            // If setLastN was invoked before the bridge channel completed
+            // opening, apply the specified value now that the channel
+            // is open. NOTE that -1 is the default value assumed by both
+            // RTC module and the JVB.
+            if (this._lastN !== -1) {
+                this._channel.sendSetLastNMessage(this._lastN);
+            }
+        };
+
+        this.addListener(RTCEvents.DATA_CHANNEL_OPEN,
+            this._channelOpenListener);
+
+        // Add Last N change listener.
+        this.addListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
+            this._lastNChangeListener);
     }
 
     /**
      * Receives events when Last N had changed.
-     * @param {array} lastNEndpoints the new Last N endpoints.
+     * @param {array} lastNEndpoints The new Last N endpoints.
      * @private
      */
     _onLastNChanged(lastNEndpoints = []) {
      * PeerConnection has been closed using PeerConnection.close() method.
      */
     onCallEnded() {
-        if (this.dataChannels) {
-            // DataChannels are not explicitly closed as the PeerConnection
-            // is closed on call ended which triggers data channel onclose
-            // events. The reference is cleared to disable any logic related
-            // to the data channels.
-            this.dataChannels = null;
-            this.dataChannelsOpen = false;
+        if (this._channel) {
+            // The BridgeChannel is not explicitly closed as the PeerConnection
+            // is closed on call ended which triggers datachannel onclose
+            // events. If using a WebSocket, the channel must be closed since
+            // it is not managed by the PeerConnection.
+            // The reference is cleared to disable any logic related to the
+            // channel.
+            if (this._channel && this._channel.mode === 'websocket') {
+                this._channel.close();
+            }
+
+            this._channel = null;
+            this._channelOpen = false;
         }
     }
 
      * Elects the participant with the given id to be the selected participant
      * in order to always receive video for this participant (even when last n
      * is enabled).
-     * If there is no data channel we store it and send it through the channel
-     * once it is created.
-     * @param id {string} the user id.
+     * If there is no channel we store it and send it through the channel once
+     * it is created.
+     * @param {string} id The user id.
      * @throws NetworkError or InvalidStateError or Error if the operation
      * fails.
      */
     selectEndpoint(id) {
-        // cache the value if channel is missing, till we open it
+        // Cache the value if channel is missing, till we open it.
         this._selectedEndpoint = id;
-        if (this.dataChannels && this.dataChannelsOpen) {
-            this.dataChannels.sendSelectedEndpointMessage(id);
+        if (this._channel && this._channelOpen) {
+            this._channel.sendSelectedEndpointMessage(id);
         }
     }
 
      * Elects the participant with the given id to be the pinned participant in
      * order to always receive video for this participant (even when last n is
      * enabled).
-     * @param id {string} the user id
+     * @param {stirng} id The user id.
      * @throws NetworkError or InvalidStateError or Error if the operation
      * fails.
      */
     pinEndpoint(id) {
-        // cache the value if channel is missing, till we open it
+        // Cache the value if channel is missing, till we open it.
         this._pinnedEndpoint = id;
-        if (this.dataChannels && this.dataChannelsOpen) {
-            this.dataChannels.sendPinnedEndpointMessage(id);
+        if (this._channel && this._channelOpen) {
+            this._channel.sendPinnedEndpointMessage(id);
         }
     }
 
 
     /**
      * Creates new <tt>TraceablePeerConnection</tt>
-     * @param {SignalingLayer} signaling the signaling layer that will
-     * provide information about the media or participants which is not carried
-     * over SDP.
-     * @param {Object} iceConfig an object describing the ICE config like
-     * defined in the WebRTC specification.
-     * @param {boolean} isP2P indicates whether or not the new TPC will be used
-     * in a peer to peer type of session
-     * @param {Object} options the config options
-     * @param {boolean} options.disableSimulcast if set to 'true' will disable
-     * the simulcast
-     * @param {boolean} options.disableRtx if set to 'true' will disable the RTX
-     * @param {boolean} options.preferH264 if set to 'true' H264 will be
-     * preferred over other video codecs.
+     * @param {SignalingLayer} signaling The signaling layer that will
+     *      provide information about the media or participants which is not
+     *      carried over SDP.
+     * @param {object} iceConfig An object describing the ICE config like
+     *      defined in the WebRTC specification.
+     * @param {boolean} isP2P Indicates whether or not the new TPC will be used
+     *      in a peer to peer type of session.
+     * @param {object} options The config options.
+     * @param {boolean} options.disableSimulcast If set to 'true' will disable
+     *      the simulcast.
+     * @param {boolean} options.disableRtx If set to 'true' will disable the
+     *      RTX.
+     * @param {boolean} options.preferH264 If set to 'true' H264 will be
+     *      preferred over other video codecs.
      * @return {TraceablePeerConnection}
      */
     createPeerConnection(signaling, iceConfig, isP2P, options) {
     /**
      * Returns the local tracks of the given media type, or all local tracks if
      * no specific type is given.
-     * @param {MediaType} [mediaType] optional media type filter
+     * @param {MediaType} [mediaType] Optional media type filter.
      * (audio or video).
      */
     getLocalTracks(mediaType) {
 
     /**
      * Obtains all remote tracks currently known to this RTC module instance.
-     * @param {MediaType} [mediaType] the remote tracks will be filtered
-     * by their media type if this argument is specified.
+     * @param {MediaType} [mediaType] The remote tracks will be filtered
+     *      by their media type if this argument is specified.
      * @return {Array<JitsiRemoteTrack>}
      */
     getRemoteTracks(mediaType) {
 
     /**
      * Set mute for all local audio streams attached to the conference.
-     * @param value the mute value
+     * @param value The mute value.
      * @returns {Promise}
      */
     setAudioMute(value) {
      * Removes all JitsiRemoteTracks associated with given MUC nickname
      * (resource part of the JID). Returns array of removed tracks.
      *
-     * @param {string} owner - The resource part of the MUC JID.
+     * @param {string} Owner The resource part of the MUC JID.
      * @returns {JitsiRemoteTrack[]}
      */
     removeRemoteTracks(owner) {
     /**
      * Returns true if changing the input (camera / microphone) or output
      * (audio) device is supported and false if not.
-     * @params {string} [deviceType] - type of device to change. Default is
+     * @param {string} [deviceType] Type of device to change. Default is
      *      undefined or 'input', 'output' - for audio output device change.
      * @returns {boolean} true if available, false otherwise.
      */
     /**
      * Returns list of available media devices if its obtained, otherwise an
      * empty array is returned/
-     * @returns {Array} list of available media devices.
+     * @returns {array} list of available media devices.
      */
     static getCurrentlyAvailableMediaDevices() {
         return RTCUtils.getCurrentlyAvailableMediaDevices();
 
     /**
      * Sets current audio output device.
-     * @param {string} deviceId - id of 'audiooutput' device from
-     *      navigator.mediaDevices.enumerateDevices()
-     * @returns {Promise} - resolves when audio output is changed, is rejected
+     * @param {string} deviceId Id of 'audiooutput' device from
+     *      navigator.mediaDevices.enumerateDevices().
+     * @returns {Promise} resolves when audio output is changed, is rejected
      *      otherwise
      */
     static setAudioOutputDevice(deviceId) {
      * "streams/channels/tracks" for receiving remote stream/tracks, as opposed
      * to Plan B where there are only 3 channels: audio, video and data.
      *
-     * @param {MediaStream} stream the WebRTC MediaStream instance
+     * @param {MediaStream} stream The WebRTC MediaStream instance.
      * @returns {boolean}
      */
     static isUserStream(stream) {
      * "streams/channels/tracks" for receiving remote stream/tracks, as opposed
      * to Plan B where there are only 3 channels: audio, video and data.
      *
-     * @param {string} streamId the id of WebRTC MediaStream
+     * @param {string} streamId The id of WebRTC MediaStream.
      * @returns {boolean}
      */
     static isUserStreamById(streamId) {
 
     /**
      * Allows to receive list of available cameras/microphones.
-     * @param {function} callback would receive array of devices as an argument
+     * @param {function} callback Would receive array of devices as an
+     *      argument.
      */
     static enumerateDevices(callback) {
         RTCUtils.enumerateDevices(callback);
     /**
      * A method to handle stopping of the stream.
      * One point to handle the differences in various implementations.
-     * @param mediaStream MediaStream object to stop.
+     * @param {MediaStream} mediaStream MediaStream object to stop.
      */
     static stopMediaStream(mediaStream) {
         RTCUtils.stopMediaStream(mediaStream);
     }
 
     /**
-     * Closes all currently opened data channels.
+     * Closes the currently opened bridge channel.
      */
-    closeAllDataChannels() {
-        if (this.dataChannels) {
-            this.dataChannels.closeAllChannels();
-            this.dataChannelsOpen = false;
+    closeBridgeChannel() {
+        if (this._channel) {
+            this._channel.close();
+            this._channelOpen = false;
 
             this.removeListener(RTCEvents.LASTN_ENDPOINT_CHANGED,
                 this._lastNChangeListener);
     /* eslint-enable max-params */
 
     /**
-     * Sends message via the datachannels.
-     * @param to {string} the id of the endpoint that should receive the
-     * message. If "" the message will be sent to all participants.
-     * @param payload {object} the payload of the message.
+     * Sends message via the bridge channel.
+     * @param {string} to The id of the endpoint that should receive the
+     *      message. If "" the message will be sent to all participants.
+     * @param {object} payload The payload of the message.
      * @throws NetworkError or InvalidStateError or Error if the operation
-     * fails or there is no data channel created
+     * fails or there is no data channel created.
      */
-    sendDataChannelMessage(to, payload) {
-        if (this.dataChannels) {
-            this.dataChannels.sendDataChannelMessage(to, payload);
+    sendChannelMessage(to, payload) {
+        if (this._channel) {
+            this._channel.sendMessage(to, payload);
         } else {
-            throw new Error('Data channels support is disabled!');
+            throw new Error('Channel support is disabled!');
         }
     }
 
      * Selects a new value for "lastN". The requested amount of videos are going
      * to be delivered after the value is in effect. Set to -1 for unlimited or
      * all available videos.
-     * @param value {number} the new value for lastN.
+     * @param {number} value the new value for lastN.
      */
     setLastN(value) {
         if (this._lastN !== value) {
             this._lastN = value;
-            if (this.dataChannels && this.dataChannelsOpen) {
-                this.dataChannels.sendSetLastNMessage(value);
+            if (this._channel && this._channelOpen) {
+                this._channel.sendSetLastNMessage(value);
             }
             this.eventEmitter.emit(RTCEvents.LASTN_VALUE_CHANGED, value);
         }
 
     /**
      * Indicates if the endpoint id is currently included in the last N.
-     *
-     * @param {string} id the endpoint id that we check for last N.
+     * @param {string} id The endpoint id that we check for last N.
      * @returns {boolean} true if the endpoint id is in the last N or if we
-     * don't have data channel support, otherwise we return false.
+     * don't have bridge channel support, otherwise we return false.
      */
     isInLastN(id) {
-        return !this._lastNEndpoints // lastNEndpoints not initialised yet
+        return !this._lastNEndpoints // lastNEndpoints not initialised yet.
             || this._lastNEndpoints.indexOf(id) > -1;
     }
 }

modules/RTC/RTCBrowserType.js

         return !RTCBrowserType.isFirefox();
     },
 
+    /**
+     * Checks if the current browser supports WebRTC datachannels.
+     * @return {boolean}
+     */
+    supportsDataChannels() {
+        // NOTE: Edge does not yet implement DataChannel.
+        return !RTCBrowserType.isEdge();
+    },
+
     /**
      * Checks if the current browser reports round trip time statistics for
      * the ICE candidate pair.

modules/xmpp/JingleSessionPC.js

          */
         this._gatheringReported = false;
 
+        /**
+         * WebSocket URL for the bridge channel with the videobridge.
+         * @type {string}
+         */
+        this.bridgeWebSocketUrl = null;
+
         this.lasticecandidate = false;
         this.closed = false;
 
         });
     }
 
+    /**
+     * Reads the "url" parameter in the <web-socket> tag of the jingle offer iq
+     * and stores it into this.bridgeWebSocketUrl.
+     * @param contets
+     */
+    readBridgeWebSocketUrl(contents) {
+        const webSocket
+            = $(contents)
+                .find('transport>web-socket')
+                .first();
+
+        if (webSocket.length === 1) {
+            this.bridgeWebSocketUrl = webSocket[0].getAttribute('url');
+        }
+    }
+
     /**
      * Makes the underlying TraceablePeerConnection generate new SSRC for
      * the recvonly video stream.
 
         remoteSdp.fromJingle(offerIq);
         this.readSsrcInfo($(offerIq).find('>content'));
+        this.readBridgeWebSocketUrl($(offerIq).find('>content'));
 
         return remoteSdp;
     }

modules/xmpp/moderator.js

 /* global $, $iq, Promise, Strophe */
 
 const logger = require('jitsi-meet-logger').getLogger(__filename);
+
 const XMPPEvents = require('../../service/xmpp/XMPPEvents');
 const AuthenticationEvents
     = require('../../service/authentication/AuthenticationEvents');
 const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
 
+import RTCBrowserType from '../RTC/RTCBrowserType';
 import Settings from '../settings/Settings';
 
 /**
                 value: this.options.conference.minBitrate
             }).up();
     }
-    if (this.options.conference.openSctp !== undefined) {
-        elem.c(
-            'property', {
-                name: 'openSctp',
-                value: this.options.conference.openSctp
-            }).up();
+
+    let openSctp;
+
+    switch (this.options.conference.openBridgeChannel) {
+    case 'datachannel':
+    case true:
+    case undefined:
+        openSctp = true;
+        break;
+    case 'websocket':
+        openSctp = false;
+        break;
+    }
+
+    if (openSctp && !RTCBrowserType.supportsDataChannels()) {
+        openSctp = false;
     }
+
+    elem.c(
+        'property', {
+            name: 'openSctp',
+            value: openSctp
+        }).up();
+
     if (this.options.conference.startAudioMuted !== undefined) {
         elem.c(
             'property', {