quickblox 2.24.0 → 2.24.1-alpha.1

package/src/modules/chat/qbChat.js

@@ -11,6 +11,13 @@ var chatUtils = require('./qbChatHelpers'),
 
 var unsupportedError = 'This function isn\'t supported outside of the browser (...yet)';
 
+/**
+ * [CROS-1061] How long to wait for the server to answer a Notice enable/disable
+ * IQ before reporting an error to the caller. Without a bound the callback is
+ * never invoked when the server stays silent.
+ */
+var NOTICE_IQ_TIMEOUT_MS = 10000;
+
 var XMPP;
 
 /** create StropheJS or NodeXMPP connection object */
@@ -44,6 +51,7 @@ NOTICE_KNOWN_MODULE_IDS[noticeConsts.NOTICE_MODULE_IDENTIFIER.UPDATED_MESSAGE] =
 NOTICE_KNOWN_MODULE_IDS[noticeConsts.NOTICE_MODULE_IDENTIFIER.DELETED_MESSAGE] = true;
 NOTICE_KNOWN_MODULE_IDS[noticeConsts.NOTICE_MODULE_IDENTIFIER.UPDATED_DIALOG] = true;
 NOTICE_KNOWN_MODULE_IDS[noticeConsts.NOTICE_MODULE_IDENTIFIER.DELETED_DIALOG] = true;
+NOTICE_KNOWN_MODULE_IDS[noticeConsts.NOTICE_MODULE_IDENTIFIER.CREATED_DIALOG] = true;
 
 /**
  * Cross-env: get all direct child elements of `parent` whose tag name equals
@@ -327,6 +335,91 @@ function _parseCustomData(extraParams) {
     return out;
 }
 
+/**
+ * Build a partial QBChatDialog object from a dialog-notice <extraParams>.
+ * Shared by NoticeUpdatedDialog and NoticeCreatedDialog (SR-2952) — the server
+ * sends a full dialog snapshot in both cases. Fields with null/empty values are
+ * omitted by the server, so every read is guarded.
+ *
+ * CreatedDialog additionally carries created_at/updated_at/user_id (creator) and
+ * has no last_message* fields (dialog just created); UpdatedDialog carries
+ * last_message* and (per server contract) may also carry created_at/updated_at/
+ * user_id. Reading them here for both is safe — absent fields are simply skipped.
+ *
+ * @param {Element} extraParams
+ * @param {String} dialogId - already-resolved dialog_id text.
+ * @return {Object} partial dialog snapshot.
+ */
+function _parseDialogSnapshot(extraParams, dialogId) {
+    var dlg = {};
+    dlg._id = dialogId;
+
+    var name = chatUtils.getElementText(extraParams, 'name');
+    if (name !== undefined && name !== null && name !== '') {
+        dlg.name = name;
+    }
+    var photo = chatUtils.getElementText(extraParams, 'photo');
+    if (photo !== undefined && photo !== null && photo !== '') {
+        dlg.photo = photo;
+    }
+    var typeText = chatUtils.getElementText(extraParams, 'type');
+    var typeNum = parseInt(typeText, 10);
+    if (!isNaN(typeNum)) {
+        dlg.type = typeNum;
+    }
+    var occupants = _parseNumericIdsCsv(chatUtils.getElementText(extraParams, 'occupants_ids'));
+    if (occupants.length > 0) {
+        dlg.occupants_ids = occupants;
+    }
+    var admins = _parseNumericIdsCsv(chatUtils.getElementText(extraParams, 'admin_ids'));
+    if (admins.length > 0) {
+        dlg.admin_ids = admins;
+    }
+    var isJoinReqText = chatUtils.getElementText(extraParams, 'is_join_required');
+    if (isJoinReqText !== undefined && isJoinReqText !== null && isJoinReqText !== '') {
+        var isJoinReq = parseInt(isJoinReqText, 10);
+        dlg.is_join_required = isNaN(isJoinReq) ? isJoinReqText : isJoinReq;
+    }
+    var roomJid = chatUtils.getElementText(extraParams, 'xmpp_room_jid');
+    if (roomJid !== undefined && roomJid !== null && roomJid !== '') {
+        // Server may pretty-print xmpp_room_jid with surrounding whitespace.
+        dlg.xmpp_room_jid = roomJid.trim();
+    }
+    var customData = _parseCustomData(extraParams);
+    if (customData !== undefined) {
+        dlg.custom_data = customData;
+    }
+    // Creation / modification metadata (present on CreatedDialog; also valid on
+    // UpdatedDialog per server contract). Kept as ISO-8601 strings verbatim.
+    var createdAt = chatUtils.getElementText(extraParams, 'created_at');
+    if (createdAt !== undefined && createdAt !== null && createdAt !== '') {
+        dlg.created_at = createdAt;
+    }
+    var updatedAt = chatUtils.getElementText(extraParams, 'updated_at');
+    if (updatedAt !== undefined && updatedAt !== null && updatedAt !== '') {
+        dlg.updated_at = updatedAt;
+    }
+    var userIdText = chatUtils.getElementText(extraParams, 'user_id');
+    var userId = parseInt(userIdText, 10);
+    if (!isNaN(userId)) {
+        dlg.user_id = userId;
+    }
+    // Last message fields (present on UpdatedDialog; absent on a freshly
+    // CreatedDialog — the guards below simply skip them then).
+    var lmText = chatUtils.getElementText(extraParams, 'last_message');
+    if (lmText) { dlg.last_message = lmText; }
+    var lmId = chatUtils.getElementText(extraParams, 'last_message_id');
+    if (lmId) { dlg.last_message_id = lmId; }
+    var lmDsText = chatUtils.getElementText(extraParams, 'last_message_date_sent');
+    var lmDs = parseInt(lmDsText, 10);
+    if (!isNaN(lmDs)) { dlg.last_message_date_sent = lmDs; }
+    var lmUidText = chatUtils.getElementText(extraParams, 'last_message_user_id');
+    var lmUid = parseInt(lmUidText, 10);
+    if (!isNaN(lmUid)) { dlg.last_message_user_id = lmUid; }
+
+    return dlg;
+}
+
 /**
  * Parse a Notice headline stanza into {type, payload} ready for routing.
  * Returns null if stanza is not a Notice (no urn:xmpp:notice:0 namespace, or
@@ -422,59 +515,12 @@ function _parseNoticeStanza(stanza) {
                 message: msg
             };
         }
-    } else if (type === IDS.UPDATED_DIALOG) {
-        // Build a partial QBChatDialog object from extraParams (full server snapshot).
-        var dlg = {};
-        dlg._id = dialogId;
-        var name = chatUtils.getElementText(extraParams, 'name');
-        if (name !== undefined && name !== null && name !== '') {
-            dlg.name = name;
-        }
-        var photo = chatUtils.getElementText(extraParams, 'photo');
-        if (photo !== undefined && photo !== null && photo !== '') {
-            dlg.photo = photo;
-        }
-        var typeText = chatUtils.getElementText(extraParams, 'type');
-        var typeNum = parseInt(typeText, 10);
-        if (!isNaN(typeNum)) {
-            dlg.type = typeNum;
-        }
-        var occupants = _parseNumericIdsCsv(chatUtils.getElementText(extraParams, 'occupants_ids'));
-        if (occupants.length > 0) {
-            dlg.occupants_ids = occupants;
-        }
-        var admins = _parseNumericIdsCsv(chatUtils.getElementText(extraParams, 'admin_ids'));
-        if (admins.length > 0) {
-            dlg.admin_ids = admins;
-        }
-        var isJoinReqText = chatUtils.getElementText(extraParams, 'is_join_required');
-        if (isJoinReqText !== undefined && isJoinReqText !== null && isJoinReqText !== '') {
-            var isJoinReq = parseInt(isJoinReqText, 10);
-            dlg.is_join_required = isNaN(isJoinReq) ? isJoinReqText : isJoinReq;
-        }
-        var roomJid = chatUtils.getElementText(extraParams, 'xmpp_room_jid');
-        if (roomJid !== undefined && roomJid !== null && roomJid !== '') {
-            dlg.xmpp_room_jid = roomJid;
-        }
-        var customData = _parseCustomData(extraParams);
-        if (customData !== undefined) {
-            dlg.custom_data = customData;
-        }
-        // Last message fields.
-        var lmText = chatUtils.getElementText(extraParams, 'last_message');
-        if (lmText) { dlg.last_message = lmText; }
-        var lmId = chatUtils.getElementText(extraParams, 'last_message_id');
-        if (lmId) { dlg.last_message_id = lmId; }
-        var lmDsText = chatUtils.getElementText(extraParams, 'last_message_date_sent');
-        var lmDs = parseInt(lmDsText, 10);
-        if (!isNaN(lmDs)) { dlg.last_message_date_sent = lmDs; }
-        var lmUidText = chatUtils.getElementText(extraParams, 'last_message_user_id');
-        var lmUid = parseInt(lmUidText, 10);
-        if (!isNaN(lmUid)) { dlg.last_message_user_id = lmUid; }
-
+    } else if (type === IDS.UPDATED_DIALOG || type === IDS.CREATED_DIALOG) {
+        // Full server dialog snapshot. UpdatedDialog and CreatedDialog (SR-2952)
+        // share the same shape; they differ only by moduleIdentifier (routing).
         payload = {
             kind: 'dialog',
-            dialog: dlg
+            dialog: _parseDialogSnapshot(extraParams, dialogId)
         };
     } else {
         return null;
@@ -521,6 +567,10 @@ function _routeNoticeEvent(chatProxy, parsed) {
         if (typeof chatProxy.onDialogUpdatedListener === 'function') {
             Utils.safeCallbackCall(chatProxy.onDialogUpdatedListener, p.dialog);
         }
+    } else if (type === IDS.CREATED_DIALOG) {
+        if (typeof chatProxy.onDialogCreatedListener === 'function') {
+            Utils.safeCallbackCall(chatProxy.onDialogCreatedListener, p.dialog);
+        }
     }
 }
 
@@ -621,6 +671,15 @@ function ChatProxy(service) {
     this.onMessageReactionChangedListener = null;
     this.onDialogDeletedListener = null;
     this.onDialogUpdatedListener = null;
+    /**
+     * NoticeCreatedDialog listener (SR-2952). Fired when a Group or Private
+     * dialog is created and the current user has the Notice feature enabled.
+     * Signature: onDialogCreatedListener(dialog). The dialog is a partial
+     * snapshot from the creation notice — it carries created_at/updated_at/
+     * user_id (creator) but no last_message* fields (the dialog is brand new),
+     * and for a private dialog no xmpp_room_jid. Not fired for Public dialogs.
+     */
+    this.onDialogCreatedListener = null;
 
     // [QC-1550] XMPP connection is considered "verified" only after the first
     // successful pong response. Strophe emits Status.CONNECTED at the transport
@@ -1800,6 +1859,22 @@ ChatProxy.prototype = {
         self._isConnecting = false;
         self._sessionHasExpired = false;
 
+        // [CROS-1061] A new XMPP session never carries the previous session's
+        // Notice subscription: the server binds <enable xmlns="urn:xmpp:notice:0"/>
+        // to the stream, so it is gone once the stream is gone. Without this
+        // reset the flag stays `true` after a transport reconnect while no
+        // notices are delivered any more, and isNoticesEnabled() misleads the
+        // application into skipping the re-enable (verified against a live
+        // server: socket break -> reconnect -> flag true, zero notice stanzas;
+        // clearing the flag and re-sending <enable> restored delivery).
+        //
+        // Placed in the shared preamble, above the isInitialConnect branch, and
+        // above the onReconnectListener call below: with
+        // config.pingLocalhostTimeInterval === 0 that listener fires
+        // synchronously from this function, and a consumer re-enabling notices
+        // from it must not observe a stale `true`.
+        self._isNoticesEnabled = false;
+
         self._enableCarbons();
 
         if (isInitialConnect) {
@@ -1810,7 +1885,6 @@ ChatProxy.prototype = {
             self._isConnectionVerified = true;
             self._isReconnectListenerPending = false;
 
-            // TODO(2.25.0): auto-enable Notice Feature here (see qbChat.js enableNotices JSDoc).
             self.roster.get(function (contacts) {
                 xmppClient.send(presence);
 
@@ -1818,7 +1892,24 @@ ChatProxy.prototype = {
                 callback(self.roster.contacts);
             });
         } else {
+            // [CROS-1061] Union of the rooms still tracked on this instance and
+            // the ones an explicit reconnect() had to drop. Consumed once —
+            // clearing it here keeps a later session (or another user after
+            // logout) from resurrecting a stale list.
+            //
+            // Safe to build the join stanzas at this point: setUserCurrentJid()
+            // above has already installed the new JID, and muc.join() derives
+            // the presence `from` out of it. Moving this block above that call
+            // would send from="".
             var rooms = Object.keys(self.muc.joinedRooms);
+            var remembered = self.muc._roomsToRejoin || [];
+
+            for (var r = 0; r < remembered.length; r++) {
+                if (rooms.indexOf(remembered[r]) === -1) {
+                    rooms.push(remembered[r]);
+                }
+            }
+            self.muc._roomsToRejoin = [];
 
             xmppClient.send(presence);
 
@@ -2041,6 +2132,11 @@ ChatProxy.prototype = {
         // connection had a chance to verify itself.
         this._isConnectionVerified = false;
         this._isReconnectListenerPending = false;
+        // [CROS-1061] Remember the rooms before dropping them, so the re-join
+        // loop in _postConnectActions has something to restore. Without this the
+        // list is lost and group dialogs stop receiving message-level notices
+        // until the page is reloaded.
+        this.muc._roomsToRejoin = Object.keys(this.muc.joinedRooms);
         this.muc.joinedRooms = {};
         this.helpers.setUserCurrentJid('');
 
@@ -2434,6 +2530,9 @@ ChatProxy.prototype = {
         this._checkConnectionTimer = undefined;
         this._checkExpiredSessionTimer = undefined;
         this.muc.joinedRooms = {};
+        // [CROS-1061] Never carry rooms across a logout: re-joining the previous
+        // user's rooms from a new JID is answered with 403/407 by the server.
+        this.muc._roomsToRejoin = [];
         // [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,
@@ -2465,19 +2564,29 @@ ChatProxy.prototype = {
      * Subscribe the current XMPP session to Notice Feature stanzas
      * (urn:xmpp:notice:0). After a successful IQ result the server starts
      * delivering NoticeUpdatedMessage / NoticeDeletedMessage /
-     * NoticeUpdatedDialog / NoticeDeletedDialog headline stanzas.
+     * NoticeCreatedDialog / NoticeUpdatedDialog / NoticeDeletedDialog
+     * headline stanzas.
      *
-     * The local enabled flag is reset to false on chat disconnect — consumers
-     * must call enableNotices() again after a reconnect (intentional divergence
-     * from the Android SDK, which auto-restores the subscription).
+     * The subscription belongs to the XMPP session, so it does not survive a
+     * reconnect: the local enabled flag is reset to false whenever a new session
+     * is established (initial connect and every reconnect alike) as well as on
+     * disconnect. Consumers must call enableNotices() again after a reconnect —
+     * an intentional divergence from the Android SDK, which auto-restores the
+     * subscription. Reacting to onReconnectListener is the supported way to do
+     * that.
      *
-     * TODO(2.25.0): make auto-enable SDK-internal — fire on initial connect and
-     * on relogin after session-expired, skip on Stream-Management reconnect.
-     * Spec & three-state matrix are tracked in the internal 2.25.0 backlog
-     * (auto-enable notices).
+     * Concurrent calls are safe: each IQ carries its own unique id, responses
+     * are dispatched per id, and the flag is set independently for each result.
+     * Calling enableNotices() again before the previous callback fires is
+     * therefore allowed — for example when a second reconnect arrives while the
+     * first enable is still in flight.
      *
-     * Do not call enableNotices again before the previous callback fires —
-     * concurrent enable calls are not specified.
+     * If the server does not answer, the callback receives an error after a
+     * timeout instead of never being called.
+     *
+     * TODO(2.25.0): make auto-enable SDK-internal — fire on initial connect and
+     * on every reconnect. Spec & three-state matrix are tracked in the internal
+     * 2.25.0 backlog (auto-enable notices).
      *
      * @memberof QB.chat
      * @param {enableNoticesCallback} callback - Called with (error, result) on IQ result.
@@ -2516,7 +2625,10 @@ ChatProxy.prototype = {
      * Returns the local Notice Feature subscription flag.
      * @memberof QB.chat
      * @return {Boolean} true after a successful enableNotices(), false otherwise.
-     *   Reset to false on chat disconnect; not synchronized with the server.
+     *   Reset to false on disconnect and whenever a new XMPP session is
+     *   established, so after a reconnect it reports false until the consumer
+     *   enables notices again. Not synchronized with the server: it reflects
+     *   what this client last requested, not the server's own state.
      * @since 2.24.0
      */
     isNoticesEnabled: function () {
@@ -2569,10 +2681,34 @@ ChatProxy.prototype = {
         }
 
         if (Utils.getEnv().browser) {
-            self.connection.sendIQ(iq, _onSuccess, _onError);
+            // [CROS-1061] Without the 4th argument Strophe never times the IQ out,
+            // so a server that stays silent leaves the caller without any callback
+            // at all — the application spins forever. On timeout Strophe calls
+            // _onError(null), which reports a 'cancel' error and leaves the flag
+            // untouched.
+            //
+            // Note: this covers "server does not answer". It does NOT cover
+            // "socket died", because the timeout is an addTimedHandler and
+            // connection.reset() (called from the DISCONNECTED branch) clears
+            // timedHandlers. That case is covered by the consumer-side timeout.
+            self.connection.sendIQ(iq, _onSuccess, _onError, NOTICE_IQ_TIMEOUT_MS);
         } else {
             // Node/NativeScript path: register callback in nodeStanzasCallbacks map.
+            // This path does not go through sendIQ, so the timeout is ours to run.
+            var noticeIqTimer = setTimeout(function () {
+                // Drop the pending entry first: _onIQ only dispatches while the
+                // entry exists, so a late answer after this point is ignored
+                // instead of invoking the callback a second time.
+                delete self.nodeStanzasCallbacks[iqParams.id];
+                _onError(null);
+            }, NOTICE_IQ_TIMEOUT_MS);
+
             self.nodeStanzasCallbacks[iqParams.id] = function (stanza) {
+                // Must be first: otherwise a timely answer still leaves the timer
+                // armed, and it would fire later and call the callback a second
+                // time with an error.
+                clearTimeout(noticeIqTimer);
+
                 // The map handler receives the result/error stanza. Inspect type to dispatch.
                 var iqType = chatUtils.getAttr(stanza, 'type');
                 if (iqType === 'result') {
@@ -2901,6 +3037,20 @@ function MucProxy(options) {
     this.nodeStanzasCallbacks = options.nodeStanzasCallbacks;
     //
     this.joinedRooms = {};
+
+    /**
+     * [CROS-1061] Rooms carried across an explicit QB.chat.reconnect().
+     *
+     * reconnect() has to clear joinedRooms — the new session holds no presence
+     * yet — but until now it dropped the list without keeping a copy, so the
+     * re-join loop in _postConnectActions found nothing to restore and group
+     * dialogs silently stopped receiving message-level notices.
+     *
+     * Written only by reconnect(), read and cleared once by _postConnectActions,
+     * and cleared by disconnect() so one user's rooms can never be re-joined
+     * from another user's JID.
+     */
+    this._roomsToRejoin = [];
 }
 
 MucProxy.prototype = {

package/src/modules/chat/qbNoticeConsts.js

@@ -23,7 +23,8 @@ var NOTICE_MODULE_IDENTIFIER = {
     UPDATED_MESSAGE: 'NoticeUpdatedMessage',
     DELETED_MESSAGE: 'NoticeDeletedMessage',
     UPDATED_DIALOG:  'NoticeUpdatedDialog',
-    DELETED_DIALOG:  'NoticeDeletedDialog'
+    DELETED_DIALOG:  'NoticeDeletedDialog',
+    CREATED_DIALOG:  'NoticeCreatedDialog'
 };
 
 module.exports = {

package/src/qbConfig.js

@@ -12,8 +12,8 @@
  */
 
 var config = {
-  version: '2.24.0',
-  buildNumber: '1180',
+  version: '2.24.1-alpha.1',
+  buildNumber: '1181',
   creds: {
     'appId': 0,
     'authKey': '',