ref(JitsiTrack) Alpha sort the methods.

modules/RTC/JitsiTrack.js

         this._setStream(stream);
     }
 
-    /* eslint-enable max-params */
-
     /**
      * Adds onended/oninactive handler to a MediaStream or a MediaStreamTrack.
      * Firefox doesn't fire a inactive event on the MediaStream, instead it fires
         }
     }
 
+    /**
+     * Attach time to first media tracker only if there is conference and only
+     * for the first element.
+     *
+     * @param {HTMLElement} container the HTML container which can be 'video' or
+     * 'audio' element.
+     * @private
+     */
+    _attachTTFMTracker(container) { // eslint-disable-line no-unused-vars
+        // Should be defined by the classes that are extending JitsiTrack
+    }
+
+    /**
+     * Eventually will trigger RTCEvents.TRACK_ATTACHED event.
+     * @param container the video/audio container to which this stream is
+     *        attached and for which event will be fired.
+     * @private
+     */
+    _maybeFireTrackAttached(container) {
+        if (this.conference && container) {
+            this.conference._onTrackAttach(this, container);
+        }
+    }
+
+    /**
+     * Called when the track has been attached to a new container.
+     *
+     * @param {HTMLElement} container the HTML container which can be 'video' or
+     * 'audio' element.
+     * @private
+     */
+    _onTrackAttach(container) { // eslint-disable-line no-unused-vars
+        // Should be defined by the classes that are extending JitsiTrack
+    }
+
+    /**
+     * Called when the track has been detached from a container.
+     *
+     * @param {HTMLElement} container the HTML container which can be 'video' or
+     * 'audio' element.
+     * @private
+     */
+    _onTrackDetach(container) { // eslint-disable-line no-unused-vars
+        // Should be defined by the classes that are extending JitsiTrack
+    }
+
     /**
      * Sets handler to the WebRTC MediaStream or MediaStreamTrack object
      * depending on the passed type.
         }
     }
 
-    /**
-     * Unregisters all event handlers bound to the underlying media stream/track
-     * @private
-     */
-    _unregisterHandlers() {
-        if (!this.stream) {
-            logger.warn(
-                `${this}: unable to unregister handlers - no stream object`);
-
-            return;
-        }
-
-        for (const type of this.handlers.keys()) {
-            // FIXME Why only video tracks?
-            for (const videoTrack of this.stream.getVideoTracks()) {
-                videoTrack[trackHandler2Prop[type]] = undefined;
-            }
-        }
-        if (this._streamInactiveHandler) {
-            this._addMediaStreamInactiveHandler(undefined);
-        }
-    }
-
     /**
      * Sets the stream property of JitsiTrack object and sets all stored
      * handlers to it.
     }
 
     /**
-     * Returns the video type (camera or desktop) of this track.
+     * Unregisters all event handlers bound to the underlying media stream/track
+     * @private
      */
-    getVideoType() {
-        return this.videoType;
-    }
+    _unregisterHandlers() {
+        if (!this.stream) {
+            logger.warn(
+                `${this}: unable to unregister handlers - no stream object`);
 
-    /**
-     * Returns the type (audio or video) of this track.
-     */
-    getType() {
-        return this.type;
+            return;
+        }
+
+        for (const type of this.handlers.keys()) {
+            // FIXME Why only video tracks?
+            for (const videoTrack of this.stream.getVideoTracks()) {
+                videoTrack[trackHandler2Prop[type]] = undefined;
+            }
+        }
+        if (this._streamInactiveHandler) {
+            this._addMediaStreamInactiveHandler(undefined);
+        }
     }
 
     /**
-     * Check if this is an audio track.
+     * Attaches the MediaStream of this track to an HTML container.
+     * Adds the container to the list of containers that are displaying the
+     * track.
+     *
+     * @param container the HTML container which can be 'video' or 'audio'
+     * element.
+     *
+     * @returns {void}
      */
-    isAudioTrack() {
-        return this.getType() === MediaType.AUDIO;
+    attach(container) {
+        if (this.stream) {
+            this._onTrackAttach(container);
+            RTCUtils.attachMediaStream(container, this.stream);
+        }
+        this.containers.push(container);
+        this._maybeFireTrackAttached(container);
+        this._attachTTFMTracker(container);
     }
 
     /**
-     * Checks whether the underlying WebRTC <tt>MediaStreamTrack</tt> is muted
-     * according to it's 'muted' field status.
-     * @return {boolean} <tt>true</tt> if the underlying
-     * <tt>MediaStreamTrack</tt> is muted or <tt>false</tt> otherwise.
+     * Removes this JitsiTrack from the passed HTML container.
+     *
+     * @param container the HTML container to detach from this JitsiTrack. If
+     * <tt>null</tt> or <tt>undefined</tt>, all containers are removed. A
+     * container can be a 'video', 'audio' or 'object' HTML element instance to
+     * which this JitsiTrack is currently attached.
      */
-    isWebRTCTrackMuted() {
-        return this.track && this.track.muted;
+    detach(container) {
+        for (let cs = this.containers, i = cs.length - 1; i >= 0; --i) {
+            const c = cs[i];
+
+            if (!container) {
+                this._onTrackDetach(c);
+                RTCUtils.attachMediaStream(c, null);
+            }
+            if (!container || c === container) {
+                cs.splice(i, 1);
+            }
+        }
+
+        if (container) {
+            this._onTrackDetach(container);
+            RTCUtils.attachMediaStream(container, null);
+        }
     }
 
     /**
-     * Check if this is a video track.
+     * Removes attached event listeners.
+     *
+     * @returns {Promise}
      */
-    isVideoTrack() {
-        return this.getType() === MediaType.VIDEO;
+    dispose() {
+        this.removeAllListeners();
+
+        this.disposed = true;
+
+        return Promise.resolve();
     }
 
     /**
-     * Checks whether this is a local track.
-     * @abstract
-     * @return {boolean} 'true' if it's a local track or 'false' otherwise.
+     * Returns id of the track.
+     * @returns {string|null} id of the track or null if this is fake track.
      */
-    isLocal() {
-        throw new Error('Not implemented by subclass');
+    getId() {
+        return this.getStreamId();
     }
 
     /**
-     * Check whether this is a local audio track.
-     *
-     * @return {boolean} -  true if track represents a local audio track, false otherwise.
+     * Returns the msid of the stream attached to the JitsiTrack object or null
+     * if no stream is attached.
      */
-    isLocalAudioTrack() {
-        return this.isAudioTrack() && this.isLocal();
+    getMSID() {
+        const streamId = this.getStreamId();
+        const trackId = this.getTrackId();
+
+        return streamId && trackId ? `${streamId} ${trackId}` : null;
     }
 
     /**
         return this.track ? this.track.id : null;
     }
 
+    /**
+     * Returns the type (audio or video) of this track.
+     */
+    getType() {
+        return this.type;
+    }
+
     /**
      * Return meaningful usage label for this track depending on it's media and
      * eventual video type.
     }
 
     /**
-     * Eventually will trigger RTCEvents.TRACK_ATTACHED event.
-     * @param container the video/audio container to which this stream is
-     *        attached and for which event will be fired.
-     * @private
-     */
-    _maybeFireTrackAttached(container) {
-        if (this.conference && container) {
-            this.conference._onTrackAttach(this, container);
-        }
-    }
-
-    /**
-     * Attaches the MediaStream of this track to an HTML container.
-     * Adds the container to the list of containers that are displaying the
-     * track.
-     *
-     * @param container the HTML container which can be 'video' or 'audio'
-     * element.
-     *
-     * @returns {void}
+     * Returns the video type (camera or desktop) of this track.
      */
-    attach(container) {
-        if (this.stream) {
-            this._onTrackAttach(container);
-            RTCUtils.attachMediaStream(container, this.stream);
-        }
-        this.containers.push(container);
-        this._maybeFireTrackAttached(container);
-        this._attachTTFMTracker(container);
+    getVideoType() {
+        return this.videoType;
     }
 
     /**
-     * Removes this JitsiTrack from the passed HTML container.
-     *
-     * @param container the HTML container to detach from this JitsiTrack. If
-     * <tt>null</tt> or <tt>undefined</tt>, all containers are removed. A
-     * container can be a 'video', 'audio' or 'object' HTML element instance to
-     * which this JitsiTrack is currently attached.
+     * Checks whether the MediaStream is active/not ended.
+     * When there is no check for active we don't have information and so
+     * will return that stream is active (in case of FF).
+     * @returns {boolean} whether MediaStream is active.
      */
-    detach(container) {
-        for (let cs = this.containers, i = cs.length - 1; i >= 0; --i) {
-            const c = cs[i];
-
-            if (!container) {
-                this._onTrackDetach(c);
-                RTCUtils.attachMediaStream(c, null);
-            }
-            if (!container || c === container) {
-                cs.splice(i, 1);
-            }
-        }
-
-        if (container) {
-            this._onTrackDetach(container);
-            RTCUtils.attachMediaStream(container, null);
+    isActive() {
+        if (typeof this.stream.active !== 'undefined') {
+            return this.stream.active;
         }
-    }
 
-    /**
-     * Called when the track has been attached to a new container.
-     *
-     * @param {HTMLElement} container the HTML container which can be 'video' or
-     * 'audio' element.
-     * @private
-     */
-    _onTrackAttach(container) { // eslint-disable-line no-unused-vars
-        // Should be defined by the classes that are extending JitsiTrack
+        return true;
     }
 
     /**
-     * Called when the track has been detached from a container.
-     *
-     * @param {HTMLElement} container the HTML container which can be 'video' or
-     * 'audio' element.
-     * @private
+     * Check if this is an audio track.
      */
-    _onTrackDetach(container) { // eslint-disable-line no-unused-vars
-        // Should be defined by the classes that are extending JitsiTrack
+    isAudioTrack() {
+        return this.getType() === MediaType.AUDIO;
     }
 
     /**
-     * Attach time to first media tracker only if there is conference and only
-     * for the first element.
-     *
-     * @param {HTMLElement} container the HTML container which can be 'video' or
-     * 'audio' element.
-     * @private
+     * Checks whether this is a local track.
+     * @abstract
+     * @return {boolean} 'true' if it's a local track or 'false' otherwise.
      */
-    _attachTTFMTracker(container) { // eslint-disable-line no-unused-vars
-        // Should be defined by the classes that are extending JitsiTrack
+    isLocal() {
+        throw new Error('Not implemented by subclass');
     }
 
     /**
-     * Removes attached event listeners.
+     * Check whether this is a local audio track.
      *
-     * @returns {Promise}
+     * @return {boolean} -  true if track represents a local audio track, false otherwise.
      */
-    dispose() {
-        this.removeAllListeners();
-
-        this.disposed = true;
-
-        return Promise.resolve();
+    isLocalAudioTrack() {
+        return this.isAudioTrack() && this.isLocal();
     }
 
     /**
-     * Returns id of the track.
-     * @returns {string|null} id of the track or null if this is fake track.
+     * Check if this is a video track.
      */
-    getId() {
-        return this.getStreamId();
+    isVideoTrack() {
+        return this.getType() === MediaType.VIDEO;
     }
 
     /**
-     * Checks whether the MediaStream is active/not ended.
-     * When there is no check for active we don't have information and so
-     * will return that stream is active (in case of FF).
-     * @returns {boolean} whether MediaStream is active.
+     * Checks whether the underlying WebRTC <tt>MediaStreamTrack</tt> is muted
+     * according to it's 'muted' field status.
+     * @return {boolean} <tt>true</tt> if the underlying
+     * <tt>MediaStreamTrack</tt> is muted or <tt>false</tt> otherwise.
      */
-    isActive() {
-        if (typeof this.stream.active !== 'undefined') {
-            return this.stream.active;
-        }
-
-        return true;
+    isWebRTCTrackMuted() {
+        return this.track && this.track.muted;
     }
 
     /**
         }
     }
 
-    /**
-     * Returns the msid of the stream attached to the JitsiTrack object or null
-     * if no stream is attached.
-     */
-    getMSID() {
-        const streamId = this.getStreamId();
-        const trackId = this.getTrackId();
-
-        return streamId && trackId ? `${streamId} ${trackId}` : null;
-    }
-
     /**
      * Sets new audio output device for track's DOM elements. Video tracks are
      * ignored.