[eslint] require-jsdoc

.eslintrc.js

         'padded-blocks': 0,
         'quote-props': 0,
         'quotes': [ 'error', 'single' ],
+        'require-jsdoc': [
+            'error',
+            {
+                'require': {
+                    'ClassDeclaration': true,
+                    'FunctionDeclaration': true,
+                    'MethodDefinition': true
+                }
+            }
+        ],
         'semi': [ 'error', 'always' ],
         'semi-spacing': 2,
         'sort-vars': 2,

JitsiMeetJS.js

 // JitsiMediaDevicesEvents.PERMISSION_PROMPT_IS_SHOWN event
 const USER_MEDIA_PERMISSION_PROMPT_TIMEOUT = 500;
 
+/**
+ *
+ * @param resolution
+ */
 function getLowerResolution(resolution) {
     if (!Resolutions[resolution]) {
         return null;

JitsiParticipant.js

         return this._role;
     }
 
+    /**
+     *
+     */
     supportsDTMF() {
         return this._supportsDTMF;
     }

doc/example/example.js

     }
 }
 
+/**
+ *
+ * @param id
+ */
 function onUserLeft(id) {
     console.log('user left');
     if (!remoteTracks[id]) {
         disconnect);
 }
 
+/**
+ *
+ */
 function unload() {
     for (let i = 0; i < localTracks.length; i++) {
         localTracks[i].stop();
 
 let isVideo = true;
 
+/**
+ *
+ */
 function switchVideo() { // eslint-disable-line no-unused-vars
     isVideo = !isVideo;
     if (localTracks[1]) {
         .catch(error => console.log(error));
 }
 
+/**
+ *
+ * @param selected
+ */
 function changeAudioOutput(selected) { // eslint-disable-line no-unused-vars
     JitsiMeetJS.mediaDevices.setAudioOutputDevice(selected.value);
 }

modules/DTMF/JitsiDTMFManager.js

 const logger = require('jitsi-meet-logger').getLogger(__filename);
 
+/**
+ *
+ * @param localAudio
+ * @param peerConnection
+ */
 function JitsiDTMFManager(localAudio, peerConnection) {
     const audioTrack = localAudio.getTrack();
 
     logger.debug('Initialized DTMFSender');
 }
 
-
 JitsiDTMFManager.prototype.sendTones = function(tones, duration, pause) {
     this.dtmfSender.insertDTMF(tones, duration || 200, pause || 200);
 };

modules/RTC/RTC.js

 
 const logger = getLogger(__filename);
 
+/**
+ *
+ * @param tracksInfo
+ * @param options
+ */
 function createLocalTracks(tracksInfo, options) {
     const newTracks = [];
     let deviceId = null;
     return newTracks;
 }
 
+/**
+ *
+ */
 export default class RTC extends Listenable {
+    /**
+     *
+     * @param conference
+     * @param options
+     */
     constructor(conference, options = {}) {
         super();
         this.conference = conference;
         }
     }
 
+    /**
+     *
+     * @param eventType
+     * @param listener
+     */
     static addListener(eventType, listener) {
         RTCUtils.addListener(eventType, listener);
     }
 
+    /**
+     *
+     * @param eventType
+     * @param listener
+     */
     static removeListener(eventType, listener) {
         RTCUtils.removeListener(eventType, listener);
     }
 
+    /**
+     *
+     */
     static isRTCReady() {
         return RTCUtils.isRTCReady();
     }
 
+    /**
+     *
+     * @param options
+     */
     static init(options = {}) {
         this.options = options;
 
         return RTCUtils.init(this.options);
     }
 
+    /**
+     *
+     */
     static getDeviceAvailability() {
         return RTCUtils.getDeviceAvailability();
     }
 
     }
 
+    /**
+     *
+     * @param track
+     */
     addLocalTrack(track) {
         if (!track) {
             throw new Error('track must not be null nor undefined');
         return Promise.all(mutePromises);
     }
 
+    /**
+     *
+     * @param track
+     */
     removeLocalTrack(track) {
         const pos = this.localTracks.indexOf(track);
 
         return toBeRemoved;
     }
 
+    /**
+     *
+     */
     static getPCConstraints() {
         return RTCUtils.pcConstraints;
     }
 
+    /**
+     *
+     * @param elSelector
+     * @param stream
+     */
     static attachMediaStream(elSelector, stream) {
         return RTCUtils.attachMediaStream(elSelector, stream);
     }
 
+    /**
+     *
+     * @param stream
+     */
     static getStreamID(stream) {
         return RTCUtils.getStreamID(stream);
     }
         }
     }
 
+    /**
+     *
+     * @param resource
+     * @param audioLevel
+     */
     setAudioLevel(resource, audioLevel) {
         if (!resource) {
             return;

modules/RTC/RTCBrowserType.js

     // Add version getters for other browsers when needed
 };
 
-// detectOpera() must be called before detectChrome() !!!
-// otherwise Opera wil be detected as Chrome
+/**
+ * detectOpera() must be called before detectChrome() !!!
+ * otherwise Opera wil be detected as Chrome
+ */
 function detectChrome() {
     if (navigator.webkitGetUserMedia) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_CHROME;
     return null;
 }
 
+/**
+ *
+ */
 function detectOpera() {
     const userAgent = navigator.userAgent;
 
     return null;
 }
 
+/**
+ *
+ */
 function detectFirefox() {
     if (navigator.mozGetUserMedia) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_FIREFOX;
     return null;
 }
 
+/**
+ *
+ */
 function detectSafari() {
     if (/^((?!chrome).)*safari/i.test(navigator.userAgent)) {
         currentBrowser = RTCBrowserType.RTC_BROWSER_SAFARI;
     return null;
 }
 
+/**
+ *
+ */
 function detectIE() {
     let version;
     const ua = window.navigator.userAgent;
     return null;
 }
 
+/**
+ *
+ */
 function detectNWJS() {
     const userAgent = navigator.userAgent;
 
     return null;
 }
 
+/**
+ *
+ */
 function detectReactNative() {
     const match
         = navigator.userAgent.match(/\b(react[ \t_-]*native)(?:\/(\S+))?/i);
     return version;
 }
 
+/**
+ *
+ */
 function detectBrowser() {
     let version;
     const detectors = [

modules/RTC/RTCUtils.js

 
 let currentlyAvailableMediaDevices;
 
-let rawEnumerateDevicesWithCallback;
-
 /**
  * "rawEnumerateDevicesWithCallback" will be initialized only after WebRTC is
  * ready. Otherwise it is too early to assume that the devices listing is not
  * supported.
  */
+let rawEnumerateDevicesWithCallback;
 
+/**
+ *
+ */
 function initRawEnumerateDevicesWithCallback() {
     rawEnumerateDevicesWithCallback = navigator.mediaDevices
         && navigator.mediaDevices.enumerateDevices
 
 let rtcReady = false;
 
+/**
+ *
+ * @param constraints
+ * @param resolution
+ */
 function setResolutionConstraints(constraints, resolution) {
     const isAndroid = RTCBrowserType.isAndroid();
 
                 .sort()
                 .join(''));
 
+    /**
+     *
+     * @param info
+     */
     function mediaDeviceInfoToJSON(info) {
         return JSON.stringify({
             kind: info.kind,
     element.src = src || '';
 }
 
-// Options parameter is to pass config options. Currently uses only "useIPv6".
+/**
+ *
+ */
 class RTCUtils extends Listenable {
+    /**
+     *
+     */
     constructor() {
         super(eventEmitter);
     }
 
+    /**
+     *
+     * @param options
+     */
     init(options) {
         if (typeof options.disableAEC === 'boolean') {
             disableAEC = options.disableAEC;
         });
     }
 
+    /**
+     *
+     */
     getDeviceAvailability() {
         return devices;
     }
 
+    /**
+     *
+     */
     isRTCReady() {
         return rtcReady;
     }
 
+    /**
+     *
+     */
     _isDeviceListAvailable() {
         if (!rtcReady) {
             throw new Error('WebRTC not ready yet');
 
 const rtcUtils = new RTCUtils();
 
+/**
+ *
+ * @param options
+ */
 function obtainDevices(options) {
     if (!options.devices || options.devices.length === 0) {
         return options.successCallback(options.streams || {});
         });
 }
 
-// In case of IE we continue from 'onReady' callback
-// passed to RTCUtils constructor. It will be invoked by Temasys plugin
-// once it is initialized.
+/**
+ * In case of IE we continue from 'onReady' callback passed to RTCUtils
+ * constructor. It will be invoked by Temasys plugin once it is initialized.
+ *
+ * @param options
+ * @param GUM
+ */
 function onReady(options, GUM) {
     rtcReady = true;
     eventEmitter.emit(RTCEvents.RTC_READY, true);

modules/RTC/ScreenObtainer.js

     }
 }
 
+/**
+ *
+ * @param callback
+ * @param options
+ */
 function checkChromeExtInstalled(callback, options) {
     if (typeof chrome === 'undefined' || !chrome || !chrome.runtime) {
         // No API, so no extension for sure
     );
 }
 
+/**
+ *
+ * @param options
+ * @param streamCallback
+ * @param failCallback
+ */
 function doGetStreamFromExtension(options, streamCallback, failCallback) {
     // Sends 'getStream' msg to the extension.
     // Extension id must be defined in the config.
         getWebStoreInstallUrl(options));
 }
 
+/**
+ *
+ * @param options
+ */
 function initChromeExtension(options) {
     // Initialize Chrome extension inline installs
     initInlineInstalls(options);

modules/TalkMutedDetection.js

 import * as JitsiConferenceEvents from '../JitsiConferenceEvents';
 
+/**
+ *
+ */
 export default class TalkMutedDetection {
     /**
      * Creates TalkMutedDetection

modules/connectivity/ConnectionQuality.js

  * value of 0% indicates a poor connection.
  */
 export default class ConnectionQuality {
+    /**
+     *
+     * @param conference
+     * @param eventEmitter
+     * @param options
+     */
     constructor(conference, eventEmitter, options) {
         this.eventEmitter = eventEmitter;
 

modules/connectivity/ParticipantConnectionStatus.js

         }
     }
 
+    /**
+     *
+     * @param participant
+     * @param newStatus
+     */
     _changeConnectionStatus(participant, newStatus) {
         if (participant.isConnectionActive() !== newStatus) {
 

modules/settings/Settings.js

     return global.localStorage;
 }
 
+/**
+ *
+ */
 function _p8() {
     return `${Math.random().toString(16)}000000000`.substr(2, 8);
 }
 
+/**
+ *
+ */
 function generateUniqueId() {
     return _p8() + _p8() + _p8() + _p8();
 }
     return username;
 }
 
+/**
+ *
+ */
 class Settings {
+    /**
+     *
+     */
     constructor() {
         const localStorage = getLocalStorage();
 

modules/statistics/AnalyticsAdapter.js

  * Interface for analytics handlers.
  */
 class AnalyticsAbstract {
+    /**
+     *
+     */
     sendEvent() {} // eslint-disable-line no-empty-function
 }
 
  * @extends AnalyticsAbstract
  */
 class CacheAnalytics extends AnalyticsAbstract {
+    /**
+     *
+     */
     constructor() {
         super();
 
  * This class will store and manage the handlers that are going to be used.
  */
 class AnalyticsAdapter {
+    /**
+     *
+     */
     constructor() {
         this.analyticsHandlers = new Set();
 

modules/statistics/CallStats.js

 };
 
 /* eslint-disable no-invalid-this */
+
+/**
+ *
+ * @param err
+ * @param msg
+ */
 function initCallback(err, msg) {
     logger.log(`CallStats Status: err=${err} msg=${msg}`);
 

modules/statistics/RTPStatsCollector.js

     this.bitrate.upload = 0;
 };
 
+/**
+ *
+ */
 function ConferenceStats() {
 
     /**
 
     const getStatValue = this._getStatValue;
 
+    /**
+     *
+     * @param report
+     * @param name
+     */
     function getNonNegativeStat(report, name) {
         let value = getStatValue(report, name);
 

modules/statistics/statistics.js

  */
 let isCallstatsLoaded = false;
 
-// Since callstats.io is a third party, we cannot guarantee the quality of their
-// service. More specifically, their server may take noticeably long time to
-// respond. Consequently, it is in our best interest (in the sense that the
-// intergration of callstats.io is pretty important to us but not enough to
-// allow it to prevent people from joining a conference) to (1) start
-// downloading their API as soon as possible and (2) do the downloading
-// asynchronously.
+/**
+ * Since callstats.io is a third party, we cannot guarantee the quality of their
+ * service. More specifically, their server may take noticeably long time to
+ * respond. Consequently, it is in our best interest (in the sense that the
+ * intergration of callstats.io is pretty important to us but not enough to
+ * allow it to prevent people from joining a conference) to (1) start
+ * downloading their API as soon as possible and (2) do the downloading
+ * asynchronously.
+ *
+ * @param customScriptUrl
+ */
 function loadCallStatsAPI(customScriptUrl) {
     if (!isCallstatsLoaded) {
         ScriptUtil.loadScript(
 
 };
 
+/**
+ *
+ * @param xmpp
+ * @param options
+ */
 function Statistics(xmpp, options) {
     this.rtpStats = null;
     this.eventEmitter = new EventEmitter();

modules/xmpp/Caps.js

 const IDENTITY_PROPERTIES_FOR_COMPARE = [ 'category', 'type', 'lang' ];
 const HASH = 'sha-1';
 
+/**
+ *
+ * @param a
+ * @param b
+ */
 function compareIdentities(a, b) {
     let res = 0;
 

modules/xmpp/ChatRoom.js

 // of chaining function calls, allow long function call chains.
 /* eslint-disable newline-per-chained-call */
 
+/**
+ *
+ */
 export default class ChatRoom extends Listenable {
 
     /* eslint-disable max-params */
 
+    /**
+     *
+     * @param connection
+     * @param jid
+     * @param password
+     * @param XMPP
+     * @param options
+     */
     constructor(connection, jid, password, XMPP, options) {
         super();
         this.xmpp = XMPP;
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     */
     initPresenceMap() {
         this.presMap.to = this.myroomjid;
         this.presMap.xns = 'http://jabber.org/protocol/muc';
         this.addVideoInfoToPresence(false);
     }
 
+    /**
+     *
+     * @param devices
+     */
     updateDeviceAvailability(devices) {
         this.presMap.nodes.push({
             'tagName': 'devices',
         });
     }
 
+    /**
+     *
+     * @param password
+     */
     join(password) {
         this.password = password;
         this.moderator.allocateConferenceFocus(() => this.sendPresence(true));
     }
 
+    /**
+     *
+     * @param fromJoin
+     */
     sendPresence(fromJoin) {
         const to = this.presMap.to;
 
         this.connection.flush();
     }
 
+    /**
+     *
+     */
     discoRoomInfo() {
       // https://xmpp.org/extensions/xep-0045.html#disco-roominfo
 
         });
     }
 
-
+    /**
+     *
+     */
     createNonAnonymousRoom() {
         // http://xmpp.org/extensions/xep-0045.html#createroom-reserved
 
         });
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresence(pres) {
         const from = pres.getAttribute('from');
 
         this.participantPropertyListener = listener;
     }
 
+    /**
+     *
+     * @param node
+     * @param from
+     */
     processNode(node, from) {
         // make sure we catch all errors coming from any handler
         // otherwise we can remove the presence handler from strophe
         }
     }
 
+    /**
+     *
+     * @param body
+     * @param nickname
+     */
     sendMessage(body, nickname) {
         const msg = $msg({ to: this.roomjid,
             type: 'groupchat' });
         this.eventEmitter.emit(XMPPEvents.SENDING_CHAT_MESSAGE, body);
     }
 
+    /**
+     *
+     * @param subject
+     */
     setSubject(subject) {
         const msg = $msg({ to: this.roomjid,
             type: 'groupchat' });
         this.moderator.onMucMemberLeft(jid);
     }
 
+    /**
+     *
+     * @param pres
+     * @param from
+     */
     onPresenceUnavailable(pres, from) {
         // room destroyed ?
         if ($(pres).find('>x[xmlns="http://jabber.org/protocol/muc#user"]'
         }
     }
 
+    /**
+     *
+     * @param msg
+     * @param from
+     */
     onMessage(msg, from) {
         const nick
             = $(msg).find('>nick[xmlns="http://jabber.org/protocol/nick"]')
         }
     }
 
+    /**
+     *
+     * @param pres
+     * @param from
+     */
     onPresenceError(pres, from) {
         if ($(pres)
                 .find(
         }
     }
 
+    /**
+     *
+     * @param jid
+     */
     kick(jid) {
         const kickIQ = $iq({ to: this.roomjid,
             type: 'set' })
 
     /* eslint-disable max-params */
 
+    /**
+     *
+     * @param key
+     * @param onSuccess
+     * @param onError
+     * @param onNotSupported
+     */
     lockRoom(key, onSuccess, onError, onNotSupported) {
         // http://xmpp.org/extensions/xep-0045.html#roomconfig
         this.connection.sendIQ(
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     * @param key
+     * @param values
+     */
     addToPresence(key, values) {
         values.tagName = key;
         this.removeFromPresence(key);
         this.presMap.nodes.push(values);
     }
 
+    /**
+     *
+     * @param key
+     */
     removeFromPresence(key) {
         const nodes = this.presMap.nodes.filter(node => key !== node.tagName);
 
         this.presMap.nodes = nodes;
     }
 
+    /**
+     *
+     * @param name
+     * @param handler
+     */
     addPresenceListener(name, handler) {
         this.presHandlers[name] = handler;
     }
 
+    /**
+     *
+     * @param name
+     */
     removePresenceListener(name) {
         delete this.presHandlers[name];
     }
         return null;
     }
 
+    /**
+     *
+     */
     isModerator() {
         return this.role === 'moderator';
     }
 
+    /**
+     *
+     * @param peerJid
+     */
     getMemberRole(peerJid) {
         if (this.members[peerJid]) {
             return this.members[peerJid].role;
         return null;
     }
 
+    /**
+     *
+     * @param mute
+     * @param callback
+     */
     setVideoMute(mute, callback) {
         this.sendVideoInfoPresence(mute);
         if (callback) {
         }
     }
 
+    /**
+     *
+     * @param mute
+     * @apram callback
+     */
     setAudioMute(mute, callback) {
         return this.sendAudioInfoPresence(mute, callback);
     }
 
+    /**
+     *
+     * @param mute
+     */
     addAudioInfoToPresence(mute) {
         this.removeFromPresence('audiomuted');
         this.addToPresence('audiomuted',
                 value: mute.toString() });
     }
 
+    /**
+     *
+     * @param mute
+     * @param callback
+     */
     sendAudioInfoPresence(mute, callback) {
         this.addAudioInfoToPresence(mute);
         if (this.connection) {
         }
     }
 
+    /**
+     *
+     * @param mute
+     */
     addVideoInfoToPresence(mute) {
         this.removeFromPresence('videomuted');
         this.addToPresence('videomuted',
                 value: mute.toString() });
     }
 
+    /**
+     *
+     * @param mute
+     */
     sendVideoInfoPresence(mute) {
         this.addVideoInfoToPresence(mute);
         if (!this.connection) {
             error => logger.log('set mute error', error));
     }
 
+    /**
+     *
+     * @param iq
+     */
     onMute(iq) {
         const from = iq.getAttribute('from');
 
             const timeout = setTimeout(() => onMucLeft(true), 5000);
             const eventEmitter = this.eventEmitter;
 
+            /**
+             *
+             * @param doReject
+             */
             function onMucLeft(doReject = false) {
                 eventEmitter.removeListener(XMPPEvents.MUC_LEFT, onMucLeft);
                 clearTimeout(timeout);

modules/xmpp/ConnectionPlugin.js

      * Base class for strophe connection plugins.
      */
     return class extends base {
+        /**
+         *
+         */
         constructor(...args) {
             super(...args);
             this.connection = null;
         }
+
+        /**
+         *
+         * @param connection
+         */
         init(connection) {
             this.connection = connection;
         }

modules/xmpp/JingleSession.js

 
 const logger = getLogger(__filename);
 
-/*
+/**
  * JingleSession provides an API to manage a single Jingle session. We will
  * have different implementations depending on the underlying interface used
  * (i.e. WebRTC and ORTC) and here we hold the code common to all of them.
      * {@link initialize}.
      * @protected
      */
-    doInitialize() { } // eslint-disable-line no-empty-function
+    doInitialize() {} // eslint-disable-line no-empty-function
+
+    /* eslint-disable no-unused-vars, no-empty-function */
 
     /**
      * Adds the ICE candidates found in the 'contents' array as remote
      * candidates?
      * Note: currently only used on transport-info
+     *
+     * @param contents
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    addIceCandidates(contents) { }
+    addIceCandidates(contents) {}
+
+    /* eslint-enable no-unused-vars, no-empty-function */
 
     /**
      * Returns current state of this <tt>JingleSession</tt> instance.
         return this.state;
     }
 
+    /* eslint-disable no-unused-vars, no-empty-function */
+
     /**
      * Handles an 'add-source' event.
      *
      * @param contents an array of Jingle 'content' elements.
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    addSources(contents) { }
+    addSources(contents) {}
 
     /**
      * Handles a 'remove-source' event.
      *
      * @param contents an array of Jingle 'content' elements.
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    removeSources(contents) { }
+    removeSources(contents) {}
+
+    /* eslint-disable max-params */
 
     /**
      * Terminates this Jingle session by sending session-terminate
      * @param failure a callback called when either timeout occurs or ERROR
      * response is received.
      */
-    // eslint-disable-next-line max-params, no-unused-vars, no-empty-function
-    terminate(reason, text, success, failure) { }
+    terminate(reason, text, success, failure) {}
+
+    /* eslint-enable max-params */
 
     /**
      * Handles an offer from the remote peer (prepares to accept a session).
      * error object with details(which is meant more to be printed to the logger
      * than analysed in the code, as the error is unrecoverable anyway)
      */
-    // eslint-disable-next-line no-unused-vars, no-empty-function
-    acceptOffer(jingle, success, failure) { }
+    acceptOffer(jingle, success, failure) {}
+
+    /* eslint-enable no-unused-vars, no-empty-function */
 }

modules/xmpp/JingleSessionPC.js

  */
 const IQ_TIMEOUT = 10000;
 
+/**
+ *
+ */
 export default class JingleSessionPC extends JingleSession {
 
     /* eslint-disable max-params */
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     */
     doInitialize() {
         this.lasticecandidate = false;
 
         };
     }
 
+    /**
+     *
+     * @param candidate
+     */
     sendIceCandidate(candidate) {
         const localSDP = new SDP(this.peerconnection.localDescription.sdp);
 
         }
     }
 
+    /**
+     *
+     * @param candidates
+     */
     sendIceCandidates(candidates) {
         logger.log('sendIceCandidates', candidates);
         const cand = $iq({ to: this.peerjid,
             }), IQ_TIMEOUT);
     }
 
+    /**
+     *
+     * @param contents
+     */
     readSsrcInfo(contents) {
         $(contents).each((i1, content) => {
             const ssrcs
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     * @param reasonCondition
+     * @param reasonText
+     */
     onTerminated(reasonCondition, reasonText) {
         this.state = 'ended';
 
         };
     }
 
+    /**
+     *
+     * @param session
+     * @param error
+     */
     static onJingleFatalError(session, error) {
         if (this.room) {
             this.room.eventEmitter.emit(

modules/xmpp/SDP.js

 
 const SDPUtil = require('./SDPUtil');
 
-// SDP STUFF
+/**
+ *
+ * @param sdp
+ */
 function SDP(sdp) {
     const media = sdp.split('\r\nm=');
 

modules/xmpp/SDPDiffer.js

 const SDPUtil = require('./SDPUtil');
 
 // this could be useful in Array.prototype.
+/**
+ *
+ * @param array1
+ * @param array2
+ */
 function arrayEquals(array1, array2) {
     // if the other array is a falsy value, return
     if (!array2) {
     return true;
 }
 
+/**
+ *
+ * @param mySDP
+ * @param otherSDP
+ */
 function SDPDiffer(mySDP, otherSDP) {
     this.mySDP = mySDP;
     this.otherSDP = otherSDP;

modules/xmpp/SdpTransformUtil.js

         this.mLine = mLine;
     }
 
+    /**
+     *
+     */
     get _ssrcs() {
         if (!this.mLine.ssrcs) {
             this.mLine.ssrcs = [];

modules/xmpp/moderator.js

 
 import Settings from '../settings/Settings';
 
+/**
+ *
+ * @param step
+ */
 function createExpBackoffTimer(step) {
     let count = 1;
 
 
 /* eslint-disable max-params */
 
+/**
+ *
+ * @param roomName
+ * @param xmpp
+ * @param emitter
+ * @param options
+ */
 function Moderator(roomName, xmpp, emitter, options) {
     this.roomName = roomName;
     this.xmppService = xmpp;
 
     this.connection = this.xmppService.connection;
 
-    // FIXME:
-    // Message listener that talks to POPUP window
+    // FIXME: Message listener that talks to POPUP window
+    /**
+     *
+     * @param event
+     */
     function listener(event) {
         if (event.data && event.data.sessionId) {
             if (event.origin !== window.location.origin) {

modules/xmpp/recording.js

 
 /* eslint-disable max-params */
 
+/**
+ *
+ * @param type
+ * @param eventEmitter
+ * @param connection
+ * @param focusMucJid
+ * @param jirecon
+ * @param roomjid
+ */
 function Recording(
         type,
         eventEmitter,

modules/xmpp/strophe.emuc.js

 import { ConnectionPluginListenable } from './ConnectionPlugin';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 
+/**
+ *
+ */
 class MucConnectionPlugin extends ConnectionPluginListenable {
+    /**
+     *
+     * @param xmpp
+     */
     constructor(xmpp) {
         super();
         this.xmpp = xmpp;
         this.rooms = {};
     }
 
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
 
             'http://jitsi.org/jitmeet/audio', 'iq', 'set', null, null);
     }
 
+    /**
+     *
+     * @param jid
+     * @param password
+     * @param options
+     */
     createRoom(jid, password, options) {
         const roomJid = Strophe.getBareJidFromJid(jid);
 
         return this.rooms[roomJid];
     }
 
+    /**
+     *
+     * @param jid
+     */
     doLeave(jid) {
         this.eventEmitter.emit(
             XMPPEvents.EMUC_ROOM_REMOVED, this.rooms[jid]);
         delete this.rooms[jid];
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresence(pres) {
         const from = pres.getAttribute('from');
 
         return true;
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresenceUnavailable(pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
         return true;
     }
 
+    /**
+     *
+     * @param pres
+     */
     onPresenceError(pres) {
         const from = pres.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
         return true;
     }
 
+    /**
+     *
+     * @param msg
+     */
     onMessage(msg) {
         // FIXME: this is a hack. but jingle on muc makes nickchanges hard
         const from = msg.getAttribute('from');
         return true;
     }
 
+    /**
+     *
+     * @param iq
+     */
     onMute(iq) {
         const from = iq.getAttribute('from');
         const room = this.rooms[Strophe.getBareJidFromJid(from)];
     }
 }
 
+/**
+ *
+ * @param XMPP
+ */
 export default function(XMPP) {
     Strophe.addConnectionPlugin('emuc', new MucConnectionPlugin(XMPP));
 }

modules/xmpp/strophe.jingle.js

 // function call chains.
 /* eslint-disable newline-per-chained-call */
 
+/**
+ *
+ */
 class JingleConnectionPlugin extends ConnectionPlugin {
+    /**
+     *
+     * @param xmpp
+     * @param eventEmitter
+     */
     constructor(xmpp, eventEmitter) {
         super();
         this.xmpp = xmpp;
         };
     }
 
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
         this.connection.addHandler(this.onJingle.bind(this),
             'urn:xmpp:jingle:1', 'iq', 'set', null, null);
     }
 
+    /**
+     *
+     * @param iq
+     */
     onJingle(iq) {
         const sid = $(iq).find('jingle').attr('sid');
         const action = $(iq).find('jingle').attr('action');
         return true;
     }
 
+    /**
+     *
+     * @param sid
+     * @param reasonCondition
+     * @param reasonText
+     */
     terminate(sid, reasonCondition, reasonText) {
         if (this.sessions.hasOwnProperty(sid)) {
             if (this.sessions[sid].state !== 'ended') {
         }
     }
 
+    /**
+     *
+     */
     getStunAndTurnCredentials() {
         // get stun and turn configuration from server via xep-0215
         // uses time-limited credentials as described in

modules/xmpp/strophe.logger.js

  *  Logs raw stanzas and makes them available for download as JSON
  */
 class StropheLogger extends ConnectionPlugin {
+    /**
+     *
+     */
     constructor() {
         super();
         this.log = [];
     }
 
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
         this.connection.rawInput = this.logIncoming.bind(this);
         this.connection.rawOutput = this.logOutgoing.bind(this);
     }
 
+    /**
+     *
+     * @param stanza
+     */
     logIncoming(stanza) {
         this.log.push([ new Date().getTime(), 'incoming', stanza ]);
     }
 
+    /**
+     *
+     * @param stanza
+     */
     logOutgoing(stanza) {
         this.log.push([ new Date().getTime(), 'outgoing', stanza ]);
     }
 }
 
+/**
+ *
+ */
 export default function() {
     Strophe.addConnectionPlugin('logger', new StropheLogger());
 }

modules/xmpp/strophe.ping.js

     }
 }
 
+/**
+ *
+ * @param xmpp
+ */
 export default function(xmpp) {
     Strophe.addConnectionPlugin('ping', new PingConnectionPlugin(xmpp));
 }

modules/xmpp/strophe.rayo.js

 
 const RAYO_XMLNS = 'urn:xmpp:rayo:1';
 
+/**
+ *
+ */
 class RayoConnectionPlugin extends ConnectionPlugin {
+    /**
+     *
+     * @param connection
+     */
     init(connection) {
         super.init(connection);
 
             this.onRayo.bind(this), RAYO_XMLNS, 'iq', 'set', null, null);
     }
 
+    /**
+     *
+     * @param iq
+     */
     onRayo(iq) {
         logger.info('Rayo IQ', iq);
     }
 
     /* eslint-disable max-params */
 
+    /**
+     *
+     * @param to
+     * @param from
+     * @param roomName
+     * @param roomPass
+     * @param focusMucJid
+     */
     dial(to, from, roomName, roomPass, focusMucJid) {
         return new Promise((resolve, reject) => {
             if (!focusMucJid) {
 
     /* eslint-enable max-params */
 
+    /**
+     *
+     */
     hangup() {
         return new Promise((resolve, reject) => {
             if (!this.callResource) {
     }
 }
 
+/**
+ *
+ */
 export default function() {
     Strophe.addConnectionPlugin('rayo', new RayoConnectionPlugin());
 }

modules/xmpp/strophe.util.js

 const lastErrorStatusRegExpr
     = /request errored, status: (\d+), number of errors: \d+/;
 
+/**
+ *
+ */
 export default function() {
 
     Strophe.log = function(level, msg) {

modules/xmpp/xmpp.js

 import Listenable from '../util/Listenable';
 import Caps from './Caps';
 
+/**
+ *
+ * @param token
+ * @param bosh
+ */
 function createConnection(token, bosh = '/http-bind') {
     // Append token as URL param
     if (token) {
     return new Strophe.Connection(bosh);
 }
 
+/**
+ *
+ */
 export default class XMPP extends Listenable {
+    /**
+     *
+     * @param options
+     * @param token
+     */
     constructor(options, token) {
         super();
         this.connection = null;
         }
     }
 
+    /**
+     *
+     */
     getConnection() {
         return this.connection;
     }
         }
     }
 
+    /**
+     *
+     * @param jid
+     * @param password
+     */
     _connect(jid, password) {
         // connection.connect() starts the connection process.
         //
             this.connectionHandler.bind(this, options.password));
     }
 
+    /**
+     *
+     * @param jid
+     * @param password
+     */
     connect(jid, password) {
         this.connectParams = {
             jid,
         return this._connect(jid, password);
     }
 
+    /**
+     *
+     * @param roomName
+     * @param options
+     */
     createRoom(roomName, options) {
         // By default MUC nickname is the resource part of the JID
         let mucNickname = Strophe.getNodeFromJid(this.connection.jid);
         return (this.connection.logger || {}).log || null;
     }
 
+    /**
+     *
+     */
     dial(...args) {
         this.connection.rayo.dial(...args);
     }
 
+    /**
+     *
+     * @param jid
+     * @param mute
+     */
     setMute(jid, mute) {
         this.connection.moderate.setMute(jid, mute);
     }
 
+    /**
+     *
+     * @param jid
+     */
     eject(jid) {
         this.connection.moderate.eject(jid);
     }
 
+    /**
+     *
+     */
     getSessions() {
         return this.connection.jingle.sessions;
     }
         }
     }
 
+    /**
+     *
+     */
     _initStrophePlugins() {
         initEmuc(this);
         initJingle(this, this.eventEmitter);