quickblox 2.23.0-beta.2 → 2.23.1-beta.3

package/src/modules/chat/qbChat.js

@@ -101,6 +101,19 @@ function ChatProxy(service) {
     this._checkExpiredSessionTimer = undefined;
     this._sessionHasExpired = false;
     this._pings = {};
+
+    // [QC-1550] XMPP connection is considered "verified" only after the first
+    // successful pong response. Strophe emits Status.CONNECTED at the transport
+    // layer (TCP/WebSocket handshake completed) before XMPP-level traffic is
+    // actually flowing — this creates a race window where the application thinks
+    // chat is alive but pings can still time out. Gates onReconnectListener and
+    // onDisconnectedListener to avoid firing them based on an unverified state.
+    this._isConnectionVerified = false;
+    // [QC-1550] On reconnect, onReconnectListener is deferred until the first
+    // successful pong. This flag marks that a reconnect is awaiting verification:
+    // the ping success callback reads it to decide whether to fire the deferred
+    // listener. Reset on listener fire, on ping failure, and on logout.
+    this._isReconnectListenerPending = false;
     //
     this.helpers = new Helpers();
     //
@@ -904,12 +917,35 @@ ChatProxy.prototype = {
                                                 ' error: ', error);
                                             self._chatPingFailedCounter += 1;
                                             if (self._chatPingFailedCounter >= config.chatPingMissLimit) {
-                                                if (self.isConnected && typeof self.onDisconnectedListener === 'function') {
+                                                // [QC-1550] onDisconnectedListener should only fire when the
+                                                // previous connection was actually verified. If the ping miss
+                                                // limit is reached while we were still waiting for the first
+                                                // pong after reconnect (verification never succeeded), the
+                                                // application was never told the chat was "alive" — so we
+                                                // don't fire a misleading "disconnected" event for a state
+                                                // the consumer never observed.
+                                                if (self.isConnected && self._isConnectionVerified &&
+                                                    typeof self.onDisconnectedListener === 'function') {
                                                     Utils.safeCallbackCall(self.onDisconnectedListener);
                                                 }
+                                                // [QC-1550] Reset verification state and clear any pending
+                                                // reconnect listener — the connection has failed; the next
+                                                // CONNECTED + pong cycle will rebuild verification from
+                                                // scratch.
+                                                self._isConnectionVerified = false;
+                                                self._isReconnectListenerPending = false;
                                                 self.isConnected = false;
                                                 self._isConnecting = false;
                                                 self._chatPingFailedCounter = 0;
+                                                // [QC-1550] Stop this ping interval — it belongs to the dead
+                                                // connection. Without this, the timer keeps firing pings on
+                                                // the old XMPP session and racing with the new connection's
+                                                // ping cycle, which produced spurious pong success/failure
+                                                // interleaving in the field logs.
+                                                if (self._checkConnectionPingTimer !== undefined) {
+                                                    clearInterval(self._checkConnectionPingTimer);
+                                                    self._checkConnectionPingTimer = undefined;
+                                                }
                                                 self._establishConnection(params,'CONNECTED have SDK ping failed');
                                             }
                                         } else {
@@ -918,6 +954,32 @@ ChatProxy.prototype = {
                                                 'ok, at ', Utils.getCurrentTime(),
                                                 '_chatPingFailedCounter: ', self._chatPingFailedCounter);
                                             self._chatPingFailedCounter = 0;
+
+                                            // [QC-1550] First pong after reconnect verifies XMPP is live.
+                                            // Fire the deferred onReconnectListener now (was postponed in
+                                            // _postConnectActions). Skip if logout was triggered between
+                                            // CONNECTED and pong — listener fire would leak past logout.
+                                            if (self._isReconnectListenerPending && !self._isLogout) {
+                                                self._isConnectionVerified = true;
+                                                self._isReconnectListenerPending = false;
+                                                Utils.QBLog('[QBChat]',
+                                                    '[QC-1550] First pong success, firing deferred onReconnectListener at ',
+                                                    Utils.getCurrentTime());
+                                                if (typeof self.onLogListener === 'function') {
+                                                    Utils.safeCallbackCall(self.onLogListener,
+                                                        '[QBChat] [QC-1550] First pong success, firing deferred onReconnectListener at ' +
+                                                        chatUtils.getLocalTime());
+                                                }
+                                                if (typeof self.onReconnectListener === 'function') {
+                                                    Utils.safeCallbackCall(self.onReconnectListener);
+                                                }
+                                            } else if (!self._isConnectionVerified && !self._isLogout) {
+                                                // Edge case: pong succeeded but pending flag was cleared
+                                                // (e.g. by ping failure path racing with this success).
+                                                // Mark verified anyway so onDisconnectedListener gating
+                                                // in SDK-4 works correctly going forward.
+                                                self._isConnectionVerified = true;
+                                            }
                                         }
                                     });
                                 } catch (err) {
@@ -972,11 +1034,30 @@ ChatProxy.prototype = {
                                 '[QBChat]' + '[SDK v'+config.version+']' +' Status.DISCONNECTED at ' +
                                 chatUtils.getLocalTime()+ ' DISCONNECTED CONDITION: ' + condition);
                         }
-                        // fire 'onDisconnectedListener' only once
-                        if (self.isConnected && typeof self.onDisconnectedListener === 'function') {
+                        // [QC-1550] fire 'onDisconnectedListener' only once AND only when the
+                        // previous connection was actually verified (first pong succeeded).
+                        // See onDisconnectedListener gating in SDK-4 for full reasoning — this
+                        // is the same rule applied to transport-level disconnects.
+                        if (self.isConnected && self._isConnectionVerified &&
+                            typeof self.onDisconnectedListener === 'function') {
                             Utils.safeCallbackCall(self.onDisconnectedListener);
                         }
 
+                        // [QC-1550] Reset verification state. The next CONNECTED + pong cycle
+                        // will rebuild it. Pending reconnect listener (if any) is cancelled —
+                        // the new cycle will set a fresh one in _postConnectActions.
+                        self._isConnectionVerified = false;
+                        self._isReconnectListenerPending = false;
+
+                        // [QC-1550] Stop ping timer of the dead connection. Without this, the
+                        // interval keeps invoking self.pingchat() on a stale Strophe connection
+                        // until the new CONNECTED arrives, producing spurious failure logs and
+                        // racing with the new connection's freshly-started ping cycle.
+                        if (self._checkConnectionPingTimer !== undefined) {
+                            clearInterval(self._checkConnectionPingTimer);
+                            self._checkConnectionPingTimer = undefined;
+                        }
+
                         self.isConnected = false;
                         self._isConnecting = false;
                         self.connection.reset();
@@ -1134,8 +1215,21 @@ ChatProxy.prototype = {
      * - save user's JID;
      * - enable carbons;
      * - get and storage the user's roster (if the initial connect);
-     * - recover the joined rooms and fire 'onReconnectListener' (if the reconnect);
+     * - recover the joined rooms and defer 'onReconnectListener' until the first
+     *   pong confirms XMPP-level traffic (if the reconnect);
      * - send initial presence to the chat server.
+     *
+     * [QC-1550] On reconnect, Strophe emits Status.CONNECTED as soon as the
+     * transport handshake completes (WebSocket/BOSH), but the XMPP layer may not
+     * yet be processing traffic — pings can still time out for several seconds.
+     * Firing onReconnectListener at this moment leads consumers (e.g. UI overlays)
+     * to believe chat is fully restored, then a subsequent ping miss triggers a
+     * false "Lost connection" state. The fix defers the listener until the first
+     * pong succeeds (see ping success branch in Strophe.Status.CONNECTED handler).
+     *
+     * Fallback: when ping is disabled (config.pingLocalhostTimeInterval === 0)
+     * there is no pong to wait for, so we fire onReconnectListener immediately
+     * to preserve backward compatibility for consumers who opted out of pings.
      */
     _postConnectActions: function (callback, isInitialConnect) {
         Utils.QBLog('[QBChat]', 'Status.CONNECTED at ' + chatUtils.getLocalTime());
@@ -1161,6 +1255,13 @@ ChatProxy.prototype = {
         self._enableCarbons();
 
         if (isInitialConnect) {
+            // [QC-1550] Initial connect: no reconnect overlay race possible
+            // (user just logged in), so we mark the connection as verified
+            // immediately. This also enables onDisconnectedListener gating in
+            // the DISCONNECTED handler from this point on.
+            self._isConnectionVerified = true;
+            self._isReconnectListenerPending = false;
+
             self.roster.get(function (contacts) {
                 xmppClient.send(presence);
 
@@ -1195,8 +1296,30 @@ ChatProxy.prototype = {
             Utils.QBLog('[QBChat]', '[MUC_REJOIN] All ' + rooms.length +
                 ' join presences sent. Awaiting server confirmations...');
 
-            if (typeof self.onReconnectListener === 'function') {
-                Utils.safeCallbackCall(self.onReconnectListener);
+            // [QC-1550] Defer onReconnectListener until first successful pong.
+            // The ping success callback (in Strophe.Status.CONNECTED handler)
+            // reads _isReconnectListenerPending and fires the listener once XMPP
+            // is verified. Connection remains unverified until that point.
+            self._isConnectionVerified = false;
+
+            if (config.pingLocalhostTimeInterval === 0) {
+                // Ping disabled — no pong to wait for; preserve legacy behavior.
+                Utils.QBLog('[QBChat]',
+                    '[QC-1550] pingLocalhostTimeInterval=0, firing onReconnectListener immediately (ping disabled)');
+                self._isConnectionVerified = true;
+                self._isReconnectListenerPending = false;
+                if (typeof self.onReconnectListener === 'function') {
+                    Utils.safeCallbackCall(self.onReconnectListener);
+                }
+            } else {
+                self._isReconnectListenerPending = true;
+                Utils.QBLog('[QBChat]',
+                    '[QC-1550] onReconnectListener deferred until first pong success');
+                if (typeof self.onLogListener === 'function') {
+                    Utils.safeCallbackCall(self.onLogListener,
+                        '[QBChat] [QC-1550] onReconnectListener deferred at ' +
+                        chatUtils.getLocalTime() + ' — awaiting first pong');
+                }
             }
         }
     },
@@ -1245,7 +1368,9 @@ ChatProxy.prototype = {
             ' _isLogout=' + self._isLogout +
             ' timerExists=' + Boolean(self._checkConnectionTimer) +
             ' _isConnecting=' + self._isConnecting +
-            ' isConnected=' + self.isConnected);
+            ' isConnected=' + self.isConnected +
+            ' verified=' + self._isConnectionVerified +
+            ' pending=' + self._isReconnectListenerPending);
         if (typeof self.onLogListener === 'function') {
             Utils.safeCallbackCall(self.onLogListener,
                 '[QBChat] [RECONNECT] _establishConnection called at ' +
@@ -1253,7 +1378,9 @@ ChatProxy.prototype = {
                 ' _isLogout=' + self._isLogout +
                 ' timerExists=' + Boolean(self._checkConnectionTimer) +
                 ' _isConnecting=' + self._isConnecting +
-                ' isConnected=' + self.isConnected);
+                ' isConnected=' + self.isConnected +
+                ' verified=' + self._isConnectionVerified +
+                ' pending=' + self._isReconnectListenerPending);
         }
         if (self._isLogout || self._checkConnectionTimer) {
             Utils.QBLog('[QBChat]', '[RECONNECT] _establishConnection SKIPPED at ' +
@@ -1272,13 +1399,17 @@ ChatProxy.prototype = {
             Utils.QBLog('[QBChat]', '[RECONNECT] _connect() at ' + chatUtils.getLocalTime() +
                 ' isConnected=' + self.isConnected +
                 ' _isConnecting=' + self._isConnecting +
-                ' _sessionHasExpired=' + self._sessionHasExpired);
+                ' _sessionHasExpired=' + self._sessionHasExpired +
+                ' verified=' + self._isConnectionVerified +
+                ' pending=' + self._isReconnectListenerPending);
             if (typeof self.onLogListener === 'function') {
                 Utils.safeCallbackCall(self.onLogListener,
                     '[QBChat] [RECONNECT] _connect() at ' + chatUtils.getLocalTime() +
                     ' isConnected=' + self.isConnected +
                     ' _isConnecting=' + self._isConnecting +
-                    ' _sessionHasExpired=' + self._sessionHasExpired);
+                    ' _sessionHasExpired=' + self._sessionHasExpired +
+                    ' verified=' + self._isConnectionVerified +
+                    ' pending=' + self._isReconnectListenerPending);
             }
             if (!self.isConnected && !self._isConnecting && !self._sessionHasExpired) {
                 Utils.QBLog('[QBChat]', '[RECONNECT] executing connect() at ' + chatUtils.getLocalTime());
@@ -1292,16 +1423,24 @@ ChatProxy.prototype = {
                 // Stop retry timer only when actually connected or session expired (no point retrying).
                 // Do NOT stop timer when _isConnecting — the in-flight attempt may fail,
                 // and we need the timer to keep ticking for the next retry.
+                // [QC-1550] Note: timer is stopped on isConnected, BUT verification
+                // (_isConnectionVerified) may still be pending — the first pong has
+                // not yet arrived. The retry loop terminates here; from this point
+                // it is the ping interval that drives verification.
                 Utils.QBLog('[QBChat]', '[RECONNECT] timer stopped at ' + chatUtils.getLocalTime() +
                     ' — isConnected=' + self.isConnected +
-                    ' _sessionHasExpired=' + self._sessionHasExpired);
+                    ' _sessionHasExpired=' + self._sessionHasExpired +
+                    ' verified=' + self._isConnectionVerified +
+                    ' pending=' + self._isReconnectListenerPending);
                 clearInterval(self._checkConnectionTimer);
                 self._checkConnectionTimer = undefined;
                 if (typeof self.onLogListener === 'function') {
                     Utils.safeCallbackCall(self.onLogListener,
                         '[QBChat] [RECONNECT] timer stopped at ' + chatUtils.getLocalTime() +
                         ' — isConnected=' + self.isConnected +
-                        ' _sessionHasExpired=' + self._sessionHasExpired);
+                        ' _sessionHasExpired=' + self._sessionHasExpired +
+                        ' verified=' + self._isConnectionVerified +
+                        ' pending=' + self._isReconnectListenerPending);
                 }
             } else {
                 // _isConnecting === true — another attempt is in flight, skip this tick
@@ -1338,6 +1477,21 @@ ChatProxy.prototype = {
         }
         clearInterval(this._checkConnectionTimer);
         this._checkConnectionTimer = undefined;
+        // [QC-1550] Stop ping timer of the previous connection. Without this,
+        // the interval continues to invoke pingchat() on a stale Strophe
+        // connection across the reconnect cycle, racing with the new
+        // connection's freshly-started ping cycle once Status.CONNECTED arrives.
+        if (this._checkConnectionPingTimer !== undefined) {
+            clearInterval(this._checkConnectionPingTimer);
+            this._checkConnectionPingTimer = undefined;
+        }
+        // [QC-1550] Reset XMPP verification state — the new CONNECTED + pong
+        // cycle from _postConnectActions will rebuild it. Without this reset, a
+        // stale _isConnectionVerified=true from the previous session would let
+        // onDisconnectedListener fire on the next ping miss before the new
+        // connection had a chance to verify itself.
+        this._isConnectionVerified = false;
+        this._isReconnectListenerPending = false;
         this.muc.joinedRooms = {};
         this.helpers.setUserCurrentJid('');
 
@@ -1731,6 +1885,13 @@ ChatProxy.prototype = {
         this._checkConnectionTimer = undefined;
         this._checkExpiredSessionTimer = undefined;
         this.muc.joinedRooms = {};
+        // [QC-1550] Reset XMPP verification state on explicit disconnect so the
+        // next connect() starts from a clean slate. _isLogout guard below also
+        // prevents firing of deferred listeners if a pong arrives in flight,
+        // but resetting here keeps state consistent for consumers that call
+        // disconnect() + connect() in sequence.
+        this._isConnectionVerified = false;
+        this._isReconnectListenerPending = false;
         this._isLogout = true;
         this.helpers.setUserCurrentJid('');
 

package/src/qbConfig.js

@@ -12,8 +12,8 @@
  */
 
 var config = {
-  version: '2.23.0-beta.2',
-  buildNumber: '1178',
+  version: '2.23.1-beta.3',
+  buildNumber: '1179',
   creds: {
     'appId': 0,
     'authKey': '',