ljm_5x/modules/RTC/JitsiRemoteTrack.js

import JitsiTrack from './JitsiTrack';
import * as JitsiTrackEvents from '../../JitsiTrackEvents';
import RTCBrowserType from './RTCBrowserType';
import Statistics from '../statistics/statistics';

const logger = require('jitsi-meet-logger').getLogger(__filename);
const RTCEvents = require('../../service/RTC/RTCEvents');

let ttfmTrackerAudioAttached = false;
let ttfmTrackerVideoAttached = false;

/* eslint-disable max-params */

/**
 * 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 {string} 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
 * @constructor
 */
export default function JitsiRemoteTrack(
        rtc,
        conference,
        ownerEndpointId,
        stream,
        track,
        mediaType,
        videoType,
        ssrc,
        muted,
        isP2P) {
    JitsiTrack.call(
        this,
        conference,
        stream,
        track,
        () => {
            // Nothing to do if the track is inactive.
        },
        mediaType,
        videoType);
    this.rtc = rtc;
    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());
    }
};

/**
 * 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;
    }

    if (value) {
        this.hasBeenMuted = true;
    }

    // we can have a fake video stream
    if (this.stream) {
        this.stream.muted = value;
    }

    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;
};

/**
 * Return false;
 */
JitsiRemoteTrack.prototype.isLocal = function() {
    return false;
};

/**
 * Returns the synchronization source identifier (SSRC) of this remote track.
 * @returns {string} the SSRC of this remote track
 */
JitsiRemoteTrack.prototype.getSSRC = function() {
    return this.ssrc;
};

/**
 * 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;
    }
    this.videoType = type;
    this.eventEmitter.emit(JitsiTrackEvents.TRACK_VIDEOTYPE_CHANGED, type);
};

JitsiRemoteTrack.prototype._playCallback = function() {
    const type = this.isVideoTrack() ? 'video' : 'audio';

    const now = window.performance.now();

    console.log(`(TIME) Render ${type}:\t`, now);
    this.conference.getConnectionTimes()[`${type}.render`] = now;

    const ttfm = now
        - (this.conference.getConnectionTimes()['session.initiate']
        - this.conference.getConnectionTimes()['muc.joined'])
        - (window.connectionTimes['obtainPermissions.end']
        - window.connectionTimes['obtainPermissions.start']);

    this.conference.getConnectionTimes()[`${type}.ttfm`] = ttfm;
    console.log(`(TIME) TTFM ${type}:\t`, ttfm);
    let eventName = `${type}.ttfm`;

    if (this.hasBeenMuted) {
        eventName += '.muted';
    }
    Statistics.analytics.sendEvent(eventName, { value: 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.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));
    }
};

/**
 * Creates a text representation of this remote track instance.
 * @return {string}
 */
JitsiRemoteTrack.prototype.toString = function() {
    return `RemoteTrack[${this.ownerEndpointId}, ${this.getType()
            }, p2p: ${this.isP2P}]`;
};