feat(iframe_api): Implement readyToClose event and hangup command

conference.js

     APP.UI.hideRingOverLay();
     connection.disconnect();
     APP.API.notifyConferenceLeft(APP.conference.roomName);
-    if (requestFeedback) {
-        return APP.UI.requestFeedback();
-    } else {
-        return Promise.resolve();
-    }
-}
-
-/**
- * Disconnect from the conference and optionally request user feedback.
- * @param {boolean} [requestFeedback=false] if user feedback should be requested
- */
-function hangup (requestFeedback = false) {
-    const errCallback = (err) => {
-
-        // If we want to break out the chain in our error handler, it needs
-        // to return a rejected promise. In the case of feedback request
-        // in progress it's important to not redirect to the welcome page
-        // (see below maybeRedirectToWelcomePage call).
-        if (err === UIErrors.FEEDBACK_REQUEST_IN_PROGRESS) {
-            return Promise.reject('Feedback request in progress.');
-        }
-        else {
-            console.error('Error occurred during hanging up: ', err);
-            return Promise.resolve();
-        }
-    };
-    const disconnect = disconnectAndShowFeedback.bind(null, requestFeedback);
-
-    if (!conferenceLeftListener)
-        conferenceLeftListener = new ConferenceLeftListener();
-
-    // Make sure that leave is resolved successfully and the set the handlers
-    // to be invoked once conference had been left
-    APP.conference._room.leave()
-        .then(conferenceLeftListener.setHandler(disconnect, errCallback))
-        .catch(errCallback);
+    let promise = (requestFeedback?
+        APP.UI.requestFeedback(): Promise.resolve());
+    promise.then(() => APP.API.notifyReadyToClose());
+    return promise;
 }
 
 /**
     /**
      * Creates ConferenceLeftListener and start listening for conference
      * failed event.
+     * @param {Function} handler the function that will be called when
+     * CONFERENCE_LEFT event is fired.
+     * @param errCallback
      */
-    constructor() {
+    constructor(handler) {
+        this.handler = handler;
         room.on(ConferenceEvents.CONFERENCE_LEFT,
             this._handleConferenceLeft.bind(this));
     }
      * @private
      */
     _handleConferenceLeft() {
-        this.conferenceLeft = true;
-
-        if (this.handler)
-            this._handleLeave();
-    }
-
-    /**
-     * Sets the handlers. If we already left the conference invoke them.
-     * @param handler
-     * @param errCallback
-     */
-    setHandler (handler, errCallback) {
-        this.handler = handler;
-        this.errCallback = errCallback;
-
-        if (this.conferenceLeft)
-            this._handleLeave();
-    }
-
-    /**
-     * Invokes the handlers.
-     * @private
-     */
-    _handleLeave()
-    {
         this.handler()
-            .catch(this.errCallback)
             .then(maybeRedirectToWelcomePage)
             .catch(function(err){
                 console.log(err);
 
         // call hangup
         APP.UI.addListener(UIEvents.HANGUP, () => {
-            hangup(true);
+            this.hangup(true);
         });
 
         // logout
         APP.UI.addListener(UIEvents.LOGOUT, () => {
-            AuthHandler.logout(room).then(function (url) {
+            AuthHandler.logout(room).then(url => {
                 if (url) {
                     window.location.href = url;
                 } else {
-                    hangup(true);
+                    this.hangup(true);
                 }
             });
         });
         if(room) {
             room.sendApplicationLog(JSON.stringify({name, value}));
         }
+    },
+    /**
+     * Disconnect from the conference and optionally request user feedback.
+     * @param {boolean} [requestFeedback=false] if user feedback should be
+     * requested
+     */
+    hangup (requestFeedback = false) {
+        const errCallback = (err) => {
+            // If we want to break out the chain in our error handler, it needs
+            // to return a rejected promise. In the case of feedback request
+            // in progress it's important to not redirect to the welcome page
+            // (see below maybeRedirectToWelcomePage call).
+            if (err === UIErrors.FEEDBACK_REQUEST_IN_PROGRESS) {
+                return Promise.reject('Feedback request in progress.');
+            }
+            else {
+                console.error('Error occurred during hanging up: ', err);
+                return Promise.resolve();
+            }
+        };
+
+        const disconnect = () => {
+            return disconnectAndShowFeedback(requestFeedback)
+                        .catch(errCallback);
+        };
+
+        if (!conferenceLeftListener) {
+            conferenceLeftListener
+                = new ConferenceLeftListener(disconnect, errCallback);
+        }
+
+        room.leave().catch(errCallback);
     }
 };

doc/api.md

 api.executeCommand('toggleShareScreen', [])
 ```
 
+* **hangup** - Hangups the call. No arguments are required.
+```
+api.executeCommand('hangup', [])
+```
+
 You can also execute multiple commands using the method ```executeCommands```.
 ```
 api.executeCommands(commands)
 }
 ```
 
+* **readyToClose** - event notification fired when Jitsi Meet is ready to be closed (hangup operations are completed).
+
 You can also add multiple event listeners by using ```addEventListeners```.
 This method requires one argument of type Object. The object argument must
 have keys with the names of the events and values the listeners of the events.

modules/API/API.js

         "toggle-film-strip": APP.UI.toggleFilmStrip,
         "toggle-chat": APP.UI.toggleChat,
         "toggle-contact-list": APP.UI.toggleContactList,
-        "toggle-share-screen": APP.conference.toggleScreenSharing
+        "toggle-share-screen": APP.conference.toggleScreenSharing,
+        "video-hangup": () => APP.conference.hangup()
     };
     Object.keys(commands).forEach(function (key) {
         postis.listen(key, commands[key]);
     "participant-joined": false,
     "participant-left": false,
     "video-conference-joined": false,
-    "video-conference-left": false
+    "video-conference-left": false,
+    "video-ready-to-close": false
 };
 
 /**
         triggerEvent("video-conference-left", {roomName: room});
     },
 
+    /**
+     * Notify external application (if API is enabled) that
+     * we are ready to be closed.
+     */
+    notifyReadyToClose () {
+        triggerEvent("video-ready-to-close", {});
+    },
+
     /**
      * Removes the listeners.
      */

modules/API/external/external_api.js

     "toggleFilmStrip": "toggle-film-strip",
     "toggleChat": "toggle-chat",
     "toggleContactList": "toggle-contact-list",
-    "toggleShareScreen": "toggle-share-screen"
+    "toggleShareScreen": "toggle-share-screen",
+    "hangup": "video-hangup"
 };
 
 /**
     "participantJoined": "participant-joined",
     "participantLeft": "participant-left",
     "videoConferenceJoined": "video-conference-joined",
-    "videoConferenceLeft": "video-conference-left"
+    "videoConferenceLeft": "video-conference-left",
+    "readyToClose": "video-ready-to-close"
 };
 
 /**
  * {{
  * roomName: room //the room name of the conference
  * }}
+ * readyToClose - all hangup operations are completed and Jitsi Meet is ready
+ * to be disposed.
  * @param object
  */
 JitsiMeetExternalAPI.prototype.addEventListeners = function(object) {

modules/TokenData/TokenData.js

         //External API settings
         this.externalAPISettings = {
             forceEnable: true,
-            enabledEvents: ["video-conference-joined", "video-conference-left"]
+            enabledEvents: ["video-conference-joined", "video-conference-left",
+                "video-ready-to-close"]
         };
         this._decode();
         // Use JWT param as token if there is not other token set and if the