Fix recorder error and state handling

conference.js

 
 import ConnectionQuality from './modules/connectionquality/connectionquality';
 
+import Recorder from './modules/recorder/Recorder';
+
 import CQEvents from './service/connectionquality/CQEvents';
 import UIEvents from './service/UI/UIEvents';
 
                     devices => APP.UI.onAvailableDevicesChanged(devices)
                 );
             }
+            if (config.iAmRecorder)
+                this.recorder = new Recorder();
+
             // XXX The API will take care of disconnecting from the XMPP server
             // (and, thus, leaving the room) on unload.
             return new Promise((resolve, reject) => {
          * @param command {String} the name of the command
          * @param handler {Function} handler for the command
          */
-            addCommandListener () {
+        addCommandListener () {
             room.addCommandListener.apply(room, arguments);
         },
         /**
          * Removes command.
          * @param name {String} the name of the command.
          */
-            removeCommand () {
+        removeCommand () {
             room.removeCommand.apply(room, arguments);
         },
         /**
          * @param name {String} the name of the command.
          * @param values {Object} with keys and values that will be sent.
          */
-            sendCommand () {
+        sendCommand () {
             room.sendCommand.apply(room, arguments);
         },
         /**
          * @param name {String} the name of the command.
          * @param values {Object} with keys and values that will be sent.
          */
-            sendCommandOnce () {
+        sendCommandOnce () {
             room.sendCommandOnce.apply(room, arguments);
         }
     },
 
         room.on(ConferenceEvents.RECORDER_STATE_CHANGED, (status, error) => {
             console.log("Received recorder status change: ", status, error);
-            if(status == "error") {
-                console.error(error);
-                return;
-            }
             APP.UI.updateRecordingState(status);
         });
 

lang/main.json

         "on": "Recording",
         "off": "Recording stopped",
         "failedToStart": "Recording failed to start",
-        "buttonTooltip": "Start / stop recording"
+        "buttonTooltip": "Start / stop recording",
+        "error": "Recording failed. Please try again."
     },
     "liveStreaming":
     {
         "unavailable": "The live streaming service is currently unavailable. Please try again later.",
         "failedToStart": "Live streaming failed to start",
         "buttonTooltip": "Start / stop live stream",
-        "streamIdRequired": "Please fill in the stream id in order to launch the live streaming."
+        "streamIdRequired": "Please fill in the stream id in order to launch the live streaming.",
+        "error": "Live streaming failed. Please try again"
     }
 }

modules/UI/recording/Recording.js

     OFF: "off",
     AVAILABLE: "available",
     UNAVAILABLE: "unavailable",
-    PENDING: "pending"
+    PENDING: "pending",
+    ERROR: "error"
 };
 
 /**
             this.recordingOffKey = "liveStreaming.off";
             this.recordingPendingKey = "liveStreaming.pending";
             this.failedToStartKey = "liveStreaming.failedToStart";
+            this.recordingErrorKey = "liveStreaming.error";
             this.recordingButtonTooltip = "liveStreaming.buttonTooltip";
         }
         else {
             this.recordingOffKey = "recording.off";
             this.recordingPendingKey = "recording.pending";
             this.failedToStartKey = "recording.failedToStart";
+            this.recordingErrorKey = "recording.error";
             this.recordingButtonTooltip = "recording.buttonTooltip";
         }
 
      */
     updateRecordingUI (recordingState) {
         let buttonSelector = $('#toolbar_button_record');
-        let labelSelector = $('#recordingLabel');
 
         // TODO: handle recording state=available
         if (recordingState === Status.ON) {
             buttonSelector.removeClass(this.baseClass);
             buttonSelector.addClass(this.baseClass + " active");
 
-            labelSelector.attr("data-i18n", this.recordingOnKey);
-            moveToCorner(labelSelector, true, 3000);
-            labelSelector
-                .text(APP.translation.translateString(this.recordingOnKey));
-        } else if (recordingState === Status.OFF
-                    || recordingState === Status.UNAVAILABLE) {
+            this._updateStatusLabel(this.recordingOnKey, false);
+        }
+        else if (recordingState === Status.OFF
+                || recordingState === Status.UNAVAILABLE) {
 
             // We don't want to do any changes if this is
             // an availability change.
             buttonSelector.removeClass(this.baseClass + " active");
             buttonSelector.addClass(this.baseClass);
 
-            moveToCorner(labelSelector, false);
             let messageKey;
             if (this.currentState === Status.PENDING)
                 messageKey = this.failedToStartKey;
             else
                 messageKey = this.recordingOffKey;
 
-            labelSelector.attr("data-i18n", messageKey);
-            labelSelector.text(APP.translation.translateString(messageKey));
+            this._updateStatusLabel(messageKey, true);
 
             setTimeout(function(){
                 $('#recordingLabel').css({display: "none"});
             buttonSelector.removeClass(this.baseClass + " active");
             buttonSelector.addClass(this.baseClass);
 
-            moveToCorner(labelSelector, false);
-            labelSelector
-                .attr("data-i18n", this.recordingPendingKey);
-            labelSelector
-                .text(APP.translation.translateString(
-                    this.recordingPendingKey));
+            this._updateStatusLabel(this.recordingPendingKey, true);
+        }
+        else if (recordingState === Status.ERROR) {
+            buttonSelector.removeClass(this.baseClass + " active");
+            buttonSelector.addClass(this.baseClass);
+
+            this._updateStatusLabel(this.recordingErrorKey, true);
         }
 
         this.currentState = recordingState;
 
+        let labelSelector = $('#recordingLabel');
+
         // We don't show the label for available state.
         if (recordingState !== Status.AVAILABLE
             && !labelSelector.is(":visible"))
             this.eventEmitter.emit(UIEvents.RECORDING_TOGGLED,
                                     this.predefinedToken);
         }
+    },
+    /**
+     * Updates the status label.
+     * @param textKey the text to show
+     * @param isCentered indicates if the label should be centered on the window
+     * or moved to the top right corner.
+     */
+    _updateStatusLabel(textKey, isCentered) {
+        let labelSelector = $('#recordingLabel');
+
+        moveToCorner(labelSelector, !isCentered);
+
+        labelSelector.attr("data-i18n", textKey);
+        labelSelector.text(APP.translation.translateString(textKey));
     }
 };
 

modules/recorder/Recorder.js

+/* global APP, $, config */
+
+/**
+ * The (name of the) command which transports the recorder info.
+ */
+const _USER_INFO_COMMAND = "userinfo";
+
+/**
+ * The Recorder class is meant to take care of recorder related presence
+ * commands.
+ */
+class Recorder {
+    constructor() {
+        if (config.iAmRecorder)
+            this._sendRecorderInfo();
+    }
+
+    /**
+     * Sends the information that this is a recorder through the presence.
+     * @private
+     */
+    _sendRecorderInfo() {
+        var commands = APP.conference.commands;
+
+        // XXX The "Follow Me" command represents a snapshot of all states
+        // which are to be followed so don't forget to removeCommand before
+        // sendCommand!
+        commands.removeCommand(_USER_INFO_COMMAND);
+        var self = this;
+        commands.sendCommand(
+            _USER_INFO_COMMAND,
+            {
+                attributes: {
+                    xmlns: 'http://jitsi.org/jitmeet/userinfo',
+                    robot: true
+                }
+            });
+    }
+}
+
+export default Recorder;