quickblox 2.13.10 → 2.14.0

package/src/modules/chat/qbChat.js

@@ -95,6 +95,9 @@ function ChatProxy(service) {
     this._isLogout = false;
 
     this._checkConnectionTimer = undefined;
+    // this._checkConnectionPingTimer = undefined; //artan: 13/09/2022 at 16:30
+    this._checkExpiredSessionTimer = undefined;
+    this._sessionHasExpired = false;
     this._pings = {};
     //
     this.helpers = new Helpers();
@@ -149,6 +152,7 @@ function ChatProxy(service) {
      * - onLastUserActivityListener (userId, seconds)
      * - onDisconnectedListener
      * - onReconnectListener
+     * - onSessionExpiredListener
      */
 
     /**
@@ -768,7 +772,7 @@ ChatProxy.prototype = {
                     case Strophe.Status.AUTHFAIL:
                         self.isConnected = false;
                         self._isConnecting = false;
-                        
+
                         err = Utils.getError(401, 'Status.AUTHFAIL - The authentication attempt failed', 'QBChat');
                         
                         if (isInitialConnect) {
@@ -776,6 +780,7 @@ ChatProxy.prototype = {
                         }
                         
                         if(!self.isConnected && typeof self.onReconnectFailedListener === 'function'){
+                            // TODO: investigate problem reconnect field
                             Utils.safeCallbackCall(self.onReconnectFailedListener, err);
                         }
                         
@@ -796,7 +801,50 @@ ChatProxy.prototype = {
                         self.connection.XAddTrackedHandler(self._onIQ, null, 'iq');
                         self.connection.XAddTrackedHandler(self._onSystemMessageListener, null, 'message', 'headline');
                         self.connection.XAddTrackedHandler(self._onMessageErrorListener, null, 'message', 'error');
-                    
+
+                        // var noTimerId = typeof self._checkConnectionPingTimer === 'undefined';  //artan: 13/09/2022 at 16:30
+                        // noTimerId = config.pingLocalhostTimeInterval === 0 ? false : noTimerId;
+                        // if (noTimerId) {
+                        //     Utils.QBLog('[QBChat]', 'Init ping to localhost at ', Utils.getCurrentTime());
+                        //     self._checkConnectionPingTimer = setInterval(function() {
+                        //         self._ping(userJid,
+                        //             function(error) {
+                        //                 if (error) {
+                        //                     Utils.QBLog('[QBChat]',
+                        //                         'Local Ping: ',
+                        //                         'failed, at ', Utils.getCurrentTime(),
+                        //                         ' error: ', error);
+                        //                 } else {
+                        //                     Utils.QBLog('[QBChat]',
+                        //                         'Local Ping: ',
+                        //                         'ok, at ', Utils.getCurrentTime());
+                        //                 }
+                        //             });
+                        //     }, config.pingLocalhostTimeInterval * 1000);
+                        // }
+
+                        if (typeof self.onSessionExpiredListener === 'function') {
+                            var noExpiredSessionTimerId = typeof self._checkExpiredSessionTimer === 'undefined';
+                            if (noExpiredSessionTimerId) {
+                                Utils.QBLog('[QBChat]', 'Init timer for check session expired at ', ((new Date()).toTimeString().split(' ')[0]));
+                                self._checkExpiredSessionTimer = setInterval(function() {
+                                    var timeNow = new Date();
+                                    if (typeof config.qbTokenExpirationDate !== 'undefined') {
+                                        var timeLag = Math.round((timeNow.getTime() - config.qbTokenExpirationDate.getTime()) / (1000 * 60));
+                                        //artan 25-08-2022
+                                        // TODO: need to delete in task [CROS-815]
+                                        console.log('timeLag: ', timeLag);
+                                        if (timeLag >= 0) {
+                                            self._sessionHasExpired = true;
+                                            Utils.safeCallbackCall(self.onSessionExpiredListener, null);
+                                        }
+                                    }
+                                    // TODO: in task [CROS-815], may by need to change 5 * 1000 to config.liveSessionInterval * 1000
+                                }, 5 * 1000);
+
+                            }
+                        }
+
                         self._postConnectActions(function(roster) {
                             callback(null, roster);
                         }, isInitialConnect);
@@ -917,10 +965,13 @@ ChatProxy.prototype = {
     _postConnectActions: function(callback, isInitialConnect) {
         Utils.QBLog('[QBChat]', 'Status.CONNECTED at ' + chatUtils.getLocalTime());
 
-        var self = this,
-            xmppClient = Utils.getEnv().browser ? self.connection : self.Client,
-            presence = Utils.getEnv().browser ? $pres() : chatUtils.createStanza(XMPP.Stanza, null, 'presence');
-                
+        var self = this;
+        var isBrowser = Utils.getEnv().browser;
+        var xmppClient = isBrowser ? self.connection : self.Client;
+        var presence = isBrowser ?
+            $pres() :
+            chatUtils.createStanza(XMPP.Stanza, null, 'presence');
+
         if (config.streamManagement.enable && config.chatProtocol.active === 2) {
             self.streamManagement.enable(self.connection, null);
             self.streamManagement.sentMessageCallback = self._sentMessageCallback;
@@ -930,6 +981,7 @@ ChatProxy.prototype = {
         
         self.isConnected = true;
         self._isConnecting = false;
+        self._sessionHasExpired = false;
 
         self._enableCarbons();
 
@@ -958,16 +1010,21 @@ ChatProxy.prototype = {
     },
 
     _establishConnection: function(params) {
+        //  TODO: must to call if only qbTokenExpirationDate is not expried
         var self = this;
-        
+        Utils.QBLog('[QBChat]', '_establishConnection called');
         if (self._isLogout || self._checkConnectionTimer) {
+            Utils.QBLog('[QBChat]', '_establishConnection return');
             return;
         }
 
         var _connect = function() {
-            if (!self.isConnected && !self._isConnecting) {
+            Utils.QBLog('[QBChat]', 'call _connect() in _establishConnection ');
+            if (!self.isConnected && !self._isConnecting && !self._sessionHasExpired) {
+                Utils.QBLog('[QBChat]', 'call connect() again in _establishConnection ');
                 self.connect(params);
             } else {
+                Utils.QBLog('[QBChat]', 'stop timer in _establishConnection ');
                 clearInterval(self._checkConnectionTimer);
                 self._checkConnectionTimer = undefined;
             }
@@ -975,6 +1032,8 @@ ChatProxy.prototype = {
 
         _connect();
 
+
+        // TODO: investigate problem with interval connection
         self._checkConnectionTimer = setInterval(function() {
             _connect();
         }, config.chatReconnectionTimeInterval * 1000);
@@ -988,6 +1047,7 @@ ChatProxy.prototype = {
      * @returns {String} messageId - The current message id (was generated by SDK)
      * */
     send: function(jid_or_user_id, message) {
+        Utils.QBLog('[QBChat]', 'Call send ' + JSON.stringify(message));
         var self = this,
             builder = Utils.getEnv().browser ? $msg : XMPP.Stanza;
 
@@ -1050,6 +1110,7 @@ ChatProxy.prototype = {
      * @returns {String} messageId - The current message id (was generated by SDK)
      * */
     sendSystemMessage: function(jid_or_user_id, message) {
+        Utils.QBLog('[QBChat]', 'Call sendSystemMessage ' + JSON.stringify(message));
         var self = this,
             builder = Utils.getEnv().browser ? $msg : XMPP.Stanza,
             paramsCreateMsg = {
@@ -1098,6 +1159,7 @@ ChatProxy.prototype = {
      * @param {String | Number} jid_or_user_id - Use opponent id or jid for 1 to 1 chat, and room jid for group chat.
      * */
     sendIsTypingStatus: function(jid_or_user_id) {
+        Utils.QBLog('[QBChat]', 'Call sendIsTypingStatus ');
         var self = this,
             stanzaParams = {
                 from: self.helpers.getUserCurrentJid(),
@@ -1112,10 +1174,12 @@ ChatProxy.prototype = {
             xmlns: chatUtils.MARKERS.STATES
         });
 
-        if(Utils.getEnv().browser){
-            self.connection.send(stanza);
-        } else {
-            self.Client.send(stanza);
+        if (self.connection.connected) {
+            if(Utils.getEnv().browser){
+                self.connection.send(stanza);
+            } else {
+                self.Client.send(stanza);
+            }
         }
     },
 
@@ -1125,6 +1189,7 @@ ChatProxy.prototype = {
      * @param {String | Number} jid_or_user_id - Use opponent id or jid for 1 to 1 chat, and room jid for group chat.
      * */
     sendIsStopTypingStatus: function(jid_or_user_id) {
+        Utils.QBLog('[QBChat]', 'Call sendIsStopTypingStatus ');
         var self = this,
             stanzaParams = {
                 from: self.helpers.getUserCurrentJid(),
@@ -1139,10 +1204,12 @@ ChatProxy.prototype = {
             xmlns: chatUtils.MARKERS.STATES
         });
 
-        if(Utils.getEnv().browser){
-            self.connection.send(stanza);
-        } else {
-            self.Client.send(stanza);
+        if (self.connection.connected) {
+            if(Utils.getEnv().browser){
+                self.connection.send(stanza);
+            } else {
+                self.Client.send(stanza);
+            }
         }
     },
 
@@ -1155,6 +1222,7 @@ ChatProxy.prototype = {
      * @param {Number} params.dialogId - The dialog id
      * */
     sendDeliveredStatus: function(params) {
+        Utils.QBLog('[QBChat]', 'Call sendDeliveredStatus ');
         var self = this,
             stanzaParams = {
                 type: 'chat',
@@ -1191,6 +1259,7 @@ ChatProxy.prototype = {
      * @param {Number} params.dialogId - The dialog id
      * */
     sendReadStatus: function(params) {
+        Utils.QBLog('[QBChat]', 'Call sendReadStatus ' + JSON.stringify(params));
         var self = this,
             stanzaParams = {
                 type: 'chat',
@@ -1224,6 +1293,7 @@ ChatProxy.prototype = {
      * @param {(Number|String)} jid_or_user_id - The user id or jid, that the last activity we want to know
      * */
     getLastUserActivity: function(jid_or_user_id) {
+        Utils.QBLog('[QBChat]', 'Call getLastUserActivity ');
         var iqParams,
             builder,
             iq;
@@ -1250,7 +1320,47 @@ ChatProxy.prototype = {
         }
     },
 
+    _ping: function(jid_or_user_id, callback){
+        var self = this;
+        var id = this.helpers.getUniqueId('ping');
+        var builder = Utils.getEnv().browser ? $iq : XMPP.Stanza;
+        var to;
+        var _callback;
+        var stanza;
+
+        //to = config.endpoints.chat;
+        to = 'http://localhost';
+        _callback = callback;
+
+
+        var iqParams = {
+            from: this.helpers.getUserCurrentJid(),
+            id: id,
+            to: to,
+            type: 'get'
+        };
+        stanza = chatUtils.createStanza(builder, iqParams, 'iq');
+        stanza.c('ping', { xmlns: "urn:xmpp:ping" });
+
+        var noAnswer = function () {
+            _callback('No answer');
+            self._pings[id] = undefined;
+            delete self._pings[id];
+        };
+        if (Utils.getEnv().browser) {
+            this.connection.send(stanza);
+        } else {
+            this.Client.send(stanza);
+        }
+        this._pings[id] = {
+            callback: _callback,
+            interval: setTimeout(noAnswer, config.pingTimeout * 1000)
+        };
+        return id;
+    },
+
     ping: function (jid_or_user_id, callback) {
+        Utils.QBLog('[QBChat]', 'Call ping ');
         var self = this;
         var id = this.helpers.getUniqueId('ping');
         var builder = Utils.getEnv().browser ? $iq : XMPP.Stanza;
@@ -1302,8 +1412,11 @@ ChatProxy.prototype = {
      * @memberof QB.chat
      * */
     disconnect: function() {
+        Utils.QBLog('[QBChat]', 'Call disconnect ');
         clearInterval(this._checkConnectionTimer);
+        clearInterval(this._checkExpiredSessionTimer);
         this._checkConnectionTimer = undefined;
+        this._checkExpiredSessionTimer = undefined;
         this.muc.joinedRooms = {};
         this._isLogout = true;
         this.helpers.setUserCurrentJid('');

package/src/plugins/streamManagement.js

@@ -43,6 +43,8 @@ function StreamManagement(options) {
     // The client send stanza counter.
     this._clientSentStanzasCounter = null;
 
+    this._intervalId = null;
+    
     this._timeInterval = 2000;
 
     this.sentMessageCallback = null;
@@ -127,7 +129,12 @@ StreamManagement.prototype._addEnableHandlers = function () {
         if(tagName === 'enabled'){
             self._isStreamManagementEnabled = true;
 
-            setInterval(self._timeoutCallback.bind(self), self._timeInterval);
+            return true;
+        }
+
+        if (self._isStreamManagementEnabled && tagName === 'message') {
+            clearInterval(self._intervalId);
+            self._intervalId = setInterval(self._timeoutCallback.bind(self), self._timeInterval);
 
             return true;
         }
@@ -167,17 +174,22 @@ StreamManagement.prototype.send = function (stanza, message) {
         bodyContent = chatUtils.getElementText(stanzaXML, 'body') || '',
         attachments = chatUtils.getAllElements(stanzaXML, 'attachment') || '';
 
-    self._originalSend.call(self._c, stanza);
-
-    if (tagName === 'message' && (type === 'chat' || type === 'groupchat') && (bodyContent || attachments.length)) {
-        self._sendStanzasRequest({
-            message: message,
-            time: Date.now() + self._timeInterval,
-            expect: self._clientSentStanzasCounter
-        });
+    try {
+        self._originalSend.call(self._c, stanza);
+    } catch (e) {
+        Utils.QBLog('[QBChat]', e.message);
+    } finally {
+        if (tagName === 'message' && (type === 'chat' || type === 'groupchat') && (bodyContent || attachments.length)) {
+            self._sendStanzasRequest({
+                message: message,
+                time: Date.now() + self._timeInterval,
+                expect: self._clientSentStanzasCounter
+            });
+        }
+    
+        self._clientSentStanzasCounter++;
     }
 
-    self._clientSentStanzasCounter++;
 };
 
 StreamManagement.prototype._sendStanzasRequest = function (data) {
@@ -186,10 +198,14 @@ StreamManagement.prototype._sendStanzasRequest = function (data) {
     if(self._isStreamManagementEnabled){
         self._stanzasQueue.push(data);
 
-        var stanza = Utils.getEnv().browser ? $build('r', { xmlns: self._NS}) :
-            chatUtils.createStanza(self._nodeBuilder, { xmlns: self._NS}, 'r');
+        var stanza = Utils.getEnv().browser ? $build('r', { xmlns: self._NS }) :
+            chatUtils.createStanza(self._nodeBuilder, { xmlns: self._NS }, 'r');
 
-        self._originalSend.call(self._c, stanza);
+        if (self._c.connected) {
+            self._originalSend.call(self._c, stanza);
+        } else {
+            self._checkCounterOnIncomeStanza();
+        }
     }
 };
 
@@ -198,13 +214,15 @@ StreamManagement.prototype.getClientSentStanzasCounter = function(){
 };
 
 StreamManagement.prototype._checkCounterOnIncomeStanza = function (count){
-    if (this._stanzasQueue[0].expect !== count){
-        this.sentMessageCallback(this._stanzasQueue[0].message);
-    } else {
-        this.sentMessageCallback(null, this._stanzasQueue[0].message);
+    if (this._stanzasQueue.length) {
+        if (this._stanzasQueue[0].expect !== count){
+            this.sentMessageCallback(this._stanzasQueue[0].message);
+        } else {
+            this.sentMessageCallback(null, this._stanzasQueue[0].message);
+        }
+    
+        this._stanzasQueue.shift();
     }
-
-    this._stanzasQueue.shift();
 };
 
 StreamManagement.prototype._increaseReceivedStanzasCounter = function(){

package/src/qbConfig.js

@@ -12,16 +12,16 @@
  */
 
 var config = {
-  version: '2.13.10',
-  buildNumber: '1104',
+  version: '2.14.0',
+  buildNumber: '1135',
   creds: {
-    appId: '',
-    authKey: '',
-    authSecret: '',
-    accountKey: ''
+    'appId': 0,
+    'authKey': '',
+    'authSecret': '',
+    'accountKey': ''
   },
   endpoints: {
-    api: 'api.quickblox.com',
+    api: 'apistage6.quickblox.com/',
     chat: 'chat.quickblox.com',
     muc: 'muc.chat.quickblox.com'
   },
@@ -35,6 +35,7 @@ var config = {
     active: 2
   },
   pingTimeout: 30,
+  pingLocalhostTimeInterval: 5,
   chatReconnectionTimeInterval: 5,
   webrtc: {
     answerTimeInterval: 60,
@@ -45,7 +46,7 @@ var config = {
     statsReportTimeInterval: false,
     iceServers: [
       {
-        urls: 'turn:turn.quickblox.com',
+        urls: ['turn:turn.quickblox.com', 'stun:turn.quickblox.com'],
         username: 'quickblox',
         credential: 'baccb97ba2d92d71e26eb9886da5f1e0'
       }
@@ -72,10 +73,12 @@ var config = {
   },
   timeout: null,
   debug: {
-    mode: 0,
+    mode: 1,
     file: null
   },
-  addISOTime: false
+  addISOTime: false,
+  qbTokenExpirationDate: null,
+  liveSessionInterval: 120,
 };
 
 config.set = function(options) {
@@ -105,4 +108,23 @@ config.set = function(options) {
   });
 };
 
+/*
+* 17.08.22 artan: waiting for backend fix, look at tasks:
+* [CROS-815] - Update sessionExpirationDate on each request
+* [SR-1322] - Set param Access-Control-Expose-Headerson server side
+ */
+config.updateSessionExpirationDate = function (tokenExpirationDate, headerHasToken = false) {
+  var connectionTimeLag = 1; // minute
+  var newDate = new Date(tokenExpirationDate);
+  newDate.setMinutes ( newDate.getMinutes() - connectionTimeLag);
+  // TODO: need to check in [CROS-815]
+  if (!headerHasToken) {
+    console.log('in date: ', newDate);
+    newDate.setMinutes ( newDate.getMinutes() + config.liveSessionInterval );
+    console.log('out date: ', newDate);
+  }
+  config.qbTokenExpirationDate = newDate;
+  console.log('updateSessionExpirationDate ... Set value: ', tokenExpirationDate);
+};
+
 module.exports = config;

package/src/qbMain.js

@@ -28,12 +28,24 @@ QuickBlox.prototype = {
     _getOS: Utils.getOS.bind(Utils),
 
     /**
+     * Init QuickBlox SDK with User Account data for start session with token.
      * @memberof QB
-     * @param {Number | String} appIdOrToken - Application ID (from your admin panel) or Session Token.
-     * @param {String | Number} authKeyOrAppId - Authorization key or Application ID. You need to set up Application ID if you use session token as appIdOrToken parameter.
-     * @param {String} authSecret - Authorization secret key (from your admin panel).
+     * @param {Number} appId - Application ID (from your admin panel).
+     * @param {String | Number} accountKey - Account key (from your admin panel).
      * @param {Object} configMap - Settings object for QuickBlox SDK.
      */
+    initWithAppId: function(appId, accountKey, configMap) {
+        if (typeof appId !== 'number') {
+            throw new Error('Type of appId must be a number');
+        }
+        if (appId === '' || appId === undefined || appId === null ||
+            accountKey === '' || accountKey === undefined || accountKey === null) {
+            throw new Error('Cannot init QuickBlox without app credentials (app ID, auth key)');
+        } else {
+            this.init('', appId, null, accountKey, configMap);
+        }
+    },
+
     init: function(appIdOrToken, authKeyOrAppId, authSecret, accountKey, configMap) {
         if (typeof accountKey === 'string' && accountKey.length) {
             if (configMap && typeof configMap === 'object') {
@@ -148,6 +160,37 @@ QuickBlox.prototype = {
         this.auth.getSession(callback);
     },
 
+    /**
+     * Set up user session token to current session and return it
+     * @memberof QB
+     * @param {String} token - a User Session Token
+     * @param {getSessionCallback} callback - The getSessionCallback function.
+     * @callback getSessionCallback
+     * @param {Object} error - The error object
+     * @param {Object} session - Contains of session object
+     * */
+    startSessionWithToken: function(token, callback) {
+        if (token === undefined) throw new Error('Cannot start session with undefined token');
+        else if (token === '') throw new Error('Cannot start session with empty string token');
+        else if (token === null) throw new Error('Cannot start session with null value token');
+        else if (typeof callback !== 'function') throw new Error('Cannot start session without callback function');
+        else {
+            try {
+                this.service.setSession({token: token});
+            } catch (err) {
+                callback(err, null);
+            }
+            if (typeof callback === 'function') {
+                try{
+                    this.auth.getSession(callback);
+                }
+                catch(er){
+                    callback(er, null);
+                }
+            }
+        }
+    },
+
     /**
      * Creat new session. {@link https://quickblox.com/developers/Javascript#Authorization More info}
      * @memberof QB

package/src/qbProxy.js

@@ -140,6 +140,15 @@ ServiceProxy.prototype = {
             .then(function(response) {
                 qbResponse = response;
 
+                if (qbRequest.method === 'GET' || qbRequest.method === 'POST'){
+                    // TODO: need to check in [CROS-815]
+                    var qbTokenExpirationDate = qbResponse.headers.get('qb-token-expirationdate');
+                    var headerHasToken  = !(qbTokenExpirationDate === null ||
+                        typeof qbTokenExpirationDate === 'undefined');
+                    qbTokenExpirationDate  = (headerHasToken) ? qbTokenExpirationDate : new Date();
+                    self.qbInst.config.updateSessionExpirationDate(qbTokenExpirationDate, headerHasToken);
+                }
+
                 if (qbDataType === 'text') {
                     return response.text();
                 } else {
@@ -155,6 +164,8 @@ ServiceProxy.prototype = {
             }).then(function(body) {
             _requestCallback(null, qbResponse, body);
         }, function(error) {
+                // TODO: review in [CROS-815]
+            console.log('Error: ', error);
             _requestCallback(error);
         });
 

package/src/qbUtils.js

@@ -147,6 +147,10 @@ var Utils = {
             '000000'.substr(0, 6 - increment.length) + increment;
     },
 
+    getCurrentTime: function() {
+      return ((new Date()).toTimeString().split(' ')[0]);
+    },
+
     injectISOTimes: function(data) {
         if (data.created_at) {
             if (typeof data.created_at === 'number') data.iso_created_at = new Date(data.created_at * 1000).toISOString();