Handles private messages received by speakerstats component.

Updates speakers stats with values received by the spealerstats component, all the logic is activate only in case we discover speakerstats component address from disco-info and the incoming message is coming from that component.

JitsiConference.js

 import ComponentsVersions from './modules/version/ComponentsVersions';
 import VideoSIPGW from './modules/videosipgw/VideoSIPGW';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
-import { JITSI_MEET_MUC_TYPE } from './modules/xmpp/ChatRoom';
+import { JITSI_MEET_MUC_TYPE } from './modules/xmpp/xmpp';
 import * as MediaType from './service/RTC/MediaType';
 import * as RTCEvents from './service/RTC/RTCEvents';
 import VideoType from './service/RTC/VideoType';

modules/statistics/SpeakerStatsCollector.js

 import * as JitsiConferenceEvents from '../../JitsiConferenceEvents';
 import SpeakerStats from './SpeakerStats';
+import XMPPEvents from '../../service/xmpp/XMPPEvents';
 
 /**
  * A collection for tracking speaker stats. Attaches listeners
         conference.addEventListener(
             JitsiConferenceEvents.DISPLAY_NAME_CHANGED,
             this._onDisplayNameChange.bind(this));
+        conference.xmpp.addListener(
+            XMPPEvents.SPEAKER_STATS_RECEIVED,
+            this._updateStats.bind(this));
     }
 
     /**
     getStats() {
         return this.stats.users;
     }
+
+    /**
+     * Updates of the current stats is requested, passing the new values.
+     *
+     * @param {Object} newStats - The new values used to update current one.
+     * @private
+     */
+    _updateStats(newStats) {
+        for (const userId in newStats) { // eslint-disable-line guard-for-in
+            let speakerStatsToUpdate;
+
+            if (this.stats.users[userId]) {
+                speakerStatsToUpdate = this.stats.users[userId];
+
+                if (!speakerStatsToUpdate.getDisplayName()) {
+                    speakerStatsToUpdate
+                        .setDisplayName(newStats[userId].displayName);
+                }
+            } else {
+                speakerStatsToUpdate = new SpeakerStats(
+                    userId, newStats[userId].displayName);
+                this.stats.users[userId] = speakerStatsToUpdate;
+                speakerStatsToUpdate.markAsHasLeft();
+            }
+
+            speakerStatsToUpdate.totalDominantSpeakerTime
+                = newStats[userId].totalDominantSpeakerTime;
+        }
+    }
 }

modules/xmpp/ChatRoom.js

     return res;
 }
 
-/**
- * The name of the field used to recognize a chat message as carrying a JSON
- * payload from another endpoint.
- * If the json-message of a chat message contains a valid JSON object, and the
- * JSON has this key, then it is a valid json-message to be sent.
- */
-export const JITSI_MEET_MUC_TYPE = 'type';
-
-/**
- * Check if the given argument is a valid JSON ENDPOINT_MESSAGE string by
- * parsing it and checking if it has a field called 'type'.
- *
- * @param {string} jsonString check if this string is a valid json string
- * and contains the special structure.
- * @returns {boolean, object} if given object is a valid JSON string, return
- * the json object. Otherwise, returns false.
- */
-function tryParseJSONAndVerify(jsonString) {
-    try {
-        const json = JSON.parse(jsonString);
-
-        // Handle non-exception-throwing cases:
-        // Neither JSON.parse(false) or JSON.parse(1234) throw errors,
-        // hence the type-checking,
-        // but... JSON.parse(null) returns null, and
-        // typeof null === "object",
-        // so we must check for that, too.
-        // Thankfully, null is falsey, so this suffices:
-        if (json && typeof json === 'object') {
-            const type = json[JITSI_MEET_MUC_TYPE];
-
-            if (typeof type !== 'undefined') {
-                return json;
-            }
-
-            logger.debug('parsing valid json but does not have correct '
-                + 'structure', 'topic: ', type);
-        }
-    } catch (e) {
-
-        return false;
-    }
-
-    return false;
-}
-
 // XXX As ChatRoom constructs XMPP stanzas and Strophe is build around the idea
 // of chaining function calls, allow long function call chains.
 /* eslint-disable newline-per-chained-call */
             this.discoRoomInfo();
         }
         const jsonMessage = $(msg).find('>json-message').text();
-        const parsedJson = tryParseJSONAndVerify(jsonMessage);
+        const parsedJson = this.xmpp.tryParseJSONAndVerify(jsonMessage);
 
         // We emit this event if the message is a valid json, and is not
         // delivered after a delay, i.e. stamp is undefined.

modules/xmpp/xmpp.js

 import Listenable from '../util/Listenable';
 import Caps from './Caps';
 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
+import XMPPEvents from '../../service/xmpp/XMPPEvents';
 
 const logger = getLogger(__filename);
 
     return conn;
 }
 
+/**
+ * The name of the field used to recognize a chat message as carrying a JSON
+ * payload from another endpoint.
+ * If the json-message of a chat message contains a valid JSON object, and
+ * the JSON has this key, then it is a valid json-message to be sent.
+ */
+export const JITSI_MEET_MUC_TYPE = 'type';
+
 /**
  *
  */
                     identities.forEach(identity => {
                         if (identity.type === 'speakerstats') {
                             this.speakerStatsComponentAddress = identity.name;
+
+                            this.connection.addHandler(
+                                this._onPrivateMessage.bind(this), null,
+                                'message', null, null);
                         }
                     });
                 })
 
         this.connection.send(msg);
     }
+
+    /**
+     * Check if the given argument is a valid JSON ENDPOINT_MESSAGE string by
+     * parsing it and checking if it has a field called 'type'.
+     *
+     * @param {string} jsonString check if this string is a valid json string
+     * and contains the special structure.
+     * @returns {boolean, object} if given object is a valid JSON string, return
+     * the json object. Otherwise, returns false.
+     */
+    tryParseJSONAndVerify(jsonString) {
+        try {
+            const json = JSON.parse(jsonString);
+
+            // Handle non-exception-throwing cases:
+            // Neither JSON.parse(false) or JSON.parse(1234) throw errors,
+            // hence the type-checking,
+            // but... JSON.parse(null) returns null, and
+            // typeof null === "object",
+            // so we must check for that, too.
+            // Thankfully, null is falsey, so this suffices:
+            if (json && typeof json === 'object') {
+                const type = json[JITSI_MEET_MUC_TYPE];
+
+                if (typeof type !== 'undefined') {
+                    return json;
+                }
+
+                logger.debug('parsing valid json but does not have correct '
+                    + 'structure', 'topic: ', type);
+            }
+        } catch (e) {
+            return false;
+        }
+
+        return false;
+    }
+
+    /**
+     * A private message is received, message that is not addressed to the muc.
+     * We expect private message coming from speaker stats component if it is
+     * enabled and running.
+     *
+     * @param {string} msg - The message.
+     */
+    _onPrivateMessage(msg) {
+        const from = msg.getAttribute('from');
+
+        if (!this.speakerStatsComponentAddress
+            || from !== this.speakerStatsComponentAddress) {
+            return;
+        }
+
+        const jsonMessage = $(msg).find('>json-message')
+            .text();
+        const parsedJson = this.tryParseJSONAndVerify(jsonMessage);
+
+        if (parsedJson
+            && parsedJson[JITSI_MEET_MUC_TYPE] === 'speakerstats'
+            && parsedJson.users) {
+            this.eventEmitter.emit(
+                XMPPEvents.SPEAKER_STATS_RECEIVED, parsedJson.users);
+        }
+
+        return true;
+    }
 }

service/xmpp/XMPPEvents.js

      */
     SESSION_ACCEPT_TIMEOUT: 'xmpp.session_accept_timeout',
 
+    /**
+     * Event fired when speaker stats update message is received.
+     */
+    SPEAKER_STATS_RECEIVED: 'xmpp.speaker_stats_received',
+
     // Designates an event indicating that we should join the conference with
     // audio and/or video muted.
     START_MUTED_FROM_FOCUS: 'xmpp.start_muted_from_focus',