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

JitsiConference.js

 /**
  * Joins the conference.
  * @param password {string} the password
+ * @param replaceParticipant {boolean} whether the current join replaces
+ * an existing participant with same jwt from the meeting.
  */
-JitsiConference.prototype.join = function(password) {
+JitsiConference.prototype.join = function(password, replaceParticipant = false) {
     if (this.room) {
-        this.room.join(password).then(() => this._maybeSetSITimeout());
+        this.room.join(password, replaceParticipant).then(() => this._maybeSetSITimeout());
     }
 };
 
  * @param botType the member botType, if any
  * @param fullJid the member full jid, if any
  * @param features the member botType, if any
+ * @param isReplaceParticipant whether this join replaces a participant with
+ * the same jwt.
  */
 JitsiConference.prototype.onMemberJoined = function(
-        jid, nick, role, isHidden, statsID, status, identity, botType, fullJid, features) {
+        jid, nick, role, isHidden, statsID, status, identity, botType, fullJid, features, isReplaceParticipant) {
     const id = Strophe.getResourceFromJid(jid);
 
     if (id === 'focus' || this.myUserId() === id) {
     participant.setRole(role);
     participant.setBotType(botType);
     participant.setFeatures(features);
+    participant.setIsReplacing(isReplaceParticipant);
 
     this.participants[id] = participant;
     this.eventEmitter.emit(
         });
 };
 
+/* eslint-disable max-params */
+
 /**
  * Designates an event indicating that we were kicked from the XMPP MUC.
  * @param {boolean} isSelfPresence - whether it is for local participant
  * @param {string?} kickedParticipantId - when it is not a kick for local participant,
  * this is the id of the participant which was kicked.
  * @param {string} reason - reason of the participant to kick
+ * @param {boolean?} isReplaceParticipant - whether this is a server initiated kick in order
+ * to replace it with a participant with same jwt.
  */
-JitsiConference.prototype.onMemberKicked = function(isSelfPresence, actorId, kickedParticipantId, reason) {
+JitsiConference.prototype.onMemberKicked = function(
+        isSelfPresence,
+        actorId,
+        kickedParticipantId,
+        reason,
+        isReplaceParticipant) {
     // This check which be true when we kick someone else. With the introduction of lobby
     // the ChatRoom KICKED event is now also emitted for ourselves (the kicker) so we want to
     // avoid emitting an event where `undefined` kicked someone.
 
     if (isSelfPresence) {
         this.eventEmitter.emit(
-            JitsiConferenceEvents.KICKED, actorParticipant, reason);
+            JitsiConferenceEvents.KICKED, actorParticipant, reason, isReplaceParticipant);
 
         this.leave();
 
 
     const kickedParticipant = this.participants[kickedParticipantId];
 
+    kickedParticipant.setIsReplaced(isReplaceParticipant);
+
     this.eventEmitter.emit(
         JitsiConferenceEvents.PARTICIPANT_KICKED, actorParticipant, kickedParticipant, reason);
 };

JitsiParticipant.js

      * @param {string} statsID - optional participant statsID
      * @param {string} status - the initial status if any.
      * @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.
      */
-    constructor(jid, conference, displayName, hidden, statsID, status, identity) {
+    constructor(jid, conference, displayName, hidden, statsID, status, identity, isReplacing, isReplaced) {
         this._jid = jid;
         this._id = Strophe.getResourceFromJid(jid);
         this._conference = conference;
         this._connectionStatus = ParticipantConnectionStatus.ACTIVE;
         this._properties = {};
         this._identity = identity;
+        this._isReplacing = isReplacing;
+        this._isReplaced = isReplaced;
         this._features = new Set();
     }
 
         return this._hidden;
     }
 
+    /**
+     * @returns {Boolean} Wheter this participants replaces another participant
+     * from the meeting.
+     */
+    isReplacing() {
+        return this._isReplacing;
+    }
+
+    /**
+     * @returns {Boolean} Wheter this participants will be replaced by another
+     * participant in the meeting.
+     */
+    isReplaced() {
+        return this._isReplaced;
+    }
+
     /**
      * @returns {Boolean} Whether this participant has muted their audio.
      */
         this._role = newRole;
     }
 
+    /**
+     * Sets whether participant is replacing another based on jwt.
+     * @param {String} newIsReplacing - whether is replacing.
+     */
+    setIsReplacing(newIsReplacing) {
+        this._isReplacing = newIsReplacing;
+    }
+
+    /**
+     * Sets whether participant is being replaced by another based on jwt.
+     * @param {String} newIsReplacing - whether is being replaced.
+     */
+    setIsReplaced(newIsReplaced) {
+        this._isReplaced = newIsReplaced;
+    }
+
     /**
      *
      */

modules/xmpp/ChatRoom.js

         this.roomjid = Strophe.getBareJidFromJid(jid);
         this.myroomjid = jid;
         this.password = password;
+        this.replaceParticipant = false;
         logger.info(`Joined MUC as ${this.myroomjid}`);
         this.members = {};
         this.presMap = {};
      * @returns {Promise} - resolved when join completes. At the time of this
      * writing it's never rejected.
      */
-    join(password) {
+    join(password, replaceParticipant) {
         this.password = password;
+        this.replaceParticipant = replaceParticipant;
 
         return new Promise(resolve => {
             this.options.disableFocus
         // be considered as joining, and server can send us the message history
         // for the room on every presence
         if (fromJoin) {
+            if (this.replaceParticipant) {
+                pres.c('flip_device').up();
+            }
+
             pres.c('x', { xmlns: this.presMap.xns });
 
             if (this.password) {
         const mucUserItem
             = xElement && xElement.getElementsByTagName('item')[0];
 
+        member.isReplaceParticipant
+            = pres.getElementsByTagName('flip_device').length;
+
         member.affiliation
             = mucUserItem && mucUserItem.getAttribute('affiliation');
         member.role = mucUserItem && mucUserItem.getAttribute('role');
                     member.identity,
                     member.botType,
                     member.jid,
-                    member.features);
+                    member.features,
+                    member.isReplaceParticipant);
 
                 // we are reporting the status with the join
                 // so we do not want a second event about status update
                         + '>status[code="307"]')
                 .length;
         const membersKeys = Object.keys(this.members);
+        const isReplaceParticipant = $(pres).find('flip_device').length;
 
         if (isKick) {
             const actorSelect
                 = $(pres)
                 .find('>x[xmlns="http://jabber.org/protocol/muc#user"]>item>actor');
-
             let actorNick;
 
             if (actorSelect.length) {
                 isSelfPresence,
                 actorNick,
                 Strophe.getResourceFromJid(from),
-                reason);
+                reason,
+                isReplaceParticipant);
         }
 
         if (isSelfPresence) {

modules/xmpp/ChatRoom.spec.js

                 undefined,
                 undefined,
                 'fulljid',
-                undefined // features
+                undefined, // features
+                0 // isReplaceParticipant
             ]);
         });
 
                 undefined,
                 undefined,
                 'jid=attr',
-                undefined); // features
+                undefined, // features
+                0); // isReplaceParticipant
+        });
+
+        it('parses muc user replacing other user correctly', () => {
+            const presStr = '' +
+              '<presence to="tojid" from="fromjid">' +
+                  '<x xmlns="http://jabber.org/protocol/muc#user">' +
+                      '<item jid="jid=attr" affiliation="affiliation-attr" role="role-attr"/>' +
+                  '</x>' +
+                  '<flip_device />' +
+              '</presence>';
+            const pres = new DOMParser().parseFromString(presStr, 'text/xml').documentElement;
+
+            room.onPresence(pres);
+            expect(emitterSpy.calls.count()).toEqual(2);
+            expect(emitterSpy.calls.argsFor(0)).toEqual([
+                XMPPEvents.PRESENCE_RECEIVED,
+                jasmine.any(Object)
+            ]);
+            expect(emitterSpy).toHaveBeenCalledWith(
+              XMPPEvents.MUC_MEMBER_JOINED,
+              'fromjid',
+              undefined, // nick
+              'role-attr', // role
+              jasmine.any(Boolean), // isHiddenDomain
+              undefined, // statsID
+              undefined,
+              undefined,
+              undefined,
+              'jid=attr',
+              undefined, // features
+              1); // isReplaceParticipant
         });
 
         it('parses identity correctly', () => {
                 expectedIdentity,
                 undefined,
                 'fulljid',
-                undefined // features
+                undefined, // features
+                0 // isReplaceParticipant
             ]);
         });
 
                 undefined,
                 expectedBotType,
                 'fulljid',
-                undefined // features
+                undefined, // features
+                0 // isReplaceParticipant
             ]);
         });