feat: Skips using disco-info for features. (#1450)

* fix: Drops unused parameter of join and sendPresence.

* feat: Skips using disco-info for features.

Uses presence to publish features added externally.
Recognizes jigasi participants using a specific presence extension used by jigasi.

* squash: Fixes tests.

* squash: Adds e2ee to the features in presence.

* squash: Fix function name and docs.

* squash: Drops detecting jigasi from initiator.

Using the newly added presence features.

* squash: Drops unused var.

* squash: Fix comments.

* squash: Adds a constant and for E2EEE feature.

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/xmpp';
+import {
+    FEATURE_E2EE,
+    FEATURE_JIGASI,
+    JITSI_MEET_MUC_TYPE
+} from './modules/xmpp/xmpp';
 import * as MediaType from './service/RTC/MediaType';
 import VideoType from './service/RTC/VideoType';
 import {
  * @param status the initial status if any
  * @param identity the member identity, if any
  * @param botType the member botType, if any
+ * @param fullJid the member full jid, if any
+ * @param features the member botType, if any
  */
 JitsiConference.prototype.onMemberJoined = function(
-        jid, nick, role, isHidden, statsID, status, identity, botType) {
+        jid, nick, role, isHidden, statsID, status, identity, botType, fullJid, features) {
     const id = Strophe.getResourceFromJid(jid);
 
     if (id === 'focus' || this.myUserId() === id) {
 
     participant._role = role;
     participant._botType = botType;
+    participant._features = features || new Set();
+
     this.participants[id] = participant;
     this.eventEmitter.emit(
         JitsiConferenceEvents.USER_JOINED,
             participant._supportsDTMF = features.has('urn:xmpp:jingle:dtmf:0');
             this.updateDTMFSupport();
 
-            if (features.has('http://jitsi.org/protocol/jigasi')) {
+            if (features.has(FEATURE_JIGASI)) {
                 participant.setProperty('features_jigasi', true);
             }
 
-            if (features.has('https://jitsi.org/meet/e2ee')) {
+            if (features.has(FEATURE_E2EE)) {
                 participant.setProperty('features_e2ee', true);
             }
         })

JitsiConferenceEventManager.js

     const conference = this.conference;
 
     conference.xmpp.caps.removeListener(
-        XMPPEvents.PARTCIPANT_FEATURES_CHANGED,
-        this.xmppListeners[XMPPEvents.PARTCIPANT_FEATURES_CHANGED]);
-    delete this.xmppListeners[XMPPEvents.PARTCIPANT_FEATURES_CHANGED];
+        XMPPEvents.PARTICIPANT_FEATURES_CHANGED,
+        this.xmppListeners[XMPPEvents.PARTICIPANT_FEATURES_CHANGED]);
+    delete this.xmppListeners[XMPPEvents.PARTICIPANT_FEATURES_CHANGED];
 
     Object.keys(this.xmppListeners).forEach(eventName => {
         conference.xmpp.removeListener(
 JitsiConferenceEventManager.prototype.setupXMPPListeners = function() {
     const conference = this.conference;
 
-    const featuresChangedListener = from => {
-        const participant
-            = conference.getParticipantById(
-            Strophe.getResourceFromJid(from));
+    const featuresChangedListener = (from, features) => {
+        const participant = conference.getParticipantById(Strophe.getResourceFromJid(from));
 
         if (participant) {
-            conference.eventEmitter.emit(
-                JitsiConferenceEvents.PARTCIPANT_FEATURES_CHANGED,
-                participant);
+            participant._features = features;
+            conference.eventEmitter.emit(JitsiConferenceEvents.PARTCIPANT_FEATURES_CHANGED, participant);
         }
     };
 
-    conference.xmpp.caps.addListener(
-        XMPPEvents.PARTCIPANT_FEATURES_CHANGED,
-        featuresChangedListener);
-    this.xmppListeners[XMPPEvents.PARTCIPANT_FEATURES_CHANGED]
-        = featuresChangedListener;
+    conference.xmpp.caps.addListener(XMPPEvents.PARTICIPANT_FEATURES_CHANGED, featuresChangedListener);
+    this.xmppListeners[XMPPEvents.PARTICIPANT_FEATURES_CHANGED] = featuresChangedListener;
 
     this._addConferenceXMPPListener(
         XMPPEvents.CALL_INCOMING,

JitsiConnection.js

  * immediately submitted to the others.
  */
 JitsiConnection.prototype.addFeature = function(feature, submit = false) {
-    return this.xmpp.caps.addFeature(feature, submit);
+    this.xmpp.caps.addFeature(feature, submit, true);
 };
 
 /**
  * immediately submitted to the others.
  */
 JitsiConnection.prototype.removeFeature = function(feature, submit = false) {
-    return this.xmpp.caps.removeFeature(feature, submit);
+    this.xmpp.caps.removeFeature(feature, submit, true);
 };
 
 /**

JitsiParticipant.js

         this._connectionStatus = ParticipantConnectionStatus.ACTIVE;
         this._properties = {};
         this._identity = identity;
+        this._features = new Set();
     }
 
     /* eslint-enable max-params */
         return this._supportsDTMF;
     }
 
+    /**
+     * Returns a set with the features for the participant.
+     * @returns {Promise<Set<String>, Error>}
+     */
+    getFeatures() {
+        return Promise.resolve(this._features);
+    }
+
     /**
      * Returns a set with the features for the participant.
      * @param {int} timeout the timeout in ms for reply from the participant.
      * @returns {Promise<Set<String>, Error>}
      */
-    getFeatures(timeout = 5000) {
+    queryFeatures(timeout = 5000) {
         if (this._getFeaturesPromise) {
             return this._getFeaturesPromise;
         }

modules/xmpp/Caps.js

         this.version = '';
         this.rooms = new Set();
 
+        // We keep track of features added outside the library and we publish them
+        // in the presence of the participant for simplicity, avoiding the disco info request-response.
+        this.externalFeatures = new Set();
+
         const emuc = connection.emuc;
 
         emuc.addListener(XMPPEvents.EMUC_ROOM_ADDED,
      * @param {String} feature the name of the feature.
      * @param {boolean} submit if true - new presence with updated "c" node
      * will be sent.
+     * @param {boolean} external whether this feature was added externally to the library.
+     * We put features used directly by the clients (is jibri, remote-control enabled etc.) in the presence
+     * to avoid additional disco-info queries by those clients.
      */
-    addFeature(feature, submit = false) {
+    addFeature(feature, submit = false, external = false) {
         this.disco.addFeature(feature);
         this._generateVersion();
+
+        if (external && !this.externalFeatures.has(feature)) {
+            this.externalFeatures.add(feature);
+            this.rooms.forEach(room => this._updateRoomWithExternalFeatures(room));
+        }
+
         if (submit) {
             this.submit();
         }
      * @param {String} feature the name of the feature.
      * @param {boolean} submit if true - new presence with updated "c" node
      * will be sent.
+     * @param {boolean} external whether this feature was added externally to the library.
      */
-    removeFeature(feature, submit = false) {
+    removeFeature(feature, submit = false, external = false) {
         this.disco.removeFeature(feature);
         this._generateVersion();
+
+        if (external && this.externalFeatures.has(feature)) {
+            this.externalFeatures.delete(feature);
+            this.rooms.forEach(room => this._updateRoomWithExternalFeatures(room));
+        }
+
         if (submit) {
             this.submit();
         }
         this.rooms.forEach(room => room.sendPresence());
     }
 
+    /**
+     * Updates the presences in the room based on the current values in externalFeatures.
+     * @param {ChatRoom} room the room to update.
+     * @private
+     */
+    _updateRoomWithExternalFeatures(room) {
+        if (this.externalFeatures.size === 0) {
+            room.removeFromPresence('features');
+        } else {
+            const children = [];
+
+            this.externalFeatures.forEach(f => {
+                children.push({
+                    'tagName': 'feature',
+                    attributes: { 'var': f }
+                });
+            });
+
+            room.addToPresence('features', { children });
+        }
+    }
+
     /**
      * Returns a set with the features for a participant.
      * @param {String} jid the jid of the participant
         this.rooms.add(room);
         room.addListener(XMPPEvents.MUC_MEMBER_LEFT, this._onMucMemberLeft);
         this._fixChatRoomPresenceMap(room);
+
+        this._updateRoomWithExternalFeatures(room);
     }
 
     /**
         this.jidToVersion[from] = { version,
             node };
         if (oldVersion && oldVersion.version !== version) {
-            this.eventEmitter.emit(XMPPEvents.PARTCIPANT_FEATURES_CHANGED,
-                from);
+            this.eventEmitter.emit(XMPPEvents.PARTICIPANT_FEATURES_CHANGED, from);
         }
 
         // return true to not remove the handler from Strophe

modules/xmpp/ChatRoom.js

 /* global $, __filename */
 
 import { getLogger } from 'jitsi-meet-logger';
+import isEqual from 'lodash.isequal';
 import { $iq, $msg, $pres, Strophe } from 'strophe.js';
 
 import * as JitsiTranscriptionStatus from '../../JitsiTranscriptionStatus';
     /**
      * Joins the chat room.
      * @param {string} password - Password to unlock room on joining.
-     * @param {Object} customJoinPresenceExtensions - Key values object to be used
-     * for the initial presence, they key will be an xmpp node and its text is the value,
-     * and those will be added to the initial <x xmlns='http://jabber.org/protocol/muc'/>
      * @returns {Promise} - resolved when join completes. At the time of this
      * writing it's never rejected.
      */
-    join(password, customJoinPresenceExtensions) {
+    join(password) {
         this.password = password;
 
         return new Promise(resolve => {
                     : this.moderator.allocateConferenceFocus();
 
             preJoin.then(() => {
-                this.sendPresence(true, customJoinPresenceExtensions);
+                this.sendPresence(true);
                 this._removeConnListeners.push(
                     this.connection.addEventListener(
                         XmppConnection.Events.CONN_STATUS_CHANGED,
     /**
      *
      * @param fromJoin - Whether this is initial presence to join the room.
-     * @param customJoinPresenceExtensions - Object of key values to be added to the initial presence only.
      */
-    sendPresence(fromJoin, customJoinPresenceExtensions) {
+    sendPresence(fromJoin) {
         const to = this.presMap.to;
 
         if (!this.connection || !this.connection.connected || !to || (!this.joined && !fromJoin)) {
             if (this.password) {
                 pres.c('password').t(this.password).up();
             }
-            if (customJoinPresenceExtensions) {
-                Object.keys(customJoinPresenceExtensions).forEach(key => {
-                    pres.c(key).t(customJoinPresenceExtensions[key]).up();
-                });
-            }
             pres.up();
         }
 
             case 'identity':
                 member.identity = extractIdentityInformation(node);
                 break;
+            case 'features': {
+                member.features = this._extractFeatures(node);
+                break;
+            }
             case 'stat': {
                 const { attributes } = node;
 
             hasStatusUpdate = member.status !== undefined;
             hasVersionUpdate = member.version !== undefined;
             if (member.isFocus) {
-                this._initFocus(from, jid);
+                this._initFocus(from, member.features);
             } else {
                 // identity is being added to member joined, so external
                 // services can be notified for that (currently identity is
                     member.status,
                     member.identity,
                     member.botType,
-                    member.jid);
+                    member.jid,
+                    member.features);
 
                 // we are reporting the status with the join
                 // so we do not want a second event about status update
                 // so this case should not happen, if public jid is turned off we will receive the jid
                 // when we become moderator in the room
                 memberOfThis.isFocus = true;
-                this._initFocus(from, jid);
+                this._initFocus(from, member.features);
             }
 
             // store the new display name
                 hasVersionUpdate = true;
                 memberOfThis.version = member.version;
             }
+
+            if (!isEqual(memberOfThis.features, member.features)) {
+                memberOfThis.features = member.features;
+                this.eventEmitter.emit(XMPPEvents.PARTICIPANT_FEATURES_CHANGED, from, member.features);
+            }
         }
 
         // after we had fired member or room joined events, lets fire events
 
                     this.eventEmitter.emit(
                         XMPPEvents.CONFERENCE_PROPERTIES_CHANGED, properties);
+
+                    this.restartByTerminateSupported = properties['support-terminate-restart'] === 'true';
+                    logger.info(`Jicofo supports restart by terminate: ${this.supportsRestartByTerminate()}`);
                 }
                 break;
             case 'transcription-status': {
     }
 
     /**
-     * Initialize some properties when the focus participant is verified.
-     * @param from jid of the focus
-     * @param mucJid the jid of the focus in the muc
+     * Extracts the features from the presence.
+     * @param node the node to process.
+     * @return features the Set of features where extracted data is added.
+     * @private
      */
-    _initFocus(from, mucJid) {
-        // skip if we have queried jicofo already, it will not change
-        if (this.focusFeatures) {
-            return;
+    _extractFeatures(node) {
+        const features = new Set();
+
+        for (let j = 0; j < node.children.length; j++) {
+            const { attributes } = node.children[j];
+
+            if (attributes && attributes.var) {
+                features.add(attributes.var);
+            }
         }
 
-        this.focusMucJid = from;
+        return features;
+    }
 
-        logger.info(`Ignore focus: ${from}, real JID: ${mucJid}`);
-        this.xmpp.caps.getFeatures(mucJid, 15000).then(features => {
-            this.focusFeatures = features;
-            logger.info(`Jicofo supports restart by terminate: ${this.supportsRestartByTerminate()}`);
-        }, error => {
-            logger.error('Failed to discover Jicofo features', error && error.message);
-        });
+    /**
+     * Initialize some properties when the focus participant is verified.
+     * @param from jid of the focus
+     * @param features the features reported in jicofo presence
+     */
+    _initFocus(from, features) {
+        this.focusMucJid = from;
+        this.focusFeatures = features;
     }
 
     /**
      * @returns {boolean}
      */
     supportsRestartByTerminate() {
-        return this.focusFeatures
-            ? this.focusFeatures.has('https://jitsi.org/meet/jicofo/terminate-restart')
-            : false;
+        return this.restartByTerminateSupported;
     }
 
     /**

modules/xmpp/ChatRoom.spec.js

                 'status-text',
                 undefined,
                 undefined,
-                'fulljid'
+                'fulljid',
+                undefined // features
             ]);
         });
 
                 undefined,
                 undefined,
                 undefined,
-                'jid=attr');
+                'jid=attr',
+                undefined); // features
         });
 
         it('parses identity correctly', () => {
                 'status-text',
                 expectedIdentity,
                 undefined,
-                'fulljid'
+                'fulljid',
+                undefined // features
             ]);
         });
 
                 'status-text',
                 undefined,
                 expectedBotType,
-                'fulljid'
+                'fulljid',
+                undefined // features
             ]);
         });
 

modules/xmpp/xmpp.js

  */
 export const JITSI_MEET_MUC_TYPE = 'type';
 
+/**
+ * The feature used by jigasi participants.
+ * @type {string}
+ */
+export const FEATURE_JIGASI = 'http://jitsi.org/protocol/jigasi';
+
+/**
+ * The feature used by the lib to mark support for e2ee. We use the feature by putting it in the presence
+ * to avoid additional signaling (disco-info).
+ * @type {string}
+ */
+export const FEATURE_E2EE = 'https://jitsi.org/meet/e2ee';
+
 /**
  *
  */
         }
 
         if (E2EEncryption.isSupported(this.options)) {
-            this.caps.addFeature('https://jitsi.org/meet/e2ee');
+            this.caps.addFeature(FEATURE_E2EE, false, true);
         }
     }
 

service/xmpp/XMPPEvents.js

     /**
      * Indicates that the features of the participant has been changed.
      */
-    PARTCIPANT_FEATURES_CHANGED: 'xmpp.partcipant_features_changed',
+    PARTICIPANT_FEATURES_CHANGED: 'xmpp.participant_features_changed',
     PASSWORD_REQUIRED: 'xmpp.password_required',
 
     /**