feat(replace-participant): Replace participant with same jwt in the conf

- update lib-jitsi-meet to version with support for replacing participant

conference.js

 
         // not enough rights to create conference
         case JitsiConferenceErrors.AUTHENTICATION_REQUIRED: {
+            const { replaceParticipant }
+                = APP.store.getState()['features/base/config'];
+
+
             // Schedule reconnect to check if someone else created the room.
             this.reconnectTimeout = setTimeout(() => {
                 APP.store.dispatch(conferenceWillJoin(room));
-                room.join();
+                room.join(null, replaceParticipant);
             }, 5000);
 
             const { password }
      *
      */
     connect() {
+        const { replaceParticipant } = APP.store.getState()['features/base/config'];
+
         // the local storage overrides here and in connection.js can be used by jibri
-        room.join(jitsiLocalStorage.getItem('xmpp_conference_password_override'));
+        room.join(jitsiLocalStorage.getItem('xmpp_conference_password_override'), replaceParticipant);
     }
 }
 
             JitsiConferenceEvents.LOCK_STATE_CHANGED,
             (...args) => APP.store.dispatch(lockStateChanged(room, ...args)));
 
-        room.on(JitsiConferenceEvents.KICKED, participant => {
+        room.on(JitsiConferenceEvents.KICKED, (participant, reason, isReplaced) => {
+            if (isReplaced) {
+                // this event triggers when the local participant is kicked, `participant`
+                // is the kicker. In replace participant case, kicker is undefined,
+                // as the server initiated it. We mark in store the local participant
+                // as being replaced based on jwt.
+                const localParticipant = getLocalParticipant(APP.store.getState());
+
+                APP.store.dispatch(participantUpdated({
+                    conference: room,
+                    id: localParticipant.id,
+                    isReplaced
+                }));
+            }
             APP.store.dispatch(kickedOut(room, participant));
         });
 

modules/UI/authentication/AuthHandler.js

     }).then(url => {
         // de-authenticate conference on the fly
         if (room.isJoined()) {
-            room.join();
+            const { replaceParticipant }
+                = APP.store.getState()['features/base/config'];
+
+            room.join(null, replaceParticipant);
         }
 
         return url;

package-lock.json

       }
     },
     "lib-jitsi-meet": {
-      "version": "github:jitsi/lib-jitsi-meet#2259d4418574841a782e98df27c44370bb84df45",
-      "from": "github:jitsi/lib-jitsi-meet#2259d4418574841a782e98df27c44370bb84df45",
+      "version": "github:jitsi/lib-jitsi-meet#fad985e95a9e8a4fb8a1b8b1ad2cfef75370c866",
+      "from": "github:jitsi/lib-jitsi-meet#fad985e95a9e8a4fb8a1b8b1ad2cfef75370c866",
       "requires": {
         "@jitsi/js-utils": "1.0.2",
         "@jitsi/sdp-interop": "github:jitsi/sdp-interop#5fc4af6dcf8a6e6af9fedbcd654412fd47b1b4ae",

package.json

     "jquery-i18next": "1.2.1",
     "js-md5": "0.6.1",
     "jwt-decode": "2.2.0",
-    "lib-jitsi-meet": "github:jitsi/lib-jitsi-meet#2259d4418574841a782e98df27c44370bb84df45",
+    "lib-jitsi-meet": "github:jitsi/lib-jitsi-meet#fad985e95a9e8a4fb8a1b8b1ad2cfef75370c866",
     "libflacjs": "github:mmig/libflac.js#93d37e7f811f01cf7d8b6a603e38bd3c3810907d",
     "lodash": "4.17.21",
     "moment": "2.29.1",

react/features/base/conference/actions.js

 
         sendLocalParticipant(state, conference);
 
-        conference.join(password);
+        conference.join(password, config.replaceParticipant);
     };
 }
 
         const { authRequired, password }
             = getState()['features/base/conference'];
 
+        const { replaceParticipant }
+            = getState()['features/base/config'];
+
         authRequired && dispatch(_conferenceWillJoin(authRequired));
-        authRequired && authRequired.join(password);
+        authRequired && authRequired.join(password, replaceParticipant);
     };
 }
 

react/features/base/conference/functions.js

     if (user.isHidden()) {
         dispatch(hiddenParticipantJoined(id, displayName));
     } else {
+        const isReplacing = user.isReplacing && user.isReplacing();
+
         dispatch(participantJoined({
             botType: user.getBotType(),
             connectionStatus: user.getConnectionStatus(),
             id,
             name: displayName,
             presence: user.getStatus(),
-            role: user.getRole()
+            role: user.getRole(),
+            isReplacing
         }));
     }
 }
     if (user.isHidden()) {
         dispatch(hiddenParticipantLeft(id));
     } else {
-        dispatch(participantLeft(id, conference));
+        const isReplaced = user.isReplaced && user.isReplaced();
+
+        dispatch(participantLeft(id, conference, isReplaced));
     }
 }
 

react/features/base/config/configWhitelist.js

     'requireDisplayName',
     'remoteVideoMenu',
     'roomPasswordNumberOfDigits',
+    'replaceParticipant',
     'resolution',
     'startAudioMuted',
     'startAudioOnly',

react/features/base/participants/actions.js

  * with the participant identified by the specified {@code id}. Only the local
  * participant is allowed to not specify an associated {@code JitsiConference}
  * instance.
+ * @param {boolean} isReplaced - Whether the participant is to be replaced in the meeting.
  * @returns {{
  *     type: PARTICIPANT_LEFT,
  *     participant: {
  *     }
  * }}
  */
-export function participantLeft(id, conference) {
+export function participantLeft(id, conference, isReplaced) {
     return {
         type: PARTICIPANT_LEFT,
         participant: {
             conference,
-            id
+            id,
+            isReplaced
         }
     };
 }
         dispatch({
             type: PARTICIPANT_KICKED,
             kicked: kicked.getId(),
-            kicker: kicker.getId()
+            kicker: kicker?.getId()
         });
 
+        if (kicked.isReplaced && kicked.isReplaced()) {
+            return;
+        }
+
         dispatch(showNotification({
             titleArguments: {
                 kicked:

react/features/base/participants/middleware.js

         for (const p of getState()['features/base/participants']) {
             !p.local
                 && (!conference || p.conference !== conference)
-                && dispatch(participantLeft(p.id, p.conference));
+                && dispatch(participantLeft(p.id, p.conference, p.isReplaced));
         }
     });
 
     if (!action.participant.local
             && (!startAudioMuted
                 || getParticipantCount(state) < startAudioMuted)) {
+        const { isReplacing, isReplaced } = action.participant;
+
         if (action.type === PARTICIPANT_JOINED) {
             const { presence } = action.participant;
 
             // The sounds for the poltergeist are handled by features/invite.
-            if (presence !== INVITED && presence !== CALLING) {
+            if (presence !== INVITED && presence !== CALLING && !isReplacing) {
                 dispatch(playSound(PARTICIPANT_JOINED_SOUND_ID));
             }
-        } else if (action.type === PARTICIPANT_LEFT) {
+        } else if (action.type === PARTICIPANT_LEFT && !isReplaced) {
             dispatch(playSound(PARTICIPANT_LEFT_SOUND_ID));
         }
     }

react/features/base/participants/reducer.js

         dominantSpeaker,
         email,
         isFakeParticipant,
+        isReplacing,
         isJigasi,
         loadableAvatarUrl,
         local,
         email,
         id,
         isFakeParticipant,
+        isReplacing,
         isJigasi,
         loadableAvatarUrl,
         local: local || false,

react/features/conference/actions.native.js

  */
 export function notifyKickedOut(participant: Object, submit: ?Function) {
     return (dispatch: Dispatch<any>, getState: Function) => {
+        if (!participant || (participant.isReplaced && participant.isReplaced())) {
+            submit && submit();
+
+            return;
+        }
+
         dispatch(openDialog(AlertDialog, {
             contentKey: {
                 key: 'dialog.kickTitle',

react/features/conference/actions.web.js

  */
 export function notifyKickedOut(participant: Object, _: ?Function) { // eslint-disable-line no-unused-vars
     return (dispatch: Dispatch<any>, getState: Function) => {
+        if (!participant || (participant.isReplaced && participant.isReplaced())) {
+            return;
+        }
+
         const args = {
             participantDisplayName:
                 getParticipantDisplayName(getState, participant.getId())

react/features/external-api/middleware.js

                 id: getLocalParticipant(store.getState()).id,
                 local: true
             },
-            { id: action.participant.getId() }
+            { id: action.participant ? action.participant.getId() : undefined }
         );
         break;
 

react/features/lobby/components/AbstractKnockingParticipantList.js

 
     return {
         _participants: knockingParticipants,
-        _visible: lobbyEnabled && isLocalParticipantModerator(state) && Boolean(knockingParticipants.length)
+        _visible: lobbyEnabled && isLocalParticipantModerator(state)
+          && Boolean(knockingParticipants && knockingParticipants.length)
     };
 }

react/features/notifications/middleware.js

         const { participant: p } = action;
         const { dispatch, getState } = store;
 
-        if (!p.local && !joinLeaveNotificationsDisabled()) {
+        if (!p.local && !joinLeaveNotificationsDisabled() && !p.isReplacing) {
             dispatch(showParticipantJoinedNotification(
                 getParticipantDisplayName(getState, p.id)
             ));
             // Do not show the notification for mobile and also when the focus indicator is disabled.
             const displayName = getParticipantDisplayName(getState, p.id);
 
-            dispatch(showNotification({
-                descriptionArguments: { to: displayName || '$t(notify.somebody)' },
-                descriptionKey: 'notify.grantedTo',
-                titleKey: 'notify.somebody',
-                title: displayName
-            },
-            NOTIFICATION_TIMEOUT));
+            if (!p.isReplacing) {
+                dispatch(showNotification({
+                    descriptionArguments: { to: displayName || '$t(notify.somebody)' },
+                    descriptionKey: 'notify.grantedTo',
+                    titleKey: 'notify.somebody',
+                    title: displayName
+                },
+                NOTIFICATION_TIMEOUT));
+            }
         }
 
         return result;
 
             if (typeof interfaceConfig === 'object'
                 && participant
-                && !participant.local) {
+                && !participant.local
+                && !action.participant.isReplaced) {
                 store.dispatch(showNotification({
                     descriptionKey: 'notify.disconnected',
                     titleKey: 'notify.somebody',