ref(JitsiTrack): prototype -> class

modules/RTC/JitsiRemoteTrack.js

@@ -13,23 +13,27 @@ let ttfmTrackerVideoAttached = false;
 
 /**
  * Represents a single media track (either audio or video).
- * @param {RTC} rtc the RTC service instance.
- * @param {JitsiConference} conference the conference to which this track
- *        belongs to
- * @param {string} ownerEndpointId the endpoint ID of the track owner
- * @param {MediaStream} stream WebRTC MediaStream, parent of the track
- * @param {MediaStreamTrack} track underlying WebRTC MediaStreamTrack for
- *        the new JitsiRemoteTrack
- * @param {MediaType} mediaType the type of the media
- * @param {VideoType} videoType the type of the video if applicable
- * @param {number} ssrc the SSRC number of the Media Stream
- * @param {boolean} muted the initial muted state
- * @param {boolean} isP2P indicates whether or not this track belongs to a P2P
- * session
- * @throws {TypeError} if <tt>ssrc</tt> is not a number.
- * @constructor
  */
-export default function JitsiRemoteTrack(
+export default class JitsiRemoteTrack extends JitsiTrack {
+    /**
+     * Creates new JitsiRemoteTrack instance.
+     * @param {RTC} rtc the RTC service instance.
+     * @param {JitsiConference} conference the conference to which this track
+     *        belongs to
+     * @param {string} ownerEndpointId the endpoint ID of the track owner
+     * @param {MediaStream} stream WebRTC MediaStream, parent of the track
+     * @param {MediaStreamTrack} track underlying WebRTC MediaStreamTrack for
+     *        the new JitsiRemoteTrack
+     * @param {MediaType} mediaType the type of the media
+     * @param {VideoType} videoType the type of the video if applicable
+     * @param {number} ssrc the SSRC number of the Media Stream
+     * @param {boolean} muted the initial muted state
+     * @param {boolean} isP2P indicates whether or not this track belongs to a
+     * P2P session
+     * @throws {TypeError} if <tt>ssrc</tt> is not a number.
+     * @constructor
+     */
+    constructor(
         rtc,
         conference,
         ownerEndpointId,
@@ -40,222 +44,236 @@ export default function JitsiRemoteTrack(
         ssrc,
         muted,
         isP2P) {
-    JitsiTrack.call(
-        this,
-        conference,
-        stream,
-        track,
-        () => {
-            // Nothing to do if the track is inactive.
-        },
-        mediaType,
-        videoType);
-    this.rtc = rtc;
-
-    // Prevent from mixing up type of SSRC which should be a number
-    if (typeof ssrc !== 'number') {
-        throw new TypeError(`SSRC ${ssrc} is not a number`);
-    }
-    this.ssrc = ssrc;
-    this.ownerEndpointId = ownerEndpointId;
-    this.muted = muted;
-    this.isP2P = isP2P;
-
-    // we want to mark whether the track has been ever muted
-    // to detect ttfm events for startmuted conferences, as it can significantly
-    // increase ttfm values
-    this.hasBeenMuted = muted;
-
-    // Bind 'onmute' and 'onunmute' event handlers
-    if (this.rtc && this.track) {
-        this._bindMuteHandlers();
+        super(
+            conference,
+            stream,
+            track,
+            () => {
+                // Nothing to do if the track is inactive.
+            },
+            mediaType,
+            videoType);
+        this.rtc = rtc;
+
+        // Prevent from mixing up type of SSRC which should be a number
+        if (typeof ssrc !== 'number') {
+            throw new TypeError(`SSRC ${ssrc} is not a number`);
+        }
+        this.ssrc = ssrc;
+        this.ownerEndpointId = ownerEndpointId;
+        this.muted = muted;
+        this.isP2P = isP2P;
+
+        // we want to mark whether the track has been ever muted
+        // to detect ttfm events for startmuted conferences, as it can
+        // significantly increase ttfm values
+        this.hasBeenMuted = muted;
+
+        // Bind 'onmute' and 'onunmute' event handlers
+        if (this.rtc && this.track) {
+            this._bindMuteHandlers();
+        }
     }
-}
 
-/* eslint-enable max-params */
-
-JitsiRemoteTrack.prototype = Object.create(JitsiTrack.prototype);
-JitsiRemoteTrack.prototype.constructor = JitsiRemoteTrack;
-
-JitsiRemoteTrack.prototype._bindMuteHandlers = function() {
-    // Use feature detection for finding what event handling function is
-    // supported. On Internet Explorer, which uses uses temasys/firebreath, the
-    // track will have attachEvent instead of addEventListener.
-    //
-    // FIXME it would be better to use recently added '_setHandler' method, but
-    // 1. It does not allow to set more than one handler to the event
-    // 2. It does mix MediaStream('inactive') with MediaStreamTrack events
-    // 3. Allowing to bind more than one event handler requires too much
-    //    refactoring around camera issues detection.
-    if (this.track.addEventListener) {
-        this.track.addEventListener('mute', () => this._onTrackMute());
-        this.track.addEventListener('unmute', () => this._onTrackUnmute());
-    } else if (this.track.attachEvent) {
-        // FIXME Internet Explorer is not emitting out mute/unmute events.
-        this.track.attachEvent('onmute', () => this._onTrackMute());
-        this.track.attachEvent('onunmute', () => this._onTrackUnmute());
+    /* eslint-enable max-params */
+    /**
+     * Attaches the track muted handlers.
+     *
+     * @returns {void}
+     */
+    _bindMuteHandlers() {
+        // Use feature detection for finding what event handling function is
+        // supported. On Internet Explorer, which uses uses temasys/firebreath,
+        // the track will have attachEvent instead of addEventListener.
+        //
+        // FIXME it would be better to use recently added '_setHandler' method,
+        // but:
+        // 1. It does not allow to set more than one handler to the event
+        // 2. It does mix MediaStream('inactive') with MediaStreamTrack events
+        // 3. Allowing to bind more than one event handler requires too much
+        //    refactoring around camera issues detection.
+        if (this.track.addEventListener) {
+            this.track.addEventListener('mute', () => this._onTrackMute());
+            this.track.addEventListener('unmute', () => this._onTrackUnmute());
+        } else if (this.track.attachEvent) {
+            // FIXME Internet Explorer is not emitting out mute/unmute events.
+            this.track.attachEvent('onmute', () => this._onTrackMute());
+            this.track.attachEvent('onunmute', () => this._onTrackUnmute());
+        }
     }
-};
-
-/**
- * Callback invoked when the track is muted. Emits an event notifying listeners
- * of the mute event.
- *
- * @private
- * @returns {void}
- */
-JitsiRemoteTrack.prototype._onTrackMute = function() {
-    logger.debug(
-        `"onmute" event(${Date.now()}): `,
-        this.getParticipantId(), this.getType(), this.getSSRC());
-
-    this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_MUTE, this);
-};
 
-/**
- * Callback invoked when the track is unmuted. Emits an event notifying
- * listeners of the mute event.
- *
- * @private
- * @returns {void}
- */
-JitsiRemoteTrack.prototype._onTrackUnmute = function() {
-    logger.debug(
-        `"onunmute" event(${Date.now()}): `,
-        this.getParticipantId(), this.getType(), this.getSSRC());
-
-    this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_UNMUTE, this);
-};
-
-/**
- * Sets current muted status and fires an events for the change.
- * @param value the muted status.
- */
-JitsiRemoteTrack.prototype.setMute = function(value) {
-    if (this.muted === value) {
-        return;
+    /**
+     * Callback invoked when the track is muted. Emits an event notifying
+     * listeners of the mute event.
+     *
+     * @private
+     * @returns {void}
+     */
+    _onTrackMute() {
+        logger.debug(
+            `"onmute" event(${Date.now()}): `,
+            this.getParticipantId(), this.getType(), this.getSSRC());
+
+        this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_MUTE, this);
     }
 
-    if (value) {
-        this.hasBeenMuted = true;
+    /**
+     * Callback invoked when the track is unmuted. Emits an event notifying
+     * listeners of the mute event.
+     *
+     * @private
+     * @returns {void}
+     */
+    _onTrackUnmute() {
+        logger.debug(
+            `"onunmute" event(${Date.now()}): `,
+            this.getParticipantId(), this.getType(), this.getSSRC());
+
+        this.rtc.eventEmitter.emit(RTCEvents.REMOTE_TRACK_UNMUTE, this);
     }
 
-    // we can have a fake video stream
-    if (this.stream) {
-        this.stream.muted = value;
+    /**
+     * Sets current muted status and fires an events for the change.
+     * @param value the muted status.
+     */
+    setMute(value) {
+        if (this.muted === value) {
+            return;
+        }
+
+        if (value) {
+            this.hasBeenMuted = true;
+        }
+
+        // we can have a fake video stream
+        if (this.stream) {
+            this.stream.muted = value;
+        }
+
+        this.muted = value;
+        this.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, this);
     }
 
-    this.muted = value;
-    this.eventEmitter.emit(JitsiTrackEvents.TRACK_MUTE_CHANGED, this);
-};
-
-/**
- * Returns the current muted status of the track.
- * @returns {boolean|*|JitsiRemoteTrack.muted} <tt>true</tt> if the track is
- * muted and <tt>false</tt> otherwise.
- */
-JitsiRemoteTrack.prototype.isMuted = function() {
-    return this.muted;
-};
-
-/**
- * Returns the participant id which owns the track.
- * @returns {string} the id of the participants. It corresponds to the Colibri
- * endpoint id/MUC nickname in case of Jitsi-meet.
- */
-JitsiRemoteTrack.prototype.getParticipantId = function() {
-    return this.ownerEndpointId;
-};
+    /**
+     * Returns the current muted status of the track.
+     * @returns {boolean|*|JitsiRemoteTrack.muted} <tt>true</tt> if the track is
+     * muted and <tt>false</tt> otherwise.
+     */
+    isMuted() {
+        return this.muted;
+    }
 
-/**
- * Return false;
- */
-JitsiRemoteTrack.prototype.isLocal = function() {
-    return false;
-};
+    /**
+     * Returns the participant id which owns the track.
+     *
+     * @returns {string} the id of the participants. It corresponds to the
+     * Colibri endpoint id/MUC nickname in case of Jitsi-meet.
+     */
+    getParticipantId() {
+        return this.ownerEndpointId;
+    }
 
-/**
- * Returns the synchronization source identifier (SSRC) of this remote track.
- * @returns {number} the SSRC of this remote track
- */
-JitsiRemoteTrack.prototype.getSSRC = function() {
-    return this.ssrc;
-};
+    /**
+     * Return false;
+     */
+    isLocal() {
+        return false;
+    }
 
-/**
- * Changes the video type of the track
- * @param type the new video type("camera", "desktop")
- */
-JitsiRemoteTrack.prototype._setVideoType = function(type) {
-    if (this.videoType === type) {
-        return;
+    /**
+     * Returns the synchronization source identifier (SSRC) of this remote
+     * track.
+     *
+     * @returns {number} the SSRC of this remote track.
+     */
+    getSSRC() {
+        return this.ssrc;
     }
-    this.videoType = type;
-    this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
-};
 
-JitsiRemoteTrack.prototype._playCallback = function() {
-    const type = this.isVideoTrack() ? 'video' : 'audio';
+    /**
+     * Changes the video type of the track.
+     *
+     * @param {string} type - The new video type("camera", "desktop").
+     */
+    _setVideoType(type) {
+        if (this.videoType === type) {
+            return;
+        }
+        this.videoType = type;
+        this.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
+    }
 
-    const now = window.performance.now();
+    /**
+     * Handles track play events.
+     */
+    _playCallback() {
+        const type = this.isVideoTrack() ? 'video' : 'audio';
 
-    console.log(`(TIME) Render ${type}:\t`, now);
-    this.conference.getConnectionTimes()[`${type}.render`] = now;
+        const now = window.performance.now();
 
-    const ttfm = now
-        - (this.conference.getConnectionTimes()['session.initiate']
-        - this.conference.getConnectionTimes()['muc.joined'])
-        - (window.connectionTimes['obtainPermissions.end']
-        - window.connectionTimes['obtainPermissions.start']);
+        console.log(`(TIME) Render ${type}:\t`, now);
+        this.conference.getConnectionTimes()[`${type}.render`] = now;
 
-    this.conference.getConnectionTimes()[`${type}.ttfm`] = ttfm;
-    console.log(`(TIME) TTFM ${type}:\t`, ttfm);
-    let eventName = `${type}.ttfm`;
+        const ttfm = now
+            - (this.conference.getConnectionTimes()['session.initiate']
+            - this.conference.getConnectionTimes()['muc.joined'])
+            - (window.connectionTimes['obtainPermissions.end']
+            - window.connectionTimes['obtainPermissions.start']);
 
-    if (this.hasBeenMuted) {
-        eventName += '.muted';
-    }
-    Statistics.analytics.sendEvent(eventName, { value: ttfm });
-};
+        this.conference.getConnectionTimes()[`${type}.ttfm`] = ttfm;
+        console.log(`(TIME) TTFM ${type}:\t`, ttfm);
+        let eventName = `${type}.ttfm`;
 
-/**
- * Attach time to first media tracker only if there is conference and only
- * for the first element.
- * @param container the HTML container which can be 'video' or 'audio' element.
- *        It can also be 'object' element if Temasys plugin is in use and this
- *        method has been called previously on video or audio HTML element.
- * @private
- */
-JitsiRemoteTrack.prototype._attachTTFMTracker = function(container) {
-    if ((ttfmTrackerAudioAttached && this.isAudioTrack())
-        || (ttfmTrackerVideoAttached && this.isVideoTrack())) {
-        return;
+        if (this.hasBeenMuted) {
+            eventName += '.muted';
+        }
+        Statistics.analytics.sendEvent(eventName, { value: ttfm });
     }
 
-    if (this.isAudioTrack()) {
-        ttfmTrackerAudioAttached = true;
-    }
-    if (this.isVideoTrack()) {
-        ttfmTrackerVideoAttached = true;
+    /**
+     * Attach time to first media tracker only if there is conference and only
+     * for the first element.
+     * @param container the HTML container which can be 'video' or 'audio'
+     * element. It can also be 'object' element if Temasys plugin is in use and
+     * this method has been called previously on video or audio HTML element.
+     * @private
+     */
+    _attachTTFMTracker(container) {
+        if ((ttfmTrackerAudioAttached && this.isAudioTrack())
+            || (ttfmTrackerVideoAttached && this.isVideoTrack())) {
+            return;
+        }
+
+        if (this.isAudioTrack()) {
+            ttfmTrackerAudioAttached = true;
+        }
+        if (this.isVideoTrack()) {
+            ttfmTrackerVideoAttached = true;
+        }
+
+        if (RTCBrowserType.isTemasysPluginUsed()) {
+            // XXX Don't require Temasys unless it's to be used because it
+            // doesn't run on React Native, for example.
+            const AdapterJS = require('./adapter.screenshare');
+
+            // FIXME: this is not working for IE11
+            AdapterJS.addEvent(
+                container,
+                'play',
+                this._playCallback.bind(this));
+        } else {
+            container.addEventListener(
+                'canplay',
+                this._playCallback.bind(this));
+        }
     }
 
-    if (RTCBrowserType.isTemasysPluginUsed()) {
-        // XXX Don't require Temasys unless it's to be used because it doesn't
-        // run on React Native, for example.
-        const AdapterJS = require('./adapter.screenshare');
-
-        // FIXME: this is not working for IE11
-        AdapterJS.addEvent(container, 'play', this._playCallback.bind(this));
-    } else {
-        container.addEventListener('canplay', this._playCallback.bind(this));
+    /**
+     * Creates a text representation of this remote track instance.
+     * @return {string}
+     */
+    toString() {
+        return `RemoteTrack[${this.ownerEndpointId}, ${this.getType()
+                }, p2p: ${this.isP2P}]`;
     }
-};
-
-/**
- * Creates a text representation of this remote track instance.
- * @return {string}
- */
-JitsiRemoteTrack.prototype.toString = function() {
-    return `RemoteTrack[${this.ownerEndpointId}, ${this.getType()
-            }, p2p: ${this.isP2P}]`;
-};
+}

modules/RTC/JitsiTrack.js

@@ -54,400 +54,380 @@ function addMediaStreamInactiveHandler(mediaStream, handler) {
     }
 }
 
-/* eslint-disable max-params */
-
 /**
  * Represents a single media track (either audio or video).
- * @constructor
- * @param rtc the rtc instance
- * @param stream the WebRTC MediaStream instance
- * @param track the WebRTC MediaStreamTrack instance, must be part of
- * the given <tt>stream</tt>.
- * @param streamInactiveHandler the function that will handle
- *        onended/oninactive events of the stream.
- * @param trackMediaType the media type of the JitsiTrack
- * @param videoType the VideoType for this track if any
  */
-export default function JitsiTrack(
-    conference,
-    stream,
-    track,
-    streamInactiveHandler,
-    trackMediaType,
-    videoType) {
+export default class JitsiTrack extends EventEmitter {
+    /* eslint-disable max-params */
     /**
-     * Array with the HTML elements that are displaying the streams.
-     * @type {Array}
+     * Represents a single media track (either audio or video).
+     * @constructor
+     * @param rtc the rtc instance
+     * @param stream the WebRTC MediaStream instance
+     * @param track the WebRTC MediaStreamTrack instance, must be part of
+     * the given <tt>stream</tt>.
+     * @param streamInactiveHandler the function that will handle
+     *        onended/oninactive events of the stream.
+     * @param trackMediaType the media type of the JitsiTrack
+     * @param videoType the VideoType for this track if any
      */
-    this.containers = [];
-    this.conference = conference;
-    this.stream = stream;
-    this.eventEmitter = new EventEmitter();
-    this.audioLevel = -1;
-    this.type = trackMediaType;
-    this.track = track;
-    this.videoType = videoType;
-    this.handlers = {};
+    constructor(
+        conference,
+        stream,
+        track,
+        streamInactiveHandler,
+        trackMediaType,
+        videoType) {
+        super();
+
+        // aliases for addListener/removeListener
+        this.addEventListener = this.addListener;
+        this.removeEventListener = this.off = this.removeListener;
+
+        /**
+         * Array with the HTML elements that are displaying the streams.
+         * @type {Array}
+         */
+        this.containers = [];
+        this.conference = conference;
+        this.stream = stream;
+        this.audioLevel = -1;
+        this.type = trackMediaType;
+        this.track = track;
+        this.videoType = videoType;
+        this.handlers = {};
+
+        /**
+         * Indicates whether this JitsiTrack has been disposed. If true, this
+         * JitsiTrack is to be considered unusable and operations involving it
+         * are to fail (e.g. {@link JitsiConference#addTrack(JitsiTrack)},
+         * {@link JitsiConference#removeTrack(JitsiTrack)}).
+         * @type {boolean}
+         */
+        this.disposed = false;
+        this._setHandler('inactive', streamInactiveHandler);
+    }
+
+    /* eslint-enable max-params */
 
     /**
-     * Indicates whether this JitsiTrack has been disposed. If true, this
-     * JitsiTrack is to be considered unusable and operations involving it are
-     * to fail (e.g. {@link JitsiConference#addTrack(JitsiTrack)},
-     * {@link JitsiConference#removeTrack(JitsiTrack)}).
-     * @type {boolean}
+     * Sets handler to the WebRTC MediaStream or MediaStreamTrack object
+     * depending on the passed type.
+     * @param {string} type the type of the handler that is going to be set
+     * @param {Function} handler the handler.
      */
-    this.disposed = false;
-    this._setHandler('inactive', streamInactiveHandler);
-}
-
-/* eslint-enable max-params */
+    _setHandler(type, handler) {
+        this.handlers[type] = handler;
+        if (!this.stream) {
+            return;
+        }
 
-/**
- * Sets handler to the WebRTC MediaStream or MediaStreamTrack object depending
- * on the passed type.
- * @param {string} type the type of the handler that is going to be set
- * @param {Function} handler the handler.
- */
-JitsiTrack.prototype._setHandler = function(type, handler) {
-    this.handlers[type] = handler;
-    if (!this.stream) {
-        return;
+        if (type === 'inactive') {
+            if (RTCBrowserType.isFirefox()) {
+                implementOnEndedHandling(this);
+            }
+            addMediaStreamInactiveHandler(this.stream, handler);
+        } else if (trackHandler2Prop.hasOwnProperty(type)) {
+            this.stream.getVideoTracks().forEach(track => {
+                track[trackHandler2Prop[type]] = handler;
+            }, this);
+        }
     }
 
-    if (type === 'inactive') {
-        if (RTCBrowserType.isFirefox()) {
-            implementOnEndedHandling(this);
-        }
-        addMediaStreamInactiveHandler(this.stream, handler);
-    } else if (trackHandler2Prop.hasOwnProperty(type)) {
-        this.stream.getVideoTracks().forEach(track => {
-            track[trackHandler2Prop[type]] = handler;
+    /**
+     * Sets the stream property of JitsiTrack object and sets all stored
+     * handlers to it.
+     * @param {MediaStream} stream the new stream.
+     */
+    _setStream(stream) {
+        this.stream = stream;
+        Object.keys(this.handlers).forEach(type => {
+            typeof this.handlers[type] === 'function'
+                && this._setHandler(type, this.handlers[type]);
         }, this);
     }
-};
-
-/**
- * Sets the stream property of JitsiTrack object and sets all stored handlers
- * to it.
- * @param {MediaStream} stream the new stream.
- */
-JitsiTrack.prototype._setStream = function(stream) {
-    this.stream = stream;
-    Object.keys(this.handlers).forEach(function(type) {
-        typeof this.handlers[type] === 'function'
-            && this._setHandler(type, this.handlers[type]);
-    }, this);
-};
-
-/**
- * Returns the type (audio or video) of this track.
- */
-JitsiTrack.prototype.getType = function() {
-    return this.type;
-};
-
-/**
- * Check if this is an audio track.
- */
-JitsiTrack.prototype.isAudioTrack = function() {
-    return this.getType() === MediaType.AUDIO;
-};
-
-/**
- * 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.
- */
-JitsiTrack.prototype.isWebRTCTrackMuted = function() {
-    return this.track && this.track.muted;
-};
-
-/**
- * Check if this is a video track.
- */
-JitsiTrack.prototype.isVideoTrack = function() {
-    return this.getType() === MediaType.VIDEO;
-};
-
-/**
- * Checks whether this is a local track.
- * @abstract
- * @return {boolean} 'true' if it's a local track or 'false' otherwise.
- */
-JitsiTrack.prototype.isLocal = function() {
-    throw new Error('Not implemented by subclass');
-};
-
-/**
- * Returns the WebRTC MediaStream instance.
- */
-JitsiTrack.prototype.getOriginalStream = function() {
-    return this.stream;
-};
 
-/**
- * Returns the ID of the underlying WebRTC Media Stream(if any)
- * @returns {String|null}
- */
-JitsiTrack.prototype.getStreamId = function() {
-    return this.stream ? this.stream.id : null;
-};
-
-/**
- * Return the underlying WebRTC MediaStreamTrack
- * @returns {MediaStreamTrack}
- */
-JitsiTrack.prototype.getTrack = function() {
-    return this.track;
-};
-
-/**
- * Returns the ID of the underlying WebRTC MediaStreamTrack(if any)
- * @returns {String|null}
- */
-JitsiTrack.prototype.getTrackId = function() {
-    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.
- * @returns {string}
- */
-JitsiTrack.prototype.getUsageLabel = function() {
-    if (this.isAudioTrack()) {
-        return 'mic';
+    /**
+     * Check if this is an audio track.
+     */
+    isAudioTrack() {
+        return this.getType() === MediaType.AUDIO;
     }
 
-    return this.videoType ? this.videoType : 'default';
+    /**
+     * 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.
+     */
+    isWebRTCTrackMuted() {
+        return this.track && this.track.muted;
+    }
 
-};
+    /**
+     * Check if this is a video track.
+     */
+    isVideoTrack() {
+        return this.getType() === MediaType.VIDEO;
+    }
 
-/**
- * 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
- */
-JitsiTrack.prototype._maybeFireTrackAttached = function(container) {
-    if (this.conference && container) {
-        this.conference._onTrackAttach(this, container);
+    /**
+     * Checks whether this is a local track.
+     * @abstract
+     * @return {boolean} 'true' if it's a local track or 'false' otherwise.
+     */
+    isLocal() {
+        throw new Error('Not implemented by subclass');
     }
-};
 
-/**
- * Attaches the MediaStream of this track to an HTML container.
- * Adds the container to the list of containers that are displaying the track.
- * Note that Temasys plugin will replace original audio/video element with
- * 'object' when stream is being attached to the container for the first time.
- *
- * * NOTE * if given container element is not visible when the stream is being
- * attached it will be shown back given that Temasys plugin is currently in use.
- *
- * @param container the HTML container which can be 'video' or 'audio' element.
- *        It can also be 'object' element if Temasys plugin is in use and this
- *        method has been called previously on video or audio HTML element.
- *
- * @returns potentially new instance of container if it was replaced by the
- *          library. That's the case when Temasys plugin is in use.
- */
-JitsiTrack.prototype.attach = function(container) {
-    let c = container;
+    /**
+     * Returns the WebRTC MediaStream instance.
+     */
+    getOriginalStream() {
+        return this.stream;
+    }
 
-    if (this.stream) {
-        c = RTCUtils.attachMediaStream(container, this.stream);
+    /**
+     * Returns the ID of the underlying WebRTC Media Stream(if any)
+     * @returns {String|null}
+     */
+    getStreamId() {
+        return this.stream ? this.stream.id : null;
     }
-    this.containers.push(c);
-    this._maybeFireTrackAttached(c);
-    this._attachTTFMTracker(c);
 
-    return c;
-};
+    /**
+     * Return the underlying WebRTC MediaStreamTrack
+     * @returns {MediaStreamTrack}
+     */
+    getTrack() {
+        return this.track;
+    }
 
-/**
- * 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.
- */
-JitsiTrack.prototype.detach = function(container) {
-    for (let cs = this.containers, i = cs.length - 1; i >= 0; --i) {
-        const c = cs[i];
+    /**
+     * Returns the ID of the underlying WebRTC MediaStreamTrack(if any)
+     * @returns {String|null}
+     */
+    getTrackId() {
+        return this.track ? this.track.id : null;
+    }
 
-        if (!container) {
-            RTCUtils.attachMediaStream(c, null);
-        }
-        if (!container || c === container) {
-            cs.splice(i, 1);
+    /**
+     * Return meaningful usage label for this track depending on it's media and
+     * eventual video type.
+     * @returns {string}
+     */
+    getUsageLabel() {
+        if (this.isAudioTrack()) {
+            return 'mic';
         }
+
+        return this.videoType ? this.videoType : 'default';
     }
 
-    if (container) {
-        RTCUtils.attachMediaStream(container, null);
+    /**
+     * 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);
+        }
     }
-};
 
-/**
- * Attach time to first media tracker only if there is conference and only
- * for the first element.
- * @param container the HTML container which can be 'video' or 'audio' element.
- *        It can also be 'object' element if Temasys plugin is in use and this
- *        method has been called previously on video or audio HTML element.
- * @private
- */
-// eslint-disable-next-line no-unused-vars
-JitsiTrack.prototype._attachTTFMTracker = function(container) {
-    // Should be defined by the classes that are extending JitsiTrack
-};
+    /**
+     * Attaches the MediaStream of this track to an HTML container.
+     * Adds the container to the list of containers that are displaying the
+     * track. Note that Temasys plugin will replace original audio/video element
+     * with 'object' when stream is being attached to the container for the
+     * first time.
+     * * NOTE * if given container element is not visible when the stream is
+     * being attached it will be shown back given that Temasys plugin is
+     * currently in use.
+     *
+     * @param container the HTML container which can be 'video' or 'audio'
+     * element. It can also be 'object' element if Temasys plugin is in use and
+     * this method has been called previously on video or audio HTML element.
+     *
+     * @returns potentially new instance of container if it was replaced by the
+     *          library. That's the case when Temasys plugin is in use.
+     */
+    attach(container) {
+        let c = container;
 
-/**
- * Removes attached event listeners.
- *
- * @returns {Promise}
- */
-JitsiTrack.prototype.dispose = function() {
-    this.eventEmitter.removeAllListeners();
+        if (this.stream) {
+            c = RTCUtils.attachMediaStream(container, this.stream);
+        }
+        this.containers.push(c);
+        this._maybeFireTrackAttached(c);
+        this._attachTTFMTracker(c);
 
-    this.disposed = true;
+        return c;
+    }
 
-    return Promise.resolve();
-};
+    /**
+     * 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.
+     */
+    detach(container) {
+        for (let cs = this.containers, i = cs.length - 1; i >= 0; --i) {
+            const c = cs[i];
+
+            if (!container) {
+                RTCUtils.attachMediaStream(c, null);
+            }
+            if (!container || c === container) {
+                cs.splice(i, 1);
+            }
+        }
 
-/**
- * Returns true if this is a video track and the source of the video is a
- * screen capture as opposed to a camera.
- */
-JitsiTrack.prototype.isScreenSharing = function() {
-    // FIXME: Should be fixed or removed.
-};
+        if (container) {
+            RTCUtils.attachMediaStream(container, null);
+        }
+    }
 
-/**
- * Returns id of the track.
- * @returns {string|null} id of the track or null if this is fake track.
- */
-JitsiTrack.prototype.getId = function() {
-    if (this.stream) {
-        return RTCUtils.getStreamID(this.stream);
+    /**
+     * 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. It can also be 'object' element if Temasys plugin is in
+     * use and this method has been called previously on video or audio HTML
+     * element.
+     * @private
+     */
+    _attachTTFMTracker(container) { // eslint-disable-line no-unused-vars
+        // Should be defined by the classes that are extending JitsiTrack
     }
 
-    return null;
+    /**
+     * Removes attached event listeners.
+     *
+     * @returns {Promise}
+     */
+    dispose() {
+        this.removeAllListeners();
 
-};
+        this.disposed = true;
 
-/**
- * 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.
- */
-JitsiTrack.prototype.isActive = function() {
-    if (typeof this.stream.active !== 'undefined') {
-        return this.stream.active;
+        return Promise.resolve();
     }
 
-    return true;
+    /**
+     * Returns true if this is a video track and the source of the video is a
+     * screen capture as opposed to a camera.
+     */
+    isScreenSharing() {
+        // FIXME: Should be fixed or removed.
+    }
 
-};
+    /**
+     * Returns id of the track.
+     * @returns {string|null} id of the track or null if this is fake track.
+     */
+    getId() {
+        if (this.stream) {
+            return RTCUtils.getStreamID(this.stream);
+        }
 
-/**
- * Attaches a handler for events(For example - "audio level changed".).
- * All possible event are defined in JitsiTrackEvents.
- * @param eventId the event ID.
- * @param handler handler for the event.
- */
-JitsiTrack.prototype.on = function(eventId, handler) {
-    if (this.eventEmitter) {
-        this.eventEmitter.on(eventId, handler);
+        return null;
     }
-};
 
-/**
- * Removes event listener
- * @param eventId the event ID.
- * @param [handler] optional, the specific handler to unbind
- */
-JitsiTrack.prototype.off = function(eventId, handler) {
-    if (this.eventEmitter) {
-        this.eventEmitter.removeListener(eventId, handler);
-    }
-};
+    /**
+     * 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.
+     */
+    isActive() {
+        if (typeof this.stream.active !== 'undefined') {
+            return this.stream.active;
+        }
 
-// Common aliases for event emitter
-JitsiTrack.prototype.addEventListener = JitsiTrack.prototype.on;
-JitsiTrack.prototype.removeEventListener = JitsiTrack.prototype.off;
+        return true;
+    }
 
-/**
- * Sets the audio level for the stream
- * @param {number} audioLevel value between 0 and 1
- * @param {TraceablePeerConnection} [tpc] the peerconnection instance which
- * is source for the audio level. It can be <tt>undefined</tt> for
- * a local track if the audio level was measured outside of the peerconnection
- * (see /modules/statistics/LocalStatsCollector.js).
- */
-JitsiTrack.prototype.setAudioLevel = function(audioLevel, tpc) {
-    if (this.audioLevel !== audioLevel) {
-        this.audioLevel = audioLevel;
-        this.eventEmitter.emit(
-            JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
-            audioLevel,
-            tpc);
+    /**
+     * Sets the audio level for the stream
+     * @param {number} audioLevel value between 0 and 1
+     * @param {TraceablePeerConnection} [tpc] the peerconnection instance which
+     * is source for the audio level. It can be <tt>undefined</tt> for
+     * a local track if the audio level was measured outside of the
+     * peerconnection (see /modules/statistics/LocalStatsCollector.js).
+     */
+    setAudioLevel(audioLevel, tpc) {
+        if (this.audioLevel !== audioLevel) {
+            this.audioLevel = audioLevel;
+            this.emit(
+                JitsiTrackEvents.TRACK_AUDIO_LEVEL_CHANGED,
+                audioLevel,
+                tpc);
+        }
     }
-};
 
-/**
- * Returns the msid of the stream attached to the JitsiTrack object or null if
- * no stream is attached.
- */
-JitsiTrack.prototype.getMSID = function() {
-    const streamId = this.getStreamId();
-    const trackId = this.getTrackId();
+    /**
+     * 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;
-};
+        return streamId && trackId ? `${streamId} ${trackId}` : null;
+    }
 
-/**
- * Sets new audio output device for track's DOM elements. Video tracks are
- * ignored.
- * @param {string} audioOutputDeviceId - id of 'audiooutput' device from
- *      navigator.mediaDevices.enumerateDevices(), '' for default device
- * @emits JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED
- * @returns {Promise}
- */
-JitsiTrack.prototype.setAudioOutput = function(audioOutputDeviceId) {
-    const self = this;
+    /**
+     * Sets new audio output device for track's DOM elements. Video tracks are
+     * ignored.
+     * @param {string} audioOutputDeviceId - id of 'audiooutput' device from
+     *      navigator.mediaDevices.enumerateDevices(), '' for default device
+     * @emits JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED
+     * @returns {Promise}
+     */
+    setAudioOutput(audioOutputDeviceId) {
+        if (!RTCUtils.isDeviceChangeAvailable('output')) {
+            return Promise.reject(
+                new Error('Audio output device change is not supported'));
+        }
 
-    if (!RTCUtils.isDeviceChangeAvailable('output')) {
-        return Promise.reject(
-            new Error('Audio output device change is not supported'));
-    }
+        // All audio communication is done through audio tracks, so ignore
+        // changing audio output for video tracks at all.
+        if (this.isVideoTrack()) {
+            return Promise.resolve();
+        }
 
-    // All audio communication is done through audio tracks, so ignore changing
-    // audio output for video tracks at all.
-    if (this.isVideoTrack()) {
-        return Promise.resolve();
+        return (
+            Promise.all(
+                    this.containers.map(
+                        element =>
+                            element.setSinkId(audioOutputDeviceId)
+                                .catch(error => {
+                                    logger.warn(
+                                        'Failed to change audio output device'
+                                            + ' on element. Default or'
+                                            + ' previously set audio output'
+                                            + ' device will be used.',
+                                        element,
+                                        error);
+                                    throw error;
+                                })))
+                .then(() => {
+                    this.emit(
+                        JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED,
+                        audioOutputDeviceId);
+                }));
     }
-
-    return (
-        Promise.all(
-                this.containers.map(
-                    element =>
-                        element.setSinkId(audioOutputDeviceId)
-                            .catch(error => {
-                                logger.warn(
-                                    'Failed to change audio output device on'
-                                        + ' element. Default or previously set'
-                                        + ' audio output device will be used.',
-                                    element,
-                                    error);
-                                throw error;
-                            })))
-            .then(() => {
-                self.eventEmitter.emit(
-                    JitsiTrackEvents.TRACK_AUDIO_OUTPUT_CHANGED,
-                    audioOutputDeviceId);
-            }));
-};
+}