ref(recording): change implementation to match VideoSIPGW (#769)

* ref(recording): change implementation to match VideoSIPGW

VideoSIPGW takes in a chat room and uses instance variables
on the chat room. RecordingManager has been changed to
mirror this approach because of the case where jitsi is
deployed on a domain requiring authentication. In that
case, the initial chat room is created and fails, a
new chat room (connection) is created for authentication,
authentication is put onto the failed chat room, and the
failed chat room is used. As such, recordingManager
should not be tied to chat room creation itself but
rather tied to the first chat room.

* squash: use git mv to detect capitalization change

JitsiConference.js

 import TalkMutedDetection from './modules/TalkMutedDetection';
 import Transcriber from './modules/transcription/transcriber';
 import VideoType from './service/RTC/VideoType';
+import RecordingManager from './modules/recording/RecordingManager';
 import VideoSIPGW from './modules/videosipgw/VideoSIPGW';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
 import * as XMPPEvents from './service/xmpp/XMPPEvents';
     this.p2pJingleSession = null;
 
     this.videoSIPGWHandler = new VideoSIPGW(this.room);
+    this.recordingManager = new RecordingManager(this.room);
 }
 
 // FIXME convert JitsiConference to ES6 - ASAP !
  */
 JitsiConference.prototype.startRecording = function(options) {
     if (this.room) {
-        return this.room.startRecording(options);
+        return this.recordingManager.startRecording(options);
     }
 
     return Promise.reject(new Error('The conference is not created yet!'));
  */
 JitsiConference.prototype.stopRecording = function(sessionID) {
     if (this.room) {
-        return this.room.stopRecording(sessionID);
+        return this.recordingManager.stopRecording(sessionID);
     }
 
     return Promise.reject(new Error('The conference is not created yet!'));

modules/recording/recordingManager.js → modules/recording/RecordingManager.js

 const logger = getLogger(__filename);
 
 /**
- * A singleton responsible for starting and stopping recording sessions and
- * emitting state updates for them.
+ * A class responsible for starting and stopping recording sessions and emitting
+ * state updates for them.
  */
-const recordingManager = {
+class RecordingManager {
     /**
-     * All known recording sessions from the current conference.
-     */
-    _sessions: {},
-
-    /**
-     * Initialize recordingManager with other objects that are necessary for
-     * starting a recording.
+     * Initialize {@code RecordingManager} with other objects that are necessary
+     * for starting a recording.
      *
-     * @param {Object} eventEmitter - The eventEmitter to be used for
-     * broadcasting recording state changes.
-     * @param {Object} connection - The MUC connection used for sending out
-     * messages regarding recording.
-     * @param {string} focusMucJid - The ID of the conference (MUC) the focus
-     * is in.
+     * @param {ChatRoom} chatRoom - The chat room to handle.
      * @returns {void}
      */
-    init(eventEmitter, connection, focusMucJid) {
-        this._eventEmitter = eventEmitter;
-        this._connection = connection;
-        this._focusMucJid = focusMucJid;
-    },
+    constructor(chatRoom) {
+        /**
+         * All known recording sessions from the current conference.
+         */
+        this._sessions = {};
+
+        this._chatRoom = chatRoom;
+
+        this.onPresence = this.onPresence.bind(this);
+
+        this._chatRoom.eventEmitter.addListener(
+            XMPPEvents.PRESENCE_RECEIVED, this.onPresence);
+    }
 
     /**
      * Finds an existing recording session by session ID.
      */
     getSession(sessionID) {
         return this._sessions[sessionID];
-    },
+    }
 
     /**
      * Callback to invoke to parse through a presence update to find recording
      * related updates (from Jibri participant doing the recording and the
      * focus which controls recording).
      *
-     * @param {Node} presence - An XMPP presence update.
-     * @param {boolean} isHiddenDomain - Whether or not the presence update
-     * comes from a participant that is trusted but not visible, as would be the
-     * case with the Jibri recorder participant.
+     * @param {Object} event - The presence data from the pubsub event.
+     * @param {Node} event.presence - An XMPP presence update.
+     * @param {boolean} event.fromHiddenDomain - Whether or not the update comes
+     * from a participant that is trusted but not visible, as would be the case
+     * with the Jibri recorder participant.
      * @returns {void}
      */
-    onPresence(presence, isHiddenDomain) {
+    onPresence({ fromHiddenDomain, presence }) {
         if (recordingXMLUtils.isFromFocus(presence)) {
             this._handleFocusPresence(presence);
-        } else if (isHiddenDomain) {
+        } else if (fromHiddenDomain) {
             this._handleJibriPresence(presence);
         }
-    },
-
-    /**
-     * Sets the currently known ID of the conference (MUC). This method exists
-     * in case the ID is not known at init time.
-     *
-     * @param {string} focusMucJid - The ID of the conference (MUC) the focus
-     * is in.
-     * @returns {void}
-     */
-    setFocusMucJid(focusMucJid) {
-        this._focusMucJid = focusMucJid;
-    },
+    }
 
     /**
      * Start a recording session.
     startRecording(options) {
         const session = new JibriSession({
             ...options,
-            connection: this._connection
+            connection: this._chatRoom.connection
         });
 
         return session.start({
             broadcastId: options.broadcastId,
-            focusMucJid: this._focusMucJid,
+            focusMucJid: this._chatRoom.focusMucJid,
             streamId: options.streamId
         })
             .then(() => {
 
                 return Promise.reject(error);
             });
-    },
+    }
 
     /**
      * Stop a recording session.
         const session = this.getSession(sessionID);
 
         if (session) {
-            return session.stop({ focusMucJid: this._focusMucJid });
+            return session.stop({ focusMucJid: this._chatRoom.focusMucJid });
         }
 
         return Promise.reject(new Error('Could not find session'));
-    },
+    }
 
     /**
      * Stores a reference to the passed in JibriSession.
      */
     _addSession(session) {
         this._sessions[session.getID()] = session;
-    },
+    }
 
     /**
      * Create a new instance of a recording session and stores a reference to
      */
     _createSession(sessionID, status, mode) {
         const session = new JibriSession({
-            connection: this._connection,
-            focusMucJid: this._focusMucJid,
+            connection: this._chatRoom.connection,
+            focusMucJid: this._chatRoom.focusMucJid,
             mode,
             sessionID,
             status
         this._addSession(session);
 
         return session;
-    },
+    }
 
     /**
      * Notifies listeners of an update to a recording session.
      * @param {JibriSession} session - The session that has been updated.
      */
     _emitSessionUpdate(session) {
-        this._eventEmitter.emit(XMPPEvents.RECORDER_STATE_CHANGED, session);
-    },
+        this._chatRoom.eventEmitter.emit(
+            XMPPEvents.RECORDER_STATE_CHANGED, session);
+    }
 
     /**
      * Parses presence to update an existing JibriSession or to create a new
         }
 
         this._emitSessionUpdate(session);
-    },
+    }
 
     /**
      * Handles updates from the Jibri which can broadcast a YouTube URL that
 
         this._emitSessionUpdate(session);
     }
-};
+}
 
-export default recordingManager;
+export default RecordingManager;

modules/xmpp/ChatRoom.js

 import GlobalOnErrorHandler from '../util/GlobalOnErrorHandler';
 import * as JitsiTranscriptionStatus from '../../JitsiTranscriptionStatus';
 import Listenable from '../util/Listenable';
-import recordingManager from '../recording/recordingManager';
 import Settings from '../settings/Settings';
 import * as MediaType from '../../service/RTC/MediaType';
 import XMPPEvents from '../../service/xmpp/XMPPEvents';
 
         this.locked = false;
         this.transcriptionStatus = JitsiTranscriptionStatus.OFF;
-
-        recordingManager.init(
-            this.eventEmitter,
-            this.connection,
-            this.focusMucJid);
     }
 
     /* eslint-enable max-params */
                 && this.options.hiddenDomain
                     === jid.substring(jid.indexOf('@') + 1, jid.indexOf('/'));
 
-        recordingManager.onPresence(pres, member.isHiddenDomain);
+        this.eventEmitter.emit(XMPPEvents.PRESENCE_RECEIVED, {
+            fromHiddenDomain: member.isHiddenDomain,
+            presence: pres
+        });
 
         const xEl = pres.querySelector('x');
 
     _initFocus(from, mucJid) {
         this.focusMucJid = from;
 
-        recordingManager.setFocusMucJid(this.focusMucJid);
-
         logger.info(`Ignore focus: ${from}, real JID: ${mucJid}`);
     }
 
         return data;
     }
 
-    /**
-     * Starts a recording session.
-     *
-     * @param {Object} options - Configuration for the recording. See
-     * {@link recordingManager#startRecording} for more info.
-     * @returns {Promise} See {@link recordingManager#startRecording} for more
-     * info.
-     */
-    startRecording(options) {
-        return recordingManager.startRecording(options);
-    }
-
-    /**
-     * Stops a recording session.
-     *
-     * @param {string} sessionID - The ID of the recording session that should
-     * be stopped.
-     * @returns {Promise} See {@link recordingManager#stopRecording} for more
-     * info.
-     */
-    stopRecording(sessionID) {
-        return recordingManager.stopRecording(sessionID);
-    }
-
     /**
      * Returns true if the SIP calls are supported and false otherwise
      */

modules/xmpp/ChatRoom.spec.js

             const pres = new DOMParser().parseFromString(presStr, 'text/xml').documentElement;
 
             room.onPresence(pres);
-            expect(emitterSpy.calls.count()).toEqual(1);
+            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',
             const pres = new DOMParser().parseFromString(presStr, 'text/xml').documentElement;
 
             room.onPresence(pres);
-            expect(emitterSpy.calls.count()).toEqual(1);
+            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',
             };
 
             room.onPresence(pres);
-            expect(emitterSpy.calls.count()).toEqual(1);
+            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',

service/xmpp/XMPPEvents.js

      * Indicates that phone number changed.
      */
     PHONE_NUMBER_CHANGED: 'conference.phoneNumberChanged',
+    PRESENCE_RECEIVED: 'xmpp.presence_received',
     PRESENCE_STATUS: 'xmpp.presence_status',
     PROMPT_FOR_LOGIN: 'xmpp.prompt_for_login',