@techsee/techsee-media-service 999.0.2-switch → 999.0.3-alpha

package/lib/MultiParty/OpentokMultiPartyService.js

@@ -0,0 +1,888 @@
+"use strict";
+
+var __extends = void 0 && (void 0).__extends || function () {
+  var _extendStatics = function extendStatics(d, b) {
+    _extendStatics = Object.setPrototypeOf || {
+      __proto__: []
+    } instanceof Array && function (d, b) {
+      d.__proto__ = b;
+    } || function (d, b) {
+      for (var p in b) {
+        if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p];
+      }
+    };
+
+    return _extendStatics(d, b);
+  };
+
+  return function (d, b) {
+    _extendStatics(d, b);
+
+    function __() {
+      this.constructor = d;
+    }
+
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+  };
+}();
+
+var __assign = void 0 && (void 0).__assign || function () {
+  __assign = Object.assign || function (t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+      }
+    }
+
+    return t;
+  };
+
+  return __assign.apply(this, arguments);
+};
+
+var __awaiter = void 0 && (void 0).__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+var __generator = void 0 && (void 0).__generator || function (thisArg, body) {
+  var _ = {
+    label: 0,
+    sent: function sent() {
+      if (t[0] & 1) throw t[1];
+      return t[1];
+    },
+    trys: [],
+    ops: []
+  },
+      f,
+      y,
+      t,
+      g;
+  return g = {
+    next: verb(0),
+    "throw": verb(1),
+    "return": verb(2)
+  }, typeof Symbol === "function" && (g[Symbol.iterator] = function () {
+    return this;
+  }), g;
+
+  function verb(n) {
+    return function (v) {
+      return step([n, v]);
+    };
+  }
+
+  function step(op) {
+    if (f) throw new TypeError("Generator is already executing.");
+
+    while (_) {
+      try {
+        if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+        if (y = 0, t) op = [op[0] & 2, t.value];
+
+        switch (op[0]) {
+          case 0:
+          case 1:
+            t = op;
+            break;
+
+          case 4:
+            _.label++;
+            return {
+              value: op[1],
+              done: false
+            };
+
+          case 5:
+            _.label++;
+            y = op[1];
+            op = [0];
+            continue;
+
+          case 7:
+            op = _.ops.pop();
+
+            _.trys.pop();
+
+            continue;
+
+          default:
+            if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+              _ = 0;
+              continue;
+            }
+
+            if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+              _.label = op[1];
+              break;
+            }
+
+            if (op[0] === 6 && _.label < t[1]) {
+              _.label = t[1];
+              t = op;
+              break;
+            }
+
+            if (t && _.label < t[2]) {
+              _.label = t[2];
+
+              _.ops.push(op);
+
+              break;
+            }
+
+            if (t[2]) _.ops.pop();
+
+            _.trys.pop();
+
+            continue;
+        }
+
+        op = body.call(thisArg, _);
+      } catch (e) {
+        op = [6, e];
+        y = 0;
+      } finally {
+        f = t = 0;
+      }
+    }
+
+    if (op[0] & 5) throw op[1];
+    return {
+      value: op[0] ? op[1] : void 0,
+      done: true
+    };
+  }
+};
+
+var __spreadArrays = void 0 && (void 0).__spreadArrays || function () {
+  for (var s = 0, i = 0, il = arguments.length; i < il; i++) {
+    s += arguments[i].length;
+  }
+
+  for (var r = Array(s), k = 0, i = 0; i < il; i++) {
+    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) {
+      r[k] = a[j];
+    }
+  }
+
+  return r;
+};
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OpentokMultiPartyService = void 0;
+
+var MediaConstants_1 = require("../MediaConstants");
+
+var MediaUtils_1 = require("../MediaUtils");
+
+var MediaCapabilitiesService_1 = require("./MediaCapabilitiesService");
+
+var MediaCapabilitiesUtils_1 = require("./MediaCapabilitiesUtils");
+
+var MultiPartyService_1 = require("./MultiPartyService");
+
+var trace = MediaUtils_1.getMediaTracer('Multiparty'); // The preferred camera position to use for the video source
+
+var OpentokFacingMode;
+
+(function (OpentokFacingMode) {
+  OpentokFacingMode["USER"] = "user";
+  OpentokFacingMode["ENVIRONMENT"] = "environment";
+})(OpentokFacingMode || (OpentokFacingMode = {}));
+
+var OpentokMultiPartyService =
+/** @class */
+function (_super) {
+  __extends(OpentokMultiPartyService, _super);
+
+  function OpentokMultiPartyService(settings, getParticipantId) {
+    var _this = _super.call(this, settings) || this;
+
+    _this.getParticipantId = getParticipantId;
+    _this.subscriberList = [];
+
+    _this.connect = function (credentials) {
+      try {
+        _this.session = OT.initSession(credentials.apiKey, credentials.sessionId);
+
+        _this.session.on('connectionCreated', _this.connectionCreatedHandler);
+
+        _this.session.on('connectionDestroyed', _this.connectionDestroyedHandler);
+
+        _this.session.on('streamCreated', _this.streamCreatedHandler);
+
+        _this.session.on('streamDestroyed', _this.streamDestroyedHandler);
+
+        _this.session.on('streamPropertyChanged', _this.streamPropertyChangedHandler);
+
+        _this.session.on('sessionDisconnected', _this.sessionDisconnectedHandler);
+
+        _this.session.connect(credentials.token, function (error) {
+          var _a;
+
+          if (error) {
+            (_a = _this.session) === null || _a === void 0 ? void 0 : _a.off();
+            _this.session = undefined;
+
+            _this.traceErrorCallback(error);
+
+            _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.connectFailed, {
+              meta: {
+                err: JSON.stringify(error)
+              }
+            });
+
+            return;
+          }
+
+          _this.createPublisher(_this.settings);
+        });
+      } catch (err) {
+        trace.error(JSON.stringify(err));
+
+        _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.connectFailed, {
+          meta: {
+            err: JSON.stringify(err)
+          }
+        });
+      }
+    };
+
+    _this.disconnect = function () {
+      try {
+        trace.info('Disconnecting from session');
+
+        if (_this.session) {
+          _this.session.disconnect();
+
+          trace.info('Disconnection from session completed');
+        }
+      } catch (err) {
+        trace.error(JSON.stringify(err));
+      }
+    };
+
+    _this.createPublisher = function (settings) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var canStartWithAudio, canStartWithVideo;
+
+        var _a;
+
+        return __generator(this, function (_b) {
+          switch (_b.label) {
+            case 0:
+              return [4
+              /*yield*/
+              , MediaCapabilitiesUtils_1.checkAudioCapabilities()];
+
+            case 1:
+              canStartWithAudio = _b.sent();
+              return [4
+              /*yield*/
+              , MediaCapabilitiesUtils_1.checkVideoCapabilities()];
+
+            case 2:
+              canStartWithVideo = _b.sent();
+
+              if (!canStartWithAudio && !canStartWithVideo) {
+                // FIXME: use emitter
+                trace.error('Did not create publisher due to lack of media capabilities.');
+                return [2
+                /*return*/
+                ];
+              }
+
+              if (!!this.currentPublisher) return [3
+              /*break*/
+              , 4];
+              return [4
+              /*yield*/
+              , this.initPublisher(__assign(__assign({}, settings), {
+                cameraEnabled: settings.cameraEnabled && canStartWithVideo,
+                startWithAudioMuted: settings.startWithAudioMuted && canStartWithAudio
+              }))];
+
+            case 3:
+              _b.sent();
+
+              if (!this.currentPublisher) {
+                throw new Error('Creating session requires initialized publisher');
+              }
+
+              this.currentPublisher && ((_a = this.session) === null || _a === void 0 ? void 0 : _a.publish(this.currentPublisher, this.traceErrorCallback));
+              _b.label = 4;
+
+            case 4:
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    _this.publishAudio = function (shouldMute) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var canPublishAudio;
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              return [4
+              /*yield*/
+              , MediaCapabilitiesUtils_1.checkAudioCapabilities()];
+
+            case 1:
+              canPublishAudio = _a.sent(); // why do we care about audio if 'shouldMute' is true?
+
+              if (shouldMute && !canPublishAudio) {
+                trace.error('could not publish audio');
+                return [2
+                /*return*/
+                ];
+              }
+
+              if (!!this.currentPublisher) return [3
+              /*break*/
+              , 3];
+              return [4
+              /*yield*/
+              , this.createPublisher(__assign(__assign({}, this.settings), {
+                // so if 'shouldMute' is true then we DON't mute?
+                startWithAudioMuted: !shouldMute
+              }))];
+
+            case 2:
+              _a.sent();
+
+              return [3
+              /*break*/
+              , 4];
+
+            case 3:
+              this.currentPublisher.publishAudio(shouldMute);
+              _a.label = 4;
+
+            case 4:
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    _this.publishVideo = function (shouldPublishVideo) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var canPublishVideo;
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              return [4
+              /*yield*/
+              , MediaCapabilitiesUtils_1.checkVideoCapabilities()];
+
+            case 1:
+              canPublishVideo = _a.sent();
+
+              if (shouldPublishVideo && !canPublishVideo) {
+                trace.error('could not publish video');
+                return [2
+                /*return*/
+                ];
+              }
+
+              if (!!this.currentPublisher) return [3
+              /*break*/
+              , 3];
+              return [4
+              /*yield*/
+              , this.createPublisher(__assign(__assign({}, this.settings), {
+                cameraEnabled: shouldPublishVideo
+              }))];
+
+            case 2:
+              _a.sent();
+
+              return [3
+              /*break*/
+              , 4];
+
+            case 3:
+              this.currentPublisher.publishVideo(shouldPublishVideo);
+              _a.label = 4;
+
+            case 4:
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    _this.switchCamera = function () {
+      return __awaiter(_this, void 0, void 0, function () {
+        var mediaCapabilitiesService, deviceId, cameraType_1, err_1;
+
+        var _this = this;
+
+        var _a;
+
+        return __generator(this, function (_b) {
+          switch (_b.label) {
+            case 0:
+              _b.trys.push([0, 2,, 3]);
+
+              return [4
+              /*yield*/
+              , MediaCapabilitiesService_1.MediaCapabilitiesService.getInstance()];
+
+            case 1:
+              mediaCapabilitiesService = _b.sent();
+
+              if (!mediaCapabilitiesService.supportSwitchCamera) {
+                throw new Error('Not Support switch camera');
+              }
+
+              deviceId = '';
+
+              switch (this.settings.selectedCamera) {
+                case MediaConstants_1.MultiPartyCameraTypes.BACK:
+                  cameraType_1 = MediaConstants_1.MultiPartyCameraTypes.FRONT;
+                  deviceId = mediaCapabilitiesService.frontCameraDeviceId;
+                  break;
+
+                case MediaConstants_1.MultiPartyCameraTypes.FRONT:
+                  cameraType_1 = MediaConstants_1.MultiPartyCameraTypes.BACK;
+                  deviceId = mediaCapabilitiesService.backCameraDeviceId;
+                  break;
+
+                default:
+                  throw new Error("cameraType not valid: " + this.settings.selectedCamera);
+              }
+
+              return [2
+              /*return*/
+              , (_a = this.currentPublisher) === null || _a === void 0 ? void 0 : _a.setVideoSource(deviceId).then(function () {
+                _this.settings.selectedCamera = cameraType_1;
+
+                _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.cameraSourceChanged, {
+                  cameraSource: cameraType_1
+                });
+
+                trace.info("Success to switch camera to cameraType: " + cameraType_1);
+              })];
+
+            case 2:
+              err_1 = _b.sent();
+              trace.error(JSON.stringify(err_1));
+              throw err_1;
+
+            case 3:
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    _this.initPublisher = function (settings) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var selectedCamera, isMobile, mediaCapabilitiesService, frontCameraDeviceId, backCameraDeviceId, videoSourceId, mobileCameraType, err_2;
+
+        var _this = this;
+
+        var _a, _b, _c;
+
+        return __generator(this, function (_d) {
+          switch (_d.label) {
+            case 0:
+              _d.trys.push([0, 2,, 3]);
+
+              selectedCamera = settings.selectedCamera;
+              isMobile = MediaCapabilitiesUtils_1.checkIsMobile();
+              return [4
+              /*yield*/
+              , MediaCapabilitiesService_1.MediaCapabilitiesService.getInstance()];
+
+            case 1:
+              mediaCapabilitiesService = _d.sent();
+              frontCameraDeviceId = mediaCapabilitiesService.frontCameraDeviceId, backCameraDeviceId = mediaCapabilitiesService.backCameraDeviceId;
+              videoSourceId = (selectedCamera === MediaConstants_1.MultiPartyCameraTypes.FRONT ? frontCameraDeviceId : backCameraDeviceId) || undefined;
+              mobileCameraType = settings.selectedCamera === MediaConstants_1.MultiPartyCameraTypes.FRONT ? OpentokFacingMode.USER : OpentokFacingMode.ENVIRONMENT;
+              this.currentPublisher = OT.initPublisher(this.getParticipantId(((_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.connectionId) || ''), {
+                insertMode: 'append',
+                fitMode: 'cover',
+                width: '100%',
+                height: '100%',
+                style: {
+                  buttonDisplayMode: 'off',
+                  archiveStatusDisplayMode: 'off',
+                  audioLevelDisplayMode: 'off',
+                  backgroundImageURI: ((_c = this.branding) === null || _c === void 0 ? void 0 : _c.backgroundImageURI) || MultiPartyService_1.DEFAULT_AVATAR_URI
+                },
+                publishAudio: !settings.startWithAudioMuted,
+                publishVideo: settings.cameraEnabled,
+                videoSource: !isMobile ? videoSourceId : undefined,
+                facingMode: isMobile || !videoSourceId ? mobileCameraType : undefined
+              }, this.traceErrorCallback);
+
+              if (!this.currentPublisher) {
+                trace.error('failed to init publisher');
+              } else {
+                this.currentPublisher.on('videoElementCreated', function (event) {
+                  trace.info('videoElementCreated', event);
+
+                  _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.videoElementCreated, event);
+                });
+                this.currentPublisher.on('streamDestroyed', function (event) {
+                  var _a;
+
+                  trace.info('Publisher stream destroyed', event);
+
+                  _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.streamDestroyed, {
+                    event: event,
+                    participantId: _this.getParticipantId((_a = event === null || event === void 0 ? void 0 : event.stream) === null || _a === void 0 ? void 0 : _a.connection.connectionId)
+                  });
+                });
+                this.currentPublisher.on('accessDenied', function (event) {
+                  var _a;
+
+                  trace.info('Publisher denied media permissions', event);
+                  var connection = (_a = _this.session) === null || _a === void 0 ? void 0 : _a.connection;
+                  var connectionId = connection === null || connection === void 0 ? void 0 : connection.connectionId;
+
+                  var participantId = _this.getParticipantId(connectionId);
+
+                  var isOwnConnection = _this.ownConnectionId === connectionId;
+
+                  _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.mediaDeviceAccessDenied, {
+                    connectionId: connectionId,
+                    isOwnConnection: isOwnConnection,
+                    participantId: participantId
+                  });
+                });
+                this.currentPublisher.on('streamCreated', function (event) {
+                  return __awaiter(_this, void 0, void 0, function () {
+                    var participantId;
+
+                    var _a, _b, _c, _d, _e, _f;
+
+                    return __generator(this, function (_g) {
+                      switch (_g.label) {
+                        case 0:
+                          return [4
+                          /*yield*/
+                          , MediaCapabilitiesService_1.MediaCapabilitiesService.setDevicesList()];
+
+                        case 1:
+                          _g.sent();
+
+                          participantId = this.getParticipantId((_a = event === null || event === void 0 ? void 0 : event.stream) === null || _a === void 0 ? void 0 : _a.connection.connectionId);
+                          this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.streamCreated, {
+                            event: event,
+                            participantId: participantId,
+                            startWithAudioMuted: this.settings.startWithAudioMuted,
+                            hasAudio: (_b = event === null || event === void 0 ? void 0 : event.stream) === null || _b === void 0 ? void 0 : _b.hasAudio,
+                            hasVideo: (_c = event === null || event === void 0 ? void 0 : event.stream) === null || _c === void 0 ? void 0 : _c.hasVideo,
+                            isOwnConnection: this.ownConnectionId === ((_e = (_d = event === null || event === void 0 ? void 0 : event.stream) === null || _d === void 0 ? void 0 : _d.connection) === null || _e === void 0 ? void 0 : _e.connectionId)
+                          });
+                          trace.info('publisher stream created', {
+                            event: event,
+                            hasAudio: (_f = this.currentPublisher) === null || _f === void 0 ? void 0 : _f['stream.hasAudio'],
+                            participantId: participantId
+                          });
+                          return [2
+                          /*return*/
+                          ];
+                      }
+                    });
+                  });
+                });
+              }
+
+              return [3
+              /*break*/
+              , 3];
+
+            case 2:
+              err_2 = _d.sent();
+              trace.error(JSON.stringify(err_2));
+              throw err_2;
+
+            case 3:
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    _this.reinitializeStreams = function (settings) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var _this = this;
+
+        return __generator(this, function (_a) {
+          switch (_a.label) {
+            case 0:
+              if (this.currentPublisher) {
+                this.currentPublisher.destroy();
+                this.currentPublisher = undefined;
+              }
+
+              return [4
+              /*yield*/
+              , this.createPublisher(settings)];
+
+            case 1:
+              _a.sent();
+
+              this.subscriberList = this.subscriberList.map(function (s) {
+                var _a;
+
+                var connectionId = s.connectionId,
+                    subscriber = s.subscriber;
+                var stream = subscriber.stream;
+                (_a = _this.session) === null || _a === void 0 ? void 0 : _a.unsubscribe(subscriber);
+                return __assign(__assign({}, s), {
+                  subscriber: _this.createSubscriber(stream, connectionId)
+                });
+              });
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    _this.streamCreatedHandler = function (event) {
+      return __awaiter(_this, void 0, void 0, function () {
+        var stream, connection, connectionId, participantId, subscriber;
+
+        var _a, _b;
+
+        return __generator(this, function (_c) {
+          switch (_c.label) {
+            case 0:
+              trace.info('streamCreatedHandler', event.stream);
+              stream = event.stream;
+              connection = stream.connection;
+              connectionId = connection.connectionId;
+              participantId = this.getParticipantId(connectionId);
+              return [4
+              /*yield*/
+              , MediaCapabilitiesService_1.MediaCapabilitiesService.setDevicesList()];
+
+            case 1:
+              _c.sent();
+
+              this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.streamCreated, {
+                event: event,
+                participantId: participantId,
+                startWithAudioMuted: this.settings.startWithAudioMuted,
+                isOwnConnection: this.ownConnectionId === connectionId,
+                hasVideo: (_a = event === null || event === void 0 ? void 0 : event.stream) === null || _a === void 0 ? void 0 : _a.hasVideo,
+                hasAudio: (_b = event === null || event === void 0 ? void 0 : event.stream) === null || _b === void 0 ? void 0 : _b.hasAudio
+              });
+
+              if (!this.ownConnectionId || !stream || connectionId === this.ownConnectionId) {
+                return [2
+                /*return*/
+                ];
+              }
+
+              if (this.subscriberList.length >= MultiPartyService_1.maxParticipantsNumber - 1) {
+                trace.info("a new subscriber cannot be added, as the number of participants reached its limit: " + MultiPartyService_1.maxParticipantsNumber);
+                return [2
+                /*return*/
+                ];
+              }
+
+              subscriber = this.createSubscriber(stream, connectionId);
+              this.subscriberList.push({
+                subscriber: subscriber,
+                connectionId: connectionId,
+                clientRole: this.getClientRole(connection)
+              });
+              return [2
+              /*return*/
+              ];
+          }
+        });
+      });
+    };
+
+    _this.streamPropertyChangedHandler = function (event) {
+      var _a;
+
+      trace.info('streamPropertyChangedHandler', event);
+      var stream = event.stream;
+
+      _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.videoAudioStatus, {
+        hasVideo: stream === null || stream === void 0 ? void 0 : stream.hasVideo,
+        hasAudio: stream === null || stream === void 0 ? void 0 : stream.hasAudio,
+        participantId: _this.getParticipantId(stream === null || stream === void 0 ? void 0 : stream.connection.connectionId),
+        isOwnConnection: _this.ownConnectionId === ((_a = stream === null || stream === void 0 ? void 0 : stream.connection) === null || _a === void 0 ? void 0 : _a.connectionId),
+        stream: stream
+      });
+    };
+
+    _this.streamDestroyedHandler = function (event) {
+      var _a;
+
+      trace.info('streamDestroyedHandler', event);
+      var stream = event.stream;
+      var destroyedConnectionId = stream && stream.connection && stream.connection.connectionId;
+
+      _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.streamDestroyed, {
+        event: event,
+        participantId: _this.getParticipantId((_a = event === null || event === void 0 ? void 0 : event.stream) === null || _a === void 0 ? void 0 : _a.connection.connectionId)
+      });
+
+      _this.subscriberList = _this.subscriberList.filter(function (subscriber) {
+        return subscriber.connectionId !== destroyedConnectionId;
+      });
+    };
+
+    _this.connectionCreatedHandler = function (event) {
+      trace.info('connectionCreatedHandler', event);
+      var connection = event.connection;
+
+      if (!_this.ownConnectionId || !connection) {
+        return;
+      }
+
+      _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.participantsNumberChanged, _this.subscriberList.length);
+
+      var clientRole = _this.getClientRole(connection);
+
+      _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.connectionCreated, {
+        clientRole: clientRole,
+        event: event,
+        participantId: _this.getParticipantId(connection.connectionId),
+        isOwnConnection: _this.ownConnectionId === connection.connectionId
+      });
+    };
+
+    _this.connectionDestroyedHandler = function (event) {
+      var connection = event.connection;
+
+      var clientRole = _this.getClientRole(connection);
+
+      trace.info('connectionDestroyedHandler', event);
+
+      _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.connectionDestroyed, {
+        clientRole: clientRole,
+        event: event,
+        participantId: _this.getParticipantId(event === null || event === void 0 ? void 0 : event.connection.connectionId)
+      });
+
+      if (!_this.ownConnectionId || !connection || connection.connectionId !== _this.ownConnectionId) {
+        return;
+      }
+
+      _this.emit(MultiPartyService_1.MULTI_PARTY_EVENTS.participantsNumberChanged, _this.subscriberList.length);
+
+      _this.session = undefined;
+    };
+
+    _this.traceErrorCallback = function (error) {
+      trace.error(JSON.stringify(error));
+    };
+
+    _this.sessionDisconnectedHandler = function (event) {
+      trace.info('sessionDisconnectedHandler', event); // ToDo: Below line makes no sense (according to the OT types). This is not how OT signals work.
+      // this?.session?.signal({ retryAfterReconnect: true });
+    };
+
+    _this.createSubscriber = function (stream, connectionId) {
+      var _a; // ToDo: OT session can be undefined. This needs to be fixed.
+
+
+      var subscriber = _this.session.subscribe(stream, _this.getParticipantId(connectionId), {
+        insertMode: 'append',
+        fitMode: 'cover',
+        width: '100%',
+        height: '100%',
+        style: {
+          buttonDisplayMode: 'off',
+          audioLevelDisplayMode: 'off',
+          backgroundImageURI: ((_a = _this.branding) === null || _a === void 0 ? void 0 : _a.backgroundImageURI) || MultiPartyService_1.DEFAULT_AVATAR_URI
+        }
+      }, function (err) {
+        _this.traceErrorCallback(err);
+
+        subscriber === null || subscriber === void 0 ? void 0 : subscriber.on('videoElementCreated', function (event) {
+          trace.info('videoElementCreated', event);
+        });
+      });
+
+      return subscriber;
+    };
+
+    _this.branding = settings.branding;
+    return _this;
+  }
+
+  Object.defineProperty(OpentokMultiPartyService.prototype, "ownConnectionId", {
+    get: function get() {
+      var _a, _b;
+
+      return ((_b = (_a = this.session) === null || _a === void 0 ? void 0 : _a.connection) === null || _b === void 0 ? void 0 : _b.connectionId) || '';
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Object.defineProperty(OpentokMultiPartyService.prototype, "subscribers", {
+    get: function get() {
+      return __spreadArrays(this.subscriberList);
+    },
+    enumerable: false,
+    configurable: true
+  });
+
+  OpentokMultiPartyService.prototype.getClientRole = function (connection) {
+    return (connection === null || connection === void 0 ? void 0 : connection.data) && JSON.parse(connection.data).clientRole || MediaConstants_1.SessionClientRole.USER;
+  };
+
+  return OpentokMultiPartyService;
+}(MultiPartyService_1.MultiPartyService);
+
+exports.OpentokMultiPartyService = OpentokMultiPartyService;
+//# sourceMappingURL=OpentokMultiPartyService.js.map