feat(recording): frontend logic can support live streaming and recording (#741)

* feat(recording): frontend logic can support live streaming and recording

Instead of either live streaming or recording, now both can live together.
The changes to facilitate such include the following:
- Remove the old recording.js module which allowed one recording at a time.
- Remove events for live stream url changes as the url is now part of a
  sesssion and not fired independently.
- Availability of sipgw and recording are gone. Instead sessions have a
  failure reason. For sipgw sessions, store that failure and emit it to
  listeners.
- Create a new recordingManager singleton that can start/stop sessions
  and handle updating known state of those sessions. Known state is
  emitted through one event.
- Create a JibriSession model to encapsulate state of a session.

* update comments, use map to store sessions

* always pass in focusmucjid

* try to fix jibrisession docs and remove default null

JitsiConference.js

@@ -1267,19 +1267,6 @@ JitsiConference.prototype.onDisplayNameChanged = function(jid, displayName) {
         displayName);
 };
 
-/**
- * Callback invoked when a known live stream URL has been updated.
- *
- * @params {*} ...args - Information regarding which participant has an updated
- * live stream URL and what that live stream URL is.
- * @returns {void}
- */
-JitsiConference.prototype.onLiveStreamURLChange = function(...args) {
-    this.eventEmitter.emit(
-        JitsiConferenceEvents.LIVE_STREAM_URL_CHANGED,
-        ...args);
-};
-
 /**
  * Notifies this JitsiConference that a JitsiRemoteTrack was added into
  * the conference.
@@ -1748,44 +1735,33 @@ JitsiConference.prototype.sendTones = function(tones, duration, pause) {
 };
 
 /**
- * Returns true if recording is supported and false if not.
+ * Starts recording the current conference.
+ *
+ * @param {Object} options - Configuration for the recording. See
+ * {@link Chatroom#startRecording} for more info.
+ * @returns {Promise} See {@link Chatroom#startRecording} for more info.
  */
-JitsiConference.prototype.isRecordingSupported = function() {
+JitsiConference.prototype.startRecording = function(options) {
     if (this.room) {
-        return this.room.isRecordingSupported();
+        return this.room.startRecording(options);
     }
 
-    return false;
+    return Promise.reject(new Error('The conference is not created yet!'));
 };
 
 /**
- * Returns null if the recording is not supported, "on" if the recording started
- * and "off" if the recording is not started.
- */
-JitsiConference.prototype.getRecordingState = function() {
-    return this.room ? this.room.getRecordingState() : undefined;
-};
-
-/**
- * Returns the url of the recorded video.
- */
-JitsiConference.prototype.getRecordingURL = function() {
-    return this.room ? this.room.getRecordingURL() : null;
-};
-
-/**
- * Starts/stops the recording
+ * Stop a recording session.
+ *
+ * @param {string} sessionID - The ID of the recording session that
+ * should be stopped.
+ * @returns {Promise} See {@link Chatroom#stopRecording} for more info.
  */
-JitsiConference.prototype.toggleRecording = function(options) {
+JitsiConference.prototype.stopRecording = function(sessionID) {
     if (this.room) {
-        return this.room.toggleRecording(options, (status, error) => {
-            this.eventEmitter.emit(
-                JitsiConferenceEvents.RECORDER_STATE_CHANGED, status, error);
-        });
+        return this.room.stopRecording(sessionID);
     }
-    this.eventEmitter.emit(
-        JitsiConferenceEvents.RECORDER_STATE_CHANGED, 'error',
-        new Error('The conference is not created yet!'));
+
+    return Promise.reject(new Error('The conference is not created yet!'));
 };
 
 /**

JitsiConferenceEventManager.js

@@ -266,24 +266,19 @@ JitsiConferenceEventManager.prototype.setupChatRoomListeners = function() {
     chatRoom.addListener(XMPPEvents.DISPLAY_NAME_CHANGED,
         conference.onDisplayNameChanged.bind(conference));
 
-    chatRoom.addListener(XMPPEvents.LIVE_STREAM_URL_CHANGE,
-        conference.onLiveStreamURLChange.bind(conference));
-
     chatRoom.addListener(XMPPEvents.LOCAL_ROLE_CHANGED, role => {
         conference.onLocalRoleChanged(role);
 
         // log all events for the recorder operated by the moderator
         if (conference.statistics && conference.isModerator()) {
             conference.on(JitsiConferenceEvents.RECORDER_STATE_CHANGED,
-                (status, error) => {
+                recorderSession => {
                     const logObject = {
+                        error: recorderSession.getError(),
                         id: 'recorder_status',
-                        status
+                        status: recorderSession.getStatus()
                     };
 
-                    if (error) {
-                        logObject.error = error;
-                    }
                     Statistics.sendLog(JSON.stringify(logObject));
                 });
         }

JitsiConferenceEvents.js

@@ -122,11 +122,6 @@ export const KICKED = 'conference.kicked';
  */
 export const LAST_N_ENDPOINTS_CHANGED = 'conference.lastNEndpointsChanged';
 
-/**
- * A known participant's live stream URL has changed.
- */
-export const LIVE_STREAM_URL_CHANGED = 'conference.liveStreamURLChanged';
-
 /**
  * Indicates that the room has been locked or unlocked.
  */

JitsiMeetJS.js

@@ -12,13 +12,11 @@ import * as JitsiConnectionErrors from './JitsiConnectionErrors';
 import * as JitsiConnectionEvents from './JitsiConnectionEvents';
 import JitsiMediaDevices from './JitsiMediaDevices';
 import * as JitsiMediaDevicesEvents from './JitsiMediaDevicesEvents';
-import JitsiRecorderErrors from './JitsiRecorderErrors';
 import JitsiTrackError from './JitsiTrackError';
 import * as JitsiTrackErrors from './JitsiTrackErrors';
 import * as JitsiTrackEvents from './JitsiTrackEvents';
 import * as JitsiTranscriptionStatus from './JitsiTranscriptionStatus';
 import LocalStatsCollector from './modules/statistics/LocalStatsCollector';
-import Recording from './modules/xmpp/recording';
 import Logger from 'jitsi-meet-logger';
 import * as MediaType from './service/RTC/MediaType';
 import Resolutions from './service/RTC/Resolutions';
@@ -28,6 +26,7 @@ import RTC from './modules/RTC/RTC';
 import browser from './modules/browser';
 import RTCUIHelper from './modules/RTC/RTCUIHelper';
 import ScriptUtil from './modules/util/ScriptUtil';
+import recordingConstants from './modules/recording/recordingConstants';
 import Statistics from './modules/statistics/statistics';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
 
@@ -132,8 +131,7 @@ export default _mergeNamespaceAndModule({
     JitsiConnection,
     constants: {
         participantConnectionStatus: ParticipantConnectionStatus,
-        recordingStatus: Recording.status,
-        recordingTypes: Recording.types,
+        recording: recordingConstants,
         sipVideoGW: VideoSIPGWConstants,
         transcriptionStatus: JitsiTranscriptionStatus
     },
@@ -147,7 +145,6 @@ export default _mergeNamespaceAndModule({
     errors: {
         conference: JitsiConferenceErrors,
         connection: JitsiConnectionErrors,
-        recorder: JitsiRecorderErrors,
         track: JitsiTrackErrors
     },
     errorTypes: {

JitsiRecorderErrors.js

@@ -1,32 +0,0 @@
-/**
- * Enumeration with the errors for the conference.
- * @type {{string: string}}
- */
-const JitsiRecorderErrors = {
-    /**
-     * Indicates that the recorder is currently unavailable.
-     */
-    RECORDER_UNAVAILABLE: 'recorder.unavailable',
-
-    /**
-     * Indicates that all available recorders are currently busy.
-     */
-    RECORDER_BUSY: 'recorder.busy',
-
-    /**
-     * Indicates that the authentication token is missing.
-     */
-    NO_TOKEN: 'recorder.noToken',
-
-    /**
-     * Indicates that a state change failed.
-     */
-    STATE_CHANGE_FAILED: 'recorder.stateChangeFailed',
-
-    /**
-     * Indicates an invalid state.
-     */
-    INVALID_STATE: 'recorder.invalidState'
-};
-
-module.exports = JitsiRecorderErrors;

doc/example/example.js

@@ -150,13 +150,6 @@ function onConnectionSuccess() {
     room.on(
         JitsiMeetJS.events.conference.TRACK_AUDIO_LEVEL_CHANGED,
         (userID, audioLevel) => console.log(`${userID} - ${audioLevel}`));
-    room.on(
-        JitsiMeetJS.events.conference.RECORDER_STATE_CHANGED,
-        () =>
-            console.log(
-                `${room.isRecordingSupported()} - ${
-                    room.getRecordingState()} - ${
-                    room.getRecordingURL()}`));
     room.on(
         JitsiMeetJS.events.conference.PHONE_NUMBER_CHANGED,
         () => console.log(`${room.getPhoneNumber()} - ${room.getPhonePin()}`));

modules/recording/JibriSession.js

@@ -0,0 +1,216 @@
+import { $iq } from 'strophe.js';
+
+import recordingXMLUtils from './recordingXMLUtils';
+
+/**
+ * Represents a recording session.
+ */
+export default class JibriSession {
+    /**
+     * Initializes a new JibriSession instance.
+     *
+     * @constructor
+     */
+    constructor(options = {}) {
+        this._connection = options.connection;
+        this._mode = options.mode;
+
+        this._setSessionID(options.sessionID);
+        this.setStatus(options.status);
+    }
+
+    /**
+     * Returns the error related to the session instance, if any.
+     *
+     * @returns {string|undefined}
+     */
+    getError() {
+        return this._error;
+    }
+
+    /**
+     * Returns the session ID of the session instance.
+     *
+     * @returns {string|undefined}
+     */
+    getID() {
+        return this._sessionID;
+    }
+
+    /**
+     * Returns the streaming URL of the session.
+     *
+     * @returns {string|undefined}
+     */
+    getLiveStreamViewURL() {
+        return this._liveStreamViewURL;
+    }
+
+    /**
+     * Returns the current status of the session.
+     *
+     * @returns {string|undefined}
+     */
+    getStatus() {
+        return this._status;
+    }
+
+    /**
+     * Returns the current recording mode of the session, such as "file".
+     *
+     * @returns {string}
+     */
+    getMode() {
+        return this._mode;
+    }
+
+    /**
+     * Sets the last known error message related to the session.
+     *
+     * @param {string} error - The error string explaining why the session
+     * entered an error state.
+     * @returns {void}
+     */
+    setError(error) {
+        this._error = error;
+    }
+
+    /**
+     * Sets the last live stream URL for the session instance. Usually this is
+     * a YouTube URL and usually this is only set for "stream" sessions.
+     *
+     * @param {string} url - The live stream URL associated with the session.
+     * @returns {void}
+     */
+    setLiveStreamViewURL(url) {
+        this._liveStreamViewURL = url;
+    }
+
+    /**
+     * Sets the last known status for this recording session.
+     *
+     * @param {string} status - The new status to set.
+     * @returns {void}
+     */
+    setStatus(status) {
+        this._status = status;
+    }
+
+    /**
+     * Sends a message to start the actual recording.
+     *
+     * @param {Object} options - Additional arguments for starting the
+     * recording.
+     * @param {string} [optional] options.broadcastId - The broadcast ID of an
+     * associated YouTube stream, used for knowing the URL from which the stream
+     * can be viewed.
+     * @param {string} options.focusMucJid - The JID of the focus participant
+     * that controls recording.
+     * @param {streamId} options.streamId - Necessary for live streaming, this
+     * is the the stream key needed to start a live streaming session with the
+     * streaming service provider.
+     * @returns Promise
+     */
+    start({ broadcastId, focusMucJid, streamId }) {
+        return new Promise((resolve, reject) => {
+            this._connection.sendIQ(
+                this._createIQ({
+                    action: 'start',
+                    focusMucJid,
+                    broadcastId,
+                    streamId
+                }),
+                result => {
+                    // All users will eventually receive the 'pending' status
+                    // from the backend, but for the user initiating the session
+                    // it's better to give some instant feedback that recording
+                    // is starting so fire 'pending' here manually.
+                    this.setStatus('pending');
+                    this._setSessionID(
+                        recordingXMLUtils.getSessionIdFromIq(result));
+
+                    resolve();
+                },
+                error => {
+                    this._setErrorFromIq(error);
+
+                    reject(error);
+                });
+        });
+    }
+
+    /**
+     * Sends a message to actually stop the recording session.
+     *
+     * @param {Object} options - Additional arguments for stopping the
+     * recording.
+     * @param {Object} options.focusMucJid - The JID of the focus participant
+     * that controls recording.
+     * @returns Promise
+     */
+    stop({ focusMucJid }) {
+        return new Promise((resolve, reject) => {
+            this._connection.sendIQ(
+                this._createIQ({
+                    action: 'stop',
+                    focusMucJid
+                }),
+                resolve,
+                reject);
+        });
+    }
+
+    /**
+     * Generates the message to change the status of the recording session.
+     *
+     * @param {string} status - The new status to which the recording session
+     * should transition.
+     * @param {string} [optional] options.broadcastId - The broadcast ID of an
+     * associated YouTube stream, used for knowing the URL from which the stream
+     * can be viewed.
+     * @param {string} options.focusMucJid - The JID of the focus participant
+     * that controls recording.
+     * @param {streamId} options.streamId - Necessary for live streaming, this
+     * is the the stream key needed to start a live streaming session with the
+     * streaming service provider.
+     * @returns Object - The XMPP IQ message.
+     */
+    _createIQ({ action, broadcastId, focusMucJid, streamId }) {
+        return $iq({
+            to: focusMucJid,
+            type: 'set'
+        })
+        .c('jibri', {
+            'xmlns': 'http://jitsi.org/protocol/jibri',
+            'action': action,
+            'recording_mode': this._mode,
+            'streamid': streamId,
+            'you_tube_broadcast_id': broadcastId
+        })
+        .up();
+    }
+
+    /**
+     * Handles the error from an iq and stores the error.
+     *
+     * @param {Node} errorIq - The error response from an Iq.
+     * @private
+     * @returns {void}
+     */
+    _setErrorFromIq(errorIq) {
+        const error = errorIq.getElementsByTagName('error')[0];
+
+        this.setError(error.children[0].tagName);
+    }
+
+    /**
+     * Sets the known session ID for this recording session.
+     *
+     * @param {string} sessionID
+     * @private
+     * @returns {void}
+     */
+    _setSessionID(sessionID) {
+        this._sessionID = sessionID;
+    }
+}

modules/recording/recordingConstants.js

@@ -0,0 +1,17 @@
+export default {
+    error: {
+        BUSY: 'busy',
+        ERROR: 'error',
+        RESOURCE_CONSTRAINT: 'resource-constraint',
+        SERVICE_UNAVAILABLE: 'service-unavailable'
+    },
+    mode: {
+        FILE: 'file',
+        STREAM: 'stream'
+    },
+    status: {
+        OFF: 'off',
+        ON: 'on',
+        PENDING: 'pending'
+    }
+};

modules/recording/recordingManager.js

@@ -0,0 +1,257 @@
+import { getLogger } from 'jitsi-meet-logger';
+
+import XMPPEvents from '../../service/xmpp/XMPPEvents';
+
+import JibriSession from './JibriSession';
+import recordingXMLUtils from './recordingXMLUtils';
+
+const logger = getLogger(__filename);
+
+/**
+ * A singleton responsible for starting and stopping recording sessions and
+ * emitting state updates for them.
+ */
+const recordingManager = {
+    /**
+     * All known recording sessions from the current conference.
+     */
+    _sessions: {},
+
+    /**
+     * Initialize 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.
+     * @returns {void}
+     */
+    init(eventEmitter, connection, focusMucJid) {
+        this._eventEmitter = eventEmitter;
+        this._connection = connection;
+        this._focusMucJid = focusMucJid;
+    },
+
+    /**
+     * Finds an existing recording session by session ID.
+     *
+     * @param {string} sessionID - The session ID associated with the recording.
+     * @returns {JibriSession|undefined}
+     */
+    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.
+     * @returns {void}
+     */
+    onPresence(presence, isHiddenDomain) {
+        if (recordingXMLUtils.isFromFocus(presence)) {
+            this._handleFocusPresence(presence);
+        } else if (isHiddenDomain) {
+            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.
+     *
+     * @param {Object} options - Configuration for the recording.
+     * @param {string} [optional] options.broadcastId - The channel on which a
+     * live stream will occur.
+     * @param {string} options.mode - The mode in which recording should be
+     * started. Recognized values are "file" and "stream".
+     * @param {string} [optional] options.streamId - The stream key to be used
+     * for live stream broadcasting. Required for live streaming.
+     * @returns {Promise} A promise for starting a recording, which will pass
+     * back the session on success. The promise resolves after receiving an
+     * acknowledgment of the start request success or fail.
+     */
+    startRecording(options) {
+        const session = new JibriSession({
+            ...options,
+            connection: this._connection
+        });
+
+        return session.start({
+            broadcastId: options.broadcastId,
+            focusMucJid: this._focusMucJid,
+            streamId: options.streamId
+        })
+            .then(() => {
+                // Only store the session and emit if the session has not been
+                // added already. This is a workaround for the session getting
+                // created due to a presence update to announce a "pending"
+                // recording being received before JibriSession#start finishes.
+                if (!this.getSession(session.getID())) {
+                    this._addSession(session);
+                    this._emitSessionUpdate(session);
+                }
+
+                return session;
+            })
+            .catch(error => {
+                this._emitSessionUpdate(session);
+
+                return Promise.reject(error);
+            });
+    },
+
+    /**
+     * Stop a recording session.
+     *
+     * @param {string} sessionID - The ID associated with the recording session
+     * to be stopped.
+     * @returns {Promise} The promise resolves after receiving an
+     * acknowledgment of the stop request success or fail.
+     */
+    stopRecording(sessionID) {
+        const session = this.getSession(sessionID);
+
+        if (session) {
+            return session.stop({ focusMucJid: this._focusMucJid });
+        }
+
+        return Promise.reject(new Error('Could not find session'));
+    },
+
+    /**
+     * Stores a reference to the passed in JibriSession.
+     *
+     * @param {string} session - The JibriSession instance to store.
+     * @returns {void}
+     */
+    _addSession(session) {
+        this._sessions[session.getID()] = session;
+    },
+
+    /**
+     * Create a new instance of a recording session and stores a reference to
+     * it.
+     *
+     * @param {string} sessionID - The session ID of the recording in progress.
+     * @param {string} status - The current status of the recording session.
+     * @param {string} mode - The recording mode of the session.
+     * @returns {JibriSession}
+     */
+    _createSession(sessionID, status, mode) {
+        const session = new JibriSession({
+            connection: this._connection,
+            focusMucJid: this._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);
+    },
+
+    /**
+     * Parses presence to update an existing JibriSession or to create a new
+     * JibriSession.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {void}
+     */
+    _handleFocusPresence(presence) {
+        const jibriStatus = recordingXMLUtils.getFocusRecordingUpdate(presence);
+
+        if (!jibriStatus) {
+            return;
+        }
+
+        const { sessionID, status, error, recordingMode } = 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).
+        let session = this.getSession(sessionID);
+
+        // Handle the case where a status update is received in presence but
+        // the local participant has joined while the JibriSession has already
+        // ended.
+        if (!session && status === 'off') {
+            logger.warn(
+                'Ignoring recording presence update',
+                'Received a new session with status off.');
+
+            return;
+        }
+
+        if (!session) {
+            session = this._createSession(sessionID, status, recordingMode);
+        }
+
+        session.setStatus(status);
+
+        if (error) {
+            session.setError(error);
+        }
+
+        this._emitSessionUpdate(session);
+    },
+
+    /**
+     * Handles updates from the Jibri which can broadcast a YouTube URL that
+     * needs to be updated in a JibriSession.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {void}
+     */
+    _handleJibriPresence(presence) {
+        const { liveStreamViewURL, mode, sessionID }
+            = recordingXMLUtils.getHiddenDomainUpdate(presence);
+
+        if (!sessionID) {
+            logger.warn(
+                'Ignoring potential jibri presence due to no session id.');
+
+            return;
+        }
+
+        let session = this.getSession(sessionID);
+
+        if (!session) {
+            session = this._createSession(sessionID, '', mode);
+        }
+
+        session.setLiveStreamViewURL(liveStreamViewURL);
+
+        this._emitSessionUpdate(session);
+    }
+};
+
+export default recordingManager;

modules/recording/recordingXMLUtils.js

@@ -0,0 +1,93 @@
+/**
+ * A collection of utility functions for taking in XML and parsing it to return
+ * certain values.
+ */
+export default {
+    /**
+     * Parses the presence update of the focus and returns an object with the
+     * statuses related to recording.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {Object} The current presence values related to recording.
+     */
+    getFocusRecordingUpdate(presence) {
+        const jibriStatus = presence
+            && presence.getElementsByTagName('jibri-recording-status')[0];
+
+        if (!jibriStatus) {
+            return;
+        }
+
+        return {
+            error: jibriStatus.getAttribute('failure_reason'),
+            recordingMode: jibriStatus.getAttribute('recording_mode'),
+            sessionID: jibriStatus.getAttribute('session_id'),
+            status: jibriStatus.getAttribute('status')
+        };
+    },
+
+    /**
+     * Parses the presence update from a hidden domain participant and returns
+     * an object with the statuses related to recording.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {Object} The current presence values related to recording.
+     */
+    getHiddenDomainUpdate(presence) {
+        const liveStreamViewURLContainer
+            = presence.getElementsByTagName('live-stream-view-url')[0];
+        const liveStreamViewURL = liveStreamViewURLContainer
+            && liveStreamViewURLContainer.textContent;
+        const modeContainer
+            = presence.getElementsByTagName('mode')[0];
+        const mode = modeContainer
+            && modeContainer.textContent
+            && modeContainer.textContent.toLowerCase();
+        const sessionIDContainer
+            = presence.getElementsByTagName('session_id')[0];
+        const sessionID
+            = sessionIDContainer && sessionIDContainer.textContent;
+
+        return {
+            liveStreamViewURL,
+            mode,
+            sessionID
+        };
+    },
+
+    /**
+     * Returns the recording session ID from a successful IQ.
+     *
+     * @param {Node} response - The response from the IQ.
+     * @returns {string} The session ID of the recording session.
+     */
+    getSessionIdFromIq(response) {
+        const jibri = response && response.getElementsByTagName('jibri')[0];
+
+        return jibri && jibri.getAttribute('session_id');
+    },
+
+    /**
+     * Returns the recording session ID from a presence, if it exists.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {string|undefined} The session ID of the recording session.
+     */
+    getSessionId(presence) {
+        const sessionIdContainer
+            = presence.getElementsByTagName('session_id')[0];
+        const sessionId = sessionIdContainer && sessionIdContainer.textContent;
+
+        return sessionId;
+    },
+
+    /**
+     * Returns whether or not a presence is from the focus.
+     *
+     * @param {Node} presence - An XMPP presence update.
+     * @returns {boolean} True if the presence is from the focus.
+     */
+    isFromFocus(presence) {
+        return presence.getAttribute('from').includes('focus');
+    }
+};

modules/videosipgw/JitsiVideoSIPGWSession.js

@@ -81,8 +81,11 @@ export default class JitsiVideoSIPGWSession extends Listenable {
      * Changes the state of this session.
      *
      * @param {string} newState - The new {VideoSIPGWConstants} state to set.
+     * @param {string} [optional] failureReason - The reason why a failure state
+     * was entered.
+     * @returns {void}
      */
-    setState(newState) {
+    setState(newState, failureReason) {
         if (newState === this.state) {
             return;
         }
@@ -93,6 +96,7 @@ export default class JitsiVideoSIPGWSession extends Listenable {
         this.eventEmitter.emit(STATE_CHANGED,
             {
                 address: this.sipAddress,
+                failureReason,
                 oldState,
                 newState: this.state,
                 displayName: this.displayName

modules/videosipgw/VideoSIPGW.js

@@ -26,39 +26,10 @@ export default class VideoSIPGW {
         // VideoSIPGW, JitsiConference and ChatRoom are not reusable and no
         // more than one VideoSIPGW can be created per JitsiConference,
         // so we don't bother to cleanup
-        chatRoom.addPresenceListener('jibri-sip-status',
-            this.handleJibriSIPStatus.bind(this));
         chatRoom.addPresenceListener('jibri-sip-call-state',
             this.handleJibriSIPState.bind(this));
     }
 
-    /**
-     * Handles presence nodes with name: jibri-sip-status.
-     *
-     * @param {Object} node the presence node Object to handle.
-     * Object representing part of the presence received over xmpp.
-     */
-    handleJibriSIPStatus(node) {
-        const attributes = node.attributes;
-
-        if (!attributes) {
-            return;
-        }
-
-        logger.debug('Handle video sip gw status : ', attributes);
-        const newStatus = attributes.status;
-
-        // check for global availability of the service
-        if (newStatus !== this.status
-            && (newStatus === Constants.STATUS_UNDEFINED
-                || newStatus === Constants.STATUS_AVAILABLE
-                || newStatus === Constants.STATUS_BUSY)) {
-            this.status = newStatus;
-            this.eventEmitter.emit(
-                XMPPEvents.VIDEO_SIP_GW_AVAILABILITY_CHANGED, this.status);
-        }
-    }
-
     /**
      * Handles presence nodes with name: jibri-sip-call-state.
      *
@@ -96,7 +67,7 @@ export default class VideoSIPGW {
             const session = this.sessions[address];
 
             if (session) {
-                session.setState(newState);
+                session.setState(newState, attributes.failure_reason);
             } else {
                 logger.warn('Video SIP GW session not found:', address);
             }

modules/xmpp/ChatRoom.js

@@ -6,12 +6,12 @@ import { $iq, $msg, $pres, Strophe } from 'strophe.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';
 
 import Moderator from './moderator';
-import Recorder from './recording';
 
 const logger = getLogger(__filename);
 
@@ -172,6 +172,11 @@ export default class ChatRoom extends Listenable {
 
         this.locked = false;
         this.transcriptionStatus = JitsiTranscriptionStatus.OFF;
+
+        recordingManager.init(
+            this.eventEmitter,
+            this.connection,
+            this.focusMucJid);
     }
 
     /* eslint-enable max-params */
@@ -419,17 +424,7 @@ export default class ChatRoom extends Listenable {
                 && this.options.hiddenDomain
                     === jid.substring(jid.indexOf('@') + 1, jid.indexOf('/'));
 
-        // Check isHiddenDomain as a way to verify a live stream URL is from a
-        // trusted source. This prevents users from trying to display arbitrary
-        // live stream URLs.
-        if (member.isHiddenDomain) {
-            const liveStreamViewURLItem
-                = pres.getElementsByTagName('live-stream-view-url')[0];
-
-            if (liveStreamViewURLItem) {
-                member.liveStreamViewURL = liveStreamViewURLItem.textContent;
-            }
-        }
+        recordingManager.onPresence(pres, member.isHiddenDomain);
 
         const xEl = pres.querySelector('x');
 
@@ -441,7 +436,6 @@ export default class ChatRoom extends Listenable {
 
         parser.packet2JSON(pres, nodes);
         this.lastPresences[from] = nodes;
-        let jibri = null;
 
         // process nodes to extract data needed for MUC_JOINED and
         // MUC_MEMBER_JOINED events
@@ -530,13 +524,6 @@ export default class ChatRoom extends Listenable {
                     member.status,
                     member.identity);
 
-                if (member.liveStreamViewURL) {
-                    this.eventEmitter.emit(
-                        XMPPEvents.LIVE_STREAM_URL_CHANGE,
-                        from,
-                        member.liveStreamViewURL);
-                }
-
                 // we are reporting the status with the join
                 // so we do not want a second event about status update
                 hasStatusUpdate = false;
@@ -576,15 +563,6 @@ export default class ChatRoom extends Listenable {
                 hasStatusUpdate = true;
                 memberOfThis.status = member.status;
             }
-
-            if (memberOfThis.liveStreamViewURL !== member.liveStreamViewURL) {
-                memberOfThis.liveStreamViewURL = member.liveStreamViewURL;
-                this.eventEmitter.emit(
-                    XMPPEvents.LIVE_STREAM_URL_CHANGE,
-                    from,
-                    member.liveStreamViewURL);
-            }
-
         }
 
         // after we had fired member or room joined events, lets fire events
@@ -614,9 +592,6 @@ export default class ChatRoom extends Listenable {
                     this.eventEmitter.emit(XMPPEvents.BRIDGE_DOWN);
                 }
                 break;
-            case 'jibri-recording-status':
-                jibri = node;
-                break;
             case 'transcription-status': {
                 const { attributes } = node;
 
@@ -660,13 +635,6 @@ export default class ChatRoom extends Listenable {
                 from,
                 member.status);
         }
-
-        if (jibri) {
-            this.lastJibri = jibri;
-            if (this.recording) {
-                this.recording.handleJibriPresence(jibri);
-            }
-        }
     }
 
     /**
@@ -676,14 +644,9 @@ export default class ChatRoom extends Listenable {
      */
     _initFocus(from, mucJid) {
         this.focusMucJid = from;
-        if (!this.recording) {
-            this.recording = new Recorder(this.options.recordingType,
-                this.eventEmitter, this.connection, this.focusMucJid,
-                this.options.jirecon, this.roomjid);
-            if (this.lastJibri) {
-                this.recording.handleJibriPresence(this.lastJibri);
-            }
-        }
+
+        recordingManager.setFocusMucJid(this.focusMucJid);
+
         logger.info(`Ignore focus: ${from}, real JID: ${mucJid}`);
     }
 
@@ -840,13 +803,6 @@ export default class ChatRoom extends Listenable {
         const membersKeys = Object.keys(this.members);
 
         if (!isSelfPresence) {
-            if (this.members[from].liveStreamViewURL) {
-                this.eventEmitter.emit(
-                    XMPPEvents.LIVE_STREAM_URL_CHANGE,
-                    from,
-                    undefined);
-            }
-
             delete this.members[from];
             this.onParticipantLeft(from, false);
         } else if (membersKeys.length > 0) {
@@ -1300,44 +1256,27 @@ export default class ChatRoom extends Listenable {
     }
 
     /**
-     * Returns true if the recording is supproted and false if not.
-     */
-    isRecordingSupported() {
-        if (this.recording) {
-            return this.recording.isSupported();
-        }
-
-        return false;
-    }
-
-    /**
-     * Returns null if the recording is not supported, "on" if the recording
-     * started and "off" if the recording is not started.
-     */
-    getRecordingState() {
-        return this.recording ? this.recording.getState() : undefined;
-    }
-
-    /**
-     * Returns the url of the recorded video.
+     * 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.
      */
-    getRecordingURL() {
-        return this.recording ? this.recording.getURL() : null;
+    startRecording(options) {
+        return recordingManager.startRecording(options);
     }
 
     /**
-     * Starts/stops the recording
-     * @param token token for authentication
-     * @param statusChangeHandler {function} receives the new status as
-     * argument.
+     * 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.
      */
-    toggleRecording(options, statusChangeHandler) {
-        if (this.recording) {
-            return this.recording.toggleRecording(options, statusChangeHandler);
-        }
-
-        return statusChangeHandler('error',
-            new Error('The conference is not created yet!'));
+    stopRecording(sessionID) {
+        return recordingManager.stopRecording(sessionID);
     }
 
     /**

modules/xmpp/recording.js

@@ -1,433 +0,0 @@
-/* global $ */
-
-import { getLogger } from 'jitsi-meet-logger';
-import { $iq } from 'strophe.js';
-
-const XMPPEvents = require('../../service/xmpp/XMPPEvents');
-const JitsiRecorderErrors = require('../../JitsiRecorderErrors');
-const GlobalOnErrorHandler = require('../util/GlobalOnErrorHandler');
-
-const logger = getLogger(__filename);
-
-/**
- * Extracts the error details from given error element/node.
- *
- * @param {Element|Object} errorIqNode - Either DOM element or the structure
- * from ChatRoom packet2JSON.
- * @return {{
- *     code: string,
- *     type: string,
- *     message: string
- * }}
- */
-function getJibriErrorDetails(errorIqNode) {
-    if (typeof errorIqNode.querySelector === 'function') {
-        const error = errorIqNode.querySelector('error');
-        const errorText = error && error.querySelector('text');
-
-        return error && {
-            code: error.attributes.code && error.attributes.code.value,
-            type: error.attributes.type && error.attributes.type.value,
-            message: errorText && errorText.textContent
-        };
-    }
-
-    let error = null;
-
-    for (const child of errorIqNode.children) {
-        if (child.tagName === 'error') {
-            error = child;
-            break;
-        }
-    }
-
-    if (!error) {
-        return null;
-    }
-
-    let errorText = null;
-
-    for (const errorChild of error.children) {
-        if (errorChild.tagName === 'text') {
-            errorText = errorChild.value;
-            break;
-        }
-    }
-
-    return {
-        code: error.attributes.code,
-        type: error.attributes.type,
-        message: errorText
-    };
-}
-
-/* eslint-disable max-params */
-
-/**
- *
- * @param type
- * @param eventEmitter
- * @param connection
- * @param focusMucJid
- * @param jirecon
- * @param roomjid
- */
-export default function Recording(
-        type,
-        eventEmitter,
-        connection,
-        focusMucJid,
-        jirecon,
-        roomjid) {
-    this.eventEmitter = eventEmitter;
-    this.connection = connection;
-    this.state = null;
-    this.focusMucJid = focusMucJid;
-    this.jirecon = jirecon;
-    this.url = null;
-    this.type = type;
-    this._isSupported
-        = !(
-            (type === Recording.types.JIRECON && !this.jirecon)
-                || (type !== Recording.types.JIBRI
-                    && type !== Recording.types.JIBRI_FILE
-                    && type !== Recording.types.COLIBRI));
-
-    /**
-     * The ID of the jirecon recording session. Jirecon generates it when we
-     * initially start recording, and it needs to be used in subsequent requests
-     * to jirecon.
-     */
-    this.jireconRid = null;
-    this.roomjid = roomjid;
-}
-
-/* eslint-enable max-params */
-
-Recording.types = {
-    COLIBRI: 'colibri',
-    JIRECON: 'jirecon',
-    JIBRI: 'jibri',
-    JIBRI_FILE: 'jibri_file'
-};
-
-Recording.status = {
-    ON: 'on',
-    OFF: 'off',
-    AVAILABLE: 'available',
-    UNAVAILABLE: 'unavailable',
-    PENDING: 'pending',
-    RETRYING: 'retrying',
-    ERROR: 'error',
-    BUSY: 'busy',
-    FAILED: 'failed'
-};
-
-Recording.action = {
-    START: 'start',
-    STOP: 'stop'
-};
-
-Recording.prototype.handleJibriPresence = function(jibri) {
-    const attributes = jibri.attributes;
-
-    if (!attributes) {
-        return;
-    }
-
-    const newState = attributes.status;
-    const errorDetails = getJibriErrorDetails(jibri);
-
-    logger.log(`Handle Jibri presence : ${newState}`, errorDetails);
-
-    if (newState === this.state) {
-        return;
-    }
-
-    if (newState === 'undefined') {
-        this.state = Recording.status.UNAVAILABLE;
-    } else if (newState === Recording.status.OFF) {
-        if (!this.state
-            || this.state === 'undefined'
-            || this.state === Recording.status.UNAVAILABLE) {
-            this.state = Recording.status.AVAILABLE;
-        } else {
-            this.state = Recording.status.OFF;
-        }
-    } else {
-        this.state = newState;
-    }
-
-    this.eventEmitter.emit(XMPPEvents.RECORDER_STATE_CHANGED, this.state);
-};
-
-/* eslint-disable max-params */
-
-Recording.prototype.setRecordingJibri = function(
-        state,
-        callback,
-        errCallback,
-        options = {}) {
-    if (state === this.state) {
-        errCallback(JitsiRecorderErrors.INVALID_STATE);
-    }
-
-    // FIXME jibri does not accept IQ without 'url' attribute set ?
-    const iq
-        = $iq({
-            to: this.focusMucJid,
-            type: 'set'
-        })
-            .c('jibri', {
-                'xmlns': 'http://jitsi.org/protocol/jibri',
-                'action':
-                    state === Recording.status.ON
-                        ? Recording.action.START
-                        : Recording.action.STOP,
-                'recording_mode':
-                    this.type === Recording.types.JIBRI_FILE
-                        ? 'file'
-                        : 'stream',
-                'streamid':
-                    this.type === Recording.types.JIBRI
-                        ? options.streamId
-                        : undefined,
-                'you_tube_broadcast_id': options.broadcastId
-            })
-            .up();
-
-    logger.log(`Set jibri recording: ${state}`, iq.nodeTree);
-    logger.log(iq.nodeTree);
-    this.connection.sendIQ(
-        iq,
-        result => {
-            logger.log('Result', result);
-
-            const jibri = $(result).find('jibri');
-
-            callback(jibri.attr('state'), jibri.attr('url'));
-        },
-        error => {
-            logger.log(
-                'Failed to start recording, error: ',
-                getJibriErrorDetails(error));
-            errCallback(error);
-        });
-};
-
-/* eslint-enable max-params */
-
-Recording.prototype.setRecordingJirecon
-    = function(state, callback, errCallback) {
-        if (state === this.state) {
-            errCallback(new Error('Invalid state!'));
-        }
-
-        const iq
-            = $iq({
-                to: this.jirecon,
-                type: 'set'
-            })
-                .c('recording', { xmlns: 'http://jitsi.org/protocol/jirecon',
-                    action: state === Recording.status.ON
-                        ? Recording.action.START
-                        : Recording.action.STOP,
-                    mucjid: this.roomjid });
-
-        if (state === Recording.status.OFF) {
-            iq.attrs({ rid: this.jireconRid });
-        }
-
-        logger.log('Start recording');
-        const self = this;
-
-        this.connection.sendIQ(
-            iq,
-            result => {
-                // TODO wait for an IQ with the real status, since this is
-                // provisional?
-                // eslint-disable-next-line newline-per-chained-call
-                self.jireconRid = $(result).find('recording').attr('rid');
-
-                const stateStr
-                    = state === Recording.status.ON ? 'started' : 'stopped';
-
-                logger.log(`Recording ${stateStr}(jirecon)${result}`);
-
-                self.state = state;
-                if (state === Recording.status.OFF) {
-                    self.jireconRid = null;
-                }
-
-                callback(state);
-            },
-            error => {
-                logger.log('Failed to start recording, error: ', error);
-                errCallback(error);
-            });
-    };
-
-/* eslint-disable max-params */
-
-// Sends a COLIBRI message which enables or disables (according to 'state')
-// the recording on the bridge. Waits for the result IQ and calls 'callback'
-// with the new recording state, according to the IQ.
-Recording.prototype.setRecordingColibri = function(
-        state,
-        callback,
-        errCallback,
-        options) {
-    const elem = $iq({
-        to: this.focusMucJid,
-        type: 'set'
-    });
-
-    elem.c('conference', {
-        xmlns: 'http://jitsi.org/protocol/colibri'
-    });
-    elem.c('recording', {
-        state,
-        token: options.token
-    });
-
-    const self = this;
-
-    this.connection.sendIQ(
-        elem,
-        result => {
-            logger.log('Set recording "', state, '". Result:', result);
-            const recordingElem = $(result).find('>conference>recording');
-            const newState = recordingElem.attr('state');
-
-            self.state = newState;
-            callback(newState);
-
-            if (newState === 'pending') {
-                self.connection.addHandler(iq => {
-                    // eslint-disable-next-line newline-per-chained-call
-                    const s = $(iq).find('recording').attr('state');
-
-                    if (s) {
-                        self.state = newState;
-                        callback(s);
-                    }
-                }, 'http://jitsi.org/protocol/colibri', 'iq', null, null, null);
-            }
-        },
-        error => {
-            logger.warn(error);
-            errCallback(error);
-        }
-    );
-};
-
-/* eslint-enable max-params */
-
-Recording.prototype.setRecording = function(...args) {
-    switch (this.type) {
-    case Recording.types.JIRECON:
-        this.setRecordingJirecon(...args);
-        break;
-    case Recording.types.COLIBRI:
-        this.setRecordingColibri(...args);
-        break;
-    case Recording.types.JIBRI:
-    case Recording.types.JIBRI_FILE:
-        this.setRecordingJibri(...args);
-        break;
-    default: {
-        const errmsg = 'Unknown recording type!';
-
-        GlobalOnErrorHandler.callErrorHandler(new Error(errmsg));
-        logger.error(errmsg);
-        break;
-    }
-    }
-};
-
-/**
- * Starts/stops the recording.
- * @param {Object} options
- * @param {string} options.token token for authentication
- * @param {string} options.streamId the stream ID to be used with Jibri in
- * the streaming mode.
- * @param statusChangeHandler {function} receives the new status as argument.
- */
-Recording.prototype.toggleRecording = function(
-        options = { },
-        statusChangeHandler) {
-    const oldState = this.state;
-
-    // If the recorder is currently unavailable we throw an error.
-    if (oldState === Recording.status.UNAVAILABLE
-        || oldState === Recording.status.FAILED) {
-        statusChangeHandler(
-            Recording.status.FAILED,
-            JitsiRecorderErrors.RECORDER_UNAVAILABLE);
-    } else if (oldState === Recording.status.BUSY) {
-        statusChangeHandler(
-            Recording.status.BUSY,
-            JitsiRecorderErrors.RECORDER_BUSY);
-    }
-
-    // If we're about to turn ON the recording we need either a streamId or
-    // an authentication token depending on the recording type. If we don't
-    // have any of those we throw an error.
-    if ((oldState === Recording.status.OFF
-                || oldState === Recording.status.AVAILABLE)
-            && ((!options.token && this.type === Recording.types.COLIBRI)
-                || (!options.streamId
-                    && this.type === Recording.types.JIBRI))) {
-        statusChangeHandler(
-            Recording.status.FAILED,
-            JitsiRecorderErrors.NO_TOKEN);
-        logger.error('No token passed!');
-
-        return;
-    }
-
-    const newState
-        = oldState === Recording.status.AVAILABLE
-                || oldState === Recording.status.OFF
-            ? Recording.status.ON
-            : Recording.status.OFF;
-
-    const self = this;
-
-    logger.log('Toggle recording (old state, new state): ', oldState, newState);
-    this.setRecording(
-        newState,
-        (state, url) => {
-            // If the state is undefined we're going to wait for presence
-            // update.
-            if (state && state !== oldState) {
-                self.state = state;
-                self.url = url;
-                statusChangeHandler(state);
-            }
-        },
-        error => statusChangeHandler(Recording.status.FAILED, error),
-        options);
-};
-
-/**
- * Returns true if the recording is supproted and false if not.
- */
-Recording.prototype.isSupported = function() {
-    return this._isSupported;
-};
-
-/**
- * Returns null if the recording is not supported, "on" if the recording started
- * and "off" if the recording is not started.
- */
-Recording.prototype.getState = function() {
-    return this.state;
-};
-
-/**
- * Returns the url of the recorded video.
- */
-Recording.prototype.getURL = function() {
-    return this.url;
-};

service/xmpp/XMPPEvents.js

@@ -90,10 +90,6 @@ const XMPPEvents = {
     // Designates an event indicating that we were kicked from the XMPP MUC.
     KICKED: 'xmpp.kicked',
 
-    // Designates an event indicating that a participant's live stream URL has
-    // been updated.
-    LIVE_STREAM_URL_CHANGE: 'xmpp.live_stream_url_changed',
-
     // Designates an event indicating that our role in the XMPP MUC has changed.
     LOCAL_ROLE_CHANGED: 'xmpp.localrole_changed',