Collect dominant speaker times

JitsiConference.js

@@ -24,8 +24,11 @@ import TalkMutedDetection from './modules/TalkMutedDetection';
 import Transcriber from './modules/transcription/transcriber';
 import VideoType from './service/RTC/VideoType';
 
+import SpeakerStatsCollector from './modules/statistics/SpeakerStatsCollector';
+
 const logger = getLogger(__filename);
 
+
 /**
  * Creates a JitsiConference object with the given name and properties.
  * Note: this constructor is not a part of the public API (objects should be
@@ -93,6 +96,10 @@ function JitsiConference(options) {
      */
     this.connectionIsInterrupted = false;
 
+    /**
+     * The object which tracks active speaker times
+     */
+    this.speakerStatsCollector = new SpeakerStatsCollector(this);
 }
 
 /**
@@ -1626,4 +1633,12 @@ JitsiConference.prototype.isConnectionInterrupted = function() {
     return this.connectionIsInterrupted;
 };
 
+/**
+ * Get a summary of how long current participants have been the dominant speaker
+ * @returns {object}
+ */
+JitsiConference.prototype.getSpeakerStats = function() {
+    return this.speakerStatsCollector.getStats();
+};
+
 module.exports = JitsiConference;

modules/statistics/SpeakerStats.js

@@ -0,0 +1,132 @@
+/**
+ * A model for keeping track of each user's total
+ * time as a dominant speaker. The model also
+ * keeps track of the user's last known name
+ * in case the user has left the meeting,
+ * which is also tracked.
+ */
+class SpeakerStats {
+    /**
+     * Initializes a new SpeakerStats instance.
+     *
+     * @constructor
+     * @param {string} userId - The id of the user being tracked.
+     * @param {string} displayName - The name of the user being tracked.
+     * @param {boolean} isLocalStats - True if the stats model tracks
+     * the local user.
+     * @returns {void}
+     */
+    constructor(userId, displayName, isLocalStats) {
+        this._userId = userId;
+        this.setDisplayName(displayName);
+        this._isLocalStats = isLocalStats || false;
+        this.setIsDominantSpeaker(false);
+        this.totalDominantSpeakerTime = 0;
+        this._dominantSpeakerStart = null;
+        this._hasLeft = false;
+    }
+
+    /**
+     * Get the user id being tracked.
+     *
+     * @returns {string} The user id.
+     */
+    getUserId() {
+        return this._userId;
+    }
+
+    /**
+     * Get the name of the user being tracked.
+     *
+     * @returns {string} The user name.
+     */
+    getDisplayName() {
+        return this.displayName;
+    }
+
+    /**
+     * Updates the last known name of the user being tracked.
+     *
+     * @param {string} - The user name.
+     * @returns {void}
+     */
+    setDisplayName(newName) {
+        this.displayName = newName;
+    }
+
+    /**
+     * Returns true if the stats are tracking the local user.
+     *
+     * @returns {boolean}
+     */
+    isLocalStats() {
+        return this._isLocalStats;
+    }
+
+    /**
+     * Returns true if the tracked user is currently a dominant speaker.
+     *
+     * @returns {boolean}
+     */
+    isDominantSpeaker() {
+        return this._isDominantSpeaker;
+    }
+
+    /**
+     * Returns true if the tracked user is currently a dominant speaker.
+     *
+     * @param {boolean} - If true, the user will being accumulating time
+     * as dominant speaker. If false, the user will not accumulate time
+     * and will record any time accumulated since starting as dominant speaker.
+     * @returns {void}
+     */
+    setIsDominantSpeaker(isNowDominantSpeaker) {
+        if (!this._isDominantSpeaker && isNowDominantSpeaker) {
+            this._dominantSpeakerStart = Date.now();
+        } else if (this._isDominantSpeaker && !isNowDominantSpeaker) {
+            const now = Date.now();
+            const timeElapsed = now - (this._dominantSpeakerStart || 0);
+
+            this.totalDominantSpeakerTime += timeElapsed;
+            this._dominantSpeakerStart = null;
+        }
+
+        this._isDominantSpeaker = isNowDominantSpeaker;
+    }
+
+    /**
+     * Get how long the tracked user has been dominant speaker.
+     *
+     * @returns {number} - The speaker time in milliseconds.
+     */
+    getTotalDominantSpeakerTime() {
+        let total = this.totalDominantSpeakerTime;
+
+        if (this._isDominantSpeaker) {
+            total += Date.now() - this._dominantSpeakerStart;
+        }
+
+        return total;
+    }
+
+    /**
+     * Get whether or not the user is still in the meeting.
+     *
+     * @returns {boolean} True if the user is no longer in the meeting.
+     */
+    hasLeft() {
+        return this._hasLeft;
+    }
+
+    /**
+     * Set the user as having left the meeting.
+     *
+     * @returns {void}
+     */
+    markAsHasLeft() {
+        this._hasLeft = true;
+        this.setIsDominantSpeaker(false);
+    }
+}
+
+module.exports = SpeakerStats;

modules/statistics/SpeakerStats.spec.js

@@ -0,0 +1,60 @@
+import SpeakerStats from './SpeakerStats';
+
+describe('SpeakerStats', () => {
+    const mockUserId = 1;
+    const mockUserName = 'foo';
+    let speakerStats;
+
+    beforeEach(() => {
+        speakerStats = new SpeakerStats(mockUserId, mockUserName);
+    });
+
+    describe('markAsHasLeft', () => {
+        it('sets the user state as having left the meeting', () => {
+            speakerStats.markAsHasLeft();
+            expect(speakerStats.hasLeft()).toBe(true);
+        });
+
+        it('removes the user as a dominant speaker', () => {
+            speakerStats.setIsDominantSpeaker(true);
+            speakerStats.markAsHasLeft();
+            expect(speakerStats.isDominantSpeaker()).toBe(false);
+        });
+    });
+
+    describe('setDisplayName', () => {
+        it('updates the username', () => {
+            const newName = `new-${mockUserName}`;
+
+            speakerStats.setDisplayName(newName);
+            expect(speakerStats.getDisplayName()).toBe(newName);
+        });
+    });
+
+    describe('getTotalDominantSpeakerTime', () => {
+        const mockDate = new Date(2017, 1, 1);
+
+        beforeEach(() => {
+            jasmine.clock().install();
+            jasmine.clock().mockDate(mockDate);
+        });
+
+        afterEach(() => {
+            jasmine.clock().uninstall();
+        });
+
+        it('returns the total dominant speaker time', () => {
+            const domaintSpeakerEvents = 3;
+            const domaintSpeakerTime = 100;
+
+            for (let i = 0; i < domaintSpeakerEvents; i++) {
+                speakerStats.setIsDominantSpeaker(true);
+                jasmine.clock().tick(domaintSpeakerTime);
+                speakerStats.setIsDominantSpeaker(false);
+            }
+
+            expect(speakerStats.getTotalDominantSpeakerTime())
+              .toBe(domaintSpeakerTime * domaintSpeakerEvents);
+        });
+    });
+});

modules/statistics/SpeakerStatsCollector.js

@@ -0,0 +1,123 @@
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import SpeakerStats from './SpeakerStats';
+
+/**
+ * A collection for tracking speaker stats. Attaches listeners
+ * to the conference to automatically update on tracked events.
+ */
+class SpeakerStatsCollector {
+    /**
+     * Initializes a new SpeakerStatsCollector instance.
+     *
+     * @constructor
+     * @param {JitsiConference} conference - The conference to track.
+     * @returns {void}
+     */
+    constructor(conference) {
+        this.stats = {
+            users: {
+
+                // userId: SpeakerStats
+            },
+            dominantSpeakerId: null
+        };
+
+        const userId = conference.myUserId();
+
+        this.stats.users[userId] = new SpeakerStats(userId, null, true);
+
+        conference.addEventListener(
+            JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
+            this._onDominantSpeaker.bind(this));
+        conference.addEventListener(
+            JitsiConferenceEvents.USER_JOINED,
+            this._onUserJoin.bind(this));
+        conference.addEventListener(
+            JitsiConferenceEvents.USER_LEFT,
+            this._onUserLeave.bind(this));
+        conference.addEventListener(
+            JitsiConferenceEvents.DISPLAY_NAME_CHANGED,
+            this._onDisplayNameChange.bind(this));
+    }
+
+    /**
+     * Reacts to dominant speaker change events by changing its speaker stats
+     * models to reflect the current dominant speaker.
+     *
+     * @param {string} dominantSpeakerId - The user id of the new
+     * dominant speaker.
+     * @returns {void}
+     * @private
+     */
+    _onDominantSpeaker(dominantSpeakerId) {
+        const oldDominantSpeaker
+            = this.stats.users[this.stats.dominantSpeakerId];
+        const newDominantSpaker = this.stats.users[dominantSpeakerId];
+
+        oldDominantSpeaker && oldDominantSpeaker.setIsDominantSpeaker(false);
+        newDominantSpaker && newDominantSpaker.setIsDominantSpeaker(true);
+        this.stats.dominantSpeakerId = dominantSpeakerId;
+    }
+
+    /**
+     * Reacts to user join events by creating a new SpeakerStats model.
+     *
+     * @param {string} userId - The user id of the new user.
+     * @param {JitsiParticipant} - The JitsiParticipant model for the new user.
+     * @returns {void}
+     * @private
+     */
+    _onUserJoin(userId, participant) {
+        let savedUser = this.stats.users[userId];
+
+        if (!savedUser) {
+            savedUser = this.stats.users[userId]
+                = new SpeakerStats(userId, participant.getDisplayName());
+        }
+    }
+
+    /**
+     * Reacts to user leave events by updating the associated user's
+     * SpeakerStats model.
+     *
+     * @param {string} userId - The user id of the user that left.
+     * @returns {void}
+     * @private
+     */
+    _onUserLeave(userId) {
+        const savedUser = this.stats.users[userId];
+
+        if (savedUser) {
+            savedUser.markAsHasLeft();
+        }
+    }
+
+    /**
+     * Reacts to user name change events by updating the last known name
+     * tracked in the associated SpeakerStats model.
+     *
+     * @param {string} userId - The user id of the user that left.
+     * @returns {void}
+     * @private
+     */
+    _onDisplayNameChange(userId, newName) {
+        const savedUser = this.stats.users[userId];
+
+        if (savedUser) {
+            savedUser.setDisplayName(newName);
+        }
+    }
+
+    /**
+     * Return a copy of the tracked SpeakerStats models.
+     *
+     * @returns {Object} The keys are the user ids and the values are the
+     * associated user's SpeakerStats model.
+     * @private
+     */
+    getStats() {
+        return this.stats.users;
+    }
+}
+
+module.exports = SpeakerStatsCollector;

modules/statistics/SpeakerStatsCollector.spec.js

@@ -0,0 +1,126 @@
+import EventEmitter from 'events';
+import JitsiConference from '../../JitsiConference';
+import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
+import JitsiParticipant from '../../JitsiParticipant';
+import SpeakerStats from './SpeakerStats';
+import SpeakerStatsCollector from './SpeakerStatsCollector';
+
+const mockMyId = 1;
+const mockRemoteUser = {
+    id: 2,
+    name: 'foo'
+};
+
+/**
+ * Mock object to be used in place of a real conference.
+ *
+ * @constructor
+ */
+function MockConference() {
+    this.eventEmitter = new EventEmitter();
+}
+MockConference.prototype = Object.create(JitsiConference.prototype);
+MockConference.prototype.constructor = JitsiConference;
+
+/**
+ * Mock object to be used in place of a real JitsiParticipant.
+ *
+ * @constructor
+ * @param {string|number} id - An id for the mock user.
+ * @param {string} name - A name for the mock user.
+ * @returns {void}
+ */
+function MockJitsiParticipant(id, name) {
+    this._jid = id;
+    this._displayName = name;
+}
+MockJitsiParticipant.prototype = Object.create(JitsiParticipant.prototype);
+MockJitsiParticipant.prototype.constructor = JitsiParticipant;
+
+describe('SpeakerStatsCollector', () => {
+    let mockConference, speakerStatsCollector;
+
+    beforeEach(() => {
+        mockConference = new MockConference();
+        spyOn(mockConference, 'myUserId').and.returnValue(mockMyId);
+
+        speakerStatsCollector = new SpeakerStatsCollector(mockConference);
+
+        mockConference.eventEmitter.emit(
+            JitsiConferenceEvents.USER_JOINED,
+            mockRemoteUser.id,
+            new MockJitsiParticipant(mockRemoteUser.id, mockRemoteUser.name)
+        );
+    });
+
+    it('automatically adds the current user', () => {
+        const stats = speakerStatsCollector.getStats();
+        const currentUserStats = stats[mockMyId];
+
+        expect(currentUserStats instanceof SpeakerStats).toBe(true);
+    });
+
+    it('adds joined users to the stats', () => {
+        const stats = speakerStatsCollector.getStats();
+        const remoteUserStats = stats[mockRemoteUser.id];
+
+        expect(remoteUserStats).toBeTruthy();
+        expect(remoteUserStats instanceof SpeakerStats).toBe(true);
+        expect(remoteUserStats.getDisplayName()).toBe(mockRemoteUser.name);
+    });
+
+    describe('on user name change', () => {
+        it('updates the username', () => {
+            const newName = `new-${mockRemoteUser.name}`;
+
+            mockConference.eventEmitter.emit(
+                JitsiConferenceEvents.DISPLAY_NAME_CHANGED,
+                mockRemoteUser.id,
+                newName
+            );
+
+            const stats = speakerStatsCollector.getStats();
+            const remoteUserStats = stats[mockRemoteUser.id];
+
+            expect(remoteUserStats.getDisplayName()).toBe(newName);
+        });
+    });
+
+    describe('on user leave', () => {
+        it('retains the user stats but marks the user as left', () => {
+            mockConference.eventEmitter.emit(
+                JitsiConferenceEvents.USER_LEFT,
+                mockRemoteUser.id
+            );
+
+            const stats = speakerStatsCollector.getStats();
+            const remoteUserStats = stats[mockRemoteUser.id];
+
+            expect(remoteUserStats.hasLeft()).toBe(true);
+        });
+    });
+
+    describe('on dominant speaker change', () => {
+        it('updates models to reflect the new dominant speaker', () => {
+            const stats = speakerStatsCollector.getStats();
+            const remoteUserStats = stats[mockRemoteUser.id];
+            const currentUserStats = stats[mockMyId];
+
+            mockConference.eventEmitter.emit(
+                JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
+                mockRemoteUser.id
+            );
+
+            expect(remoteUserStats.isDominantSpeaker()).toBe(true);
+            expect(currentUserStats.isDominantSpeaker()).toBe(false);
+
+            mockConference.eventEmitter.emit(
+                JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED,
+                mockMyId
+            );
+
+            expect(remoteUserStats.isDominantSpeaker()).toBe(false);
+            expect(currentUserStats.isDominantSpeaker()).toBe(true);
+        });
+    });
+});