Adds server-side speaker stats handling.

When the main domain advertises component with type 'speakerstats' every participant will send message to the component with the name of the room where this happen.

JitsiConferenceEventManager.js

             }
             if (conference.statistics && conference.myUserId() === id) {
                 // We are the new dominant speaker.
-                conference.statistics.sendDominantSpeakerEvent();
+                conference.statistics.sendDominantSpeakerEvent(
+                    conference.room.roomjid);
             }
         });
 

modules/statistics/SpeakerStatsCollector.js

     _onDominantSpeaker(dominantSpeakerId) {
         const oldDominantSpeaker
             = this.stats.users[this.stats.dominantSpeakerId];
-        const newDominantSpaker = this.stats.users[dominantSpeakerId];
+        const newDominantSpeaker = this.stats.users[dominantSpeakerId];
 
         oldDominantSpeaker && oldDominantSpeaker.setIsDominantSpeaker(false);
-        newDominantSpaker && newDominantSpaker.setIsDominantSpeaker(true);
+        newDominantSpeaker && newDominantSpeaker.setIsDominantSpeaker(true);
         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.
  */
-Statistics.prototype.sendDominantSpeakerEvent = function() {
+Statistics.prototype.sendDominantSpeakerEvent = function(roomJid) {
     for (const cs of this.callsStatsInstances.values()) {
         cs.sendDominantSpeakerEvent();
     }
+
+    // xmpp send dominant speaker event
+    this.xmpp.sendDominantSpeakerEvent(roomJid);
 };
 
 /**

modules/xmpp/Caps.js

         if (!user || !(user.version in this.versionToCapabilities)) {
             const node = user ? `${user.node}#${user.version}` : null;
 
-
-            return new Promise((resolve, reject) =>
-                this.disco.info(jid, node, response => {
-                    const features = new Set();
-
-                    $(response)
-                        .find('>query>feature')
-                        .each(
-                            (idx, el) => features.add(el.getAttribute('var')));
+            return this._getDiscoInfo(jid, node, timeout)
+                .then(({ features }) => {
                     if (user) {
                         // TODO: Maybe use the version + node + hash as keys?
                         this.versionToCapabilities[user.version] = features;
                     }
-                    resolve(features);
-                }, reject, timeout)
-            );
+
+                    return features;
+                });
         }
 
         return Promise.resolve(this.versionToCapabilities[user.version]);
     }
 
+    /**
+     * Returns a set with the features for a host.
+     * @param {String} jid the jid of the host
+     * @param {int} timeout the timeout in ms for reply from the host.
+     * @returns {Promise<Set<String>, Error>}
+     */
+    getFeaturesAndIdentities(jid, timeout = 5000) {
+        return this._getDiscoInfo(jid, null, timeout);
+    }
+
+    /**
+     * Returns a set with the features and identities for a host.
+     * @param {String} jid the jid of the host
+     * @param {String|null} node the node to query
+     * @param {int} timeout the timeout in ms for reply from the host.
+     * @returns {Promise<Object>}
+     * @private
+     */
+    _getDiscoInfo(jid, node, timeout) {
+        return new Promise((resolve, reject) =>
+            this.disco.info(jid, node, response => {
+                const features = new Set();
+                const identities = new Set();
+
+                $(response)
+                    .find('>query>feature')
+                    .each(
+                        (_, el) => features.add(el.getAttribute('var')));
+                $(response)
+                    .find('>query>identity')
+                    .each(
+                        (_, el) => identities.add({
+                            type: el.getAttribute('type'),
+                            name: el.getAttribute('name'),
+                            category: el.getAttribute('category')
+                        }));
+                resolve({
+                    features,
+                    identities });
+            }, reject, timeout)
+        );
+    }
+
     /**
      * Adds ChatRoom instance to the list of rooms. Adds listeners to the room
      * and adds "c" element to the presences of the room.

modules/xmpp/strophe.ping.js

 
     /* eslint-enable max-params */
 
-    /**
-     * Checks if given <tt>jid</tt> has XEP-0199 ping support.
-     * @param jid the JID to be checked for ping support.
-     * @param callback function with boolean argument which will be
-     * <tt>true</tt> if XEP-0199 ping is supported by given <tt>jid</tt>
-     */
-    hasPingSupport(jid, callback) {
-        this.xmpp.caps.getFeatures(jid).then(features =>
-            callback(features.has('urn:xmpp:ping')), error => {
-            const errmsg = 'Ping feature discovery error';
-
-            GlobalOnErrorHandler.callErrorHandler(
-                new Error(`${errmsg}: ${error}`));
-            logger.error(errmsg, error);
-            callback(false);
-        });
-    }
-
     /**
      * Starts to send ping in given interval to specified remote JID.
      * This plugin supports only one such task and <tt>stopInterval</tt>

modules/xmpp/xmpp.js

 /* global $ */
 
 import { getLogger } from 'jitsi-meet-logger';
-import { Strophe } from 'strophe.js';
+import { $msg, Strophe } from 'strophe.js';
 import 'strophejs-plugin-disco';
 
 import RandomUtil from '../util/RandomUtil';
 import initStropheLogger from './strophe.logger';
 import Listenable from '../util/Listenable';
 import Caps from './Caps';
+import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 
 const logger = getLogger(__filename);
 
             // Schedule ping ?
             const pingJid = this.connection.domain;
 
-            this.connection.ping.hasPingSupport(
-                pingJid,
-                hasPing => {
-                    if (hasPing) {
+            this.caps.getFeaturesAndIdentities(pingJid)
+                .then(({ features, identities }) => {
+                    if (features.has(Strophe.NS.PING)) {
                         this.connection.ping.startInterval(pingJid);
                     } else {
                         logger.warn(`Ping NOT supported by ${pingJid}`);
                     }
+
+                    // check for speakerstats
+                    identities.forEach(identity => {
+                        if (identity.type === 'speakerstats') {
+                            this.speakerStatsComponentAddress = identity.name;
+                        }
+                    });
+                })
+                .catch(error => {
+                    const errmsg = 'Feature discovery error';
+
+                    GlobalOnErrorHandler.callErrorHandler(
+                        new Error(`${errmsg}: ${error}`));
+                    logger.error(errmsg, error);
                 });
 
             if (credentials.password) {
                 this.authenticatedUser = true;
             }
             if (this.connection && this.connection.connected
-                    && Strophe.getResourceFromJid(this.connection.jid)) {
+                && Strophe.getResourceFromJid(this.connection.jid)) {
                 // .connected is true while connecting?
                 // this.connection.send($pres());
                 this.eventEmitter.emit(
 
         return details;
     }
+
+    /**
+     * 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.
+     */
+    sendDominantSpeakerEvent(roomJid) {
+        // no speaker stats component advertised
+        if (!this.speakerStatsComponentAddress || !roomJid) {
+            return;
+        }
+
+        const msg = $msg({ to: this.speakerStatsComponentAddress });
+
+        msg.c('speakerstats', {
+            xmlns: 'http://jitsi.org/jitmeet',
+            room: `${roomJid}` })
+            .up();
+
+        this.connection.send(msg);
+    }
 }