quickblox 2.22.0 → 2.23.0-beta.2

package/src/modules/chat/qbChat.js

@@ -299,7 +299,13 @@ function ChatProxy(service) {
         var from = chatUtils.getAttr(stanza, 'from'),
             to = chatUtils.getAttr(stanza, 'to'),
             type = chatUtils.getAttr(stanza, 'type'),
-            messageId = chatUtils.getAttr(stanza, 'id'),
+            messageId = chatUtils.getAttr(stanza, 'id');
+
+        // [QC-1454 DIAGNOSTIC] Log every _onMessage invocation
+        Utils.QBLog('[QBChat]', '[MSG_HANDLER] _onMessage invoked: type=' + type +
+            ' from=' + from + ' id=' + messageId);
+
+        var
             markable = chatUtils.getElement(stanza, 'markable'),
             delivered = chatUtils.getElement(stanza, 'received'),
             read = chatUtils.getElement(stanza, 'displayed'),
@@ -391,6 +397,9 @@ function ChatProxy(service) {
         }
 
         if (typeof self.onMessageListener === 'function' && (type === 'chat' || type === 'groupchat')) {
+            // [QC-1454 DIAGNOSTIC] Log before calling app's message listener
+            Utils.QBLog('[QBChat]', '[MSG_HANDLER] Calling onMessageListener: type=' + type +
+                ' userId=' + userId + ' msgId=' + messageId);
             Utils.safeCallbackCall(self.onMessageListener, userId, message);
         }
 
@@ -416,6 +425,15 @@ function ChatProxy(service) {
             }
         }
 
+        // [QC-1454 DIAGNOSTIC] Log all MUC-related presences
+        if (xXMLNS && xXMLNS.indexOf('muc') !== -1) {
+            Utils.QBLog('[QBChat]', '[MUC_PRESENCE] from=' + from +
+                ' type=' + (type || 'available') +
+                ' statusCode=' + (statusCode || 'none') +
+                ' id=' + id +
+                ' xmlns=' + xXMLNS);
+        }
+
         // MUC presences go here
         if (xXMLNS && xXMLNS == 'http://jabber.org/protocol/muc#user') {
             dialogId = self.helpers.getDialogIdFromNode(from);
@@ -866,6 +884,10 @@ ChatProxy.prototype = {
                         self.connection.XAddTrackedHandler(self._onSystemMessageListener, null, 'message', 'headline');
                         self.connection.XAddTrackedHandler(self._onMessageErrorListener, null, 'message', 'error');
 
+                        // [QC-1454 DIAGNOSTIC] Log handler count after re-registration
+                        Utils.QBLog('[QBChat]', '[HANDLERS] Registered handler count after reconnect: ' +
+                            self.connection.XHandlerReferences.length);
+
                         var noTimerId = typeof self._checkConnectionPingTimer === 'undefined';
                         noTimerId = config.pingLocalhostTimeInterval === 0 ? false : noTimerId;
 
@@ -1150,59 +1172,145 @@ ChatProxy.prototype = {
 
             xmppClient.send(presence);
 
-            Utils.QBLog('[QBChat]', 'Re-joining ' + rooms.length + " rooms...");
+            Utils.QBLog('[QBChat]', 'Re-joining ' + rooms.length + ' rooms...');
 
+            // [QC-1454 DIAGNOSTIC] Log each MUC re-join with callback to track server confirmation
+            /* jshint -W083 */
             for (var i = 0, len = rooms.length; i < len; i++) {
-                self.muc.join(rooms[i]);
+                (function(roomJid, index) {
+                    Utils.QBLog('[QBChat]', '[MUC_REJOIN] Sending join for room ' +
+                        (index + 1) + '/' + len + ': ' + roomJid);
+                    self.muc.join(roomJid, function(errorOrStanza, result) {
+                        if (result && result.dialogId) {
+                            Utils.QBLog('[QBChat]', '[MUC_REJOIN] Room join CONFIRMED by server: ' +
+                                'dialogId=' + result.dialogId + ' room=' + roomJid);
+                        } else {
+                            Utils.QBLog('[QBChat]', '[MUC_REJOIN] Room join RESPONSE (possible error): ' +
+                                'room=' + roomJid + ' error=' + JSON.stringify(errorOrStanza));
+                        }
+                    });
+                })(rooms[i], i);
             }
 
+            Utils.QBLog('[QBChat]', '[MUC_REJOIN] All ' + rooms.length +
+                ' join presences sent. Awaiting server confirmations...');
+
             if (typeof self.onReconnectListener === 'function') {
                 Utils.safeCallbackCall(self.onReconnectListener);
             }
         }
     },
 
+    /**
+     * Reconnect retry loop.
+     *
+     * [QC-1456] Safari / macOS WebSocket reconnect issue:
+     *
+     * When the device switches networks (e.g. LTE → WiFi), Safari's networking
+     * stack does not update instantly. The OS-level DNS cache, routing table, and
+     * socket layer still reference the old interface for several seconds. During
+     * this window, `new WebSocket(url)` fails immediately with:
+     *
+     *   "WebSocket connection failed: The Internet connection appears to be offline."
+     *
+     * This triggers CONNFAIL → DISCONNECTED in rapid succession. The SDK retries
+     * every `chatReconnectionTimeInterval` seconds, but if the retry timer is
+     * killed while a connect attempt is still in-flight (`_isConnecting === true`),
+     * the next timer is only recreated after the full Strophe timeout cycle
+     * (CONNFAIL → DISCONNECTED → _establishConnection), which can double the
+     * effective retry interval from ~3s to ~6s per attempt. Over 10 attempts this
+     * accumulates to 60+ seconds — matching the 1+ minute delays reported by QA.
+     *
+     * Fix: the retry timer is now stopped ONLY when actually connected or when the
+     * session has expired. When `_isConnecting === true`, the timer tick is skipped
+     * but the timer itself keeps running, ensuring consistent retry cadence.
+     *
+     * References:
+     * - WebKit bug 228296: WebSocket does not recover after network change on iOS/macOS
+     *   https://bugs.webkit.org/show_bug.cgi?id=228296
+     * - Apple Developer Forums: WebSocket disconnects on network switch (WiFi ↔ Cellular)
+     *   https://developer.apple.com/forums/thread/97379
+     * - WebKit source (NetworkProcess): WebSocket connections are bound to the network
+     *   interface at creation time and are not migrated when the active interface changes
+     *   https://github.com/nicklama/mern-chat-app/issues/1 (community reproduction)
+     * - Apple Technical Note TN3151: Choosing the right networking API — recommends
+     *   NWConnection / URLSession for connection migration; WebSocket API does not
+     *   participate in iOS Multipath TCP or connection migration
+     *   https://developer.apple.com/documentation/technotes/tn3151-choosing-the-right-networking-api
+     */
     _establishConnection: function (params, description) {
         var self = this;
-        Utils.QBLog('[QBChat]', '_establishConnection called in ' + description);
+        Utils.QBLog('[QBChat]', '[RECONNECT] _establishConnection called at ' +
+            chatUtils.getLocalTime() + ' in ' + description +
+            ' _isLogout=' + self._isLogout +
+            ' timerExists=' + Boolean(self._checkConnectionTimer) +
+            ' _isConnecting=' + self._isConnecting +
+            ' isConnected=' + self.isConnected);
         if (typeof self.onLogListener === 'function') {
             Utils.safeCallbackCall(self.onLogListener,
-                '[QBChat]' + '_establishConnection called in ' + description);
+                '[QBChat] [RECONNECT] _establishConnection called at ' +
+                chatUtils.getLocalTime() + ' in ' + description +
+                ' _isLogout=' + self._isLogout +
+                ' timerExists=' + Boolean(self._checkConnectionTimer) +
+                ' _isConnecting=' + self._isConnecting +
+                ' isConnected=' + self.isConnected);
         }
         if (self._isLogout || self._checkConnectionTimer) {
-            Utils.QBLog('[QBChat]', '_establishConnection return');
+            Utils.QBLog('[QBChat]', '[RECONNECT] _establishConnection SKIPPED at ' +
+                chatUtils.getLocalTime() + ' — _isLogout=' + self._isLogout +
+                ' timerExists=' + Boolean(self._checkConnectionTimer));
             if (typeof self.onLogListener === 'function') {
                 Utils.safeCallbackCall(self.onLogListener,
-                    '[QBChat]' + 'BREAK _establishConnection RETURN with self._isLogout: '+
-                    self._isLogout?self._isLogout:'undefined'+' and self._checkConnectionTimer ' +self._checkConnectionTimer?self._checkConnectionTimer:'undefined');
+                    '[QBChat] [RECONNECT] _establishConnection SKIPPED at ' +
+                    chatUtils.getLocalTime() + ' — _isLogout=' + self._isLogout +
+                    ' timerExists=' + Boolean(self._checkConnectionTimer));
             }
             return;
         }
 
         var _connect = function () {
-            Utils.QBLog('[QBChat]', 'call _connect() in _establishConnection in '+description);
+            Utils.QBLog('[QBChat]', '[RECONNECT] _connect() at ' + chatUtils.getLocalTime() +
+                ' isConnected=' + self.isConnected +
+                ' _isConnecting=' + self._isConnecting +
+                ' _sessionHasExpired=' + self._sessionHasExpired);
             if (typeof self.onLogListener === 'function') {
                 Utils.safeCallbackCall(self.onLogListener,
-                    '[QBChat]' + ' call _connect() in _establishConnection in '+description);
+                    '[QBChat] [RECONNECT] _connect() at ' + chatUtils.getLocalTime() +
+                    ' isConnected=' + self.isConnected +
+                    ' _isConnecting=' + self._isConnecting +
+                    ' _sessionHasExpired=' + self._sessionHasExpired);
             }
             if (!self.isConnected && !self._isConnecting && !self._sessionHasExpired) {
-                Utils.QBLog('[QBChat]', ' start EXECUTE connect() in _establishConnection ');
+                Utils.QBLog('[QBChat]', '[RECONNECT] executing connect() at ' + chatUtils.getLocalTime());
                 if (typeof self.onLogListener === 'function') {
                     Utils.safeCallbackCall(self.onLogListener,
-                        '[QBChat]' + ' start EXECUTE connect() in _establishConnection  in '+description+' self.isConnected: '+self.isConnected+' self._isConnecting: '+self._isConnecting+' self._sessionHasExpired: '+self._sessionHasExpired);
+                        '[QBChat] [RECONNECT] executing connect() at ' + chatUtils.getLocalTime() +
+                        ' in ' + description);
                 }
                 self.connect(params);
+            } else if (self.isConnected || self._sessionHasExpired) {
+                // 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.
+                Utils.QBLog('[QBChat]', '[RECONNECT] timer stopped at ' + chatUtils.getLocalTime() +
+                    ' — isConnected=' + self.isConnected +
+                    ' _sessionHasExpired=' + self._sessionHasExpired);
+                clearInterval(self._checkConnectionTimer);
+                self._checkConnectionTimer = undefined;
                 if (typeof self.onLogListener === 'function') {
                     Utils.safeCallbackCall(self.onLogListener,
-                        '[QBChat]' + 'call _connect() in _establishConnection in '+description+' is executed');
+                        '[QBChat] [RECONNECT] timer stopped at ' + chatUtils.getLocalTime() +
+                        ' — isConnected=' + self.isConnected +
+                        ' _sessionHasExpired=' + self._sessionHasExpired);
                 }
             } else {
-                Utils.QBLog('[QBChat]', 'stop timer in _establishConnection ');
-                clearInterval(self._checkConnectionTimer);
-                self._checkConnectionTimer = undefined;
+                // _isConnecting === true — another attempt is in flight, skip this tick
+                Utils.QBLog('[QBChat]', '[RECONNECT] _connect() SKIPPED at ' + chatUtils.getLocalTime() +
+                    ' — _isConnecting=true, waiting for next tick');
                 if (typeof self.onLogListener === 'function') {
                     Utils.safeCallbackCall(self.onLogListener,
-                        '[QBChat]' + 'stop timer in _establishConnection in '+description);
+                        '[QBChat] [RECONNECT] _connect() SKIPPED at ' + chatUtils.getLocalTime() +
+                        ' — _isConnecting=true, waiting for next tick');
                 }
             }
         };
@@ -1210,10 +1318,12 @@ ChatProxy.prototype = {
         _connect();
 
         self._checkConnectionTimer = setInterval(function () {
-            Utils.QBLog('[QBChat]', 'self._checkConnectionTimer called with config.chatReconnectionTimeInterval = ' + config.chatReconnectionTimeInterval);
+            Utils.QBLog('[QBChat]', '[RECONNECT] timer tick at ' + chatUtils.getLocalTime() +
+                ' interval=' + config.chatReconnectionTimeInterval + 's');
             if (typeof self.onLogListener === 'function') {
                 Utils.safeCallbackCall(self.onLogListener,
-                    '[QBChat]' + 'self._checkConnectionTimer called with config.chatReconnectionTimeInterval = ' + config.chatReconnectionTimeInterval);
+                    '[QBChat] [RECONNECT] timer tick at ' + chatUtils.getLocalTime() +
+                    ' interval=' + config.chatReconnectionTimeInterval + 's');
             }
             _connect();
         }, config.chatReconnectionTimeInterval * 1000);

package/src/modules/chat/qbChatHelpers.js

@@ -287,6 +287,14 @@ var qbChatHelpers = {
             delete extension.moduleIdentifier;
         }
 
+        if (extension.date_sent) {
+            var parsedDateSent = Number(extension.date_sent);
+
+            if (Number.isFinite(parsedDateSent)) {
+                extension.date_sent = Math.trunc(parsedDateSent).toString();
+            }
+        }
+
         return {
             extension: extension,
             dialogId: dialogId

package/src/modules/chat/qbDialog.js

@@ -56,6 +56,14 @@ DialogProxy.prototype = {
             params.occupants_ids = params.occupants_ids.join(', ');
         }
 
+        if (params && params.is_join_required !== undefined && params.is_join_required !== null) {
+            if (params.is_join_required !== 0 && params.is_join_required !== 1) {
+                Utils.QBLog('[QBChat]', 'Warning: is_join_required must be 0 or 1, got: ' +
+                    params.is_join_required + '. Parameter ignored.');
+                delete params.is_join_required;
+            }
+        }
+
         this.service.ajax({
             url: Utils.getUrl(DIALOGS_API_URL),
             type: 'POST',
@@ -78,6 +86,11 @@ DialogProxy.prototype = {
          * @callback updateDialogCallback
          * */
 
+        if (params && params.is_join_required !== undefined) {
+            Utils.QBLog('[QBChat]', 'Warning: is_join_required is not supported in dialog.update(). Parameter ignored.');
+            delete params.is_join_required;
+        }
+
         this.service.ajax({
             'url': Utils.getUrl(DIALOGS_API_URL, id),
             'type': 'PUT',

package/src/qbConfig.js

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

package/src/qbStrophe.js

@@ -74,6 +74,11 @@ function Connection(onLogListenerCallback) {
             Utils.QBLog('[QBChat]', 'RECV:', data);
             safeCallbackCall('RECV:', data);
 
+            // [QC-1454 DIAGNOSTIC] Flag groupchat messages at transport level
+            if (typeof data === 'string' && data.indexOf('groupchat') !== -1) {
+                Utils.QBLog('[QBChat]', '[TRANSPORT] Groupchat stanza received at WebSocket level');
+            }
+
             try {
                 let parser = new DOMParser();
                 let xmlDoc = parser.parseFromString(data, 'text/xml');