Extracts the jid that start/stopped a jibri session.

JitsiConferenceEventManager.js

                     { p2p: jingleSession.isP2P }));
         });
 
-    this.chatRoomForwarder.forward(XMPPEvents.RECORDER_STATE_CHANGED,
-        JitsiConferenceEvents.RECORDER_STATE_CHANGED);
+    chatRoom.addListener(XMPPEvents.RECORDER_STATE_CHANGED,
+        (session, jid) => {
+
+            if (jid) {
+                const participant = conference.getParticipantById(
+                    Strophe.getResourceFromJid(jid));
+
+                if (session.getStatus() === 'off') {
+                    session.setTerminator(participant);
+                } else if (session.getStatus() === 'on') {
+                    session.setInitiator(participant);
+                }
+            }
+
+            conference.eventEmitter.emit(
+                JitsiConferenceEvents.RECORDER_STATE_CHANGED,
+                session);
+        });
 
     this.chatRoomForwarder.forward(XMPPEvents.TRANSCRIPTION_STATUS_CHANGED,
         JitsiConferenceEvents.TRANSCRIPTION_STATUS_CHANGED);

modules/recording/JibriSession.js

         return this._sessionID;
     }
 
+    /**
+     * Returns the initiator of the session instance.
+     *
+     * @returns {JitsiParticipant|undefined} The participant that started the session.
+     */
+    getInitiator() {
+        return this._initiator;
+    }
+
     /**
      * Returns the streaming URL of the session.
      *
         return this._status;
     }
 
+    /**
+     * Returns the jid of the participant that stopped the session.
+     *
+     * @returns {JitsiParticipant|undefined} The participant that stopped the session.
+     */
+    getTerminator() {
+        return this._terminator;
+    }
+
     /**
      * Returns the current recording mode of the session, such as "file".
      *
         this._status = status;
     }
 
+    /**
+     * Sets the creator's jid of the session.
+     * @param {JitsiParticipant} participant - The creator of the session.
+     */
+    setInitiator(participant) {
+        this._initiator = participant;
+    }
+
+    /**
+     * Sets the jid of the participant that stopped the session.
+     * @param {JitsiParticipant} participant  - The participant's jid,
+     * that stopped the session.
+     */
+    setTerminator(participant) {
+        this._terminator = participant;
+    }
+
     /**
      * Sends a message to start the actual recording.
      *

modules/recording/RecordingManager.js

      * Notifies listeners of an update to a recording session.
      *
      * @param {JibriSession} session - The session that has been updated.
+     * @param {string|undefined} initiator - The jid of the initiator of the update.
      */
-    _emitSessionUpdate(session) {
+    _emitSessionUpdate(session, initiator) {
         this._chatRoom.eventEmitter.emit(
-            XMPPEvents.RECORDER_STATE_CHANGED, session);
+            XMPPEvents.RECORDER_STATE_CHANGED, session, initiator);
     }
 
     /**
             return;
         }
 
-        const { sessionID, status, error, recordingMode } = jibriStatus;
+        const { error, initiator, recordingMode, sessionID, status } = jibriStatus;
 
         // We'll look for an existing session or create one (in case we're a
         // participant joining a call with an existing recording going on).
             session.setError(error);
         }
 
-        this._emitSessionUpdate(session);
+        this._emitSessionUpdate(session, initiator);
     }
 
     /**

modules/recording/recordingXMLUtils.js

 
         return {
             error: jibriStatus.getAttribute('failure_reason'),
+            initiator: jibriStatus.getAttribute('initiator'),
             recordingMode: jibriStatus.getAttribute('recording_mode'),
             sessionID: jibriStatus.getAttribute('session_id'),
             status: jibriStatus.getAttribute('status')