feat(JitsiConnection): disconnect->return Promise

JitsiConnection.js

@@ -74,13 +74,14 @@ JitsiConnection.prototype.attach = function(options) {
 
 /**
  * Disconnect the client from the server.
+ * @returns {Promise} - Resolves when the disconnect process is finished or rejects with an error.
  */
 JitsiConnection.prototype.disconnect = function(...args) {
     // XXX Forward any arguments passed to JitsiConnection.disconnect to
     // XMPP.disconnect. For example, the caller of JitsiConnection.disconnect
     // may optionally pass the event which triggered the disconnect in order to
     // provide the implementation with finer-grained context.
-    this.xmpp.disconnect(...args);
+    return this.xmpp.disconnect(...args);
 };
 
 /**

modules/statistics/AnalyticsAdapter.js

@@ -115,10 +115,10 @@ class AnalyticsAdapter {
      */
     dispose() {
         logger.warn('Disposing of analytics adapter.');
-        
+
         if (this.analyticsHandlers && this.analyticsHandlers.size > 0) {
             this.analyticsHandlers.forEach(handler => {
-                if ( typeof handler.dispose === 'function' ) {
+                if (typeof handler.dispose === 'function') {
                     handler.dispose();
                 }
             });

modules/xmpp/xmpp.js

@@ -92,7 +92,11 @@ export default class XMPP extends Listenable {
         // they wanted to utilize the connected connection in an unload handler
         // of their own. However, it should be fairly easy for them to do that
         // by registering their unload handler before us.
-        $(window).on('beforeunload unload', this.disconnect.bind(this));
+        $(window).on('beforeunload unload', ev => {
+            this.disconnect(ev).catch(() => {
+                // ignore errors in order to not brake the unload.
+            });
+        });
     }
 
     /**
@@ -171,6 +175,8 @@ export default class XMPP extends Listenable {
         logger.log(
             `(TIME) Strophe ${statusStr}${msg ? `[${msg}]` : ''}:\t`,
             now);
+
+        this.eventEmitter.emit(XMPPEvents.CONNECTION_STATUS_CHANGED, credentials, status, msg);
         if (status === Strophe.Status.CONNECTED
             || status === Strophe.Status.ATTACHED) {
             if (this.options.useStunTurn
@@ -490,50 +496,62 @@ export default class XMPP extends Listenable {
     /**
      * Disconnects this from the XMPP server (if this is connected).
      *
-     * @param ev optionally, the event which triggered the necessity to
+     * @param {Object} ev - Optionally, the event which triggered the necessity to
      * disconnect from the XMPP server (e.g. beforeunload, unload).
+     * @returns {Promise} - Resolves when the disconnect process is finished or rejects with an error.
      */
     disconnect(ev) {
         if (this.disconnectInProgress || !this.connection) {
             this.eventEmitter.emit(JitsiConnectionEvents.WRONG_STATE);
 
-            return;
+            return Promise.reject(new Error('Wrong connection state!'));
         }
 
         this.disconnectInProgress = true;
 
-        // XXX Strophe is asynchronously sending by default. Unfortunately, that
-        // means that there may not be enough time to send an unavailable
-        // presence or disconnect at all. Switching Strophe to synchronous
-        // sending is not much of an option because it may lead to a noticeable
-        // delay in navigating away from the current location. As a compromise,
-        // we will try to increase the chances of sending an unavailable
-        // presence and/or disconecting within the short time span that we have
-        // upon unloading by invoking flush() on the connection. We flush() once
-        // before disconnect() in order to attemtp to have its unavailable
-        // presence at the top of the send queue. We flush() once more after
-        // disconnect() in order to attempt to have its unavailable presence
-        // sent as soon as possible.
-        this.connection.flush();
-
-        if (ev !== null && typeof ev !== 'undefined') {
-            const evType = ev.type;
-
-            if (evType === 'beforeunload' || evType === 'unload') {
-                // XXX Whatever we said above, synchronous sending is the best
-                // (known) way to properly disconnect from the XMPP server.
-                // Consequently, it may be fine to have the source code and
-                // comment it in or out depending on whether we want to run with
-                // it for some time.
-                this.connection.options.sync = true;
+        return new Promise(resolve => {
+            const disconnectListener = (credentials, status) => {
+                if (status === Strophe.Status.DISCONNECTED) {
+                    resolve();
+                    this.eventEmitter.removeListener(XMPPEvents.CONNECTION_STATUS_CHANGED, disconnectListener);
+                }
+            };
+
+            this.eventEmitter.on(XMPPEvents.CONNECTION_STATUS_CHANGED, disconnectListener);
+
+            // XXX Strophe is asynchronously sending by default. Unfortunately, that
+            // means that there may not be enough time to send an unavailable
+            // presence or disconnect at all. Switching Strophe to synchronous
+            // sending is not much of an option because it may lead to a noticeable
+            // delay in navigating away from the current location. As a compromise,
+            // we will try to increase the chances of sending an unavailable
+            // presence and/or disconecting within the short time span that we have
+            // upon unloading by invoking flush() on the connection. We flush() once
+            // before disconnect() in order to attemtp to have its unavailable
+            // presence at the top of the send queue. We flush() once more after
+            // disconnect() in order to attempt to have its unavailable presence
+            // sent as soon as possible.
+            this.connection.flush();
+
+            if (ev !== null && typeof ev !== 'undefined') {
+                const evType = ev.type;
+
+                if (evType === 'beforeunload' || evType === 'unload') {
+                    // XXX Whatever we said above, synchronous sending is the best
+                    // (known) way to properly disconnect from the XMPP server.
+                    // Consequently, it may be fine to have the source code and
+                    // comment it in or out depending on whether we want to run with
+                    // it for some time.
+                    this.connection.options.sync = true;
+                }
             }
-        }
 
-        this.connection.disconnect();
+            this.connection.disconnect();
 
-        if (this.connection.options.sync !== true) {
-            this.connection.flush();
-        }
+            if (this.connection.options.sync !== true) {
+                this.connection.flush();
+            }
+        });
     }
 
     /**

service/xmpp/XMPPEvents.js

@@ -52,6 +52,11 @@ const XMPPEvents = {
     // This should go to the RTC module.
     CONNECTION_ICE_FAILED: 'xmpp.connection.ice.failed',
 
+    /**
+     * Designates an event indicating connection status changes.
+     */
+    CONNECTION_STATUS_CHANGED: 'xmpp.connection.status.changed',
+
     // Designates an event indicating that the display name of a participant
     // has changed.
     DISPLAY_NAME_CHANGED: 'xmpp.display_name_changed',