feat: Handle dominant speaker silence.

JitsiConferenceEventManager.js

         conference.onRemoteTrackRemoved.bind(conference));
 
     rtc.addListener(RTCEvents.DOMINANT_SPEAKER_CHANGED,
-        (dominant, previous) => {
-            if (conference.lastDominantSpeaker !== dominant && conference.room) {
+        (dominant, previous, silence) => {
+            if ((conference.lastDominantSpeaker !== dominant || conference.dominantSpeakerIsSilent !== silence)
+                    && conference.room) {
                 conference.lastDominantSpeaker = dominant;
+                conference.dominantSpeakerIsSilent = silence;
                 conference.eventEmitter.emit(
-                    JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED, dominant, previous);
-
-                if (previous && previous.length) {
-                    const speakerList = previous.slice(0);
-
-                    // Add the dominant speaker to the top of the list (exclude self).
-                    if (conference.myUserId !== dominant) {
-                        speakerList.splice(0, 0, dominant);
-                    }
-
-                    // Trim the list to the top 5 speakers only.
-                    if (speakerList.length > SPEAKERS_AUDIO_LEVELS) {
-                        speakerList.splice(SPEAKERS_AUDIO_LEVELS, speakerList.length - SPEAKERS_AUDIO_LEVELS);
-                    }
-                    conference.statistics && conference.statistics.setSpeakerList(speakerList);
-                }
+                    JitsiConferenceEvents.DOMINANT_SPEAKER_CHANGED, dominant, previous, silence);
                 if (conference.statistics && conference.myUserId() === dominant) {
                     // We are the new dominant speaker.
-                    conference.statistics.sendDominantSpeakerEvent(conference.room.roomjid);
+                    conference.statistics.sendDominantSpeakerEvent(conference.room.roomjid, silence);
+                }
+                if (conference.lastDominantSpeaker !== dominant) {
+                    if (previous && previous.length) {
+                        const speakerList = previous.slice(0);
+
+                        // Add the dominant speaker to the top of the list (exclude self).
+                        if (conference.myUserId !== dominant) {
+                            speakerList.splice(0, 0, dominant);
+                        }
+
+                        // Trim the list to the top 5 speakers only.
+                        if (speakerList.length > SPEAKERS_AUDIO_LEVELS) {
+                            speakerList.splice(SPEAKERS_AUDIO_LEVELS, speakerList.length - SPEAKERS_AUDIO_LEVELS);
+                        }
+                        conference.statistics && conference.statistics.setSpeakerList(speakerList);
+                    }
                 }
             }
         });

modules/RTC/BridgeChannel.js

 
             switch (colibriClass) {
             case 'DominantSpeakerEndpointChangeEvent': {
-                const { dominantSpeakerEndpoint, previousSpeakers = [] } = obj;
+                const { dominantSpeakerEndpoint, previousSpeakers = [], silence } = obj;
 
                 logger.debug(`Dominant speaker: ${dominantSpeakerEndpoint}, previous speakers: ${previousSpeakers}`);
-                emitter.emit(RTCEvents.DOMINANT_SPEAKER_CHANGED, dominantSpeakerEndpoint, previousSpeakers);
+                emitter.emit(RTCEvents.DOMINANT_SPEAKER_CHANGED, dominantSpeakerEndpoint, previousSpeakers, silence);
                 break;
             }
             case 'EndpointConnectivityStatusChangeEvent': {

modules/statistics/SpeakerStats.js

         this.setDominantSpeaker(false);
         this.totalDominantSpeakerTime = 0;
         this._dominantSpeakerStart = 0;
+        this._isDominantSpeaker = false;
+        this._isSilent = false;
         this._hasLeft = false;
         this._faceExpressions = {
             happy: 0,
      * @returns {boolean}
      */
     isDominantSpeaker() {
-        return this._dominantSpeakerStart > 0;
+        return this._isDominantSpeaker;
     }
 
     /**
      * @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.
+     * @param {boolean} silence - Indecates whether the dominant speaker is silent or not.
      * @returns {void}
      */
-    setDominantSpeaker(isNowDominantSpeaker) {
-        if (!this.isDominantSpeaker() && isNowDominantSpeaker) {
+    setDominantSpeaker(isNowDominantSpeaker, silence) {
+        if (!this.isDominantSpeaker() && isNowDominantSpeaker && !silence) {
             this._dominantSpeakerStart = Date.now();
-        } else if (this.isDominantSpeaker() && !isNowDominantSpeaker) {
-            const now = Date.now();
-            const timeElapsed = now - this._dominantSpeakerStart;
-
-            this.totalDominantSpeakerTime += timeElapsed;
-            this._dominantSpeakerStart = 0;
+        } else if (this.isDominantSpeaker()) {
+            if (!isNowDominantSpeaker) {
+                if (!this._isSilent) {
+                    const now = Date.now();
+                    const timeElapsed = now - this._dominantSpeakerStart;
+
+                    this.totalDominantSpeakerTime += timeElapsed;
+                    this._dominantSpeakerStart = 0;
+                }
+            } else if (this._isSilent && !silence) {
+                this._dominantSpeakerStart = Date.now();
+            } else if (!this._isSilent && silence) {
+                const now = Date.now();
+                const timeElapsed = now - this._dominantSpeakerStart;
+
+                this.totalDominantSpeakerTime += timeElapsed;
+                this._dominantSpeakerStart = 0;
+            }
         }
+
+        this._isDominantSpeaker = isNowDominantSpeaker;
+        this._isSilent = silence;
     }
 
     /**
     getTotalDominantSpeakerTime() {
         let total = this.totalDominantSpeakerTime;
 
-        if (this.isDominantSpeaker()) {
+        if (this.isDominantSpeaker() && !this._isSilent) {
             total += Date.now() - this._dominantSpeakerStart;
         }
 

modules/statistics/SpeakerStatsCollector.js

      * 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.
+     * @param {string} dominantSpeakerId - The user id of the new dominant speaker.
+     * @param {Array[string]} previous - The array with previous speakers.
+     * @param {boolean} silence - Indecates whether the dominant speaker is silent or not.
      * @returns {void}
      * @private
      */
-    _onDominantSpeaker(dominantSpeakerId) {
+    _onDominantSpeaker(dominantSpeakerId, previous, silence) {
         const oldDominantSpeaker
             = this.stats.users[this.stats.dominantSpeakerId];
         const newDominantSpeaker = this.stats.users[dominantSpeakerId];
 
         oldDominantSpeaker && oldDominantSpeaker.setDominantSpeaker(false);
-        newDominantSpeaker && newDominantSpeaker.setDominantSpeaker(true);
+        newDominantSpeaker && newDominantSpeaker.setDominantSpeaker(true, silence);
         this.stats.dominantSpeakerId = dominantSpeakerId;
     }
 

modules/statistics/statistics.js

  * Notifies the statistics module that we are now the dominant speaker of the
  * conference.
  * @param {String} roomJid - The room jid where the speaker event occurred.
+ * @param {boolean} silence - Whether the dominant speaker is silent or not.
  */
-Statistics.prototype.sendDominantSpeakerEvent = function(roomJid) {
+Statistics.prototype.sendDominantSpeakerEvent = function(roomJid, silence) {
     for (const cs of this.callsStatsInstances.values()) {
         cs.sendDominantSpeakerEvent();
     }
 
     // xmpp send dominant speaker event
-    this.xmpp.sendDominantSpeakerEvent(roomJid);
+    this.xmpp.sendDominantSpeakerEvent(roomJid, silence);
 };
 
 /**

modules/xmpp/xmpp.js

      * Notifies speaker stats component if available that we are the new
      * dominant speaker in the conference.
      * @param {String} roomJid - The room jid where the speaker event occurred.
+     * @param {boolean} silence - Whether the dominant speaker is silent or not.
      */
-    sendDominantSpeakerEvent(roomJid) {
+    sendDominantSpeakerEvent(roomJid, silence) {
         // no speaker stats component advertised
         if (!this.speakerStatsComponentAddress || !roomJid) {
             return;
 
         msg.c('speakerstats', {
             xmlns: 'http://jitsi.org/jitmeet',
-            room: roomJid })
+            room: roomJid,
+            silence })
             .up();
 
         this.connection.send(msg);

types/auto/modules/statistics/SpeakerStats.d.ts

     _isLocalStats: boolean;
     totalDominantSpeakerTime: number;
     _dominantSpeakerStart: number;
+    _isDominantSpeaker: boolean;
+    _isSilent: boolean;
     _hasLeft: boolean;
     _faceExpressions: {
         happy: number;
      * @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.
+     * @param {boolean} silence - Indecates whether the dominant speaker is silent or not.
      * @returns {void}
      */
-    setDominantSpeaker(isNowDominantSpeaker: any): void;
+    setDominantSpeaker(isNowDominantSpeaker: any, silence: boolean): void;
     /**
      * Get how long the tracked user has been dominant speaker.
      *

types/auto/modules/statistics/SpeakerStatsCollector.d.ts

      * 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.
+     * @param {string} dominantSpeakerId - The user id of the new dominant speaker.
+     * @param {Array[string]} previous - The array with previous speakers.
+     * @param {boolean} silence - Indecates whether the dominant speaker is silent or not.
      * @returns {void}
      * @private
      */

types/auto/modules/statistics/statistics.d.ts

      * Notifies the statistics module that we are now the dominant speaker of the
      * conference.
      * @param {String} roomJid - The room jid where the speaker event occurred.
+     * @param {boolean} silence - Whether the dominant speaker is silent or not.
      */
-    sendDominantSpeakerEvent(roomJid: string): void;
+    sendDominantSpeakerEvent(roomJid: string, silence: boolean): void;
     /**
      * Lets the underlying statistics module know where is given SSRC rendered by
      * providing renderer tag ID.

types/auto/modules/xmpp/xmpp.d.ts

      * Notifies speaker stats component if available that we are the new
      * dominant speaker in the conference.
      * @param {String} roomJid - The room jid where the speaker event occurred.
+     * @param {boolean} silence - Whether the dominant speaker is silent or not.
      */
-    sendDominantSpeakerEvent(roomJid: string): void;
+    sendDominantSpeakerEvent(roomJid: string, silence: boolean): void;
     /**
      * Sends face expressions to speaker stats component.
      * @param {String} roomJid - The room jid where the speaker event occurred.