v2.21.0

Author: Artem-K-Koltunov

quickblox-minus-h264.js

@@ -141,8 +141,13 @@ export declare interface QBConfig {
     ) => void
   }
   pingTimeout?: number
+  pingDebug?: boolean
   pingLocalhostTimeInterval?: number
   chatReconnectionTimeInterval?: number
+  /** If true, QB.init will do a short synchronous block after starting account_settings. Default: true. */
+  initBlockOnSettings?: boolean
+  /** Busy-wait duration in ms used when initBlockOnSettings=true. Default: 3000. */
+  initBlockDurationMs?: number
 }
 
 export declare interface QBError {
@@ -1636,6 +1641,13 @@ export class QuickBlox {
     config?: QBConfig,
   ): void
 
+  /**
+     * Resolves when internal async initialization (e.g., fetching `account_settings`
+     * and rebinding endpoints) is finished. If no async work was scheduled during
+     * `init`, it resolves immediately.
+  */
+  ready(): Promise<void>
+
   /**
    * Init QuickBlox SDK with User Account data to start session with token
    * ([read more](https://docs.quickblox.com/docs/js-setup#initialize-quickblox-sdk-without-authorization-key-and-secret)).

quickblox-recv-codecs.js

@@ -15129,8 +15129,10 @@ function isUndefined(arg) {
 }
 
 },{}],80:[function(require,module,exports){
+'use strict';
+
 /* eslint-env browser */
-module.exports = typeof self == 'object' ? self.FormData : window.FormData;
+module.exports = typeof self === 'object' ? self.FormData : window.FormData;
 
 },{}],81:[function(require,module,exports){
 'use strict';
@@ -55078,8 +55080,8 @@ module.exports = StreamManagement;
  */
 
 var config = {
-  version: '2.20.0',
-  buildNumber: '1165',
+  version: '2.21.0',
+  buildNumber: '1167',
   creds: {
     'appId': 0,
     'authKey': '',
@@ -55101,6 +55103,9 @@ var config = {
     active: 2
   },
   pingTimeout: 1,
+  pingDebug: false,
+  initBlockOnSettings: false,
+  initBlockDurationMs: 3000,
   pingLocalhostTimeInterval: 5,
   chatReconnectionTimeInterval: 3,
   webrtc: {
@@ -55206,6 +55211,10 @@ module.exports = config;
 var config = require('./qbConfig');
 var Utils = require('./qbUtils');
 const MessageProxy = require("./modules/chat/qbMessage");
+const Chat = require("./modules/chat/qbChat");
+const DialogProxy = require("./modules/chat/qbDialog");
+const WebRTCClient = require("./modules/webrtc/qbWebRTCClient");
+const PushNotifications = require("./modules/qbPushNotifications");
 
 // Actual QuickBlox API starts here
 function QuickBlox() {}
@@ -55290,6 +55299,10 @@ QuickBlox.prototype = {
         } else {
             this.webrtc = false;
         }
+        this._initReady = Promise.resolve();
+        var initBlockOnSettings = (typeof config.initBlockOnSettings === 'boolean') ? config.initBlockOnSettings : true;
+        var initBlockDurationMs = (typeof config.initBlockDurationMs === 'number') ? config.initBlockDurationMs : 3000;
+
 
         // Initialization by outside token
         if (typeof appIdOrToken === 'string' && (!authKeyOrAppId || typeof authKeyOrAppId === 'number') && !authSecret) {
@@ -55317,21 +55330,148 @@ QuickBlox.prototype = {
                 config.urls.account,
                 config.urls.type
             ].join('');
+
+            // generic function to capture (extract) listeners
+            var preserveListeners = function (obj) {
+                var map = {};
+                if (!obj) return map;
+                Object.keys(obj).forEach(function (k) {
+                    if (/^on[A-Z]/.test(k) && typeof obj[k] === 'function') {
+                        map[k] = obj[k];
+                    }
+                });
+                return map;
+            };
+
+            // restore
+            var reassignListeners = function (target, map) {
+                if (!target || !map) return;
+                Object.keys(map).forEach(function (k) {
+                    target[k] = map[k];
+                });
+            };
+
             // account settings
-            this.service.ajax({
-                url: accountSettingsUrl
-            }, function (err, response) {
-                if (!err && typeof response === 'object') {
-                    var update = {
-                        endpoints: {
-                            api: response.api_endpoint.replace(/^https?:\/\//, ''),
-                            chat: response.chat_endpoint
+            var self = this;
+            //
+            this._initReady = new Promise(function(resolve) {
+                self.service.ajax({ url: accountSettingsUrl }, function (err, response) {
+                    // resolve in any case (so legacy clients won’t hang)
+                    if (!err && typeof response === 'object') {
+                        // 1) apply endpoints
+                        var update = {
+                            endpoints: {
+                                api:  response.api_endpoint.replace(/^https?:\/\//, ''),
+                                chat: response.chat_endpoint
+                            }
+                        };
+                        config.set(update);
+
+                        // 2) preserve ALL previously assigned listeners (dynamically)
+                        var savedChatListeners   = preserveListeners(self.chat);
+                        var savedWebRTCListeners = preserveListeners(self.webrtc);
+
+                        // 3) re-create dependent components for the new endpoints
+                        self.pushnotifications = new PushNotifications(self.service);
+                        self.chat = new Chat(self.service);
+                        self.chat.dialog = new DialogProxy(self.service);
+                        self.chat.message = new MessageProxy(self.service);
+
+                        if (Utils.getEnv().browser) {
+                            require('webrtc-adapter');
+                            if (Utils.isWebRTCAvailble()) {
+                                var WebRTCClient = require('./modules/webrtc/qbWebRTCClient');
+                                self.webrtc = new WebRTCClient(self.service, self.chat);
+                            } else {
+                                self.webrtc = false;
+                            }
+                        } else {
+                            self.webrtc = false;
                         }
-                    };
-                    config.set(update);
-                }
+
+                        // 4) reattach listeners to the new instances
+                        reassignListeners(self.chat,   savedChatListeners);
+                        reassignListeners(self.webrtc, savedWebRTCListeners);
+                    }
+
+                    resolve(); // init completed (with or without migration)
+                });
             });
+            //
+            // previous version with callback
+            // this.service.ajax({
+            //     url: accountSettingsUrl
+            // }, function (err, response) {
+            //     if (!err && typeof response === 'object') {
+            //         var update = {
+            //             endpoints: {
+            //                 api: response.api_endpoint.replace(/^https?:\/\//, ''),
+            //                 chat: response.chat_endpoint
+            //             }
+            //         };
+            //         config.set(update);
+            //         //
+            //         self.pushnotifications = new PushNotifications(self.service);
+            //         self.chat = new Chat(self.service);
+            //         self.chat.dialog = new DialogProxy(self.service);
+            //         self.chat.message = new MessageProxy(self.service);
+            //         //
+            //         if (Utils.getEnv().browser) {
+            //             /** add adapter.js*/
+            //             require('webrtc-adapter');
+            //
+            //             /** add WebRTC API if API is avaible */
+            //             if( Utils.isWebRTCAvailble() ) {
+            //                 var WebRTCClient = require('./modules/webrtc/qbWebRTCClient');
+            //                 self.webrtc = new WebRTCClient(self.service, self.chat);
+            //             } else {
+            //                 self.webrtc = false;
+            //             }
+            //         } else {
+            //             self.webrtc = false;
+            //         }
+            //         //
+            //     }
+            // });
+            //
+        }
+        //
+        // --- artificial sync delay to increase the chance account_settings completes before legacy code continues
+        // enabled only when shouldGetSettings && config.initBlockOnSettings !== false
+        if (shouldGetSettings && initBlockOnSettings) {
+            try {
+                var __qb_init_block_until__ = Date.now() + initBlockDurationMs;
+                while (Date.now() < __qb_init_block_until__) {
+                    // intentional busy-wait (do not remove)
+                }
+            } catch (_) { /* never throw from here */ }
         }
+        //
+
+    },
+
+    /**
+     * Wait until SDK async initialization finishes (if any).
+     * It resolves after internal tasks like fetching `account_settings`,
+     * rebinding endpoints, and re-instantiating dependent modules are completed.
+     * If no async work was scheduled during `QB.init(...)`, it resolves immediately.
+     *
+     * @memberof QB
+     * @returns {Promise<void>} A promise that resolves when initialization is complete.
+     *
+     * @example
+     * QB.init(appId, authKey, authSecret, accountKey, config);
+     * QB.ready().then(function () {
+     *   // Safe point: endpoints are updated, chat/webrtc are re-created, listeners preserved.
+     *   QB.startSession({ login: 'john', password: 'secret' }, function (err, res) {
+     *     if (!err) {
+     *       QB.chat.connect({ userId: res.user.id, password: res.session.token }, function(){});
+     *     }
+     *   });
+     * });
+     */
+    ready: function() {
+        return this._initReady || Promise.resolve();
     },
 
     /**
@@ -55755,13 +55895,58 @@ ServiceProxy.prototype = {
 
                 self.handleResponse(null, body, callback, retry);
             }
+            // if (self._fetchingSettings) {
+            //     self._fetchingSettings = false;
+            //     while (self._queue.length) {
+            //         var args = self._queue.shift();
+            //         self.ajax.apply(self, args);
+            //     }
+            // }
+            //
             if (self._fetchingSettings) {
                 self._fetchingSettings = false;
+
+                var sharedApiHost  =  'api.quickblox.com';
+                var sharedChatHost = 'chat.quickblox.com';
+
+                sharedApiHost  = sharedApiHost.replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+                sharedChatHost = sharedChatHost.replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+
+                var RE_SHARED_API  = new RegExp('^https?://' + sharedApiHost.replace(/\./g, '\\.') + '(?=[:/]|$)', 'i');
+                var RE_SHARED_CHAT = new RegExp('^https?://' + sharedChatHost.replace(/\./g, '\\.') + '(?=[:/]|$)', 'i');
+
+                var newApiHost  = (self.qbInst.config.endpoints.api  || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+                var newChatHost = (self.qbInst.config.endpoints.chat || '').replace(/^https?:\/\//i, '').replace(/\/+$/, '');
+                var NEW_API_URL  = 'https://' + newApiHost;
+                var NEW_CHAT_URL = 'https://' + newChatHost;
+
                 while (self._queue.length) {
-                    var args = self._queue.shift();
+                    var args = self._queue.shift();   // [params, callback]
+                    var p = args && args[0];
+
+                    if (p && typeof p.url === 'string') {
+                        var url = p.url;
+                        var changed = false;
+
+                        if (RE_SHARED_API.test(url)) {
+                            url = url.replace(RE_SHARED_API, NEW_API_URL);
+                            changed = true;
+                        }
+                        if (RE_SHARED_CHAT.test(url)) {
+                            url = url.replace(RE_SHARED_CHAT, NEW_CHAT_URL);
+                            changed = true;
+                        }
+
+                        if (changed) {
+                            p.url = url;
+                        }
+                    }
+
                     self.ajax.apply(self, args);
                 }
             }
+
+            //
         }
 
         function retry(session) {
@@ -56029,9 +56214,68 @@ var Utils = {
     },
 
     QBLog: function(){
+        var argsArr = Array.prototype.slice.call(arguments);
+
+        function containsPing(x) {
+            var needle = 'ping';
+
+            try {
+                if (x == null) return false;
+
+                if (typeof x === 'string') {
+                    return x.toLowerCase().indexOf(needle) !== -1;
+                }
+
+                if (typeof x === 'number' || typeof x === 'boolean') {
+                    return false;
+                }
+
+                if (typeof x === 'object') {
+                    //DELETE XEP-0198 SM packages from log:
+                    // <r xmlns="urn:xmpp:sm:3"/> and <a xmlns="urn:xmpp:sm:3" h="..."/>
+                    if (typeof x.outerHTML === 'string') {
+                        var oh = x.outerHTML.replace(/\s+/g, ' ').toLowerCase();
+                        if (
+                            oh.indexOf('urn:xmpp:sm:3') !== -1 &&
+                            (/^<\s*r\b/.test(oh) || /^<\s*a\b/.test(oh))
+                        ) {
+                            return true;
+                        }
+                    }
+
+                    var candidates = [
+                        x.textContent,
+                        x.innerHTML,
+                        x.outerHTML,
+                        x.nodeName,
+                        x.tagName,
+                        x.id
+                    ];
+
+                    for (var j = 0; j < candidates.length; j++) {
+                        var s = candidates[j];
+                        if (typeof s === 'string' && s.toLowerCase().indexOf(needle) !== -1) {
+                            return true;
+                        }
+                    }
+                }
+            } catch (_) {}
+
+            return false;
+        }
+
+
+        let shouldSuppressPing1 =
+            config && config.pingDebug === false;
+        let shouldSuppressPing2 =argsArr.some(containsPing);
+
+        let shouldSuppressPing = shouldSuppressPing1 && shouldSuppressPing2;
+
         if (this.loggers) {
             for (var i=0; i<this.loggers.length; ++i) {
-                this.loggers[i](arguments);
+                if (!shouldSuppressPing) {
+                   this.loggers[i](arguments);
+                }
             }
 
             return;
@@ -56112,7 +56356,12 @@ var Utils = {
 
         if(this.loggers){
             for(var j=0;j<this.loggers.length;++j){
-                this.loggers[j](arguments);
+                // this.loggers[j](arguments);
+                //
+                if (!shouldSuppressPing) {
+                    this.loggers[j](arguments);
+                }
+                //
             }
         }
     },

quickblox.d.ts

@@ -17,6 +17,7 @@ var QBconfig = {
             enable: true
         },
         debug: true,
+        pingDebug: true,
         callBackInterval: 30,
     },
 };