VideoSIPGW updates (#649)

* Changes initialization of videoSIPGW.

* Adds some errors returned on creating videoSIPGW session.

* Fixes sending videoSIPGW session STATE_CHANGED event.

* Fixes sending jibriIQ, no result status is received.

* Adds VIDEO_SIP_GW_SESSION_STATE_CHANGED to JitsiConferenceEvents.

* Fixing comments.

JitsiConference.js

 import Transcriber from './modules/transcription/transcriber';
 import VideoType from './service/RTC/VideoType';
 import VideoSIPGW from './modules/videosipgw/VideoSIPGW';
+import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
 import * as XMPPEvents from './service/xmpp/XMPPEvents';
 
 import SpeakerStatsCollector from './modules/statistics/SpeakerStatsCollector';
      * @type {JingleSessionPC}
      */
     this.p2pJingleSession = null;
+
+    this.videoSIPGWHandler = new VideoSIPGW(this.room);
 }
 
 // FIXME convert JitsiConference to ES6 - ASAP !
     this.rtc.setReceiverVideoConstraint(maxFrameHeight);
 };
 
-/**
- * Get video SIP GW handler, if missing will create one.
- *
- * @returns {VideoSIPGW} video SIP GW handler.
- */
-JitsiConference.prototype._getVideoSIPGWHandle = function() {
-    if (!this.videoSIPGWHandler) {
-        this.videoSIPGWHandler = new VideoSIPGW(this.room);
-        logger.info('Created VideoSIPGW');
-    }
-
-    return this.videoSIPGWHandler;
-};
-
-/**
- * Checks whether video SIP GW service is available.
- *
- * @returns {boolean} whether video SIP GW service is available.
- */
-JitsiConference.prototype.isVideoSIPGWAvailable = function() {
-    return this._getVideoSIPGWHandle().isVideoSIPGWAvailable();
-};
-
 /**
  * Creates a video SIP GW session and returns it if service is enabled. Before
  * creating a session one need to check whether video SIP GW service is
  *
  * @param {string} sipAddress - The sip address to be used.
  * @param {string} displayName - The display name to be used for this session.
- * @returns {JitsiVideoSIPGWSession|null} Returns null if conference is not
+ * @returns {JitsiVideoSIPGWSession|Error} Returns null if conference is not
  * initialised and there is no room.
  */
 JitsiConference.prototype.createVideoSIPGWSession
     = function(sipAddress, displayName) {
         if (!this.room) {
-            return null;
+            return new Error(VideoSIPGWConstants.ERROR_NO_CONNECTION);
         }
 
-        return this._getVideoSIPGWHandle()
+        return this.videoSIPGWHandler
             .createVideoSIPGWSession(sipAddress, displayName);
     };

JitsiConferenceEventManager.js

     this.chatRoomForwarder.forward(XMPPEvents.VIDEO_SIP_GW_AVAILABILITY_CHANGED,
         JitsiConferenceEvents.VIDEO_SIP_GW_AVAILABILITY_CHANGED);
 
+    this.chatRoomForwarder.forward(
+        XMPPEvents.VIDEO_SIP_GW_SESSION_STATE_CHANGED,
+        JitsiConferenceEvents.VIDEO_SIP_GW_SESSION_STATE_CHANGED);
+
     this.chatRoomForwarder.forward(XMPPEvents.PHONE_NUMBER_CHANGED,
         JitsiConferenceEvents.PHONE_NUMBER_CHANGED);
 

JitsiConferenceEvents.js

 export const VIDEO_SIP_GW_AVAILABILITY_CHANGED
     = 'conference.videoSIPGWAvailabilityChanged';
 
+/**
+ * Indicates that video SIP GW Session state changed.
+ * @param {options} event - {
+ *     {string} address,
+ *     {VideoSIPGWConstants} oldState,
+ *     {VideoSIPGWConstants} newState,
+ *     {string} displayName}
+ * }.
+ */
+export const VIDEO_SIP_GW_SESSION_STATE_CHANGED
+    = 'conference.videoSIPGWSessionStateChanged';
+
 /**
  * Indicates that start muted settings changed.
  */

modules/videosipgw/JitsiVideoSIPGWSession.js

-/* global $ */
 import { getLogger } from 'jitsi-meet-logger';
 import { $iq } from 'strophe.js';
 
         const oldState = this.state;
 
         this.state = newState;
-        this.eventEmitter.emit(this.sipAddress,
+        this.eventEmitter.emit(STATE_CHANGED,
             {
-                name: STATE_CHANGED,
+                address: this.sipAddress,
                 oldState,
-                newState: this.state
+                newState: this.state,
+                displayName: this.displayName
             }
         );
     }
             .c('jibri', attributes)
             .up();
 
-        logger.log('Stop video SIP GW session', iq.nodeTree);
+        logger.debug(`${action} video SIP GW session`, iq.nodeTree);
         this.chatRoom.connection.sendIQ(
             iq,
-            result => {
-                logger.log('Result', result);
-                const initialState
-                    = $(result).find('jibri')
-                        .attr('state');
-
-                this.setState(initialState);
-            },
+            () => {}, // eslint-disable-line no-empty-function
             error => {
-                logger.log('Failed to start video SIP GW session, error: ',
-                    error);
+                logger.error(
+                    `Failed to ${action} video SIP GW session, error: `, error);
                 this.setState(VideoSIPGWConstants.STATE_FAILED);
             });
     }

modules/videosipgw/VideoSIPGW.js

     constructor(chatRoom) {
         this.chatRoom = chatRoom;
         this.eventEmitter = chatRoom.eventEmitter;
-        logger.info('creating VideoSIPGW');
+        logger.debug('creating VideoSIPGW');
         this.sessions = {};
 
         this.sessionStateChangeListener = this.sessionStateChanged.bind(this);
             return;
         }
 
-        logger.log('Handle video sip gw status : ', attributes);
+        logger.debug('Handle video sip gw status : ', attributes);
         const newStatus = attributes.status;
 
         // check for global availability of the service
             return;
         }
 
-        logger.log('Handle video sip gw state : ', attributes);
+        logger.debug('Handle video sip gw state : ', attributes);
 
         const newState = attributes.state;
 
     }
 
     /**
-     * Creates new session and stores its reference.
+     * Creates new session and stores its reference if it does not exist or
+     * returns an error otherwise.
      *
      * @param {string} sipAddress - The sip address to use.
      * @param {string} displayName - The display name to use.
-     * @returns {JitsiVideoSIPGWSession}
+     * @returns {JitsiVideoSIPGWSession|Error}
      */
     createVideoSIPGWSession(sipAddress, displayName) {
-        const session = new JitsiVideoSIPGWSession(
-            sipAddress, displayName, this.chatRoom);
-
-        session.addStateListener(this.sessionStateChangeListener);
-
         if (this.sessions[sipAddress]) {
             logger.warn('There was already a Video SIP GW session for address',
                 sipAddress);
+
+            return new Error(Constants.ERROR_SESSION_EXISTS);
         }
 
+        const session = new JitsiVideoSIPGWSession(
+            sipAddress, displayName, this.chatRoom);
+
+        session.addStateListener(this.sessionStateChangeListener);
+
         this.sessions[sipAddress] = session;
 
         return session;
     }
 
-    /**
-     * Returns whether SIP GW service is available.
-     *
-     * @returns {boolean} whether SIP GW service is available.
-     */
-    isVideoSIPGWAvailable() {
-        return this.status === Constants.STATUS_AVAILABLE;
-    }
-
     /**
      * Listener for session state changed. When a session goes to off or failed
      * we delete its reference.
      *
-     * @param {string} address - The SIP address of the session.
-     * @param {options} event - { name, oldState, newState }
+     * @param {options} event - { address, oldState, newState, displayName }
      */
-    sessionStateChanged(address, event) {
+    sessionStateChanged(event) {
+        const address = event.address;
+
         if (event.newState === Constants.STATE_OFF
             || event.newState === Constants.STATE_FAILED) {
             const session = this.sessions[address];
             session.removeStateListener(this.sessionStateChangeListener);
             delete this.sessions[address];
         }
+
+        this.eventEmitter.emit(
+            XMPPEvents.VIDEO_SIP_GW_SESSION_STATE_CHANGED,
+            event);
     }
 }

modules/videosipgw/VideoSIPGWConstants.js

  * @type {string}
  */
 export const STATE_FAILED = 'failed';
+
+/**
+ * Error on trying to create video SIP GW session in conference where
+ * there is no room connection (hasn't joined or has left the room).
+ * @type {string}
+ */
+export const ERROR_NO_CONNECTION = 'error_no_connection';
+
+/**
+ * Error on trying to create video SIP GW session with address for which
+ * there is an already created session.
+ * @type {string}
+ */
+export const ERROR_SESSION_EXISTS = 'error_session_already_exists';

service/xmpp/XMPPEvents.js

      */
     VIDEO_SIP_GW_AVAILABILITY_CHANGED: 'xmpp.videoSIPGWAvailabilityChanged',
 
+    /**
+     * Indicates that video SIP GW Session state changed.
+     * The statuses are any of the following statuses:
+     * STATE_ON, STATE_OFF, STATE_PENDING, STATE_RETRYING, STATE_FAILED.
+     * {@see VideoSIPGWConstants}
+     *
+     * @param {options} event - {address, oldState, newState, displayName}.
+     */
+    VIDEO_SIP_GW_SESSION_STATE_CHANGED:
+        'xmpp.videoSIPGWSessionStateChanged',
+
     // Designates an event indicating that the local ICE connection state has
     // changed.
     ICE_CONNECTION_STATE_CHANGED: 'xmpp.ice_connection_state_changed',