Merge branch 'master' into eslint_rules

.eslintrc.js

         'no-undef-init': 2,
         'no-undefined': 0,
         'no-unused-vars': 2,
+        'no-use-before-define': [ 'error', { 'functions': false } ],
 
         // Stylistic issues group
         'array-bracket-spacing': [

JitsiMediaDevices.js

 
 const eventEmitter = new EventEmitter();
 
-RTC.addListener(
-    RTCEvents.DEVICE_LIST_CHANGED,
-    devices =>
-        eventEmitter.emit(
-            JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED,
-            devices));
-
-RTC.addListener(RTCEvents.DEVICE_LIST_AVAILABLE,
-    devices => {
-        // log output device
-        logOutputDevice(
-            JitsiMediaDevices.getAudioOutputDevice(),
-            devices);
-    });
-
 /**
  * Gathers data and sends it to statistics.
  * @param deviceID the device id to log
     }
 };
 
+
+RTC.addListener(
+    RTCEvents.DEVICE_LIST_CHANGED,
+    devices =>
+        eventEmitter.emit(
+            JitsiMediaDevicesEvents.DEVICE_LIST_CHANGED,
+            devices));
+RTC.addListener(
+    RTCEvents.DEVICE_LIST_AVAILABLE,
+    devices =>
+        logOutputDevice(
+            JitsiMediaDevices.getAudioOutputDevice(),
+            devices));
+
 module.exports = JitsiMediaDevices;

modules/RTC/RTCBrowserType.js

 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
+let browserVersion; // eslint-disable-line prefer-const
+
 let currentBrowser;
 
+const isAndroid = navigator.userAgent.indexOf('Android') !== -1;
+
 const RTCBrowserType = {
 
     RTC_BROWSER_CHROME: 'rtc_browser.chrome',
     return 1;
 }
 
-const browserVersion = detectBrowser();
-const isAndroid = navigator.userAgent.indexOf('Android') !== -1;
+browserVersion = detectBrowser();
 
 module.exports = RTCBrowserType;

modules/RTC/RTCUtils.js

     eventEmitter.emit(RTCEvents.DEVICE_LIST_CHANGED, devicesReceived);
 }
 
-// In case of IE we continue from 'onReady' callback
-// passed to RTCUtils constructor. It will be invoked by Temasys plugin
-// once it is initialized.
-function onReady(options, GUM) {
-    rtcReady = true;
-    eventEmitter.emit(RTCEvents.RTC_READY, true);
-    screenObtainer.init(options, GUM);
-
-    // Initialize rawEnumerateDevicesWithCallback
-    initRawEnumerateDevicesWithCallback();
-
-    if (rtcUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
-        rawEnumerateDevicesWithCallback(ds => {
-            currentlyAvailableMediaDevices = ds.splice(0);
-
-            eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
-                currentlyAvailableMediaDevices);
-
-            if (isDeviceChangeEventSupported) {
-                navigator.mediaDevices.addEventListener(
-                    'devicechange',
-                    () => rtcUtils.enumerateDevices(onMediaDevicesListChanged));
-            } else {
-                pollForAvailableMediaDevices();
-            }
-        });
-    }
-}
-
 /**
  * Apply function with arguments if function exists.
  * Do nothing if function not provided.
     };
 }
 
-function obtainDevices(options) {
-    if (!options.devices || options.devices.length === 0) {
-        return options.successCallback(options.streams || {});
-    }
-
-    const device = options.devices.splice(0, 1);
-
-    options.deviceGUM[device](
-        stream => {
-            options.streams = options.streams || {};
-            options.streams[device] = stream;
-            obtainDevices(options);
-        },
-        error => {
-            Object.keys(options.streams).forEach(
-                d => rtcUtils.stopMediaStream(options.streams[d]));
-            logger.error(
-                `failed to obtain ${device} stream - stop`, error);
-
-            options.errorCallback(error);
-        });
-}
-
-
 /**
  * Handles the newly created Media Streams.
  * @param streams the new Media Streams
     return res;
 }
 
-/**
- * Wraps original attachMediaStream function to set current audio output device
- * if this is supported.
- * @param {Function} origAttachMediaStream
- * @returns {Function}
- */
-function wrapAttachMediaStream(origAttachMediaStream) {
-    return function(element, stream) {
-        // eslint-disable-next-line prefer-rest-params
-        const res = origAttachMediaStream.apply(rtcUtils, arguments);
-
-        if (stream
-                && rtcUtils.isDeviceChangeAvailable('output')
-                && stream.getAudioTracks
-                && stream.getAudioTracks().length
-
-                // we skip setting audio output if there was no explicit change
-                && audioOutputChanged) {
-            element.setSinkId(rtcUtils.getAudioOutputDevice())
-                .catch(function(ex) {
-                    const err
-                        = new JitsiTrackError(ex, null, [ 'audiooutput' ]);
-
-                    GlobalOnErrorHandler.callUnhandledRejectionHandler(
-                        { promise: this,
-                            reason: err });
-
-                    logger.warn('Failed to set audio output device for the '
-                        + 'element. Default audio output device will be used '
-                        + 'instead',
-                        element, err);
-                });
-        }
-
-        return res;
-    };
-}
-
 /**
  * Represents a default implementation of setting a <tt>MediaStream</tt> as the
  * source of a video element that tries to be browser-agnostic through feature
 
 const rtcUtils = new RTCUtils();
 
+function obtainDevices(options) {
+    if (!options.devices || options.devices.length === 0) {
+        return options.successCallback(options.streams || {});
+    }
+
+    const device = options.devices.splice(0, 1);
+
+    options.deviceGUM[device](
+        stream => {
+            options.streams = options.streams || {};
+            options.streams[device] = stream;
+            obtainDevices(options);
+        },
+        error => {
+            Object.keys(options.streams).forEach(
+                d => rtcUtils.stopMediaStream(options.streams[d]));
+            logger.error(
+                `failed to obtain ${device} stream - stop`, error);
+
+            options.errorCallback(error);
+        });
+}
+
+// In case of IE we continue from 'onReady' callback
+// passed to RTCUtils constructor. It will be invoked by Temasys plugin
+// once it is initialized.
+function onReady(options, GUM) {
+    rtcReady = true;
+    eventEmitter.emit(RTCEvents.RTC_READY, true);
+    screenObtainer.init(options, GUM);
+
+    // Initialize rawEnumerateDevicesWithCallback
+    initRawEnumerateDevicesWithCallback();
+
+    if (rtcUtils.isDeviceListAvailable() && rawEnumerateDevicesWithCallback) {
+        rawEnumerateDevicesWithCallback(ds => {
+            currentlyAvailableMediaDevices = ds.splice(0);
+
+            eventEmitter.emit(RTCEvents.DEVICE_LIST_AVAILABLE,
+                currentlyAvailableMediaDevices);
+
+            if (isDeviceChangeEventSupported) {
+                navigator.mediaDevices.addEventListener(
+                    'devicechange',
+                    () => rtcUtils.enumerateDevices(onMediaDevicesListChanged));
+            } else {
+                pollForAvailableMediaDevices();
+            }
+        });
+    }
+}
+
+/**
+ * Wraps original attachMediaStream function to set current audio output device
+ * if this is supported.
+ * @param {Function} origAttachMediaStream
+ * @returns {Function}
+ */
+function wrapAttachMediaStream(origAttachMediaStream) {
+    return function(element, stream) {
+        // eslint-disable-next-line prefer-rest-params
+        const res = origAttachMediaStream.apply(rtcUtils, arguments);
+
+        if (stream
+                && rtcUtils.isDeviceChangeAvailable('output')
+                && stream.getAudioTracks
+                && stream.getAudioTracks().length
+
+                // we skip setting audio output if there was no explicit change
+                && audioOutputChanged) {
+            element.setSinkId(rtcUtils.getAudioOutputDevice())
+                .catch(function(ex) {
+                    const err
+                        = new JitsiTrackError(ex, null, [ 'audiooutput' ]);
+
+                    GlobalOnErrorHandler.callUnhandledRejectionHandler({
+                        promise: this,
+                        reason: err
+                    });
+
+                    logger.warn('Failed to set audio output device for the '
+                        + 'element. Default audio output device will be used '
+                        + 'instead',
+                        element, err);
+                });
+        }
+
+        return res;
+    };
+}
+
 export default rtcUtils;

modules/statistics/CallStats.js

  */
 const DEFAULT_REMOTE_USER = 'jitsi';
 
-function initCallback(err, msg) {
-    logger.log(`CallStats Status: err=${err} msg=${msg}`);
-
-    CallStats.initializeInProgress = false;
-
-    // there is no lib, nothing to report to
-    if (err !== 'success') {
-        CallStats.initializeFailed = true;
-
-        return;
-    }
-
-    const ret = callStats.addNewFabric(this.peerconnection,
-        DEFAULT_REMOTE_USER,
-        callStats.fabricUsage.multiplex,
-        this.confID,
-        this.pcCallback.bind(this));
-
-    const fabricInitialized = ret.status === 'success';
-
-    if (!fabricInitialized) {
-        CallStats.initializeFailed = true;
-        logger.log('callstats fabric not initilized', ret.message);
-
-        return;
-    }
-
-    CallStats.initializeFailed = false;
-    CallStats.initialized = true;
-    CallStats.feedbackEnabled = true;
-
-    // notify callstats about failures if there were any
-    if (CallStats.reportsQueue.length) {
-        CallStats.reportsQueue.forEach(function(report) {
-            if (report.type === reportType.ERROR) {
-                const error = report.data;
-
-                CallStats._reportError.call(this, error.type, error.error,
-                    error.pc);
-            } else if (report.type === reportType.EVENT
-                && fabricInitialized) {
-                // if we have and event to report and we failed to add fabric
-                // this event will not be reported anyway, returning an error
-                const eventData = report.data;
-
-                callStats.sendFabricEvent(
-                    this.peerconnection,
-                    eventData.event,
-                    this.confID,
-                    eventData.eventData);
-            } else if (report.type === reportType.MST_WITH_USERID) {
-                const data = report.data;
-
-                callStats.associateMstWithUserID(
-                    this.peerconnection,
-                    data.callStatsId,
-                    this.confID,
-                    data.ssrc,
-                    data.usageLabel,
-                    data.containerId
-                );
-            }
-        }, this);
-        CallStats.reportsQueue.length = 0;
-    }
-}
+/**
+ * Type of pending reports, can be event or an error.
+ * @type {{ERROR: string, EVENT: string}}
+ */
+const reportType = {
+    ERROR: 'error',
+    EVENT: 'event',
+    MST_WITH_USERID: 'mstWithUserID'
+};
 
 /**
  * Returns a function which invokes f in a try/catch block, logs any exception
         initCallback.bind(callStats));
 };
 
-/**
- * Type of pending reports, can be event or an error.
- * @type {{ERROR: string, EVENT: string}}
- */
-const reportType = {
-    ERROR: 'error',
-    EVENT: 'event',
-    MST_WITH_USERID: 'mstWithUserID'
-};
-
 CallStats.prototype.pcCallback = tryCatch((err, msg) => {
     if (callStats && err !== 'success') {
         logger.error(`Monitoring status: ${err} msg: ${msg}`);
     CallStats.initializeInProgress = false;
 };
 
+function initCallback(err, msg) {
+    logger.log(`CallStats Status: err=${err} msg=${msg}`);
+
+    CallStats.initializeInProgress = false;
+
+    // there is no lib, nothing to report to
+    if (err !== 'success') {
+        CallStats.initializeFailed = true;
+
+        return;
+    }
+
+    const ret = callStats.addNewFabric(this.peerconnection,
+        DEFAULT_REMOTE_USER,
+        callStats.fabricUsage.multiplex,
+        this.confID,
+        this.pcCallback.bind(this));
+
+    const fabricInitialized = ret.status === 'success';
+
+    if (!fabricInitialized) {
+        CallStats.initializeFailed = true;
+        logger.log('callstats fabric not initilized', ret.message);
+
+        return;
+    }
+
+    CallStats.initializeFailed = false;
+    CallStats.initialized = true;
+    CallStats.feedbackEnabled = true;
+
+    // notify callstats about failures if there were any
+    if (CallStats.reportsQueue.length) {
+        CallStats.reportsQueue.forEach(function(report) {
+            if (report.type === reportType.ERROR) {
+                const error = report.data;
+
+                CallStats._reportError.call(this, error.type, error.error,
+                    error.pc);
+            } else if (report.type === reportType.EVENT
+                && fabricInitialized) {
+                // if we have and event to report and we failed to add fabric
+                // this event will not be reported anyway, returning an error
+                const eventData = report.data;
+
+                callStats.sendFabricEvent(
+                    this.peerconnection,
+                    eventData.event,
+                    this.confID,
+                    eventData.eventData);
+            } else if (report.type === reportType.MST_WITH_USERID) {
+                const data = report.data;
+
+                callStats.associateMstWithUserID(
+                    this.peerconnection,
+                    data.callStatsId,
+                    this.confID,
+                    data.ssrc,
+                    data.usageLabel,
+                    data.containerId
+                );
+            }
+        }, this);
+        CallStats.reportsQueue.length = 0;
+    }
+}
+
 module.exports = CallStats;

modules/transcription/audioRecorder.js

     trackRecorder.recorder.stop();
 }
 
-/**
- * Creates a TrackRecorder object. Also creates the MediaRecorder and
- * data array for the trackRecorder.
- * @param track the JitsiTrack holding the audio MediaStream(s)
- */
-function instantiateTrackRecorder(track) {
-    const trackRecorder = new TrackRecorder(track);
-
-    // Create a new stream which only holds the audio track
-    const originalStream = trackRecorder.track.getOriginalStream();
-    const stream = createEmptyStream();
-
-    originalStream.getAudioTracks().forEach(t => stream.addTrack(t));
-
-    // Create the MediaRecorder
-    trackRecorder.recorder = new MediaRecorder(stream,
-        { mimeType: audioRecorder.fileType });
-
-    // array for holding the recorder data. Resets it when
-    // audio already has been recorder once
-    trackRecorder.data = [];
-
-    // function handling a dataEvent, e.g the stream gets new data
-    trackRecorder.recorder.ondataavailable = function(dataEvent) {
-        if (dataEvent.data.size > 0) {
-            trackRecorder.data.push(dataEvent.data);
-        }
-    };
-
-    return trackRecorder;
-}
-
 /**
  * Determines which kind of audio recording the browser supports
  * chrome supports "audio/webm" and firefox supports "audio/ogg"
     } else if (MediaRecorder.isTypeSupported(AUDIO_OGG)) {
         return AUDIO_OGG;
     }
-    throw new Error('unable to create a MediaRecorder with the'
-            + 'right mimetype!');
-
+    throw new Error(
+        'unable to create a MediaRecorder with the right mimetype!');
 }
 
 /**
     throw new Error('cannot create a clean mediaStream');
 }
 
+/**
+ * Creates a TrackRecorder object. Also creates the MediaRecorder and
+ * data array for the trackRecorder.
+ * @param track the JitsiTrack holding the audio MediaStream(s)
+ */
+function instantiateTrackRecorder(track) {
+    const trackRecorder = new TrackRecorder(track);
+
+    // Create a new stream which only holds the audio track
+    const originalStream = trackRecorder.track.getOriginalStream();
+    const stream = createEmptyStream();
+
+    originalStream.getAudioTracks().forEach(t => stream.addTrack(t));
+
+    // Create the MediaRecorder
+    trackRecorder.recorder
+        = new MediaRecorder(stream, { mimeType: audioRecorder.fileType });
+
+    // array for holding the recorder data. Resets it when
+    // audio already has been recorder once
+    trackRecorder.data = [];
+
+    // function handling a dataEvent, e.g the stream gets new data
+    trackRecorder.recorder.ondataavailable = ({ data }) => {
+        (data.size > 0) && trackRecorder.data.push(data);
+    };
+
+    return trackRecorder;
+}
+
 /**
  * export the main object audioRecorder
  */

modules/transcription/transcriber.js

  * @param {RecordingResult} answer a RecordingResult object with a defined
  * WordArray
  */
-const blobCallBack = function(answer) {
+function blobCallBack(answer) {
     console.log(
         'retrieved an answer from the transcription service. The answer has an'
             + ` array of length: ${answer.wordArray.length}`);
 
     // and check if all results have been received.
     this.maybeMerge();
-};
+}
 
 /**
  * this method will check if the counter is zero. If it is, it will call
  * @param {Array<Array>} twoDimensionalArray the array to check
  * @returns {boolean} true if any non-zero arrays inside, otherwise false
  */
-const hasPopulatedArrays = function(twoDimensionalArray) {
+function hasPopulatedArrays(twoDimensionalArray) {
     for (let i = 0; i < twoDimensionalArray.length; i++) {
         if (twoDimensionalArray[i].length === 0) {
             twoDimensionalArray.splice(i, 1);
     }
 
     return twoDimensionalArray.length > 0;
-};
+}
 
 /**
  * Push a word to the right location in a sorted array. The array is sorted
  * @param {Array<Word>} array the sorted array to push to
  * @param {Word} word the word to push into the array
  */
-const pushWordToSortedArray = function(array, word) {
+function pushWordToSortedArray(array, word) {
     if (array.length === 0) {
         array.push(word);
     } else {
 
             return;
         }
-        let i;
 
-        for (i = 0; i < array.length; i++) {
+        for (let i = 0; i < array.length; i++) {
             if (word.begin < array[i].begin) {
                 array.splice(i, 0, word);
 
         }
         array.push(word); // fail safe
     }
-};
+}
 
 /**
  * Gives the transcriber a JitsiTrack holding an audioStream to transcribe.

modules/xmpp/SdpTransformUtil.js

             .map(ssrcInfo => ssrcInfo.id)
             .filter((ssrc, index, array) => array.indexOf(ssrc) === index)
             .length;
-
-}
-
-/**
- * Utility class for SDP manipulation using the 'sdp-transform' library.
- *
- * Typical use usage scenario:
- *
- * const transformer = new SdpTransformWrap(rawSdp);
- * const videoMLine = transformer.selectMedia('video);
- * if (videoMLine) {
- *     videoMLiner.addSSRCAttribute({
- *         id: 2342343,
- *         attribute: "cname",
- *         value: "someCname"
- *     });
- *     rawSdp = transformer.toRawSdp();
- * }
- */
-export class SdpTransformWrap {
-
-    /**
-     * Creates new instance and parses the raw SDP into objects using
-     * 'sdp-transform' lib.
-     * @param {string} rawSDP the SDP in raw text format.
-     */
-    constructor(rawSDP) {
-        this.parsedSDP = transform.parse(rawSDP);
-    }
-
-    /**
-     * Selects the first media SDP of given name.
-     * @param {string} mediaType the name of the media e.g. 'audio', 'video',
-     * 'data'.
-     * @return {MLineWrap|null} return {@link MLineWrap} instance for the media
-     * line or <tt>null</tt> if not found. The object returned references
-     * the underlying SDP state held by this <tt>SdpTransformWrap</tt> instance
-     * (it's not a copy).
-     */
-    selectMedia(mediaType) {
-        const selectedMLine
-            = this.parsedSDP.media.find(mLine => mLine.type === mediaType);
-
-
-        return selectedMLine ? new MLineWrap(selectedMLine) : null;
-    }
-
-    /**
-     * Converts the currently stored SDP state in this instance to raw text SDP
-     * format.
-     * @return {string}
-     */
-    toRawSDP() {
-        return transform.write(this.parsedSDP);
-    }
 }
 
 /**
         this.ssrcGroups.push(group);
     }
 }
+
+/**
+ * Utility class for SDP manipulation using the 'sdp-transform' library.
+ *
+ * Typical use usage scenario:
+ *
+ * const transformer = new SdpTransformWrap(rawSdp);
+ * const videoMLine = transformer.selectMedia('video);
+ * if (videoMLine) {
+ *     videoMLiner.addSSRCAttribute({
+ *         id: 2342343,
+ *         attribute: "cname",
+ *         value: "someCname"
+ *     });
+ *     rawSdp = transformer.toRawSdp();
+ * }
+ */
+export class SdpTransformWrap {
+
+    /**
+     * Creates new instance and parses the raw SDP into objects using
+     * 'sdp-transform' lib.
+     * @param {string} rawSDP the SDP in raw text format.
+     */
+    constructor(rawSDP) {
+        this.parsedSDP = transform.parse(rawSDP);
+    }
+
+    /**
+     * Selects the first media SDP of given name.
+     * @param {string} mediaType the name of the media e.g. 'audio', 'video',
+     * 'data'.
+     * @return {MLineWrap|null} return {@link MLineWrap} instance for the media
+     * line or <tt>null</tt> if not found. The object returned references
+     * the underlying SDP state held by this <tt>SdpTransformWrap</tt> instance
+     * (it's not a copy).
+     */
+    selectMedia(mediaType) {
+        const selectedMLine
+            = this.parsedSDP.media.find(mLine => mLine.type === mediaType);
+
+        return selectedMLine ? new MLineWrap(selectedMLine) : null;
+    }
+
+    /**
+     * Converts the currently stored SDP state in this instance to raw text SDP
+     * format.
+     * @return {string}
+     */
+    toRawSDP() {
+        return transform.write(this.parsedSDP);
+    }
+}