ref(Listenable): some classes to use Listenable

JitsiConference.js

 /* global Strophe, $, Promise */
 
 var logger = require("jitsi-meet-logger").getLogger(__filename);
-var RTC = require("./modules/RTC/RTC");
+import RTC from "./modules/RTC/RTC";
 var XMPPEvents = require("./service/xmpp/XMPPEvents");
 var EventEmitter = require("events");
 import * as JitsiConferenceErrors from "./JitsiConferenceErrors";

JitsiMediaDevices.js

 var EventEmitter = require("events");
 var RTCEvents = require('./service/RTC/RTCEvents');
-var RTC = require("./modules/RTC/RTC");
+import RTC from "./modules/RTC/RTC";
 var MediaType = require('./service/RTC/MediaType');
 import * as JitsiMediaDevicesEvents from "./JitsiMediaDevicesEvents";
 var Statistics = require("./modules/statistics/statistics");

JitsiMeetJS.js

 var JitsiRecorderErrors = require("./JitsiRecorderErrors");
 var Logger = require("jitsi-meet-logger");
 var MediaType = require("./service/RTC/MediaType");
-var RTC = require("./modules/RTC/RTC");
+import RTC from "./modules/RTC/RTC";
 var RTCUIHelper = require("./modules/RTC/RTCUIHelper");
 var Statistics = require("./modules/statistics/statistics");
 var Resolutions = require("./service/RTC/Resolutions");

modules/RTC/JitsiLocalTrack.js

 var MediaType = require('../../service/RTC/MediaType');
 var RTCBrowserType = require("./RTCBrowserType");
 var RTCEvents = require("../../service/RTC/RTCEvents");
-var RTCUtils = require("./RTCUtils");
+import RTCUtils from "./RTCUtils";
 var Statistics = require("../statistics/statistics");
 var VideoType = require('../../service/RTC/VideoType');
 

modules/RTC/JitsiTrack.js

 /* global __filename, module */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTCBrowserType = require("./RTCBrowserType");
-var RTCUtils = require("./RTCUtils");
+import RTCUtils from "./RTCUtils";
 import * as JitsiTrackEvents from "../../JitsiTrackEvents";
 var EventEmitter = require("events");
 var MediaType = require("../../service/RTC/MediaType");

modules/RTC/RTCUtils.js

 var VideoType = require("../../service/RTC/VideoType");
 var CameraFacingMode = require("../../service/RTC/CameraFacingMode");
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
+import Listenable from "../util/Listenable";
 
 // XXX Don't require Temasys unless it's to be used because it doesn't run on
 // React Native, for example.
     // Initialize rawEnumerateDevicesWithCallback
     initRawEnumerateDevicesWithCallback();
 
-    if (RTCUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
+    if (rtcUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
         rawEnumerateDevicesWithCallback(function (devices) {
             currentlyAvailableMediaDevices = devices.splice(0);
 
                 navigator.mediaDevices.addEventListener(
                     'devicechange',
                     function () {
-                        RTCUtils.enumerateDevices(
+                        rtcUtils.enumerateDevices(
                             onMediaDevicesListChanged);
                     });
             } else {
         },
         function (error) {
             Object.keys(options.streams).forEach(function(device) {
-                RTCUtils.stopMediaStream(options.streams[device]);
+                rtcUtils.stopMediaStream(options.streams[device]);
             });
             logger.error(
                 "failed to obtain " + device + " stream - stop", error);
  */
 function wrapAttachMediaStream(origAttachMediaStream) {
     return function(element, stream) {
-        var res = origAttachMediaStream.apply(RTCUtils, arguments);
+        var res = origAttachMediaStream.apply(rtcUtils, arguments);
 
         if (stream
-                && RTCUtils.isDeviceChangeAvailable('output')
+                && rtcUtils.isDeviceChangeAvailable('output')
                 && stream.getAudioTracks
                 && stream.getAudioTracks().length
                 // we skip setting audio output if there was no explicit change
                 && audioOutputChanged) {
-            element.setSinkId(RTCUtils.getAudioOutputDevice())
+            element.setSinkId(rtcUtils.getAudioOutputDevice())
                 .catch(function (ex) {
                     var err = new JitsiTrackError(ex, null, ['audiooutput']);
 
 }
 
 //Options parameter is to pass config options. Currently uses only "useIPv6".
-var RTCUtils = {
-    init: function (options) {
+class RTCUtils extends Listenable {
+    constructor() {
+        super(eventEmitter);
+    }
 
+    init(options) {
         if (typeof(options.disableAEC) === "boolean") {
             disableAEC = options.disableAEC;
             logger.info("Disable AEC: " + disableAEC);
                 resolve();
             }
         }.bind(this));
-    },
+    }
+
     /**
     * @param {string[]} um required user media types
     * @param {function} success_callback
     * @param {string} options.cameraDeviceId
     * @param {string} options.micDeviceId
     **/
-    getUserMediaWithConstraints: function ( um, success_callback, failure_callback, options) {
+    getUserMediaWithConstraints( um, success_callback, failure_callback, options) {
         options = options || {};
         var constraints = getConstraints(um, options);
 
                 failure_callback(new JitsiTrackError(e, constraints, um));
             }
         }
-    },
+    }
 
     /**
      * Creates the local MediaStreams.
      * @param {string} options.micDeviceId
      * @returns {*} Promise object that will receive the new JitsiTracks
      */
-    obtainAudioAndVideoPermissions: function (options) {
+    obtainAudioAndVideoPermissions (options) {
         var self = this;
 
         options = options || {};
                 }
             }
         }.bind(this));
-    },
-    addListener: function (eventType, listener) {
-        eventEmitter.on(eventType, listener);
-    },
-    removeListener: function (eventType, listener) {
-        eventEmitter.removeListener(eventType, listener);
-    },
-    getDeviceAvailability: function () {
+    }
+
+    getDeviceAvailability () {
         return devices;
-    },
-    isRTCReady: function () {
+    }
+
+    isRTCReady () {
         return rtcReady;
-    },
-    _isDeviceListAvailable: function () {
+    }
+
+    _isDeviceListAvailable () {
         if (!rtcReady)
             throw new Error("WebRTC not ready yet");
         var isEnumerateDevicesAvailable
         }
         return (typeof MediaStreamTrack !== "undefined" &&
             MediaStreamTrack.getSources)? true : false;
-    },
+    }
+
     /**
      * Returns a promise which can be used to make sure that the WebRTC stack
      * has been initialized.
      * Note that currently we do not detect stack initialization failure and
      * the promise is never rejected(unless unexpected error occurs).
      */
-    onRTCReady: function() {
+    onRTCReady () {
         if (rtcReady) {
             return Promise.resolve();
         } else {
                 // happens
             });
         }
-    },
+    }
+
     /**
      * Checks if its possible to enumerate available cameras/microphones.
      *
      * the WebRTC stack is ready, either with true if the device listing is
      * available available or with false otherwise.
      */
-    isDeviceListAvailable: function () {
+    isDeviceListAvailable () {
         return this.onRTCReady().then(function() {
             return this._isDeviceListAvailable();
         }.bind(this));
-    },
+    }
+
     /**
      * Returns true if changing the input (camera / microphone) or output
      * (audio) device is supported and false if not.
      *      undefined or 'input', 'output' - for audio output device change.
      * @returns {boolean} true if available, false otherwise.
      */
-    isDeviceChangeAvailable: function (deviceType) {
+    isDeviceChangeAvailable (deviceType) {
         return deviceType === 'output' || deviceType === 'audiooutput'
             ? isAudioOutputDeviceChangeAvailable
             : RTCBrowserType.isChrome() ||
                 RTCBrowserType.isTemasysPluginUsed()||
                 RTCBrowserType.isNWJS() ||
                 RTCBrowserType.isElectron();
-    },
+    }
     /**
      * A method to handle stopping of the stream.
      * One point to handle the differences in various implementations.
      * @param mediaStream MediaStream object to stop.
      */
-    stopMediaStream: function (mediaStream) {
+    stopMediaStream (mediaStream) {
         mediaStream.getTracks().forEach(function (track) {
             // stop() not supported with IE
             if (!RTCBrowserType.isTemasysPluginUsed() && track.stop) {
             delete mediaStream.jitsiObjectURL;
             (URL || webkitURL).revokeObjectURL(url);
         }
-    },
+    }
+
     /**
      * Returns whether the desktop sharing is enabled or not.
      * @returns {boolean}
      */
-    isDesktopSharingEnabled: function () {
+    isDesktopSharingEnabled () {
         return screenObtainer.isSupported();
-    },
+    }
+
     /**
      * Sets current audio output device.
      * @param {string} deviceId - id of 'audiooutput' device from
      * @returns {Promise} - resolves when audio output is changed, is rejected
      *      otherwise
      */
-    setAudioOutputDevice: function (deviceId) {
+    setAudioOutputDevice (deviceId) {
         if (!this.isDeviceChangeAvailable('output')) {
             Promise.reject(
                 new Error('Audio output device change is not supported'));
                 eventEmitter.emit(RTCEvents.AUDIO_OUTPUT_DEVICE_CHANGED,
                     deviceId);
             });
-    },
+    }
+
     /**
      * Returns currently used audio output device id, '' stands for default
      * device
      * @returns {string}
      */
-    getAudioOutputDevice: function () {
+    getAudioOutputDevice () {
         return audioOutputDeviceId;
-    },
+    }
 
     /**
      * Returns list of available media devices if its obtained, otherwise an
      * empty array is returned/
      * @returns {Array} list of available media devices.
      */
-    getCurrentlyAvailableMediaDevices: function () {
+    getCurrentlyAvailableMediaDevices () {
         return currentlyAvailableMediaDevices;
-    },
+    }
 
     /**
      * Returns event data for device to be reported to stats.
      * @returns {MediaDeviceInfo} device.
      */
-    getEventDataForActiveDevice: function (device) {
+    getEventDataForActiveDevice (device) {
         var devices = [];
         var deviceData = {
             "deviceId": device.deviceId,
         devices.push(deviceData);
         return { deviceList: devices };
     }
-};
+}
+
+const rtcUtils = new RTCUtils();
 
-module.exports = RTCUtils;
+export default rtcUtils;

modules/xmpp/JingleSessionPC.js

 var async = require("async");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var RTCBrowserType = require("../RTC/RTCBrowserType");
-var RTC = require("../RTC/RTC");
+import RTC from "../RTC/RTC";
 var GlobalOnErrorHandler = require("../util/GlobalOnErrorHandler");
 var Statistics = require("../statistics/statistics");
 

modules/xmpp/TraceablePeerConnection.js

 
 import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
-var RTC = require('../RTC/RTC');
+import RTC from '../RTC/RTC';
 var RTCBrowserType = require("../RTC/RTCBrowserType.js");
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var transform = require('sdp-transform');

modules/xmpp/xmpp.js

 
 import { getLogger } from "jitsi-meet-logger";
 const logger = getLogger(__filename);
-import EventEmitter from "events";
 import RandomUtil from "../util/RandomUtil";
 import * as JitsiConnectionErrors from "../../JitsiConnectionErrors";
 import * as JitsiConnectionEvents from "../../JitsiConnectionEvents";
 import initPing from "./strophe.ping";
 import initRayo from "./strophe.rayo";
 import initStropheLogger from "./strophe.logger";
+import Listenable from "../util/Listenable";
 
 function createConnection(token, bosh = '/http-bind') {
     // Append token as URL param
     return new Strophe.Connection(bosh);
 }
 
-export default class XMPP {
+export default class XMPP extends Listenable {
     constructor(options, token) {
-        this.eventEmitter = new EventEmitter();
+        super();
         this.connection = null;
         this.disconnectInProgress = false;
         this.connectionTimes = {};
         return this.connection.emuc.createRoom(roomjid, null, options);
     }
 
-    addListener (type, listener) {
-        this.eventEmitter.on(type, listener);
-    }
-
-    removeListener (type, listener) {
-        this.eventEmitter.removeListener(type, listener);
-    }
-
     /**
      * Returns the logs from strophe.jingle.
      * @returns {Object}