@jibb-open/jssdk 3.5.7 → 3.5.9

package/dist/ws/eventbus.js

@@ -0,0 +1,376 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EventBusConnection = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.url.js");
+require("core-js/modules/web.url-search-params.js");
+require("core-js/modules/es.array-buffer.constructor.js");
+require("core-js/modules/es.array-buffer.slice.js");
+require("core-js/modules/es.typed-array.uint8-array.js");
+require("core-js/modules/es.typed-array.fill.js");
+require("core-js/modules/es.typed-array.set.js");
+require("core-js/modules/es.typed-array.sort.js");
+require("core-js/modules/es.typed-array.to-locale-string.js");
+var _config = require("../config.js");
+var _index = require("../utils/logger/index.js");
+var _exceptions = require("../types/exceptions.js");
+var _retry_connection = require("./retry_connection.js");
+var _connection_base = require("./connection_base.js");
+var _types = require("../types/types.js");
+var _proto = require("../types/proto.js");
+var _auth = require("../api/auth.js");
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+const ClientType = _proto.types.ClientType;
+const ErrorCode = _proto.types.Code;
+const BusMessage = _proto.cilix.BusMessage;
+function getClientNameByType(clientType) {
+  let found = Object.entries(ClientType).find(_ref => {
+    let [k, v] = _ref;
+    return v == clientType;
+  });
+  if (!found) throw new _exceptions.InvalidArgumentError("Invalid client type: ".concat(clientType));
+  let name = found[0].toLowerCase();
+  return name;
+}
+var _expiryTimer = /*#__PURE__*/new WeakMap();
+var _handleMessage = /*#__PURE__*/new WeakSet();
+class WSConnection extends _retry_connection.RetryConnection {
+  constructor(clientType, name) {
+    let clientName = getClientNameByType(clientType).toLowerCase();
+    super("eventbus-".concat(clientName));
+    _classPrivateMethodInitSpec(this, _handleMessage);
+    _classPrivateFieldInitSpec(this, _expiryTimer, {
+      writable: true,
+      value: void 0
+    });
+    this.clientType = clientType;
+    this.socket = null;
+    this.userToken = null;
+    this.clientName = clientName;
+    this.name = name;
+    _classPrivateFieldSet(this, _expiryTimer, null);
+  }
+  async start() {
+    this.userToken = await _auth.Auth.getUserToken();
+    this.userClaims = new _types.UserClaims(this.userToken);
+    let seconds = this.userClaims.getSecondsUntilExpiry();
+    if (seconds <= 0) {
+      this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+      return;
+    }
+    _classPrivateFieldSet(this, _expiryTimer, setTimeout(() => {
+      this.stop();
+      this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+    }, seconds));
+    super.start();
+  }
+  async stop() {
+    clearTimeout(_classPrivateFieldGet(this, _expiryTimer));
+    super.stop();
+  }
+  disconnect() {
+    if (this.socket != null) {
+      this.socket.close();
+      this.socket = null;
+      //this.fireOnError(ErrorLevel.WARNING, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+      _index.logger.info("eventbus disconnect ", this.clientName);
+    }
+    super.disconnect();
+  }
+  async write(msg) {
+    await super.waitForConnection();
+    _index.logger.debug("".concat(this.getName(), ".write: "), BusMessage.toObject(msg));
+    let data = BusMessage.encode(msg).finish();
+    this.socket.send(data);
+  }
+  writeObject(msg) {
+    let err = BusMessage.verify(msg);
+    if (err) throw new Error(err);
+    let request = BusMessage.fromObject(msg);
+    return this.write(request);
+  }
+  async connect() {
+    if (this.getConnectionStatus() != _connection_base.ConnectionStatus.DISCONNECTED) return;
+    super.connect();
+    let self = this;
+    try {
+      let c = new _types.UserClaims(this.userToken);
+      if (c.isExpired()) {
+        self.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        return;
+      }
+    } catch (err) {
+      _index.logger.error(e);
+      self.onErrorMessage(ErrorCode.ERR_UNAUTHORIZED, "unauthorized");
+      return;
+    }
+    let base = new URL(_config.Config.apiBaseURL);
+    let uri = "wss://".concat(base.hostname, "/ws/eventbus/").concat(this.clientName, "?user_token=").concat(this.userToken, "&name=").concat(this.name);
+    this.socket = new WebSocket(uri);
+    this.socket.binaryType = "arraybuffer";
+    this.socket.addEventListener("open", () => {
+      self.onConnected();
+    });
+    this.socket.addEventListener("close", () => {
+      self.onDisconnected();
+    });
+    this.socket.addEventListener("message", event => {
+      _classPrivateMethodGet(self, _handleMessage, _handleMessage2).call(self, event.data);
+    });
+    this.socket.addEventListener("error", err => {
+      self.onWarningMessage(ErrorCode.ERR_IO, err);
+    });
+  }
+  onMessage(response) {
+    _index.logger.debug(response);
+  }
+}
+async function _handleMessage2(msg) {
+  try {
+    if (msg instanceof ArrayBuffer) {
+      let buffer = new Uint8Array(msg);
+      let response = BusMessage.decode(buffer);
+      buffer = null;
+      _index.logger.debug("".concat(this.getName(), ".read: "), response);
+      this.onMessage(response);
+      return;
+    }
+  } catch (err) {
+    _index.logger.error(err);
+  }
+  try {
+    let Error = JSON.parse(msg);
+    switch (Error.code) {
+      case ErrorCode.ERR_TOO_MANY_CONNECTIONS:
+      case ErrorCode.ERR_UNAUTHORIZED:
+      case ErrorCode.ERR_BAD_REQUEST:
+      case ErrorCode.ERR_TIMEOUT:
+        this.onErrorMessage(Error.code, Error.reason);
+        break;
+      default:
+        this.onInfoMessage(Error.code, Error.reason);
+        break;
+    }
+  } catch (e) {
+    this.onWarningMessage(ErrorCode.ERR_IO, e);
+  }
+}
+var _sendPreview = /*#__PURE__*/new WeakSet();
+var _onCameraListRequest = /*#__PURE__*/new WeakSet();
+var _onCameraListResponse = /*#__PURE__*/new WeakSet();
+var _onClientConnected = /*#__PURE__*/new WeakSet();
+var _onClientDisconnected = /*#__PURE__*/new WeakSet();
+var _onRuntimeConfigRequest = /*#__PURE__*/new WeakSet();
+var _onStopRequest = /*#__PURE__*/new WeakSet();
+var _onPreviewRequest = /*#__PURE__*/new WeakSet();
+var _onPreviewResponse = /*#__PURE__*/new WeakSet();
+var _onStartRequest = /*#__PURE__*/new WeakSet();
+var _onCornersReceived = /*#__PURE__*/new WeakSet();
+var _onIPSAResponse = /*#__PURE__*/new WeakSet();
+var _onTooManyPublishers = /*#__PURE__*/new WeakSet();
+var _onRecordingStarted = /*#__PURE__*/new WeakSet();
+var _onRecordingStopped = /*#__PURE__*/new WeakSet();
+class EventBusConnection extends WSConnection {
+  static getInstance() {
+    let clientType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ClientType.WEBAPP;
+    let name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    let c = EventBusConnection.instances.get(clientType);
+    if (!c) {
+      c = new EventBusConnection(clientType, name);
+      EventBusConnection.instances.set(clientType, c);
+    }
+    return c;
+  }
+  constructor() {
+    let clientType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ClientType.WEBAPP;
+    let name = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    super(clientType, name);
+    _classPrivateMethodInitSpec(this, _onRecordingStopped);
+    _classPrivateMethodInitSpec(this, _onRecordingStarted);
+    _classPrivateMethodInitSpec(this, _onTooManyPublishers);
+    _classPrivateMethodInitSpec(this, _onIPSAResponse);
+    _classPrivateMethodInitSpec(this, _onCornersReceived);
+    _classPrivateMethodInitSpec(this, _onStartRequest);
+    _classPrivateMethodInitSpec(this, _onPreviewResponse);
+    _classPrivateMethodInitSpec(this, _onPreviewRequest);
+    _classPrivateMethodInitSpec(this, _onStopRequest);
+    _classPrivateMethodInitSpec(this, _onRuntimeConfigRequest);
+    _classPrivateMethodInitSpec(this, _onClientDisconnected);
+    _classPrivateMethodInitSpec(this, _onClientConnected);
+    _classPrivateMethodInitSpec(this, _onCameraListResponse);
+    _classPrivateMethodInitSpec(this, _onCameraListRequest);
+    _classPrivateMethodInitSpec(this, _sendPreview);
+  }
+  async onMessage(msg) {
+    if (!msg || typeof msg !== 'object') return;
+    try {
+      msg.clientConnected && _classPrivateMethodGet(this, _onClientConnected, _onClientConnected2).call(this, msg);
+      msg.clientDisconnected && _classPrivateMethodGet(this, _onClientDisconnected, _onClientDisconnected2).call(this, msg);
+      msg.cameraListRequest && _classPrivateMethodGet(this, _onCameraListRequest, _onCameraListRequest2).call(this, msg);
+      msg.cameraListResponse && _classPrivateMethodGet(this, _onCameraListResponse, _onCameraListResponse2).call(this, msg);
+      msg.runtimeConfigRequest && _classPrivateMethodGet(this, _onRuntimeConfigRequest, _onRuntimeConfigRequest2).call(this, msg);
+      msg.startRequest && _classPrivateMethodGet(this, _onStartRequest, _onStartRequest2).call(this, msg);
+      msg.stopRequest && _classPrivateMethodGet(this, _onStopRequest, _onStopRequest2).call(this, msg);
+      msg.previewRequest && _classPrivateMethodGet(this, _onPreviewRequest, _onPreviewRequest2).call(this, msg);
+      msg.previewResponse && _classPrivateMethodGet(this, _onPreviewResponse, _onPreviewResponse2).call(this, msg);
+      msg.ipsaResponse && _classPrivateMethodGet(this, _onIPSAResponse, _onIPSAResponse2).call(this, msg);
+      msg.tooManyPublishers && _classPrivateMethodGet(this, _onTooManyPublishers, _onTooManyPublishers2).call(this, msg);
+      msg.recordingStarted && _classPrivateMethodGet(this, _onRecordingStarted, _onRecordingStarted2).call(this, msg);
+      msg.recordingStopped && _classPrivateMethodGet(this, _onRecordingStopped, _onRecordingStopped2).call(this, msg);
+    } catch (e) {
+      _index.logger.error(e);
+    }
+  }
+  stopStream(clientId) {
+    return this.writeObject({
+      stopRequest: {},
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  startStream(_ref2) {
+    let {
+      appConfig,
+      config,
+      runtimeConfig,
+      camera,
+      sipUri,
+      clientId
+    } = _ref2;
+    return this.writeObject({
+      startRequest: {
+        config,
+        appConfig,
+        runtimeConfig,
+        camera,
+        sipUri
+      },
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  requestCameraPreview(clientId, sourceId) {
+    return this.writeObject({
+      previewRequest: {
+        source: {
+          id: sourceId
+        }
+      },
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  setRuntimeConfig(clientId, cfg) {
+    return this.writeObject({
+      runtimeConfigRequest: cfg,
+      dst: {
+        id: clientId
+      }
+    });
+  }
+  getCameraList(clientId) {
+    let request = {
+      cameraListRequest: {},
+      dst: {
+        id: clientId
+      }
+    };
+    return this.write(request);
+  }
+  sendCameraList(camList, src, dst) {
+    let response = {
+      cameraListResponse: {
+        items: camList
+      },
+      src: src,
+      dst: dst
+    };
+    return this.writeObject(response);
+  }
+  getClientStatusList() {
+    let request = {
+      clientStatusRequest: {}
+    };
+    return this.writeObject(request);
+  }
+}
+exports.EventBusConnection = EventBusConnection;
+function _sendPreview2(image, dst) {
+  let response = {
+    previewResponse: {
+      image: image
+    },
+    dst: dst
+  };
+  return this.write(response);
+}
+async function _onCameraListRequest2(msg) {
+  let response = await this.callSubscribers('onCameraListRequest', msg.cameraListRequest);
+  this.sendCameraList(response, msg.dst, msg.src);
+}
+function _onCameraListResponse2(msg) {
+  this.notify('onCameraListResponse', msg.cameraListResponse);
+}
+function _onClientConnected2(msg) {
+  _index.logger.info("".concat(this.getName(), ": client connected: "), msg.src);
+  this.notify('onClientConnected', msg.src);
+}
+function _onClientDisconnected2(msg) {
+  _index.logger.warn("".concat(this.getName(), ": client disconnected: "), msg.src);
+  this.notify('onClientDisconnected', msg.src);
+}
+function _onRuntimeConfigRequest2(msg) {
+  this.notify('onRuntimeConfigRequest', msg.runtimeConfigRequest);
+}
+function _onStopRequest2(msg) {
+  this.notify('onStopRequest', msg.stopRequest);
+}
+async function _onPreviewRequest2(msg) {
+  let response = await this.callSubscribers('onPreviewRequest', msg.previewRequest);
+  _classPrivateMethodGet(this, _sendPreview, _sendPreview2).call(this, response, msg.src);
+}
+function _onPreviewResponse2(msg) {
+  this.notify('onPreviewResponse', msg.previewResponse);
+}
+function _onStartRequest2(msg) {
+  var _req$camera, _req$inputSource;
+  let req = msg.startRequest;
+  if (!(req !== null && req !== void 0 && (_req$camera = req.camera) !== null && _req$camera !== void 0 && _req$camera.id) && !(req !== null && req !== void 0 && req.sipUri) && req !== null && req !== void 0 && (_req$inputSource = req.inputSource) !== null && _req$inputSource !== void 0 && _req$inputSource.id) {
+    req.camera = {
+      id: req.inputSource.id
+    };
+  }
+  this.notify('onStartRequest', req);
+}
+function _onCornersReceived2(msg) {
+  this.notify('onCornersReceived', msg.corners.corners);
+}
+function _onIPSAResponse2(msg) {
+  msg && this.notify('onIPSAResponse', msg.ipsaResponse);
+}
+function _onTooManyPublishers2(msg) {
+  this.notify('onTooManyPublishers', msg.tooManyPublishers);
+}
+function _onRecordingStarted2(msg) {
+  this.notify('onRecordingStarted', msg.recordingStarted);
+}
+function _onRecordingStopped2(msg) {
+  this.notify('onRecordingStopped', msg.recordingStopped);
+}
+_defineProperty(EventBusConnection, "instances", new Map());

package/dist/ws/index.js

@@ -0,0 +1,36 @@
+"use strict";
+
+require("core-js/modules/web.dom-collections.iterator.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "EventBusConnection", {
+  enumerable: true,
+  get: function get() {
+    return _eventbus.EventBusConnection;
+  }
+});
+Object.defineProperty(exports, "IPSA", {
+  enumerable: true,
+  get: function get() {
+    return _ipsa.IPSA;
+  }
+});
+Object.defineProperty(exports, "MeetingConnection", {
+  enumerable: true,
+  get: function get() {
+    return _meeting.MeetingConnection;
+  }
+});
+require("core-js/modules/es.global-this.js");
+require("core-js/modules/es.promise.js");
+var _eventbus = require("./eventbus.js");
+var _ipsa = require("./ipsa.js");
+var _meeting = require("./meeting.js");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+if ((globalThis === null || globalThis === void 0 ? void 0 : globalThis.WebSocket) == undefined) {
+  Promise.resolve().then(() => _interopRequireWildcard(require("isomorphic-ws"))).then(webSocket => {
+    globalThis.WebSocket = webSocket.default;
+  });
+}

package/dist/ws/ipsa.js

@@ -0,0 +1,262 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IPSA = void 0;
+require("core-js/modules/es.promise.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+require("core-js/modules/web.url.js");
+require("core-js/modules/web.url-search-params.js");
+require("core-js/modules/es.array.reduce.js");
+require("core-js/modules/es.array-buffer.constructor.js");
+require("core-js/modules/es.array-buffer.slice.js");
+require("core-js/modules/es.typed-array.uint8-array.js");
+require("core-js/modules/es.typed-array.fill.js");
+require("core-js/modules/es.typed-array.set.js");
+require("core-js/modules/es.typed-array.sort.js");
+require("core-js/modules/es.typed-array.to-locale-string.js");
+var _config = require("../config.js");
+var _index = require("../utils/logger/index.js");
+var _retry_connection = require("./retry_connection.js");
+var _connection_base = require("./connection_base.js");
+var _types = require("../types/types.js");
+var _proto = require("../types/proto.js");
+function _classPrivateMethodInitSpec(obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj); }
+function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
+function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
+function _classPrivateFieldGet(receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get"); return _classApplyDescriptorGet(receiver, descriptor); }
+function _classApplyDescriptorGet(receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver); } return descriptor.value; }
+function _classPrivateMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+function _classPrivateFieldSet(receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set"); _classApplyDescriptorSet(receiver, descriptor, value); return value; }
+function _classExtractFieldDescriptor(receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to " + action + " private field on non-instance"); } return privateMap.get(receiver); }
+function _classApplyDescriptorSet(receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value); } else { if (!descriptor.writable) { throw new TypeError("attempted to set read only private field"); } descriptor.value = value; } }
+const ErrorCode = _proto.types.Code;
+var _expiryTimer = /*#__PURE__*/new WeakMap();
+var _clear = /*#__PURE__*/new WeakSet();
+var _write = /*#__PURE__*/new WeakSet();
+var _handleMessage = /*#__PURE__*/new WeakSet();
+var _onResponse = /*#__PURE__*/new WeakSet();
+var _writeInputImage = /*#__PURE__*/new WeakSet();
+var _setConfig = /*#__PURE__*/new WeakSet();
+class IPSAClass extends _retry_connection.RetryConnection {
+  constructor() {
+    super('ipsa');
+    _classPrivateMethodInitSpec(this, _setConfig);
+    _classPrivateMethodInitSpec(this, _writeInputImage);
+    _classPrivateMethodInitSpec(this, _onResponse);
+    _classPrivateMethodInitSpec(this, _handleMessage);
+    _classPrivateMethodInitSpec(this, _write);
+    _classPrivateMethodInitSpec(this, _clear);
+    _classPrivateFieldInitSpec(this, _expiryTimer, {
+      writable: true,
+      value: void 0
+    });
+    this.socket = null;
+    this.onInputImage = null;
+    this.onError = null;
+    this.onResponse = null;
+    this.userToken = null;
+    _classPrivateFieldSet(this, _expiryTimer, null);
+    _classPrivateMethodGet(this, _clear, _clear2).call(this);
+  }
+  start(_ref) {
+    let {
+      userToken,
+      request,
+      onInputImage,
+      onError,
+      onResponse
+    } = _ref;
+    if (!this.isStarted()) {
+      this.setRuntimeConfig(request.runtimeConfig);
+      this.setAppConfig(request.appConfig);
+      _classPrivateMethodGet(this, _setConfig, _setConfig2).call(this, request.config);
+      this.onInputImage = onInputImage;
+      this.onError = onError;
+      this.onResponse = onResponse;
+      this.userToken = userToken;
+      let meetingClaims = new _types.MeetingClaims(this.appConfigRequest.appConfig.meetingToken);
+      let userClaims = new _types.UserClaims(this.userToken);
+      let seconds = Math.min(userClaims.getSecondsUntilExpiry(), meetingClaims.getSecondsUntilExpiry());
+      if (seconds <= 0) {
+        this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        return;
+      } else {
+        _classPrivateFieldSet(this, _expiryTimer, setTimeout(() => {
+          this.stop();
+          this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        }, seconds));
+      }
+    }
+    super.start();
+  }
+  stop() {
+    clearTimeout(_classPrivateFieldGet(this, _expiryTimer));
+    _classPrivateMethodGet(this, _clear, _clear2).call(this);
+    super.stop();
+  }
+  disconnect() {
+    super.disconnect();
+    if (this.socket != null) {
+      this.socket.close();
+      this.socket = null;
+      //  this.fireOnError(ErrorLevel.ERROR, ErrorCode.ERR_CLOSED, "closed") //this one fired after diconnection error causes multiple connection (it call retray connection again)
+    }
+  }
+
+  async connect() {
+    if (this.getConnectionStatus() != _connection_base.ConnectionStatus.DISCONNECTED) return;
+    super.connect();
+    let meetingId = this.appConfigRequest.appConfig.meetingId;
+    let meetingToken = this.appConfigRequest.appConfig.meetingToken;
+    try {
+      let c = new _types.UserClaims(this.userToken);
+      if (c.isExpired()) {
+        this.onErrorMessage(ErrorCode.ERR_TIMEOUT, "token expired");
+        return;
+      }
+    } catch (err) {
+      this.onErrorMessage(ErrorCode.ERR_UNAUTHORIZED, "unauthorized");
+      return;
+    }
+    _index.logger.info("Connecting IPSA to meeting ".concat(meetingId, "..."));
+    let base = new URL(_config.Config.apiBaseURL);
+    let uri = "wss://".concat(base.hostname, "/ws/ipsa/").concat(meetingId, "?user_token=").concat(this.userToken, "&meeting_token=").concat(meetingToken);
+    this.socket = new WebSocket(uri);
+    this.socket.binaryType = "arraybuffer";
+    this.socket.addEventListener("open", async () => {
+      try {
+        await _classPrivateMethodGet(this, _write, _write2).call(this, this.configRequest);
+        await _classPrivateMethodGet(this, _write, _write2).call(this, this.runtimeConfigRequest);
+        await _classPrivateMethodGet(this, _write, _write2).call(this, this.appConfigRequest);
+        this.onConnected();
+      } catch (err) {
+        this.onWarningMessage(ErrorCode.ERR_IO, err);
+        this.disconnect();
+        return;
+      }
+      let loopFunction = () => {
+        if (!this.isConnected() || !this.isStarted()) return;
+        if (this.socket.bufferedAmount > 0) {
+          _index.logger.warn("ipsa: low internet speed connection");
+          setTimeout(loopFunction, 100);
+        } else {
+          setTimeout(loopFunction, 500);
+          _classPrivateMethodGet(this, _writeInputImage, _writeInputImage2).call(this).catch(err => _index.logger.error(err));
+        }
+      };
+      loopFunction();
+    });
+    this.socket.addEventListener("close", () => {
+      this.onDisconnected();
+    });
+    this.socket.addEventListener("message", event => {
+      _classPrivateMethodGet(this, _handleMessage, _handleMessage2).call(this, event.data);
+    });
+    this.socket.addEventListener("error", err => {
+      this.onWarningMessage(ErrorCode.ERR_IO, err);
+    });
+  }
+  getAverageResponseTime() {
+    let avg = NaN;
+    try {
+      let items = Array.from(this.stats.values()).map(e => e.responseTime - e.requestTime).filter(e => !isNaN(e));
+      let sum = items.reduce((a, b) => a + b);
+      avg = sum / items.length;
+    } catch (err) {}
+    return avg;
+  }
+  setRuntimeConfig(cfg) {
+    let request = _proto.ipsa.Request.create({
+      runtimeConfig: cfg
+    });
+    this.runtimeConfigRequest = request;
+    if (this.isConnected()) _classPrivateMethodGet(this, _write, _write2).call(this, request);
+  }
+  setAppConfig(cfg) {
+    let request = _proto.ipsa.Request.create({
+      appConfig: cfg
+    });
+    this.appConfigRequest = request;
+    if (this.isConnected()) _classPrivateMethodGet(this, _write, _write2).call(this, request);
+  }
+}
+function _clear2() {
+  this.appConfigRequest = null;
+  this.configRequest = null;
+  this.runtimeConfigRequest = null;
+  this.stats = new Map();
+  this.requestId = 0;
+}
+async function _write2(msg) {
+  let err = _proto.ipsa.Request.verify(msg);
+  if (err) throw new Error("invalid message: " + err);
+  if (msg) {
+    let data = _proto.ipsa.Request.encode(msg).finish();
+    this.socket.send(data);
+  }
+}
+async function _handleMessage2(msg) {
+  var _msg, _msg2, _msg3, _msg4;
+  try {
+    if (msg instanceof ArrayBuffer) {
+      let buffer = new Uint8Array(msg);
+      let response = _proto.ipsa.Response.decode(buffer);
+      _classPrivateMethodGet(this, _onResponse, _onResponse2).call(this, response);
+      return;
+    }
+  } catch (err) {
+    _index.logger.error(err);
+  }
+  try {
+    msg = JSON.parse(msg);
+    switch (msg.code) {
+      case ErrorCode.ERR_TOO_MANY_CONNECTIONS:
+      case ErrorCode.ERR_UNAUTHORIZED:
+      case ErrorCode.ERR_BAD_REQUEST:
+        this.onErrorMessage((_msg = msg) === null || _msg === void 0 ? void 0 : _msg.code, (_msg2 = msg) === null || _msg2 === void 0 ? void 0 : _msg2.reason);
+        this.stop();
+        break;
+      default:
+        this.onInfoMessage((_msg3 = msg) === null || _msg3 === void 0 ? void 0 : _msg3.code, (_msg4 = msg) === null || _msg4 === void 0 ? void 0 : _msg4.reason);
+        break;
+    }
+  } catch (e) {
+    this.onWarningMessage(ErrorCode.ERR_IO, e);
+  }
+}
+function _onResponse2(response) {
+  if (response.id >= 100) {
+    let id = response.id - 100;
+    let s = this.stats.get(id) || {};
+    s.responseTime = performance.now();
+    this.stats.set(id, s);
+  }
+  if (this.onResponse) {
+    this.onResponse(response);
+  }
+}
+async function _writeInputImage2() {
+  let img = await this.onInputImage();
+  this.requestId = (this.requestId + 1) % 8;
+  this.stats.set(this.requestId, {
+    requestTime: performance.now()
+  });
+  let request = _proto.ipsa.Request.create({
+    id: this.requestId + 100,
+    ipsa: {
+      data: img
+    }
+  });
+  _classPrivateMethodGet(this, _write, _write2).call(this, request);
+}
+function _setConfig2(cfg) {
+  let request = _proto.ipsa.Request.create({
+    config: cfg
+  });
+  this.configRequest = request;
+  if (this.isConnected()) _classPrivateMethodGet(this, _write, _write2).call(this, request);
+}
+let IPSA = new IPSAClass();
+exports.IPSA = IPSA;