Fixes JS error on unload

JitsiConference.js

@@ -1,4 +1,4 @@
-/* global Strophe, $, Promise */
+/* global Strophe, $ */
 /* jshint -W101 */
 var logger = require("jitsi-meet-logger").getLogger(__filename);
 var RTC = require("./modules/RTC/RTC");
@@ -6,7 +6,6 @@ var XMPPEvents = require("./service/xmpp/XMPPEvents");
 var RTCEvents = require("./service/RTC/RTCEvents");
 var EventEmitter = require("events");
 var JitsiConferenceEvents = require("./JitsiConferenceEvents");
-var JitsiConferenceErrors = require("./JitsiConferenceErrors");
 var JitsiParticipant = require("./JitsiParticipant");
 var Statistics = require("./modules/statistics/statistics");
 var JitsiDTMFManager = require('./modules/DTMF/JitsiDTMFManager');
@@ -52,13 +51,6 @@ JitsiConference.prototype.join = function (password) {
         this.room.join(password, this.connection.tokenPassword);
 };
 
-/**
- * Check if joined to the conference.
- */
-JitsiConference.prototype.isJoined = function () {
-    return this.room && this.room.joined;
-};
-
 /**
  * Leaves the conference.
  */
@@ -68,40 +60,6 @@ JitsiConference.prototype.leave = function () {
     this.room = null;
 };
 
-/**
- * Returns name of this conference.
- */
-JitsiConference.prototype.getName = function () {
-    return this.options.name;
-};
-
-/**
- * Check if external authentication is enabled for this conference.
- */
-JitsiConference.prototype.isExternalAuthEnabled = function () {
-    return this.room && this.room.moderator.isExternalAuthEnabled();
-};
-
-/**
- * Get url for external authentication.
- * @param {boolean} [urlForPopup] if true then return url for login popup,
- *                                else url of login page.
- * @returns {Promise}
- */
-JitsiConference.prototype.getExternalAuthUrl = function (urlForPopup) {
-    return new Promise(function (resolve, reject) {
-        if (!this.isExternalAuthEnabled()) {
-            reject();
-            return;
-        }
-        if (urlForPopup) {
-            this.room.moderator.getPopupLoginUrl(resolve, reject);
-        } else {
-            this.room.moderator.getLoginUrl(resolve, reject);
-        }
-    }.bind(this));
-};
-
 /**
  * Returns the local tracks.
  */
@@ -264,11 +222,6 @@ JitsiConference.prototype._fireMuteChangeEvent = function (track) {
  * @param track the JitsiLocalTrack object.
  */
 JitsiConference.prototype.removeTrack = function (track) {
-    if(!this.room){
-        if(this.rtc)
-            this.rtc.removeLocalStream(track);
-        return;
-    }
     this.room.removeStream(track.getOriginalStream(), function(){
         this.rtc.removeLocalStream(track);
         this.eventEmitter.emit(JitsiConferenceEvents.TRACK_REMOVED, track);
@@ -291,36 +244,6 @@ JitsiConference.prototype.isModerator = function () {
     return this.room.isModerator();
 };
 
-/**
- * Set password for the room.
- * @param {string} password new password for the room.
- * @returns {Promise}
- */
-JitsiConference.prototype.lock = function (password) {
-  if (!this.isModerator()) {
-    return Promise.reject();
-  }
-
-  var conference = this;
-  return new Promise(function (resolve, reject) {
-    conference.xmpp.lockRoom(password, function () {
-      resolve();
-    }, function (err) {
-      reject(err);
-    }, function () {
-      reject(JitsiConferenceErrors.PASSWORD_NOT_SUPPORTED);
-    });
-  });
-};
-
-/**
- * Remove password from the room.
- * @returns {Promise}
- */
-JitsiConference.prototype.unlock = function () {
-  return this.lock(undefined);
-};
-
 /**
  * Elects the participant with the given id to be the selected participant or the speaker.
  * @param id the identifier of the participant
@@ -362,13 +285,10 @@ JitsiConference.prototype.getParticipantById = function(id) {
 
 JitsiConference.prototype.onMemberJoined = function (jid, email, nick) {
     var id = Strophe.getResourceFromJid(jid);
-    if (id === 'focus') {
-       return;
-    }
     var participant = new JitsiParticipant(id, this, nick);
+    this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, id);
     this.participants[id] = participant;
-    this.eventEmitter.emit(JitsiConferenceEvents.USER_JOINED, id, participant);
-    this.xmpp.connection.disco.info(
+    this.connection.xmpp.connection.disco.info(
         jid, "node", function(iq) {
             participant._supportsDTMF = $(iq).find(
                 '>query>feature[var="urn:xmpp:jingle:dtmf:0"]').length > 0;
@@ -379,9 +299,8 @@ JitsiConference.prototype.onMemberJoined = function (jid, email, nick) {
 
 JitsiConference.prototype.onMemberLeft = function (jid) {
     var id = Strophe.getResourceFromJid(jid);
-    var participant = this.participants[id];
     delete this.participants[id];
-    this.eventEmitter.emit(JitsiConferenceEvents.USER_LEFT, id, participant);
+    this.eventEmitter.emit(JitsiConferenceEvents.USER_LEFT, id);
 };
 
 JitsiConference.prototype.onUserRoleChanged = function (jid, role) {
@@ -477,7 +396,7 @@ JitsiConference.prototype.myUserId = function () {
 
 JitsiConference.prototype.sendTones = function (tones, duration, pause) {
     if (!this.dtmfManager) {
-        var connection = this.xmpp.connection.jingle.activecall.peerconnection;
+        var connection = this.connection.xmpp.connection.jingle.activecall.peerconnection;
         if (!connection) {
             logger.warn("cannot sendTones: no conneciton");
             return;
@@ -497,13 +416,40 @@ JitsiConference.prototype.sendTones = function (tones, duration, pause) {
 };
 
 /**
- * Returns the connection state for the current room. Its ice connection state
- * for its session.
+ * Returns true if the recording is supproted and false if not.
  */
-JitsiConference.prototype.getConnectionState = function () {
-    if(this.room)
-        return this.room.getConnectionState();
-    return null;
+JitsiConference.prototype.isRecordingSupported = function () {
+    // if(this.room)
+    //     return this.room.isRecordingSupported();
+    // return false;
+};
+
+/**
+ * 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 () {
+    // if(this.room)
+    //     return this.room.getRecordingState();
+    // return "off";
+}
+
+/**
+ * Returns the url of the recorded video.
+ */
+JitsiConference.prototype.getRecordingURL = function () {
+    // if(this.room)
+    //     return this.room.getRecordingURL();
+    // return null;
+}
+
+/**
+ * Starts/stops the recording
+ * @param token a token for authentication.
+ */
+JitsiConference.prototype.toggleRecording = function (token) {
+    // if(this.room)
+    //     this.room.toggleRecording(token);
 }
 
 /**
@@ -529,18 +475,6 @@ function setupListeners(conference) {
     conference.room.addListener(XMPPEvents.MUC_JOINED, function () {
         conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_JOINED);
     });
-    conference.room.addListener(XMPPEvents.ROOM_JOIN_ERROR, function (pres) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.CONNECTION_ERROR, pres);
-    });
-    conference.room.addListener(XMPPEvents.ROOM_CONNECT_ERROR, function (pres) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.CONNECTION_ERROR, pres);
-    });
-    conference.room.addListener(XMPPEvents.PASSWORD_REQUIRED, function (pres) {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.PASSWORD_REQUIRED, pres);
-    });
-    conference.room.addListener(XMPPEvents.AUTHENTICATION_REQUIRED, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.AUTHENTICATION_REQUIRED);
-    });
 //    FIXME
 //    conference.room.addListener(XMPPEvents.MUC_JOINED, function () {
 //        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_LEFT);
@@ -564,12 +498,7 @@ function setupListeners(conference) {
         conference.eventEmitter.emit(JitsiConferenceEvents.CONNECTION_RESTORED);
     });
     conference.room.addListener(XMPPEvents.CONFERENCE_SETUP_FAILED, function () {
-        conference.eventEmitter.emit(JitsiConferenceEvents.CONFERENCE_FAILED, JitsiConferenceErrors.SETUP_FAILED);
-    });
-
-    conference.room.addListener(XMPPEvents.MESSAGE_RECEIVED, function (jid, displayName, txt, myJid, ts) {
-        var id = Strophe.getResourceFromJid(jid);
-        conference.eventEmitter.emit(JitsiConferenceEvents.MESSAGE_RECEIVED, id, txt, ts);
+        conference.eventEmitter.emit(JitsiConferenceEvents.SETUP_FAILED);
     });
 
     conference.rtc.addListener(RTCEvents.DOMINANTSPEAKER_CHANGED, function (id) {
@@ -588,9 +517,6 @@ function setupListeners(conference) {
             conference.eventEmitter.emit(JitsiConferenceEvents.LAST_N_ENDPOINTS_CHANGED,
                 lastNEndpoints, endpointsEnteringLastN);
         });
-    conference.xmpp.addListener(XMPPEvents.PASSWORD_REQUIRED, function () {
-        conference.eventEmitter.emit(JitsiConferenceErrors.PASSWORD_REQUIRED);
-    });
 
     if(conference.statistics) {
         //FIXME: Maybe remove event should not be associated with the conference.

JitsiConferenceEvents.js

@@ -83,7 +83,11 @@ var JitsiConferenceEvents = {
     /**
      * Indicates that DTMF support changed.
      */
-    DTMF_SUPPORT_CHANGED: "conference.dtmfSupportChanged"
+    DTMF_SUPPORT_CHANGED: "conference.dtmfSupportChanged",
+    /**
+     * Indicates that recording state changed.
+     */
+    RECORDING_STATE_CHANGED: "conference.recordingStateChanged"
 };
 
 module.exports = JitsiConferenceEvents;

JitsiConnection.js

@@ -8,9 +8,8 @@ var RandomUtil = require("./modules/util/RandomUtil");
  * @returns {string}
  */
 function generateUserName() {
-    return RandomUtil.randomHexString(8) + "-" + RandomUtil.randomHexString(4) +
-        "-" + RandomUtil.randomHexString(4) + "-" +
-        RandomUtil.randomHexDigit(8);
+    return RandomUtil.random8digitsHex() + "-" + RandomUtil.random4digitsHex() + "-" +
+        RandomUtil.random4digitsHex() + "-" + RandomUtil.random8digitsHex();
 }
 
 /**

modules/xmpp/ChatRoom.js

@@ -4,6 +4,7 @@ var logger = require("jitsi-meet-logger").getLogger(__filename);
 var XMPPEvents = require("../../service/xmpp/XMPPEvents");
 var Moderator = require("./moderator");
 var EventEmitter = require("events");
+var JIBRI_XMLNS = 'http://jitsi.org/protocol/jibri';
 
 var parser = {
     packet2JSON: function (packet, nodes) {
@@ -216,6 +217,7 @@ ChatRoom.prototype.onPresence = function (pres) {
     var nodes = [];
     parser.packet2JSON(pres, nodes);
     this.lastPresences[from] = nodes;
+    var jibri = null;
     for(var i = 0; i < nodes.length; i++)
     {
         var node = nodes[i];
@@ -245,6 +247,8 @@ ChatRoom.prototype.onPresence = function (pres) {
                     this.eventEmitter.emit(XMPPEvents.BRIDGE_DOWN);
                 }
                 break;
+            case "jibri-recording-status":
+                var jibri = node;
             default :
                 this.processNode(node, from);
         }
@@ -261,6 +265,8 @@ ChatRoom.prototype.onPresence = function (pres) {
             }
         if (!this.joined) {
             this.joined = true;
+            this.recording = new Recording(this.eventEmitter, this.connection,
+                this.focusMucJid);
             console.log("(TIME) MUC joined:\t", window.performance.now());
             this.eventEmitter.emit(XMPPEvents.MUC_JOINED, from, member);
         }
@@ -298,6 +304,11 @@ ChatRoom.prototype.onPresence = function (pres) {
         this.eventEmitter.emit(XMPPEvents.PRESENCE_STATUS, from, member);
     }
 
+    if(this.recording)
+    {
+        this.recording.handleJibriPresence(jibri);
+    }
+
 };
 
 ChatRoom.prototype.processNode = function (node, from) {
@@ -515,10 +526,10 @@ ChatRoom.prototype.setJingleSession = function(session){
 };
 
 
-ChatRoom.prototype.removeStream = function (stream) {
+ChatRoom.prototype.removeStream = function (stream, callback) {
     if(!this.session)
         return;
-    this.session.peerconnection.removeStream(stream);
+    this.session.removeStream(stream, callback);
 };
 
 ChatRoom.prototype.switchStreams = function (stream, oldStream, callback, isAudio) {
@@ -640,12 +651,40 @@ ChatRoom.prototype.getJidBySSRC = function (ssrc) {
 };
 
 /**
- * Returns the connection state for the current session.
+ * Returns true if the recording is supproted and false if not.
  */
-ChatRoom.prototype.getConnectionState = function () {
-    if(!this.session)
-        return null;
-    return this.session.getIceConnectionState();
+ChatRoom.prototype.isRecordingSupported = function () {
+    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.
+ */
+ChatRoom.prototype.getRecordingState = function () {
+    if(this.recording)
+        return this.recording.getState();
+    return "off";
+}
+
+/**
+ * Returns the url of the recorded video.
+ */
+ChatRoom.prototype.getRecordingURL = function () {
+    if(this.recording)
+        return this.recording.getURL();
+    return null;
+}
+
+/**
+ * Starts/stops the recording
+ * @param token token for authentication
+ */
+ChatRoom.prototype.toggleRecording = function (token) {
+    if(this.recording && this.moderator.isModerator())
+        this.recording.toggleRecording(token);
 }
 
 module.exports = ChatRoom;

modules/xmpp/recording.js

@@ -1,91 +1,37 @@
 /* global $, $iq, config, connection, focusMucJid, messageHandler,
    Toolbar, Util */
-var Moderator = require("./moderator");
-
-
-var recordingToken = null;
-var recordingEnabled;
-
-/**
- * Whether to use a jirecon component for recording, or use the videobridge
- * through COLIBRI.
- */
-var useJirecon;
-
-var useJibri;
-var eventEmitter;
-
-/**
- * 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.
- */
-var jireconRid = null;
-
-/**
- * The callback to update the recording button. Currently used from colibri
- * after receiving a pending status.
- */
-var recordingStateChangeCallback = null;
-
-function setRecordingToken(token) {
-    recordingToken = token;
-}
-
-function setRecordingJirecon(state, token, callback, connection) {
-    if (state == recordingEnabled){
-        return;
-    }
-
-    var iq = $iq({to: config.hosts.jirecon, type: 'set'})
-        .c('recording', {xmlns: 'http://jitsi.org/protocol/jirecon',
-            action: (state === 'on') ? 'start' : 'stop',
-            mucjid: connection.emuc.roomjid});
-    if (state === 'off'){
-        iq.attrs({rid: jireconRid});
-    }
-
-    console.log('Start recording');
+var XMPPEvents = require("../../service/XMPP/XMPPEvents");
+
+function Recording(ee, connection, focusMucJid) {
+    this.eventEmitter = ee;
+    this.connection = connection;
+    this.connection.jibri.setHandler(this.handleJibriIq);
+    this.state = "off";
+    this.focusMucJid = focusMucJid;
+    this.url = null;
+    this.isRecordingSupported = false;
+};
 
-    connection.sendIQ(
-        iq,
-        function (result) {
-            // TODO wait for an IQ with the real status, since this is
-            // provisional?
-            //FIXME: state should reflect the NEW state.
-            jireconRid = $(result).find('recording').attr('rid');
-            console.log('Recording ' +
-                ((state === 'on') ? 'started' : 'stopped') +
-                '(jirecon)' + result);
-            recordingEnabled = state;
-            if (state === 'off'){
-                jireconRid = null;
-            }
+Recording.prototype.handleJibriPresence = function (jibri) {
 
-            callback(state);
-        },
-        function (error) {
-            console.log('Failed to start recording, error: ', error);
-            callback(recordingEnabled);
-        });
+    this.eventEmitter.emit(XMPPEvents.RECORDING_STATE_CHANGED);
 }
 
-function setRecordingJibri(state, token, callback, connection) {
-    if (state == recordingEnabled){
+Recording.prototype.setRecording = function (state, streamId, callback){
+    if (state == this.state){
         return;
     }
 
-    var focusJid = connection.emuc.focusMucJid;
-    var iq = $iq({to: focusJid, type: 'set'})
+    var iq = $iq({to: this.focusMucJid, type: 'set'})
         .c('jibri', {
             xmlns: 'http://jitsi.org/protocol/jibri',
-            action: (state === 'on') ? 'start' : 'stop'
-            //TODO: add the stream id?
+            action: (state === 'on') ? 'start' : 'stop',
+            streamId: streamId
         }).up();
 
     console.log('Set jibri recording: '+state, iq);
 
-    connection.sendIQ(
+    this.connection.sendIQ(
         iq,
         function (result) {
             var recordingEnabled = $(result).find('jibri').attr('state');
@@ -99,127 +45,29 @@ function setRecordingJibri(state, token, callback, connection) {
         });
 }
 
-// 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.
-function setRecordingColibri(state, token, callback, connection) {
-    var elem = $iq({to: connection.emuc.focusMucJid, type: 'set'});
-    elem.c('conference', {
-        xmlns: 'http://jitsi.org/protocol/colibri'
-    });
-    elem.c('recording', {state: state, token: token});
 
-    connection.sendIQ(elem,
-        function (result) {
-            console.log('Set recording "', state, '". Result:', result);
-            var recordingElem = $(result).find('>conference>recording');
-            var newState = recordingElem.attr('state');
-
-            recordingEnabled = newState;
-            callback(newState);
-
-            if (newState === 'pending' && !recordingStateChangeCallback) {
-                recordingStateChangeCallback = callback;
-                connection.addHandler(function(iq){
-                    var state = $(iq).find('recording').attr('state');
-                    if (state)
-                        recordingStateChangeCallback(state);
-                }, 'http://jitsi.org/protocol/colibri', 'iq', null, null, null);
-            }
-        },
-        function (error) {
-            console.warn(error);
-            callback(recordingEnabled);
-        }
-    );
-}
-
-function setRecording(state, token, callback, connection) {
-    if (useJibri) {
-        setRecordingJibri(state, token, callback, connection);
-    } else if (useJirecon){
-        setRecordingJirecon(state, token, callback, connection);
-    } else {
-        setRecordingColibri(state, token, callback, connection);
-    }
-}
-
-function handleJibriIq(iq) {
-    //TODO verify it comes from the focus
-
-    var newState = $(iq).find('jibri').attr('state');
-    if (newState) {
-        eventEmitter.emit('recording.state_changed', newState);
-    }
-}
-
-var Recording = {
-    init: function (ee) {
-        eventEmitter = ee;
-        useJirecon = config.hosts &&
-            (typeof config.hosts.jirecon != "undefined");
-        useJibri = config.recordingUseJibri;
-        connection.jibri.setHandler(handleJibriIq);
-    },
-    toggleRecording: function (tokenEmptyCallback,
-                               recordingStateChangeCallback,
-                               connection) {
-        if (!Moderator.isModerator()) {
-            console.log(
-                    'non-focus, or conference not yet organized:' +
-                    ' not enabling recording');
-            return;
-        }
-
-        var self = this;
+Recording.prototype.toggleRecording = function (token) {
         // Jirecon does not (currently) support a token.
-        if (!recordingToken && !useJirecon) {
-            tokenEmptyCallback(function (value) {
-                setRecordingToken(value);
-                self.toggleRecording(tokenEmptyCallback,
-                                     recordingStateChangeCallback,
-                                     connection);
-            });
-
+        if (!token) {
+            console.error("No token passed!");
             return;
         }
 
-        var oldState = recordingEnabled;
+        var oldState = this.state;
         var newState = (oldState === 'off' || !oldState) ? 'on' : 'off';
 
-        setRecording(newState,
-            recordingToken,
+        this.setRecording(newState,
+            token,
             function (state) {
                 console.log("New recording state: ", state);
-                if (state === oldState) {
-                    // FIXME: new focus:
-                    // this will not work when moderator changes
-                    // during active session. Then it will assume that
-                    // recording status has changed to true, but it might have
-                    // been already true(and we only received actual status from
-                    // the focus).
-                    //
-                    // SO we start with status null, so that it is initialized
-                    // here and will fail only after second click, so if invalid
-                    // token was used we have to press the button twice before
-                    // current status will be fetched and token will be reset.
-                    //
-                    // Reliable way would be to return authentication error.
-                    // Or status update when moderator connects.
-                    // Or we have to stop recording session when current
-                    // moderator leaves the room.
-
-                    // Failed to change, reset the token because it might
-                    // have been wrong
-                    setRecordingToken(null);
+                if (state !== oldState) {
+                    this.state = state;
+                    this.eventEmitter.emit(XMPPEvents.RECORDING_STATE_CHANGED, state);
                 }
-                recordingStateChangeCallback(state);
-
-            },
-            connection
+            }
         );
     }
 
 };
 
-module.exports = Recording;
+module.exports = Recording;

modules/xmpp/strophe.jibri.js

@@ -4,7 +4,7 @@ var jibriHandler;
 module.exports = function() {
     Strophe.addConnectionPlugin('jibri',
         {
-            JIBRI_XMLNS: 'http://jitsi.org/protocol/jibri',
+            
             connection: null,
             init: function (conn) {
                 this.connection = conn;

service/xmpp/XMPPEvents.js

@@ -97,6 +97,10 @@ var XMPPEvents = {
     // xmpp is connected and obtained user media
     READY_TO_JOIN: 'xmpp.ready_to_join',
     FOCUS_LEFT: "xmpp.focus_left",
-    REMOTE_STREAM_RECEIVED: "xmpp.remote_stream_received"
+    REMOTE_STREAM_RECEIVED: "xmpp.remote_stream_received",
+    /**
+     * Indicates that recording state changed.
+     */
+    RECORDING_STATE_CHANGED: "xmpp.recordingStateChanged"
 };
-module.exports = XMPPEvents;
+module.exports = XMPPEvents;