Merge pull request #90 from jitsi/fix-recorder-states

Fix jibri presence initial state

JitsiConference.js

  * and "off" if the recording is not started.
  */
 JitsiConference.prototype.getRecordingState = function () {
-    if(this.room)
-        return this.room.getRecordingState();
-    return Recording.status.OFF;
+    return (this.room) ? this.room.getRecordingState() : undefined;
 }
 
 /**
  * Returns the url of the recorded video.
  */
 JitsiConference.prototype.getRecordingURL = function () {
-    if(this.room)
-        return this.room.getRecordingURL();
-    return null;
+    return (this.room) ? this.room.getRecordingURL() : null;
 }
 
 /**

modules/xmpp/ChatRoom.js

  * and "off" if the recording is not started.
  */
 ChatRoom.prototype.getRecordingState = function () {
-    if(this.recording)
-        return this.recording.getState();
-    return "off";
-};
+    return (this.recording) ? this.recording.getState() : undefined;
+}
 
 /**
  * Returns the url of the recorded video.
  */
 ChatRoom.prototype.getRecordingURL = function () {
-    if(this.recording)
-        return this.recording.getURL();
-    return null;
-};
+    return (this.recording) ? this.recording.getURL() : null;
+}
 
 /**
  * Starts/stops the recording

modules/xmpp/recording.js

     this.type = type;
     this._isSupported
         = ( type === Recording.types.JIRECON && !this.jirecon
-            || type === Recording.types.JIBRI && !this._isServiceAvailable)
+            || (type !== Recording.types.JIBRI
+                && type !== Recording.types.COLIBRI))
             ? false : true;
 
-    this._isServiceAvailable = false;
-
     /**
      * The ID of the jirecon recording session. Jirecon generates it when we
      * initially start recording, and it needs to be used in subsequent requests
         return;
 
     var newState = attributes.status;
-    console.log("handle jibri presence : ", newState);
-    var oldIsAvailable = this._isServiceAvailable;
-    // The service is available if the statu isn't undefined.
-    this._isServiceAvailable =
-        (newState && newState !== "undefined");
-
-    if (newState === "undefined"
-        || oldIsAvailable != this._isServiceAvailable
-        // If we receive an OFF state without any recording in progress we
-        // consider this to be an initial available state.
-        || (this.state === Recording.status.AVAILABLE
-            && newState === Recording.status.OFF))
-        this.state = (newState === "undefined")
-                        ? Recording.status.UNAVAILABLE
-                        : Recording.status.AVAILABLE;
-    else
-        this.state = attributes.status;
-
-    logger.log("Handle Jibri presence: ", this.state);
+    logger.log("Handle jibri presence : ", newState);
+
+    if (newState === this.state)
+        return;
+
+    if (newState === "undefined") {
+        this.state = Recording.status.UNAVAILABLE;
+    }
+    else if (newState === "off") {
+        this.state = Recording.status.AVAILABLE;
+    }
+    else {
+        this.state = newState;
+    }
 
     this.eventEmitter.emit(XMPPEvents.RECORDER_STATE_CHANGED, this.state);
 };
             // TODO wait for an IQ with the real status, since this is
             // provisional?
             self.jireconRid = $(result).find('recording').attr('rid');
-            console.log('Recording ' +
+            logger.log('Recording ' +
                 ((state === Recording.status.ON) ? 'started' : 'stopped') +
                 '(jirecon)' + result);
             self.state = state;
             callback(state);
         },
         function (error) {
-            console.log('Failed to start recording, error: ', error);
+            logger.log('Failed to start recording, error: ', error);
             errCallback(error);
         });
 };
     var self = this;
     this.connection.sendIQ(elem,
         function (result) {
-            console.log('Set recording "', state, '". Result:', result);
+            logger.log('Set recording "', state, '". Result:', result);
             var recordingElem = $(result).find('>conference>recording');
             var newState = recordingElem.attr('state');
 
             }
         },
         function (error) {
-            console.warn(error);
+            logger.warn(error);
             errCallback(error);
         }
     );
             this.setRecordingJibri(state, callback, errCallback, options);
             break;
         default:
-            console.error("Unknown recording type!");
+            logger.error("Unknown recording type!");
             return;
     }
 };