Refactor presence update 2 (#1814)

* feat: Adds events for session-add, session-remove and session-accept.

* feat: Refactor updating presence for audio/video mute and video type.

This brings few changes and fixes. Thew initial presence will always miss audioMuted and videoMuted value, those will be added on session accept. All updates to presence are done on sessionAccept, on source-add or on source-remove and the only one not signalled when camera track is replaced by video track and vice versa.
This change brings more presence updates when number of participants are below startAudioMuted/startVideoMuted, but when participants are above those numbers we get less presence update. This is important for big meetings.
Fixes wrong videoMuted state, as replace track and mute are both executed in promise, sometimes the replace-track one finishes first and when the mute one is resolved there is no conference object in the track to be able to update the presence (hitting this when we pass the startAudioMuted threshold).

* squash: Put back the tracks for _setTrackMuteStatus and _setNewVideoType.

* squash: Fix line length.

* squash: Fix skip sending presence twice.

* squash: Adds the error to the error callback.

* squash: Fix newJingleErrorHandler.

JitsiConference.js

     this._sendConferenceJoinAnalyticsEvent = this._sendConferenceJoinAnalyticsEvent.bind(this);
     this.room.addListener(XMPPEvents.MEETING_ID_SET, this._sendConferenceJoinAnalyticsEvent);
 
+    this._updateRoomPresence = this._updateRoomPresence.bind(this);
+    this.room.addListener(XMPPEvents.SESSION_ACCEPT, this._updateRoomPresence);
+    this.room.addListener(XMPPEvents.SOURCE_ADD, this._updateRoomPresence);
+    this.room.addListener(XMPPEvents.SOURCE_REMOVE, this._updateRoomPresence);
+
     this.e2eping = new E2ePing(
         this,
         config,
         this._updateProperties);
 
     room.removeListener(XMPPEvents.MEETING_ID_SET, this._sendConferenceJoinAnalyticsEvent);
+    room.removeListener(XMPPEvents.SESSION_ACCEPT, this._updateRoomPresence);
+    room.removeListener(XMPPEvents.SOURCE_ADD, this._updateRoomPresence);
+    room.removeListener(XMPPEvents.SOURCE_REMOVE, this._updateRoomPresence);
 
     this.eventManager.removeXMPPListeners();
 
                 this._sendBridgeVideoTypeMessage(newTrack);
             }
 
+            // updates presence when we replace the video tracks desktop with screen and screen with desktop
+            if (oldTrackBelongsToConference && oldTrack?.isVideoTrack()) {
+                this._updateRoomPresence(this.p2pJingleSession ? this.p2pJingleSession : this.jvbJingleSession);
+            }
+
             if (newTrack !== null && (this.isMutedByFocus || this.isVideoMutedByFocus)) {
                 this._fireMuteChangeEvent(newTrack);
             }
         }
     }
 
-    let videoTypeChanged = false;
-
-    if (newTrack.isVideoTrack()) {
-        videoTypeChanged = this._setNewVideoType(newTrack);
-    }
     this.rtc.addLocalTrack(newTrack);
 
-    // ensure that we're sharing proper "is muted" state
-    if (this._setTrackMuteStatus(newTrack, newTrack.isMuted()) || videoTypeChanged) {
-        // send presence if it was changed with vide type or mute status
-        this.room.sendPresence();
-    }
-
     newTrack.muteHandler = this._fireMuteChangeEvent.bind(this, newTrack);
     newTrack.audioLevelHandler = this._fireAudioLevelChangeEvent.bind(this);
     newTrack.addEventListener(
  * @private
  */
 JitsiConference.prototype._setNewVideoType = function(track) {
-    if (FeatureFlags.isSourceNameSignalingEnabled()) {
+    if (FeatureFlags.isSourceNameSignalingEnabled() && track) {
         // FIXME once legacy signaling using 'sendCommand' is removed, signalingLayer.setTrackVideoType must be adjusted
         // to send the presence (not just modify it).
         this._signalingLayer.setTrackVideoType(
 
     const videoTypeTagName = 'videoType';
 
+    // if track is missing we revert to default type Camera, the case where we screenshare and
+    // we return to be video muted
+    const trackVideoType = track ? track.videoType : VideoType.CAMERA;
+
     // if video type is camera and there is no videoType in presence, we skip adding it, as this is the default one
-    if (track.videoType !== VideoType.CAMERA || this.room.getFromPresence(videoTypeTagName)) {
+    if (trackVideoType !== VideoType.CAMERA || this.room.getFromPresence(videoTypeTagName)) {
         // we will not use this.sendCommand here to avoid sending the presence immediately, as later we may also set
         // and the mute status
-        return this.room.addOrReplaceInPresence(videoTypeTagName, { value: track.videoType });
+        return this.room.addOrReplaceInPresence(videoTypeTagName, { value: trackVideoType });
     }
 
     return false;
 
 /**
  * Sets mute status.
+ * @param mediaType
  * @param localTrack
  * @param isMuted
  * @param <tt>true</tt> when presence was changed, <tt>false</tt> otherwise.
  * @private
  */
-JitsiConference.prototype._setTrackMuteStatus = function(localTrack, isMuted) {
+JitsiConference.prototype._setTrackMuteStatus = function(mediaType, localTrack, isMuted) {
     if (FeatureFlags.isSourceNameSignalingEnabled()) {
         // TODO When legacy signaling part is removed, remember to adjust signalingLayer.setTrackMuteStatus, so that
         // it triggers sending the presence (it only updates it for now, because the legacy code below sends).
         this._signalingLayer.setTrackMuteStatus(
-            getSourceNameForJitsiTrack(this.myUserId(), localTrack.getType(), 0),
+            getSourceNameForJitsiTrack(this.myUserId(), mediaType, 0),
             isMuted
         );
     }
         return false;
     }
 
-    if (localTrack.isAudioTrack()) {
+    if (mediaType === MediaType.AUDIO) {
         return this.room.addAudioInfoToPresence(isMuted);
     }
 
     }
 };
 
+/**
+ * Updates room presence if needed and send the packet in case of a modification.
+ * @param {JingleSessionPC} jingleSession the session firing the event, contains the peer connection which
+ * tracks we will check.
+ * @param {Object|null} ctx a context object we can distinguish multiple calls of the same pass of updating tracks.
+ */
+JitsiConference.prototype._updateRoomPresence = function(jingleSession, ctx) {
+    // skips sending presence twice for the same pass of updating ssrcs
+    if (ctx) {
+        if (ctx.skip) {
+            return;
+        }
+        ctx.skip = true;
+    }
+
+    const localAudioTracks = jingleSession.peerconnection.getLocalTracks(MediaType.AUDIO);
+    const localVideoTracks = jingleSession.peerconnection.getLocalTracks(MediaType.VIDEO);
+    let presenceChanged = false;
+
+    if (localAudioTracks && localAudioTracks.length) {
+        presenceChanged = this._setTrackMuteStatus(MediaType.AUDIO, localAudioTracks[0], localAudioTracks[0].isMuted());
+    } else if (this._setTrackMuteStatus(MediaType.AUDIO, undefined, true)) {
+        presenceChanged = true;
+    }
+
+    if (localVideoTracks && localVideoTracks.length) {
+        const muteStatusChanged = this._setTrackMuteStatus(
+            MediaType.VIDEO, localVideoTracks[0], localVideoTracks[0].isMuted());
+        const videoTypeChanged = this._setNewVideoType(localVideoTracks[0]);
+
+        presenceChanged = presenceChanged || muteStatusChanged || videoTypeChanged;
+    } else {
+        const muteStatusChanged = this._setTrackMuteStatus(MediaType.VIDEO, undefined, true);
+        const videoTypeChanged = this._setNewVideoType(); // set back to default video type
+
+        presenceChanged = presenceChanged || muteStatusChanged || videoTypeChanged;
+    }
+
+    presenceChanged && this.room.sendPresence();
+};
+
 /**
  * Checks whether or not the conference is currently in the peer to peer mode.
  * Being in peer to peer mode means that the direct connection has been

modules/xmpp/ChatRoom.js

         return null;
     }
 
-    /**
-     *
-     * @param mute
-     */
-    setVideoMute(mute) {
-        this.sendVideoInfoPresence(mute);
-    }
-
-    /**
-     *
-     * @param mute
-     */
-    setAudioMute(mute) {
-        this.sendAudioInfoPresence(mute);
-    }
-
     /**
      *
      * @param mute
             });
     }
 
-    /**
-     *
-     * @param mute
-     */
-    sendAudioInfoPresence(mute) {
-        // FIXME resend presence on CONNECTED
-        this.addAudioInfoToPresence(mute) && this.sendPresence();
-    }
-
     /**
      *
      * @param mute
             });
     }
 
-    /**
-     *
-     * @param mute
-     */
-    sendVideoInfoPresence(mute) {
-        this.addVideoInfoToPresence(mute) && this.sendPresence();
-    }
-
     /**
      * Obtains the info about given media advertised in the MUC presence of
      * the participant identified by the given endpoint JID.

modules/xmpp/JingleSessionPC.js

                 // FIXME we may not care about RESULT packet for session-accept
                 // then we should either call 'success' here immediately or
                 // modify sendSessionAccept method to do that
-                this.sendSessionAccept(success, failure);
+                this.sendSessionAccept(() => {
+                    success();
+
+                    this.room.eventEmitter.emit(XMPPEvents.SESSION_ACCEPT, this);
+                },
+                error => {
+                    failure(error);
+
+                    this.room.eventEmitter.emit(XMPPEvents.SESSION_ACCEPT_ERROR, this, error);
+                });
             },
             failure,
             localTracks);
             );
         const removedAnySSRCs = sdpDiffer.toJingle(remove);
 
+        // context a common object for one run of ssrc update (source-add and source-remove) so we can match them if we
+        // need to
+        const ctx = {};
+
         if (removedAnySSRCs) {
             logger.info(`${this} Sending source-remove`);
             logger.debug(remove.tree());
             this.connection.sendIQ(
-                remove, null,
-                this.newJingleErrorHandler(remove), IQ_TIMEOUT);
+                remove,
+                () => {
+                    this.room.eventEmitter.emit(XMPPEvents.SOURCE_REMOVE, this, ctx);
+                },
+                this.newJingleErrorHandler(remove, error => {
+                    this.room.eventEmitter.emit(XMPPEvents.SOURCE_REMOVE_ERROR, this, error, ctx);
+                }),
+                IQ_TIMEOUT);
         }
 
         // send source-add IQ.
             logger.info(`${this} Sending source-add`);
             logger.debug(add.tree());
             this.connection.sendIQ(
-                add, null, this.newJingleErrorHandler(add), IQ_TIMEOUT);
+                add,
+                () => {
+                    this.room.eventEmitter.emit(XMPPEvents.SOURCE_ADD, this, ctx);
+                },
+                this.newJingleErrorHandler(add, error => {
+                    this.room.eventEmitter.emit(XMPPEvents.SOURCE_ADD_ERROR, this, error, ctx);
+                }),
+                IQ_TIMEOUT);
         }
     }
 

service/xmpp/XMPPEvents.js

     // a specific user of the muc.
     SENDING_PRIVATE_CHAT_MESSAGE: 'xmpp.sending_private_chat_message',
 
+    /**
+     * Event fired after receiving the confirmation about session accept.
+     */
+    SESSION_ACCEPT: 'xmpp.session_accept',
+
+    /**
+     * Event fired if we receive an error after sending the session accept.
+     */
+    SESSION_ACCEPT_ERROR: 'xmpp.session_accept_error',
+
     /**
      * Event fired when we do not get our 'session-accept' acknowledged by
      * Jicofo. It most likely means that there is serious problem with our
      */
     SESSION_ACCEPT_TIMEOUT: 'xmpp.session_accept_timeout',
 
+    /**
+     * Event fired after successful sending of jingle source-add.
+     */
+    SOURCE_ADD: 'xmpp.source_add',
+
+    /**
+     * Event fired after receiving an error sending of jingle source-add.
+     */
+    SOURCE_ADD_ERROR: 'xmpp.source_add_error',
+
+    /**
+     * Event fired after successful sending of jingle source-remove.
+     */
+    SOURCE_REMOVE: 'xmpp.source_remove',
+
+    /**
+     * Event fired after receiving an error sending of jingle source-remove.
+     */
+    SOURCE_REMOVE_ERROR: 'xmpp.source_remove_error',
+
     /**
      * Event fired when speaker stats update message is received.
      */