@observertc/observer-js 0.9.27-beta → 0.30.0-beta

package/lib/ObservedPeerConnection.js

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObservedPeerConnection = void 0;
+const events_1 = require("events");
+const Models = __importStar(require("./models/Models"));
+const ObservedInboundTrack_1 = require("./ObservedInboundTrack");
+const ObservedOutboundTrack_1 = require("./ObservedOutboundTrack");
+const SingleExecutor_1 = require("./common/SingleExecutor");
+class ObservedPeerConnection extends events_1.EventEmitter {
+    static create(config, client, storageProvider) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const model = new Models.PeerConnection({
+                roomId: client.roomId,
+                serviceId: client.serviceId,
+                callId: client.callId,
+                clientId: client.clientId,
+                peerConnectionId: config.peerConnectionId,
+            });
+            const alreadyInserted = yield storageProvider.peerConnectionStorage.insert(config.peerConnectionId, model);
+            if (alreadyInserted)
+                throw new Error(`PeerConnection with id ${config.peerConnectionId} already exists`);
+            return new ObservedPeerConnection(model, client, storageProvider);
+        });
+    }
+    constructor(_model, client, _storageProvider) {
+        super();
+        this._model = _model;
+        this.client = client;
+        this._storageProvider = _storageProvider;
+        this._closed = false;
+        this._updated = Date.now();
+        this._inboundAudioTracks = new Map();
+        this._inboundVideoTracks = new Map();
+        this._outboundAudioTracks = new Map();
+        this._outboundVideoTracks = new Map();
+        this._execute = (0, SingleExecutor_1.createSingleExecutor)();
+    }
+    get peerConnectionId() {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        return this._model.peerConnectionId;
+    }
+    get reports() {
+        return this.client.reports;
+    }
+    get stats() {
+        return this._sample;
+    }
+    get updated() {
+        return this._updated;
+    }
+    get inboundAudioTracks() {
+        return this._inboundAudioTracks;
+    }
+    get inboundVideoTracks() {
+        return this._inboundVideoTracks;
+    }
+    get outboundAudioTracks() {
+        return this._outboundAudioTracks;
+    }
+    get outboundVideoTracks() {
+        return this._outboundVideoTracks;
+    }
+    get closed() {
+        return this._closed;
+    }
+    close() {
+        if (this._closed)
+            return;
+        this._closed = true;
+        Array.from(this._inboundAudioTracks.values()).forEach((track) => track.close());
+        Array.from(this._inboundVideoTracks.values()).forEach((track) => track.close());
+        Array.from(this._outboundAudioTracks.values()).forEach((track) => track.close());
+        Array.from(this._outboundVideoTracks.values()).forEach((track) => track.close());
+        this._execute(() => this._storageProvider.peerConnectionStorage.remove(this.peerConnectionId))
+            .catch(() => void 0)
+            .finally(() => this.emit('close'));
+    }
+    update(sample, timestamp) {
+        if (this._closed)
+            return;
+        if (sample.peerConnectionId !== this._model.peerConnectionId)
+            throw new Error(`TransportId mismatch. PeerConnectionId: ${this._model.peerConnectionId} TransportId: ${sample.transportId}`);
+        this._sample = sample;
+        const report = Object.assign(Object.assign({ serviceId: this.client.call.serviceId, roomId: this.client.call.roomId, callId: this.client.call.callId, clientId: this.client.clientId, userId: this.client.userId, mediaUnitId: this.client.mediaUnitId }, sample), { timestamp, sampleSeq: -1 });
+        this.reports.addPeerConnectionTransportReports(report);
+        this._updated = timestamp;
+        this.emit('update');
+    }
+    createInboundAudioTrack(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._closed)
+                throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+            const result = yield ObservedInboundTrack_1.ObservedInboundTrack.create({
+                kind: 'audio',
+                trackId: config.trackId,
+            }, this, this._storageProvider);
+            result.on('close', () => {
+                this._inboundAudioTracks.delete(result.trackId);
+                this._model.inboundTrackIds = this._model.inboundTrackIds.filter((id) => id !== result.trackId);
+                !this._closed && this._save().catch(() => void 0);
+            });
+            this._inboundAudioTracks.set(result.trackId, result);
+            this._model.inboundTrackIds = [...(new Set([...this._model.inboundTrackIds, result.trackId]))];
+            yield this._save();
+            this.emit('newinboudaudiotrack', result);
+            return result;
+        });
+    }
+    createInboundVideoTrack(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._closed)
+                throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+            const result = yield ObservedInboundTrack_1.ObservedInboundTrack.create({
+                kind: 'video',
+                trackId: config.trackId,
+            }, this, this._storageProvider);
+            result.on('close', () => {
+                this._inboundVideoTracks.delete(result.trackId);
+                this._model.inboundTrackIds = this._model.inboundTrackIds.filter((id) => id !== result.trackId);
+                !this._closed && this._save().catch(() => void 0);
+            });
+            this._inboundVideoTracks.set(result.trackId, result);
+            this._model.inboundTrackIds = [...(new Set([...this._model.inboundTrackIds, result.trackId]))];
+            yield this._save();
+            this.emit('newinboudvideotrack', result);
+            return result;
+        });
+    }
+    createOutboundAudioTrack(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._closed)
+                throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+            const result = yield ObservedOutboundTrack_1.ObservedOutboundTrack.create({
+                kind: 'audio',
+                trackId: config.trackId,
+            }, this, this._storageProvider);
+            result.on('close', () => {
+                this._outboundAudioTracks.delete(result.trackId);
+                this._model.outboundTrackIds = this._model.outboundTrackIds.filter((id) => id !== result.trackId);
+                result.sfuStreamId && this.client.call.sfuStreamIdToOutboundAudioTrack.delete(result.sfuStreamId);
+                !this._closed && this._save().catch(() => void 0);
+            });
+            this._outboundAudioTracks.set(result.trackId, result);
+            this._model.outboundTrackIds = [...(new Set([...this._model.outboundTrackIds, result.trackId]))];
+            result.sfuStreamId && this.client.call.sfuStreamIdToOutboundAudioTrack.set(result.sfuStreamId, result);
+            yield this._save();
+            this.emit('newoutboundaudiotrack', result);
+            return result;
+        });
+    }
+    createOutboundVideoTrack(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._closed)
+                throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+            const result = yield ObservedOutboundTrack_1.ObservedOutboundTrack.create({
+                kind: 'video',
+                trackId: config.trackId,
+            }, this, this._storageProvider);
+            result.on('close', () => {
+                this._outboundVideoTracks.delete(result.trackId);
+                result.sfuStreamId && this.client.call.sfuStreamIdToOutboundVideoTrack.set(result.sfuStreamId, result);
+                this._model.outboundTrackIds = this._model.outboundTrackIds.filter((id) => id !== result.trackId);
+                !this._closed && this._save().catch(() => void 0);
+            });
+            this._outboundVideoTracks.set(result.trackId, result);
+            result.sfuStreamId && this.client.call.sfuStreamIdToOutboundVideoTrack.set(result.sfuStreamId, result);
+            this._model.outboundTrackIds = [...(new Set([...this._model.outboundTrackIds, result.trackId]))];
+            yield this._save();
+            this.emit('newoutboundvideotrack', result);
+            return result;
+        });
+    }
+    _save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._closed)
+                throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+            return this._execute(() => __awaiter(this, void 0, void 0, function* () {
+                if (this._closed)
+                    throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+                yield this._storageProvider.peerConnectionStorage.set(this.peerConnectionId, this._model);
+            }));
+        });
+    }
+}
+exports.ObservedPeerConnection = ObservedPeerConnection;