Handle recording errors

conference.js

 const TrackEvents = JitsiMeetJS.events.track;
 const TrackErrors = JitsiMeetJS.errors.track;
 
+const RecorderErrors = JitsiMeetJS.errors.recorder;
+
 let room, connection, localAudio, localVideo, roomLocker;
 let currentAudioInputDevices, currentVideoInputDevices;
 
         if(JitsiMeetJS.getGlobalOnErrorHandler){
             var oldOnErrorHandler = window.onerror;
             window.onerror = function (message, source, lineno, colno, error) {
-
                 JitsiMeetJS.getGlobalOnErrorHandler(
                     message, source, lineno, colno, error);
 
 
         room.on(ConferenceEvents.RECORDER_STATE_CHANGED, (status, error) => {
             console.log("Received recorder status change: ", status, error);
-            APP.UI.updateRecordingState(status);
+            APP.UI.updateRecordingState(status, error);
         });
 
         room.on(ConferenceEvents.USER_STATUS_CHANGED, function (id, status) {

lang/main.json

         "off": "Recording stopped",
         "failedToStart": "Recording failed to start",
         "buttonTooltip": "Start / stop recording",
-        "error": "Recording failed. Please try again."
+        "error": "Recording failed. Please try again.",
+        "unavailable": "The recording service is currently unavailable. Please try again later."
     },
     "liveStreaming":
     {
         "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.",
-        "error": "Live streaming failed. Please try again"
+        "error": "Live streaming failed. Please try again.",
+        "busy": "All recorders are currently busy. Please try again later."
     }
 }

modules/UI/UI.js

     });
 };
 
-UI.updateRecordingState = function (state) {
-    Recording.updateRecordingState(state);
+UI.updateRecordingState = function (state, error) {
+    Recording.updateRecordingState(state, error);
 };
 
 UI.notifyTokenAuthFailed = function () {

modules/UI/recording/Recording.js

     AVAILABLE: "available",
     UNAVAILABLE: "unavailable",
     PENDING: "pending",
-    ERROR: "error"
+    ERROR: "error",
+    FAILED: "failed",
+    BUSY: "busy"
 };
 
 /**
 
         if (recordingType === 'jibri') {
             this.baseClass = "fa fa-play-circle";
+            this.recordingTitle = "dialog.liveStreaming";
             this.recordingOnKey = "liveStreaming.on";
             this.recordingOffKey = "liveStreaming.off";
             this.recordingPendingKey = "liveStreaming.pending";
             this.failedToStartKey = "liveStreaming.failedToStart";
             this.recordingErrorKey = "liveStreaming.error";
             this.recordingButtonTooltip = "liveStreaming.buttonTooltip";
+            this.recordingUnavailable = "liveStreaming.unavailable";
+            this.recordingBusy = "liveStreaming.busy";
         }
         else {
             this.baseClass = "icon-recEnable";
+            this.recordingTitle = "dialog.recording";
             this.recordingOnKey = "recording.on";
             this.recordingOffKey = "recording.off";
             this.recordingPendingKey = "recording.pending";
             this.failedToStartKey = "recording.failedToStart";
             this.recordingErrorKey = "recording.error";
             this.recordingButtonTooltip = "recording.buttonTooltip";
+            this.recordingUnavailable = "recording.unavailable";
+            this.recordingBusy = "liveStreaming.busy";
         }
 
         selector.addClass(this.baseClass);
                     }
                     break;
                 }
+                case Status.BUSY: {
+                    APP.UI.messageHandler.openMessageDialog(
+                        self.recordingTitle,
+                        self.recordingBusy
+                    );
+                    break;
+                }
                 default: {
                     APP.UI.messageHandler.openMessageDialog(
-                        "dialog.liveStreaming",
-                        "liveStreaming.unavailable"
+                        self.recordingTitle,
+                        self.recordingUnavailable
                     );
                 }
             }
      * Updates the recording state UI.
      * @param recordingState gives us the current recording state
      */
-    updateRecordingState(recordingState) {
+    updateRecordingState(recordingState, error) {
         // I'm the recorder, so I don't want to see any UI related to states.
         if (config.iAmRecorder)
             return;
         if (!recordingState || this.currentState === recordingState)
             return;
 
-        this.updateRecordingUI(recordingState);
+        this.updateRecordingUI(recordingState, error);
     },
 
     /**
      * Sets the state of the recording button.
      * @param recordingState gives us the current recording state
      */
-    updateRecordingUI (recordingState) {
+    updateRecordingUI (recordingState, error) {
         let buttonSelector = $('#toolbar_button_record');
 
+        let oldState = this.currentState;
+        this.currentState = recordingState;
+
         // TODO: handle recording state=available
         if (recordingState === Status.ON) {
 
             this._updateStatusLabel(this.recordingOnKey, false);
         }
         else if (recordingState === Status.OFF
-                || recordingState === Status.UNAVAILABLE) {
+                || recordingState === Status.UNAVAILABLE
+                || recordingState === Status.BUSY
+                || recordingState === Status.FAILED) {
 
             // We don't want to do any changes if this is
             // an availability change.
-            if (this.currentState !== Status.ON
-                && this.currentState !== Status.PENDING)
+            if (oldState !== Status.ON
+                && oldState !== Status.PENDING)
                 return;
 
             buttonSelector.removeClass(this.baseClass + " active");
             buttonSelector.addClass(this.baseClass);
 
             let messageKey;
-            if (this.currentState === Status.PENDING)
+            if (oldState === Status.PENDING)
                 messageKey = this.failedToStartKey;
             else
                 messageKey = this.recordingOffKey;
 
             this._updateStatusLabel(this.recordingPendingKey, true);
         }
-        else if (recordingState === Status.ERROR) {
+        else if (recordingState === Status.ERROR
+                    || recordingState === Status.FAILED) {
             buttonSelector.removeClass(this.baseClass + " active");
             buttonSelector.addClass(this.baseClass);
 
             this._updateStatusLabel(this.recordingErrorKey, true);
+            console.log("Recording failed for the following reason: ", error);
         }
 
-        this.currentState = recordingState;
-
         let labelSelector = $('#recordingLabel');
 
         // We don't show the label for available state.