@webex/calling 3.0.0-next.4 → 3.0.0-next.41

package/dist/CallingClient/registration/register.js

@@ -0,0 +1,1286 @@
+"use strict";
+
+var _Array$from = require("@babel/runtime-corejs2/core-js/array/from");
+var _Symbol = require("@babel/runtime-corejs2/core-js/symbol");
+var _Symbol$iterator = require("@babel/runtime-corejs2/core-js/symbol/iterator");
+var _Array$isArray = require("@babel/runtime-corejs2/core-js/array/is-array");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRegistration = exports.Registration = void 0;
+var _now = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/date/now"));
+var _keys = _interopRequireDefault(require("@babel/runtime-corejs2/core-js/object/keys"));
+var _regenerator = _interopRequireDefault(require("@babel/runtime-corejs2/regenerator"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/asyncToGenerator"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _uuid = require("uuid");
+var _types = require("../../Errors/types");
+var _common = require("../../common");
+var _types2 = require("../../Metrics/types");
+var _Metrics = require("../../Metrics");
+var _calling = require("../calling");
+var _Logger = _interopRequireDefault(require("../../Logger"));
+var _SDKConnector = _interopRequireDefault(require("../../SDKConnector"));
+var _types3 = require("../../common/types");
+var _constants = require("../constants");
+var _types4 = require("../line/types");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof _Symbol !== "undefined" && o[_Symbol$iterator] || o["@@iterator"]; if (!it) { if (_Array$isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return _Array$from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+/**
+ *
+ */
+var Registration = exports.Registration = /*#__PURE__*/function () {
+  /**
+   */
+  function Registration(webex, serviceData, mutex, lineEmitter, logLevel) {
+    (0, _classCallCheck2.default)(this, Registration);
+    (0, _defineProperty2.default)(this, "sdkConnector", void 0);
+    (0, _defineProperty2.default)(this, "webex", void 0);
+    (0, _defineProperty2.default)(this, "userId", '');
+    (0, _defineProperty2.default)(this, "serviceData", void 0);
+    (0, _defineProperty2.default)(this, "failback429RetryAttempts", void 0);
+    (0, _defineProperty2.default)(this, "registrationStatus", void 0);
+    (0, _defineProperty2.default)(this, "failbackTimer", void 0);
+    (0, _defineProperty2.default)(this, "activeMobiusUrl", void 0);
+    (0, _defineProperty2.default)(this, "keepaliveTimer", void 0);
+    (0, _defineProperty2.default)(this, "rehomingIntervalMin", void 0);
+    (0, _defineProperty2.default)(this, "rehomingIntervalMax", void 0);
+    (0, _defineProperty2.default)(this, "mutex", void 0);
+    (0, _defineProperty2.default)(this, "metricManager", void 0);
+    (0, _defineProperty2.default)(this, "lineEmitter", void 0);
+    (0, _defineProperty2.default)(this, "callManager", void 0);
+    (0, _defineProperty2.default)(this, "deviceInfo", {});
+    (0, _defineProperty2.default)(this, "primaryMobiusUris", void 0);
+    (0, _defineProperty2.default)(this, "backupMobiusUris", void 0);
+    (0, _defineProperty2.default)(this, "registerRetry", false);
+    (0, _defineProperty2.default)(this, "reconnectPending", false);
+    this.sdkConnector = _SDKConnector.default;
+    this.serviceData = serviceData;
+    if (!this.sdkConnector.getWebex()) {
+      _SDKConnector.default.setWebex(webex);
+    }
+    this.webex = this.sdkConnector.getWebex();
+    this.userId = this.webex.internal.device.userId;
+    this.registrationStatus = _types3.RegistrationStatus.IDLE;
+    this.failback429RetryAttempts = 0;
+    _Logger.default.setLogger(logLevel, _constants.REGISTRATION_FILE);
+    this.rehomingIntervalMin = _constants.DEFAULT_REHOMING_INTERVAL_MIN;
+    this.rehomingIntervalMax = _constants.DEFAULT_REHOMING_INTERVAL_MAX;
+    this.mutex = mutex;
+    this.callManager = (0, _calling.getCallManager)(this.webex, serviceData.indicator);
+    this.metricManager = (0, _Metrics.getMetricManager)(this.webex, serviceData.indicator);
+    this.lineEmitter = lineEmitter;
+    this.primaryMobiusUris = [];
+    this.backupMobiusUris = [];
+  }
+  (0, _createClass2.default)(Registration, [{
+    key: "getActiveMobiusUrl",
+    value: function getActiveMobiusUrl() {
+      return this.activeMobiusUrl;
+    }
+  }, {
+    key: "setActiveMobiusUrl",
+    value: function setActiveMobiusUrl(url) {
+      _Logger.default.info("ActiveMobiusUrl: ".concat(url), {
+        method: 'setActiveMobiusUrl',
+        file: _constants.REGISTRATION_FILE
+      });
+      this.activeMobiusUrl = url;
+      this.callManager.updateActiveMobius(url);
+    }
+  }, {
+    key: "setMobiusServers",
+    value: function setMobiusServers(primaryMobiusUris, backupMobiusUris) {
+      this.primaryMobiusUris = primaryMobiusUris;
+      this.backupMobiusUris = backupMobiusUris;
+    }
+
+    /**
+     *  Implementation of sending keepalive.
+     *
+     */
+  }, {
+    key: "postKeepAlive",
+    value: (function () {
+      var _postKeepAlive = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee(url) {
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              return _context.abrupt("return", this.webex.request({
+                uri: "".concat(url, "/status"),
+                method: _types3.HTTP_METHODS.POST,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, this.webex.internal.device.url), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                service: _types3.ALLOWED_SERVICES.MOBIUS
+              }));
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function postKeepAlive(_x) {
+        return _postKeepAlive.apply(this, arguments);
+      }
+      return postKeepAlive;
+    }()
+    /**
+     * Implementation of delete device.
+     *
+     */
+    )
+  }, {
+    key: "deleteRegistration",
+    value: (function () {
+      var _deleteRegistration = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee2(url, deviceId, deviceUrl) {
+        var _response;
+        var response;
+        return _regenerator.default.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              _context2.t0 = fetch;
+              _context2.t1 = "".concat(url).concat(_constants.DEVICES_ENDPOINT_RESOURCE, "/").concat(deviceId);
+              _context2.t2 = _types3.HTTP_METHODS.DELETE;
+              _context2.t3 = _defineProperty2.default;
+              _context2.t4 = _defineProperty2.default;
+              _context2.t5 = _defineProperty2.default;
+              _context2.t6 = (0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, deviceUrl);
+              _context2.next = 10;
+              return this.webex.credentials.getUserToken();
+            case 10:
+              _context2.t7 = _context2.sent;
+              _context2.t8 = (0, _context2.t5)(_context2.t6, "Authorization", _context2.t7);
+              _context2.t9 = "".concat(_constants.WEBEX_WEB_CLIENT, "_").concat((0, _uuid.v4)());
+              _context2.t10 = (0, _context2.t4)(_context2.t8, "trackingId", _context2.t9);
+              _context2.t11 = _constants.SPARK_USER_AGENT;
+              _context2.t12 = _constants.CALLING_USER_AGENT;
+              _context2.t13 = (0, _context2.t3)(_context2.t10, _context2.t11, _context2.t12);
+              _context2.t14 = {
+                method: _context2.t2,
+                headers: _context2.t13
+              };
+              _context2.next = 20;
+              return (0, _context2.t0)(_context2.t1, _context2.t14);
+            case 20:
+              response = _context2.sent;
+              _context2.next = 26;
+              break;
+            case 23:
+              _context2.prev = 23;
+              _context2.t15 = _context2["catch"](0);
+              _Logger.default.warn("Delete failed with Mobius", {});
+            case 26:
+              this.setStatus(_types3.RegistrationStatus.INACTIVE);
+              this.lineEmitter(_types4.LINE_EVENTS.UNREGISTERED);
+              return _context2.abrupt("return", (_response = response) === null || _response === void 0 ? void 0 : _response.json());
+            case 29:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 23]]);
+      }));
+      function deleteRegistration(_x2, _x3, _x4) {
+        return _deleteRegistration.apply(this, arguments);
+      }
+      return deleteRegistration;
+    }()
+    /**
+     * Implementation of POST request for device registration.
+     *
+     */
+    )
+  }, {
+    key: "postRegistration",
+    value: (function () {
+      var _postRegistration = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee3(url) {
+        var deviceInfo;
+        return _regenerator.default.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              deviceInfo = {
+                userId: this.userId,
+                clientDeviceUri: this.webex.internal.device.url,
+                serviceData: this.serviceData
+              };
+              return _context3.abrupt("return", this.webex.request({
+                uri: "".concat(url, "device"),
+                method: _types3.HTTP_METHODS.POST,
+                headers: (0, _defineProperty2.default)((0, _defineProperty2.default)({}, _constants.CISCO_DEVICE_URL, deviceInfo.clientDeviceUri), _constants.SPARK_USER_AGENT, _constants.CALLING_USER_AGENT),
+                body: deviceInfo,
+                service: _types3.ALLOWED_SERVICES.MOBIUS
+              }));
+            case 2:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function postRegistration(_x5) {
+        return _postRegistration.apply(this, arguments);
+      }
+      return postRegistration;
+    }()
+    /**
+     * Re-attempts registration with the mobius url it was last registered
+     * to, that mobius url is expected to be updated already in this.activeMobiusUrl.
+     */
+    )
+  }, {
+    key: "restorePreviousRegistration",
+    value: (function () {
+      var _restorePreviousRegistration = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee4(caller) {
+        var abort;
+        return _regenerator.default.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              abort = false;
+              if (!this.activeMobiusUrl) {
+                _context4.next = 5;
+                break;
+              }
+              _context4.next = 4;
+              return this.attemptRegistrationWithServers(caller, [this.activeMobiusUrl]);
+            case 4:
+              abort = _context4.sent;
+            case 5:
+              return _context4.abrupt("return", abort);
+            case 6:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function restorePreviousRegistration(_x6) {
+        return _restorePreviousRegistration.apply(this, arguments);
+      }
+      return restorePreviousRegistration;
+    }()
+    /**
+     * When a failback request is rejected with 429, it means the
+     * request did not even land on primary mobius to know if it
+     * can handle this device registration now, in such cases this
+     * method is called to retry sooner than the rehoming timer value.
+     */
+    )
+  }, {
+    key: "scheduleFailback429Retry",
+    value: (function () {
+      var _scheduleFailback429Retry = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee5() {
+        var interval, abort;
+        return _regenerator.default.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              if (!(this.failback429RetryAttempts >= _constants.REG_FAILBACK_429_MAX_RETRIES)) {
+                _context5.next = 2;
+                break;
+              }
+              return _context5.abrupt("return");
+            case 2:
+              this.clearFailbackTimer();
+              this.failback429RetryAttempts += 1;
+              _Logger.default.log("Received 429 while rehoming, 429 retry count : ".concat(this.failback429RetryAttempts), {
+                file: _constants.REGISTRATION_FILE,
+                method: _constants.FAILBACK_429_RETRY_UTIL
+              });
+              interval = this.getRegRetryInterval(this.failback429RetryAttempts);
+              this.startFailbackTimer(interval);
+              _context5.next = 9;
+              return this.restorePreviousRegistration(_constants.FAILBACK_429_RETRY_UTIL);
+            case 9:
+              abort = _context5.sent;
+              if (!(!abort && !this.isDeviceRegistered())) {
+                _context5.next = 13;
+                break;
+              }
+              _context5.next = 13;
+              return this.restartRegistration(_constants.FAILBACK_429_RETRY_UTIL);
+            case 13:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5, this);
+      }));
+      function scheduleFailback429Retry() {
+        return _scheduleFailback429Retry.apply(this, arguments);
+      }
+      return scheduleFailback429Retry;
+    }()
+    /**
+     * Calculates and returns a random interval value using input argument
+     * attempt as the variable factor.
+     *
+     *                  attempted already.
+     */
+    )
+  }, {
+    key: "getRegRetryInterval",
+    value: function getRegRetryInterval() {
+      var attempt = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
+      return _constants.BASE_REG_RETRY_TIMER_VAL_IN_SEC + Math.pow(_constants.BASE_REG_TIMER_MFACTOR, attempt) + Math.floor((Math.random() * (_constants.REG_RANDOM_T_FACTOR_UPPER_LIMIT - _constants.SEC_TO_MSEC_MFACTOR + 1) + _constants.SEC_TO_MSEC_MFACTOR) / _constants.SEC_TO_MSEC_MFACTOR);
+    }
+
+    /**
+     * Schedules registration retry with primary mobius servers at a random
+     * interval calculated based on the number of times registration retry is already done
+     * Once the time taken since the beginning of retry attempt exceeds the
+     * retry threshold, it switches over to backup mobius servers.
+     *
+     */
+  }, {
+    key: "startFailoverTimer",
+    value: (function () {
+      var _startFailoverTimer = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee10() {
+        var _this = this;
+        var attempt,
+          timeElapsed,
+          loggerContext,
+          interval,
+          excessVal,
+          abort,
+          scheduledTime,
+          _args10 = arguments;
+        return _regenerator.default.wrap(function _callee10$(_context10) {
+          while (1) switch (_context10.prev = _context10.next) {
+            case 0:
+              attempt = _args10.length > 0 && _args10[0] !== undefined ? _args10[0] : 1;
+              timeElapsed = _args10.length > 1 && _args10[1] !== undefined ? _args10[1] : 0;
+              loggerContext = {
+                file: _constants.REGISTRATION_FILE,
+                method: this.startFailoverTimer.name
+              };
+              interval = this.getRegRetryInterval(attempt);
+              if (timeElapsed + interval > _constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC) {
+                excessVal = timeElapsed + interval - _constants.REG_TRY_BACKUP_TIMER_VAL_IN_SEC;
+                interval -= excessVal;
+              }
+              if (!(interval > _constants.BASE_REG_RETRY_TIMER_VAL_IN_SEC)) {
+                _context10.next = 11;
+                break;
+              }
+              scheduledTime = Math.floor((0, _now.default)() / 1000);
+              setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee7() {
+                return _regenerator.default.wrap(function _callee7$(_context7) {
+                  while (1) switch (_context7.prev = _context7.next) {
+                    case 0:
+                      _context7.next = 2;
+                      return _this.mutex.runExclusive( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee6() {
+                        var currentTime;
+                        return _regenerator.default.wrap(function _callee6$(_context6) {
+                          while (1) switch (_context6.prev = _context6.next) {
+                            case 0:
+                              _context6.next = 2;
+                              return _this.attemptRegistrationWithServers(_this.startFailoverTimer.name);
+                            case 2:
+                              abort = _context6.sent;
+                              currentTime = Math.floor((0, _now.default)() / 1000);
+                              if (!(!abort && !_this.isDeviceRegistered())) {
+                                _context6.next = 7;
+                                break;
+                              }
+                              _context6.next = 7;
+                              return _this.startFailoverTimer(attempt + 1, timeElapsed + (currentTime - scheduledTime));
+                            case 7:
+                            case "end":
+                              return _context6.stop();
+                          }
+                        }, _callee6);
+                      })));
+                    case 2:
+                    case "end":
+                      return _context7.stop();
+                  }
+                }, _callee7);
+              })), interval * _constants.SEC_TO_MSEC_MFACTOR);
+              _Logger.default.log("Scheduled retry with primary in ".concat(interval, " seconds, number of attempts : ").concat(attempt), loggerContext);
+              _context10.next = 20;
+              break;
+            case 11:
+              if (!this.backupMobiusUris.length) {
+                _context10.next = 19;
+                break;
+              }
+              _Logger.default.log('Failing over to backup servers.', loggerContext);
+              _context10.next = 15;
+              return this.attemptRegistrationWithServers(this.startFailoverTimer.name, this.backupMobiusUris);
+            case 15:
+              abort = _context10.sent;
+              if (!abort && !this.isDeviceRegistered()) {
+                interval = this.getRegRetryInterval();
+                setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee9() {
+                  return _regenerator.default.wrap(function _callee9$(_context9) {
+                    while (1) switch (_context9.prev = _context9.next) {
+                      case 0:
+                        _context9.next = 2;
+                        return _this.mutex.runExclusive( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee8() {
+                          return _regenerator.default.wrap(function _callee8$(_context8) {
+                            while (1) switch (_context8.prev = _context8.next) {
+                              case 0:
+                                _context8.next = 2;
+                                return _this.attemptRegistrationWithServers(_this.startFailoverTimer.name, _this.backupMobiusUris);
+                              case 2:
+                                abort = _context8.sent;
+                                if (!abort && !_this.isDeviceRegistered()) {
+                                  (0, _common.emitFinalFailure)(function (clientError) {
+                                    _this.lineEmitter(_types4.LINE_EVENTS.ERROR, undefined, clientError);
+                                  }, loggerContext);
+                                }
+                              case 4:
+                              case "end":
+                                return _context8.stop();
+                            }
+                          }, _callee8);
+                        })));
+                      case 2:
+                      case "end":
+                        return _context9.stop();
+                    }
+                  }, _callee9);
+                })), interval * _constants.SEC_TO_MSEC_MFACTOR);
+                _Logger.default.log("Scheduled retry with backup servers in ".concat(interval, " seconds."), loggerContext);
+              }
+              _context10.next = 20;
+              break;
+            case 19:
+              (0, _common.emitFinalFailure)(function (clientError) {
+                _this.lineEmitter(_types4.LINE_EVENTS.ERROR, undefined, clientError);
+              }, loggerContext);
+            case 20:
+            case "end":
+              return _context10.stop();
+          }
+        }, _callee10, this);
+      }));
+      function startFailoverTimer() {
+        return _startFailoverTimer.apply(this, arguments);
+      }
+      return startFailoverTimer;
+    }()
+    /**
+     * Clears the failback timer if running.
+     */
+    )
+  }, {
+    key: "clearFailbackTimer",
+    value: function clearFailbackTimer() {
+      if (this.failbackTimer) {
+        clearTimeout(this.failbackTimer);
+        this.failbackTimer = undefined;
+      }
+    }
+
+    /**
+     * Returns true if device is registered with a backup mobius.
+     */
+  }, {
+    key: "isFailbackRequired",
+    value: function isFailbackRequired() {
+      return this.isDeviceRegistered() && this.primaryMobiusUris.indexOf(this.activeMobiusUrl) === -1;
+    }
+
+    /**
+     * Calculates and returns a random value between rehomingIntervalMin and
+     * rehomingIntervalMax.
+     */
+  }, {
+    key: "getFailbackInterval",
+    value: function getFailbackInterval() {
+      return Math.floor(Math.random() * (this.rehomingIntervalMax - this.rehomingIntervalMin + 1) + this.rehomingIntervalMin);
+    }
+
+    /**
+     * Starts failback timer to move to primary mobius if device
+     * is registered with a backup mobius.
+     */
+  }, {
+    key: "initiateFailback",
+    value: function initiateFailback() {
+      if (this.isFailbackRequired()) {
+        if (!this.failbackTimer) {
+          this.failback429RetryAttempts = 0;
+          var intervalInMinutes = this.getFailbackInterval();
+          this.startFailbackTimer(intervalInMinutes * _constants.MINUTES_TO_SEC_MFACTOR);
+        }
+      } else {
+        this.failback429RetryAttempts = 0;
+        this.clearFailbackTimer();
+      }
+    }
+
+    /**
+     * Starts failback timer with the interval value received.
+     *
+     */
+  }, {
+    key: "startFailbackTimer",
+    value: function startFailbackTimer(intervalInSeconds) {
+      var _this2 = this;
+      this.failbackTimer = setTimeout( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee11() {
+        return _regenerator.default.wrap(function _callee11$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              return _context11.abrupt("return", _this2.executeFailback());
+            case 1:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee11);
+      })), intervalInSeconds * _constants.SEC_TO_MSEC_MFACTOR);
+      _Logger.default.log("Failback scheduled after ".concat(intervalInSeconds, " seconds."), {
+        file: _constants.REGISTRATION_FILE,
+        method: this.startFailbackTimer.name
+      });
+    }
+
+    /**
+     * Core logic for the failback processing, scheduled and executed
+     * at failback timer expiry.
+     */
+  }, {
+    key: "executeFailback",
+    value: (function () {
+      var _executeFailback = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee13() {
+        var _this3 = this;
+        return _regenerator.default.wrap(function _callee13$(_context13) {
+          while (1) switch (_context13.prev = _context13.next) {
+            case 0:
+              _context13.next = 2;
+              return this.mutex.runExclusive( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee12() {
+                var abort, abortNew;
+                return _regenerator.default.wrap(function _callee12$(_context12) {
+                  while (1) switch (_context12.prev = _context12.next) {
+                    case 0:
+                      if (!_this3.isFailbackRequired()) {
+                        _context12.next = 27;
+                        break;
+                      }
+                      if (!((0, _keys.default)(_this3.callManager.getActiveCalls()).length === 0)) {
+                        _context12.next = 24;
+                        break;
+                      }
+                      _Logger.default.info("Attempting failback to primary.", {
+                        file: _constants.REGISTRATION_FILE,
+                        method: _this3.executeFailback.name
+                      });
+                      _context12.next = 5;
+                      return _this3.deregister();
+                    case 5:
+                      _context12.next = 7;
+                      return _this3.attemptRegistrationWithServers(_constants.FAILBACK_UTIL);
+                    case 7:
+                      abort = _context12.sent;
+                      if (!(!abort && !_this3.isDeviceRegistered())) {
+                        _context12.next = 22;
+                        break;
+                      }
+                      _context12.next = 11;
+                      return _this3.restorePreviousRegistration(_constants.FAILBACK_UTIL);
+                    case 11:
+                      abortNew = _context12.sent;
+                      if (!abortNew) {
+                        _context12.next = 15;
+                        break;
+                      }
+                      _this3.clearFailbackTimer();
+                      return _context12.abrupt("return");
+                    case 15:
+                      if (_this3.isDeviceRegistered()) {
+                        _context12.next = 20;
+                        break;
+                      }
+                      _context12.next = 18;
+                      return _this3.restartRegistration(_this3.executeFailback.name);
+                    case 18:
+                      _context12.next = 22;
+                      break;
+                    case 20:
+                      _this3.failbackTimer = undefined;
+                      _this3.initiateFailback();
+                    case 22:
+                      _context12.next = 27;
+                      break;
+                    case 24:
+                      _Logger.default.info('Active calls present, deferring failback to next cycle.', {
+                        file: _constants.REGISTRATION_FILE,
+                        method: _this3.executeFailback.name
+                      });
+                      _this3.failbackTimer = undefined;
+                      _this3.initiateFailback();
+                    case 27:
+                    case "end":
+                      return _context12.stop();
+                  }
+                }, _callee12);
+              })));
+            case 2:
+            case "end":
+              return _context13.stop();
+          }
+        }, _callee13, this);
+      }));
+      function executeFailback() {
+        return _executeFailback.apply(this, arguments);
+      }
+      return executeFailback;
+    }()
+    /**
+     * Updates rehomingIntervalMin and rehomingIntervalMax values
+     * if received in registration response from a primary mobius
+     * server.
+     *
+     */
+    )
+  }, {
+    key: "setIntervalValues",
+    value: function setIntervalValues(deviceInfo) {
+      if (this.primaryMobiusUris.indexOf(this.activeMobiusUrl) !== -1) {
+        this.rehomingIntervalMin = deviceInfo !== null && deviceInfo !== void 0 && deviceInfo.rehomingIntervalMin ? deviceInfo.rehomingIntervalMin : _constants.DEFAULT_REHOMING_INTERVAL_MIN;
+        this.rehomingIntervalMax = deviceInfo !== null && deviceInfo !== void 0 && deviceInfo.rehomingIntervalMax ? deviceInfo.rehomingIntervalMax : _constants.DEFAULT_REHOMING_INTERVAL_MAX;
+      }
+    }
+
+    /**
+     * Retrieves information about the device as {@link IDeviceInfo}.
+     *
+     */
+  }, {
+    key: "getDeviceInfo",
+    value: function getDeviceInfo() {
+      return this.deviceInfo;
+    }
+
+    /**
+     * Checks if the device is currently registered.
+     *
+     *          by checking if isRegistered state is set to
+     *          ACTIVE, else false.
+     */
+  }, {
+    key: "isDeviceRegistered",
+    value: function isDeviceRegistered() {
+      return this.registrationStatus === _types3.RegistrationStatus.ACTIVE;
+    }
+  }, {
+    key: "getStatus",
+    value: function getStatus() {
+      return this.registrationStatus;
+    }
+  }, {
+    key: "setStatus",
+    value: function setStatus(value) {
+      this.registrationStatus = value;
+    }
+
+    /**
+     * Start fresh registration cycle with the mobius
+     * server list already present.
+     *
+     */
+  }, {
+    key: "restartRegistration",
+    value: (function () {
+      var _restartRegistration = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee14(caller) {
+        var abort;
+        return _regenerator.default.wrap(function _callee14$(_context14) {
+          while (1) switch (_context14.prev = _context14.next) {
+            case 0:
+              /*
+               * Cancel any failback timer running
+               * and start fresh registration attempt with retry as true.
+               */
+              this.clearFailbackTimer();
+              this.failback429RetryAttempts = 0;
+              _context14.next = 4;
+              return this.attemptRegistrationWithServers(caller, this.primaryMobiusUris);
+            case 4:
+              abort = _context14.sent;
+              if (!(!abort && !this.isDeviceRegistered())) {
+                _context14.next = 8;
+                break;
+              }
+              _context14.next = 8;
+              return this.startFailoverTimer();
+            case 8:
+            case "end":
+              return _context14.stop();
+          }
+        }, _callee14, this);
+      }));
+      function restartRegistration(_x7) {
+        return _restartRegistration.apply(this, arguments);
+      }
+      return restartRegistration;
+    }()
+    /**
+     * Restores the connection and attempts refreshing existing registration with server.
+     * Allows retry if not restored in the first attempt.
+     *
+     */
+    )
+  }, {
+    key: "handleConnectionRestoration",
+    value: (function () {
+      var _handleConnectionRestoration = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee16(retry) {
+        var _this4 = this;
+        return _regenerator.default.wrap(function _callee16$(_context16) {
+          while (1) switch (_context16.prev = _context16.next) {
+            case 0:
+              _context16.next = 2;
+              return this.mutex.runExclusive( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee15() {
+                var abort;
+                return _regenerator.default.wrap(function _callee15$(_context15) {
+                  while (1) switch (_context15.prev = _context15.next) {
+                    case 0:
+                      if (!retry) {
+                        _context15.next = 14;
+                        break;
+                      }
+                      _Logger.default.info('Mercury connection is up again, re-registering with Webex Calling if needed', {
+                        file: _constants.REGISTRATION_FILE,
+                        method: _this4.handleConnectionRestoration.name
+                      });
+                      _this4.clearKeepaliveTimer();
+                      if (!_this4.isDeviceRegistered()) {
+                        _context15.next = 6;
+                        break;
+                      }
+                      _context15.next = 6;
+                      return _this4.deregister();
+                    case 6:
+                      if (!_this4.activeMobiusUrl) {
+                        _context15.next = 13;
+                        break;
+                      }
+                      _context15.next = 9;
+                      return _this4.restorePreviousRegistration(_this4.handleConnectionRestoration.name);
+                    case 9:
+                      abort = _context15.sent;
+                      if (!(!abort && !_this4.isDeviceRegistered())) {
+                        _context15.next = 13;
+                        break;
+                      }
+                      _context15.next = 13;
+                      return _this4.restartRegistration(_this4.handleConnectionRestoration.name);
+                    case 13:
+                      retry = false;
+                    case 14:
+                    case "end":
+                      return _context15.stop();
+                  }
+                }, _callee15);
+              })));
+            case 2:
+              return _context16.abrupt("return", retry);
+            case 3:
+            case "end":
+              return _context16.stop();
+          }
+        }, _callee16, this);
+      }));
+      function handleConnectionRestoration(_x8) {
+        return _handleConnectionRestoration.apply(this, arguments);
+      }
+      return handleConnectionRestoration;
+    }()
+    /**
+     * Callback function for restoring registration in case of failure during initial registration
+     * due to device registration already exists.
+     *
+     */
+    )
+  }, {
+    key: "restoreRegistrationCallBack",
+    value: function restoreRegistrationCallBack() {
+      var _this5 = this;
+      return /*#__PURE__*/function () {
+        var _ref8 = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee17(restoreData, caller) {
+          var logContext, restore, finalError;
+          return _regenerator.default.wrap(function _callee17$(_context17) {
+            while (1) switch (_context17.prev = _context17.next) {
+              case 0:
+                logContext = {
+                  file: _constants.REGISTRATION_FILE,
+                  method: caller
+                };
+                if (_this5.isRegRetry()) {
+                  _context17.next = 17;
+                  break;
+                }
+                _Logger.default.info('Registration restoration in progress.', logContext);
+                restore = _this5.getExistingDevice(restoreData);
+                if (!restore) {
+                  _context17.next = 14;
+                  break;
+                }
+                _this5.setRegRetry(true);
+                _context17.next = 8;
+                return _this5.deregister();
+              case 8:
+                _context17.next = 10;
+                return _this5.restorePreviousRegistration(caller);
+              case 10:
+                finalError = _context17.sent;
+                _this5.setRegRetry(false);
+                if (_this5.isDeviceRegistered()) {
+                  _Logger.default.info('Registration restored successfully.', logContext);
+                }
+                return _context17.abrupt("return", finalError);
+              case 14:
+                _this5.lineEmitter(_types4.LINE_EVENTS.UNREGISTERED);
+                _context17.next = 18;
+                break;
+              case 17:
+                _this5.lineEmitter(_types4.LINE_EVENTS.UNREGISTERED);
+              case 18:
+                return _context17.abrupt("return", false);
+              case 19:
+              case "end":
+                return _context17.stop();
+            }
+          }, _callee17);
+        }));
+        return function (_x9, _x10) {
+          return _ref8.apply(this, arguments);
+        };
+      }();
+    }
+
+    /**
+     * Triggers the registration with the given list of Mobius servers
+     * Registration is attempted with primary and backup until it succeeds or the list is exhausted
+     */
+  }, {
+    key: "triggerRegistration",
+    value: (function () {
+      var _triggerRegistration = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee18() {
+        var abort;
+        return _regenerator.default.wrap(function _callee18$(_context18) {
+          while (1) switch (_context18.prev = _context18.next) {
+            case 0:
+              if (!(this.primaryMobiusUris.length > 0)) {
+                _context18.next = 7;
+                break;
+              }
+              _context18.next = 3;
+              return this.attemptRegistrationWithServers(this.triggerRegistration.name, this.primaryMobiusUris);
+            case 3:
+              abort = _context18.sent;
+              if (!(!this.isDeviceRegistered() && !abort)) {
+                _context18.next = 7;
+                break;
+              }
+              _context18.next = 7;
+              return this.startFailoverTimer();
+            case 7:
+            case "end":
+              return _context18.stop();
+          }
+        }, _callee18, this);
+      }));
+      function triggerRegistration() {
+        return _triggerRegistration.apply(this, arguments);
+      }
+      return triggerRegistration;
+    }()
+    /**
+     * Attempts registration with the server list received in
+     * argument one by one until registration either succeeds with
+     * one or all of them are tried.
+     *
+     *          attempt has hit a final error and a retry should not be scheduled
+     *          else false.
+     */
+    )
+  }, {
+    key: "attemptRegistrationWithServers",
+    value: (function () {
+      var _attemptRegistrationWithServers = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee19(caller) {
+        var _this6 = this;
+        var servers,
+          abort,
+          _iterator,
+          _step,
+          url,
+          _this$deviceInfo$devi,
+          resp,
+          body,
+          error,
+          _args19 = arguments;
+        return _regenerator.default.wrap(function _callee19$(_context19) {
+          while (1) switch (_context19.prev = _context19.next) {
+            case 0:
+              servers = _args19.length > 1 && _args19[1] !== undefined ? _args19[1] : this.primaryMobiusUris;
+              abort = false;
+              if (!this.isDeviceRegistered()) {
+                _context19.next = 5;
+                break;
+              }
+              _Logger.default.log("[".concat(caller, "] : Device already registered with : ").concat(this.activeMobiusUrl), {
+                file: _constants.REGISTRATION_FILE,
+                method: this.attemptRegistrationWithServers.name
+              });
+              return _context19.abrupt("return", abort);
+            case 5:
+              _iterator = _createForOfIteratorHelper(servers);
+              _context19.prev = 6;
+              _iterator.s();
+            case 8:
+              if ((_step = _iterator.n()).done) {
+                _context19.next = 53;
+                break;
+              }
+              url = _step.value;
+              _context19.prev = 10;
+              abort = false;
+              this.registrationStatus = _types3.RegistrationStatus.INACTIVE;
+              this.lineEmitter(_types4.LINE_EVENTS.CONNECTING);
+              _Logger.default.log("[".concat(caller, "] : Mobius url to contact: ").concat(url), {
+                file: _constants.REGISTRATION_FILE,
+                method: this.attemptRegistrationWithServers.name
+              });
+              // eslint-disable-next-line no-await-in-loop
+              _context19.next = 17;
+              return this.postRegistration(url);
+            case 17:
+              resp = _context19.sent;
+              this.deviceInfo = resp.body;
+              this.registrationStatus = _types3.RegistrationStatus.ACTIVE;
+              this.lineEmitter(_types4.LINE_EVENTS.REGISTERED, resp.body);
+              this.setActiveMobiusUrl(url);
+              this.setIntervalValues(this.deviceInfo);
+              this.metricManager.setDeviceInfo(this.deviceInfo);
+              this.metricManager.submitRegistrationMetric(_types2.METRIC_EVENT.REGISTRATION, _types2.REG_ACTION.REGISTER, _types2.METRIC_TYPE.BEHAVIORAL, undefined);
+              this.startKeepaliveTimer((_this$deviceInfo$devi = this.deviceInfo.device) === null || _this$deviceInfo$devi === void 0 ? void 0 : _this$deviceInfo$devi.uri, this.deviceInfo.keepaliveInterval);
+              this.initiateFailback();
+              return _context19.abrupt("break", 53);
+            case 30:
+              _context19.prev = 30;
+              _context19.t0 = _context19["catch"](10);
+              body = _context19.t0; // eslint-disable-next-line no-await-in-loop, @typescript-eslint/no-unused-vars
+              _context19.next = 35;
+              return (0, _common.handleRegistrationErrors)(body, function (clientError, finalError) {
+                if (finalError) {
+                  _this6.lineEmitter(_types4.LINE_EVENTS.ERROR, undefined, clientError);
+                } else {
+                  _this6.lineEmitter(_types4.LINE_EVENTS.UNREGISTERED);
+                }
+                _this6.metricManager.submitRegistrationMetric(_types2.METRIC_EVENT.REGISTRATION_ERROR, _types2.REG_ACTION.REGISTER, _types2.METRIC_TYPE.BEHAVIORAL, clientError);
+              }, {
+                method: this.attemptRegistrationWithServers.name,
+                file: _constants.REGISTRATION_FILE
+              }, this.restoreRegistrationCallBack());
+            case 35:
+              abort = _context19.sent;
+              if (!(this.registrationStatus === _types3.RegistrationStatus.ACTIVE)) {
+                _context19.next = 39;
+                break;
+              }
+              _Logger.default.info("[".concat(caller, "] : Device is already restored, active mobius url: ").concat(this.activeMobiusUrl), {
+                file: _constants.REGISTRATION_FILE,
+                method: this.attemptRegistrationWithServers.name
+              });
+              return _context19.abrupt("break", 53);
+            case 39:
+              if (!abort) {
+                _context19.next = 44;
+                break;
+              }
+              this.setStatus(_types3.RegistrationStatus.INACTIVE);
+              return _context19.abrupt("break", 53);
+            case 44:
+              if (!(caller === this.executeFailback.name)) {
+                _context19.next = 51;
+                break;
+              }
+              error = body.statusCode;
+              if (!(error === _types.ERROR_CODE.TOO_MANY_REQUESTS)) {
+                _context19.next = 51;
+                break;
+              }
+              _context19.next = 49;
+              return this.scheduleFailback429Retry();
+            case 49:
+              abort = true;
+              return _context19.abrupt("break", 53);
+            case 51:
+              _context19.next = 8;
+              break;
+            case 53:
+              _context19.next = 58;
+              break;
+            case 55:
+              _context19.prev = 55;
+              _context19.t1 = _context19["catch"](6);
+              _iterator.e(_context19.t1);
+            case 58:
+              _context19.prev = 58;
+              _iterator.f();
+              return _context19.finish(58);
+            case 61:
+              return _context19.abrupt("return", abort);
+            case 62:
+            case "end":
+              return _context19.stop();
+          }
+        }, _callee19, this, [[6, 55, 58, 61], [10, 30]]);
+      }));
+      function attemptRegistrationWithServers(_x11) {
+        return _attemptRegistrationWithServers.apply(this, arguments);
+      }
+      return attemptRegistrationWithServers;
+    }()
+    /**
+     * This method sets up a timer to periodically send keep-alive requests to maintain a connection.
+     * It handles retries, error handling, and re-registration attempts based on the response, ensuring continuous connectivity with the server.
+     */
+    )
+  }, {
+    key: "startKeepaliveTimer",
+    value: function startKeepaliveTimer(url, interval) {
+      var _this7 = this;
+      var keepAliveRetryCount = 0;
+      this.clearKeepaliveTimer();
+      this.keepaliveTimer = setInterval( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee21() {
+        var logContext;
+        return _regenerator.default.wrap(function _callee21$(_context21) {
+          while (1) switch (_context21.prev = _context21.next) {
+            case 0:
+              logContext = {
+                file: _constants.REGISTRATION_FILE,
+                method: _this7.startKeepaliveTimer.name
+              };
+              _context21.next = 3;
+              return _this7.mutex.runExclusive( /*#__PURE__*/(0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee20() {
+                var res, error, abort;
+                return _regenerator.default.wrap(function _callee20$(_context20) {
+                  while (1) switch (_context20.prev = _context20.next) {
+                    case 0:
+                      if (!(_this7.isDeviceRegistered() && keepAliveRetryCount < 5)) {
+                        _context20.next = 29;
+                        break;
+                      }
+                      _context20.prev = 1;
+                      _context20.next = 4;
+                      return _this7.postKeepAlive(url);
+                    case 4:
+                      res = _context20.sent;
+                      _Logger.default.info("Sent Keepalive, status: ".concat(res.statusCode), logContext);
+                      if (keepAliveRetryCount > 0) {
+                        _this7.lineEmitter(_types4.LINE_EVENTS.RECONNECTED);
+                      }
+                      keepAliveRetryCount = 0;
+                      _context20.next = 29;
+                      break;
+                    case 10:
+                      _context20.prev = 10;
+                      _context20.t0 = _context20["catch"](1);
+                      keepAliveRetryCount += 1;
+                      error = _context20.t0;
+                      _Logger.default.warn("Keep-alive missed ".concat(keepAliveRetryCount, " times. Status -> ").concat(error.statusCode, " "), logContext);
+                      _context20.next = 17;
+                      return (0, _common.handleRegistrationErrors)(error, function (clientError, finalError) {
+                        if (finalError) {
+                          _this7.lineEmitter(_types4.LINE_EVENTS.ERROR, undefined, clientError);
+                        }
+                        _this7.metricManager.submitRegistrationMetric(_types2.METRIC_EVENT.REGISTRATION, _types2.REG_ACTION.KEEPALIVE_FAILURE, _types2.METRIC_TYPE.BEHAVIORAL, clientError);
+                      }, {
+                        method: _this7.startKeepaliveTimer.name,
+                        file: _constants.REGISTRATION_FILE
+                      });
+                    case 17:
+                      abort = _context20.sent;
+                      if (!(abort || keepAliveRetryCount >= 5)) {
+                        _context20.next = 28;
+                        break;
+                      }
+                      _this7.setStatus(_types3.RegistrationStatus.INACTIVE);
+                      _this7.clearKeepaliveTimer();
+                      _this7.clearFailbackTimer();
+                      _this7.lineEmitter(_types4.LINE_EVENTS.UNREGISTERED);
+                      if (abort) {
+                        _context20.next = 26;
+                        break;
+                      }
+                      _context20.next = 26;
+                      return _this7.reconnectOnFailure(_this7.startKeepaliveTimer.name);
+                    case 26:
+                      _context20.next = 29;
+                      break;
+                    case 28:
+                      _this7.lineEmitter(_types4.LINE_EVENTS.RECONNECTING);
+                    case 29:
+                    case "end":
+                      return _context20.stop();
+                  }
+                }, _callee20, null, [[1, 10]]);
+              })));
+            case 3:
+            case "end":
+              return _context21.stop();
+          }
+        }, _callee21);
+      })), interval * 1000);
+    }
+
+    /**
+     * Clears the keepalive timer if running.
+     */
+  }, {
+    key: "clearKeepaliveTimer",
+    value: function clearKeepaliveTimer() {
+      if (this.keepaliveTimer) {
+        clearInterval(this.keepaliveTimer);
+        this.keepaliveTimer = undefined;
+      }
+    }
+  }, {
+    key: "isReconnectPending",
+    value: function isReconnectPending() {
+      return this.reconnectPending;
+    }
+  }, {
+    key: "deregister",
+    value: function () {
+      var _deregister = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee22() {
+        var _this$deviceInfo$devi2, _this$deviceInfo$devi3;
+        return _regenerator.default.wrap(function _callee22$(_context22) {
+          while (1) switch (_context22.prev = _context22.next) {
+            case 0:
+              _context22.prev = 0;
+              _context22.next = 3;
+              return this.deleteRegistration(this.activeMobiusUrl, (_this$deviceInfo$devi2 = this.deviceInfo.device) === null || _this$deviceInfo$devi2 === void 0 ? void 0 : _this$deviceInfo$devi2.deviceId, (_this$deviceInfo$devi3 = this.deviceInfo.device) === null || _this$deviceInfo$devi3 === void 0 ? void 0 : _this$deviceInfo$devi3.clientDeviceUri);
+            case 3:
+              _context22.next = 8;
+              break;
+            case 5:
+              _context22.prev = 5;
+              _context22.t0 = _context22["catch"](0);
+              _Logger.default.warn("Delete failed with Mobius", {});
+            case 8:
+              this.clearKeepaliveTimer();
+              this.setStatus(_types3.RegistrationStatus.INACTIVE);
+            case 10:
+            case "end":
+              return _context22.stop();
+          }
+        }, _callee22, this, [[0, 5]]);
+      }));
+      function deregister() {
+        return _deregister.apply(this, arguments);
+      }
+      return deregister;
+    }()
+    /**
+     *          Indicates whether the calling client is in a mode
+     *          to retry registration.
+     */
+  }, {
+    key: "isRegRetry",
+    value: function isRegRetry() {
+      return this.registerRetry;
+    }
+
+    /**
+     * Sets the received value in instance variable
+     * registerRetry for registration retry cases.
+     *
+     */
+  }, {
+    key: "setRegRetry",
+    value: function setRegRetry(value) {
+      this.registerRetry = value;
+    }
+
+    /**
+     * Restores the deviceInfo object in callingClient when receiving a 403 with error code 101.
+     *
+     */
+  }, {
+    key: "getExistingDevice",
+    value: function getExistingDevice(restoreData) {
+      if (restoreData.devices && restoreData.devices.length > 0) {
+        this.deviceInfo = {
+          userId: restoreData.userId,
+          device: restoreData.devices[0],
+          keepaliveInterval: _constants.DEFAULT_KEEPALIVE_INTERVAL,
+          rehomingIntervalMax: _constants.DEFAULT_REHOMING_INTERVAL_MAX,
+          rehomingIntervalMin: _constants.DEFAULT_REHOMING_INTERVAL_MIN
+        };
+        var stringToReplace = "".concat(_constants.DEVICES_ENDPOINT_RESOURCE, "/").concat(restoreData.devices[0].deviceId);
+        var uri = restoreData.devices[0].uri.replace(stringToReplace, '');
+        this.setActiveMobiusUrl(uri);
+        this.registrationStatus = _types3.RegistrationStatus.ACTIVE;
+        return true;
+      }
+      return false;
+    }
+
+    /**
+     * Invoked to re-register in cases when the registration
+     * is lost due to some failure.
+     * If there are active calls, it will only mark reconnectPending
+     * as true and then retry will happen when this method gets
+     * invoked again on receiving all calls cleared event from
+     * callManager.
+     *
+     */
+  }, {
+    key: "reconnectOnFailure",
+    value: (function () {
+      var _reconnectOnFailure = (0, _asyncToGenerator2.default)( /*#__PURE__*/_regenerator.default.mark(function _callee23(caller) {
+        var abort;
+        return _regenerator.default.wrap(function _callee23$(_context23) {
+          while (1) switch (_context23.prev = _context23.next) {
+            case 0:
+              this.reconnectPending = false;
+              if (this.isDeviceRegistered()) {
+                _context23.next = 13;
+                break;
+              }
+              if (!((0, _keys.default)(this.callManager.getActiveCalls()).length === 0)) {
+                _context23.next = 11;
+                break;
+              }
+              _context23.next = 5;
+              return this.restorePreviousRegistration(caller);
+            case 5:
+              abort = _context23.sent;
+              if (!(!abort && !this.isDeviceRegistered())) {
+                _context23.next = 9;
+                break;
+              }
+              _context23.next = 9;
+              return this.restartRegistration(caller);
+            case 9:
+              _context23.next = 13;
+              break;
+            case 11:
+              this.reconnectPending = true;
+              _Logger.default.info('Active call(s) present, deferred reconnect till call cleanup.', {
+                file: _constants.REGISTRATION_FILE,
+                method: this.reconnectOnFailure.name
+              });
+            case 13:
+            case "end":
+              return _context23.stop();
+          }
+        }, _callee23, this);
+      }));
+      function reconnectOnFailure(_x12) {
+        return _reconnectOnFailure.apply(this, arguments);
+      }
+      return reconnectOnFailure;
+    }())
+  }]);
+  return Registration;
+}();
+/*
+ */
+var createRegistration = exports.createRegistration = function createRegistration(webex, serviceData, mutex, lineEmitter, logLevel) {
+  return new Registration(webex, serviceData, mutex, lineEmitter, logLevel);
+};
+//# sourceMappingURL=register.js.map