feat(silent): track if participant joined without audio (#2534)

* feat(silent): track if participant joined without audio

* Fix failing tests, use jitsi.org namespace

---------

Co-authored-by: Дамян Минков <damencho@jitsi.org>

JitsiConference.js

     }
 };
 
+/**
+ * Set join without audio
+ * @param silent whether user joined without audio
+ */
+JitsiConference.prototype.setIsSilent = function(silent) {
+    if (this.room) {
+        this.room.addOrReplaceInPresence('silent', {
+            attributes: { xmlns: 'http://jitsi.org/protocol/silent' },
+            value: silent
+        }) && this.room.sendPresence();
+    }
+};
+
 /**
  * Set new subject for this conference. (available only for moderator)
  * @param {string} subject new subject
         displayName);
 };
 
+JitsiConference.prototype.onSilentStatusChanged = function(jid, isSilent) {
+    const id = Strophe.getResourceFromJid(jid);
+    const participant = this.getParticipantById(id);
+
+    if (!participant) {
+        return;
+    }
+
+    participant.setIsSilent(isSilent);
+    this.eventEmitter.emit(
+        JitsiConferenceEvents.SILENT_STATUS_CHANGED,
+        id,
+        isSilent);
+};
+
 /**
  * Notifies this JitsiConference that a JitsiRemoteTrack was added to the conference.
  *

JitsiConferenceEventManager.js

     chatRoom.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
         conference.onDisplayNameChanged.bind(conference));
 
+    chatRoom.addListener(XMPPEvents.SILENT_STATUS_CHANGED,
+        conference.onSilentStatusChanged.bind(conference));
+
     chatRoom.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, role => {
         conference.onLocalRoleChanged(role);
     });

JitsiConferenceEvents.spec.ts

         BREAKOUT_ROOMS_MOVE_TO_ROOM,
         BREAKOUT_ROOMS_UPDATED,
         METADATA_UPDATED,
+        SILENT_STATUS_CHANGED,
         JitsiConferenceEvents,
         ...others
     } = exported;
         expect( BREAKOUT_ROOMS_MOVE_TO_ROOM ).toBe( 'conference.breakout-rooms.move-to-room' );
         expect( BREAKOUT_ROOMS_UPDATED ).toBe( 'conference.breakout-rooms.updated' );
         expect( METADATA_UPDATED ).toBe( 'conference.metadata.updated' );
+        expect( SILENT_STATUS_CHANGED ).toBe( 'conference.silentStatusChanged' );
         expect( ENCODE_TIME_STATS_RECEIVED ).toBe( 'conference.encode_time_stats_received' );
 
         expect( JitsiConferenceEvents ).toBeDefined();
         expect( JitsiConferenceEvents.BREAKOUT_ROOMS_MOVE_TO_ROOM ).toBe( 'conference.breakout-rooms.move-to-room' );
         expect( JitsiConferenceEvents.BREAKOUT_ROOMS_UPDATED ).toBe( 'conference.breakout-rooms.updated' );
         expect( JitsiConferenceEvents.METADATA_UPDATED ).toBe( 'conference.metadata.updated' );
+        expect( JitsiConferenceEvents.SILENT_STATUS_CHANGED ).toBe( 'conference.silentStatusChanged' );
         expect( JitsiConferenceEvents.E2EE_VERIFICATION_READY ).toBe( 'conference.e2ee.verification.ready' );
         expect( JitsiConferenceEvents.E2EE_VERIFICATION_COMPLETED ).toBe( 'conference.e2ee.verification.completed' );
         expect( JitsiConferenceEvents.E2EE_VERIFICATION_AVAILABLE ).toBe( 'conference.e2ee.verification.available' );

JitsiConferenceEvents.ts

      */
     SERVER_REGION_CHANGED = 'conference.server_region_changed',
 
+    /**
+     * Indicates a user has joined without audio
+     */
+    SILENT_STATUS_CHANGED = 'conference.silentStatusChanged',
+
     /**
      * Indicates that start muted settings changed.
      */
 export const PROPERTIES_CHANGED = JitsiConferenceEvents.PROPERTIES_CHANGED;
 export const RECORDER_STATE_CHANGED = JitsiConferenceEvents.RECORDER_STATE_CHANGED;
 export const SERVER_REGION_CHANGED = JitsiConferenceEvents.SERVER_REGION_CHANGED;
+export const SILENT_STATUS_CHANGED = JitsiConferenceEvents.SILENT_STATUS_CHANGED;
 export const START_MUTED_POLICY_CHANGED = JitsiConferenceEvents.START_MUTED_POLICY_CHANGED;
 export const STARTED_MUTED = JitsiConferenceEvents.STARTED_MUTED;
 export const SUBJECT_CHANGED = JitsiConferenceEvents.SUBJECT_CHANGED;

JitsiParticipant.js

      * @param {object} identity - the xmpp identity
      * @param {boolean?} isReplacing - whether this is a participant replacing another into the meeting.
      * @param {boolean?} isReplaced - whether this is a participant to be kicked and replaced into the meeting.
+     * @param {boolean?} isSilent - whether participant has joined without audio
      */
-    constructor(jid, conference, displayName, hidden, statsID, status, identity, isReplacing, isReplaced) {
+    constructor(jid, conference, displayName, hidden, statsID, status, identity, isReplacing, isReplaced, isSilent) {
         this._jid = jid;
         this._id = Strophe.getResourceFromJid(jid);
         this._conference = conference;
         this._identity = identity;
         this._isReplacing = isReplacing;
         this._isReplaced = isReplaced;
+        this._isSilent = isSilent;
         this._features = new Set();
 
         /**
         return this._isReplacing;
     }
 
+    /**
+     * @returns {Boolean} Whether this participant has joined without audio.
+     */
+    isSilent() {
+        return this._isSilent;
+    }
+
     /**
      * @returns {Boolean} Whether this participant has muted their video.
      */
         this._isReplacing = newIsReplacing;
     }
 
+    /**
+     * Sets whether participant has joined without audio.
+     * @param {boolean} newIsSilent - whether is silent.
+     */
+    setIsSilent(newIsSilent) {
+        this._isSilent = newIsSilent;
+    }
+
     /**
      * Sets the value of a property of this participant, and fires an event if
      * the value has changed.

modules/xmpp/ChatRoom.js

             case 'nick':
                 member.nick = node.value;
                 break;
+            case 'silent':
+                member.isSilent = node.value;
+                break;
             case 'userId':
                 member.id = node.value;
                 break;
                     member.botType,
                     member.jid,
                     member.features,
-                    member.isReplaceParticipant);
+                    member.isReplaceParticipant,
+                    member.isSilent);
 
                 // we are reporting the status with the join
                 // so we do not want a second event about status update
                 memberOfThis.displayName = member.displayName;
             }
 
+            // join without audio
+            if (member.isSilent) {
+                memberOfThis.isSilent = member.isSilent;
+            }
+
             // update stored status message to be able to detect changes
             if (memberOfThis.status !== member.status) {
                 hasStatusUpdate = true;
                         displayName);
                 }
                 break;
+            case 'silent':
+                this.eventEmitter.emit(
+                    XMPPEvents.SILENT_STATUS_CHANGED,
+                    from,
+                    member.isSilent);
+                break;
             case 'bridgeNotAvailable':
                 if (member.isFocus && !this.noBridgeAvailable) {
                     this.noBridgeAvailable = true;

modules/xmpp/ChatRoom.spec.js

                 undefined,
                 'fulljid',
                 undefined, // features
-                0 // isReplaceParticipant
+                0, // isReplaceParticipant
+                undefined // isSilent
             ]);
         });
 
                 undefined,
                 'jid=attr',
                 undefined, // features
-                0); // isReplaceParticipant
+                0, // isReplaceParticipant
+                undefined); // isSilent
         });
 
         it('parses muc user replacing other user correctly', () => {
               undefined,
               'jid=attr',
               undefined, // features
-              1); // isReplaceParticipant
+              1, // isReplaceParticipant
+              undefined); // isSilent
         });
 
         it('parses identity correctly', () => {
                 undefined,
                 'fulljid',
                 undefined, // features
-                0 // isReplaceParticipant
+                0, // isReplaceParticipant
+                undefined // isSilent
             ]);
         });
 
                 expectedBotType,
                 'fulljid',
                 undefined, // features
-                0 // isReplaceParticipant
+                0, // isReplaceParticipant
+                undefined // isSilent
             ]);
         });
 

service/xmpp/XMPPEvents.ts

      */
     SESSION_ACCEPT_TIMEOUT = 'xmpp.session_accept_timeout',
 
+    /**
+     * Event fired when participant joins a meeting without audio.
+     */
+    SILENT_STATUS_CHANGED = 'xmpp.silent_status_changed',
+
     /**
      * Event fired after successful sending of jingle source-add.
      */