Notify for kick and mute (#915)

* Updates kicked event to inform local and remote kicks and who it affects

* Parses actor from MuteIQ and adds participant info to mute track event.

* Fixes emitting both events.

* Fixes comments.

JitsiConference.js

     };
     this.isMutedByFocus = false;
 
+    // when muted by focus we receive the jid of the initiator of the mute
+    this.mutedByFocusActor = null;
+
     // Flag indicates if the 'onCallEnded' method was ever called on this
     // instance. Used to log extra analytics event for debugging purpose.
     // We need to know if the potential issue happened before or after
         // unmute local user on server
         this.room.muteParticipant(this.room.myroomjid, false);
     }
-    this.eventEmitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track);
+
+    let actorParticipant;
+
+    if (this.mutedByFocusActor) {
+        const actorId = Strophe.getResourceFromJid(this.mutedByFocusActor);
+
+        actorParticipant = this.participants[actorId];
+    }
+
+    this.eventEmitter.emit(JitsiConferenceEvents.TRACK_MUTE_CHANGED, track, actorParticipant);
 };
 
 /**
     this._maybeClearSITimeout();
 };
 
+/**
+ * Designates an event indicating that we were kicked from the XMPP MUC.
+ * @param {boolean} isSelfPresence - whether it is for local participant
+ * or another participant.
+ * @param {string} actorId - the id of the participant who was initiator
+ * of the kick.
+ * @param {string?} kickedParticipantId - when it is not a kick for local participant,
+ * this is the id of the participant which was kicked.
+ */
+JitsiConference.prototype.onMemberKicked = function(isSelfPresence, actorId, kickedParticipantId) {
+    const actorParticipant = this.participants[actorId];
+
+    if (isSelfPresence) {
+        this.eventEmitter.emit(
+            JitsiConferenceEvents.KICKED, actorParticipant);
+
+        this.leave();
+
+        return;
+    }
+
+    const kickedParticipant = this.participants[kickedParticipantId];
+
+    this.eventEmitter.emit(
+        JitsiConferenceEvents.PARTICIPANT_KICKED, actorParticipant, kickedParticipant);
+};
+
 /**
  * Method called on local MUC role change.
  * @param {string} role the name of new user's role as defined by XMPP MUC.

JitsiConferenceEventManager.js

 
 
     chatRoom.addListener(XMPPEvents.AUDIO_MUTED_BY_FOCUS,
-        () => {
+        actor => {
             // TODO: Add a way to differentiate between commands which caused
             // us to mute and those that did not change our state (i.e. we were
             // already muted).
             Statistics.sendAnalytics(createRemotelyMutedEvent());
 
+            conference.mutedByFocusActor = actor;
+
             // set isMutedByFocus when setAudioMute Promise ends
             conference.rtc.setAudioMute(true).then(
                 () => {
                     conference.isMutedByFocus = true;
-                },
-                () =>
-                    logger.warn(
-                        'Error while audio muting due to focus request'));
+                    conference.mutedByFocusActor = null;
+                })
+                .catch(
+                    error => {
+                        conference.mutedByFocusActor = null;
+                        logger.warn(
+                            'Error while audio muting due to focus request', error);
+                    });
         }
     );
 
             node.value);
     });
 
-    this.chatRoomForwarder.forward(XMPPEvents.KICKED,
-        JitsiConferenceEvents.KICKED);
     chatRoom.addListener(XMPPEvents.KICKED,
-        () => {
-            conference.leave();
-        });
+        conference.onMemberKicked.bind(conference));
     chatRoom.addListener(XMPPEvents.SUSPEND_DETECTED,
         conference.onSuspendDetected.bind(conference));
 

JitsiConferenceEvents.js

 
 /**
  * You are kicked from the conference.
+ * @param {JitsiParticipant} the participant that initiated the kick.
  */
 export const KICKED = 'conference.kicked';
 
+/**
+ * Participant was kicked from the conference.
+ * @param {JitsiParticipant} the participant that initiated the kick.
+ * @param {JitsiParticipant} the participant that was kicked.
+ */
+export const PARTICIPANT_KICKED = 'conference.participant_kicked';
+
 /**
  * The Last N set is changed.
  *
 
 /**
  * A media track ( attached to the conference) mute status was changed.
+ * @param {JitsiParticipant|null} the participant that initiated the mute
+ * if it is a remote mute.
  */
 export const TRACK_MUTE_CHANGED = 'conference.trackMuteChanged';
 

modules/xmpp/ChatRoom.js

                 .length;
         const membersKeys = Object.keys(this.members);
 
+        if (isKick) {
+            const actorSelect
+                = $(pres)
+                .find('>x[xmlns="http://jabber.org/protocol/muc#user"]>item>actor');
+
+            let actorNick;
+
+            if (actorSelect.length) {
+                actorNick = actorSelect.attr('nick');
+            }
+
+            // if no member is found this is the case we had kicked someone
+            // and we are not in the list of members
+            if (membersKeys.find(jid => Strophe.getResourceFromJid(jid) === actorNick)) {
+                // we first fire the kicked so we can show the participant
+                // who kicked, before notifying that participant left
+                // we fire kicked for us and for any participant kicked
+                this.eventEmitter.emit(
+                    XMPPEvents.KICKED,
+                    isSelfPresence,
+                    actorNick,
+                    Strophe.getResourceFromJid(from));
+            }
+        }
+
         if (!isSelfPresence) {
             delete this.members[from];
             this.onParticipantLeft(from, false);
                 this.eventEmitter.emit(XMPPEvents.MUC_LEFT);
             }
         }
-
-        if (isKick && this.myroomjid === from) {
-            this.eventEmitter.emit(XMPPEvents.KICKED);
-        }
     }
 
     /**
         const mute = $(iq).find('mute');
 
         if (mute.length && mute.text() === 'true') {
-            this.eventEmitter.emit(XMPPEvents.AUDIO_MUTED_BY_FOCUS);
+            this.eventEmitter.emit(XMPPEvents.AUDIO_MUTED_BY_FOCUS, mute.attr('actor'));
         } else {
             // XXX Why do we support anything but muting? Why do we encode the
             // value in the text of the element? Why do we use a separate XML

service/xmpp/XMPPEvents.js

     // Event fired when we have failed to set initial offer
     JINGLE_FATAL_ERROR: 'xmpp.jingle_fatal_error',
 
-    // Designates an event indicating that we were kicked from the XMPP MUC.
+    /**
+     * Designates an event indicating that we were kicked from the XMPP MUC.
+     * @param {boolean} isSelfPresence - whether it is for local participant
+     * or another participant.
+     * @param {string} actorJid - the jid of the participant who was initator
+     * of the kick.
+     * @param {?string} participantJid - when it is not a kick for local participant,
+     * this is the jid of the participant which was kicked.
+     */
     KICKED: 'xmpp.kicked',
 
     // Designates an event indicating that our role in the XMPP MUC has changed.