@observertc/observer-js 0.9.27-beta → 0.30.0-e12fcb4.0

package/src/ObservedInboundTrack.ts

@@ -0,0 +1,238 @@
+import { EventEmitter } from 'events';
+import { StorageProvider } from './storages/StorageProvider';
+import * as Models from './models/Models';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { InboundAudioTrack, InboundVideoTrack } from '@observertc/sample-schemas-js';
+import { ObservedOutboundTrack } from './ObservedOutboundTrack';
+import { InboundAudioTrackReport, InboundVideoTrackReport } from '@observertc/report-schemas-js';
+import { MediaKind } from './common/types';
+import { createSingleExecutor } from './common/SingleExecutor';
+
+export type ObservedInboundTrackConfig<K extends MediaKind> = {
+	trackId: string;
+	kind: K;
+	sfuStreamId?: string;
+	sfuSinkId?: string;
+}
+
+export type ObservedInboundTrackEvents<K extends MediaKind> = {
+	update: [],
+	close: [],
+	remoteoutboundtrack: [ObservedOutboundTrack<K>],
+};
+
+export type ObservedInboundTrackStatsUpdate<K extends MediaKind> = K extends 'audio' ? InboundAudioTrack : InboundVideoTrack;
+
+export type ObservedInboundTrackStats<K extends MediaKind> = ObservedInboundTrackStatsUpdate<K> & {
+	ssrc: number;
+	bitrate: number;
+	fractionLost: number;
+	rttInMs?: number;
+};
+
+// {
+// 	[Property in keyof ObservedInboundTrackStats<K>]: ObservedInboundTrackStats<K>[Property];
+// }
+
+export declare interface ObservedInboundTrack<Kind extends MediaKind> {
+	on<U extends keyof ObservedInboundTrackEvents<Kind>>(event: U, listener: (...args: ObservedInboundTrackEvents<Kind>[U]) => void): this;
+	off<U extends keyof ObservedInboundTrackEvents<Kind>>(event: U, listener: (...args: ObservedInboundTrackEvents<Kind>[U]) => void): this;
+	once<U extends keyof ObservedInboundTrackEvents<Kind>>(event: U, listener: (...args: ObservedInboundTrackEvents<Kind>[U]) => void): this;
+	emit<U extends keyof ObservedInboundTrackEvents<Kind>>(event: U, ...args: ObservedInboundTrackEvents<Kind>[U]): boolean;
+	update(sample: ObservedInboundTrackStatsUpdate<Kind>, timestamp: number): void;
+}
+
+export class ObservedInboundTrack<Kind extends MediaKind> extends EventEmitter	{
+	public static async create<K extends MediaKind>(
+		config: ObservedInboundTrackConfig<K>,
+		peerConnection: ObservedPeerConnection,
+		storageProvider: StorageProvider,
+	) {
+		const model = new Models.InboundTrack({
+			serviceId: peerConnection.client.serviceId,
+			roomId: peerConnection.client.roomId,
+			callId: peerConnection.client.callId,
+			clientId: peerConnection.client.clientId,
+			mediaUnitId: peerConnection.client.mediaUnitId,
+			peerConnectionId: peerConnection.peerConnectionId,
+			trackId: config.trackId,
+			kind: config.kind,
+			sfuStreamId: config.sfuStreamId,
+			sfuSinkId: config.sfuSinkId,
+		});
+
+		const alreadyInserted = await storageProvider.inboundTrackStorage.insert(config.trackId, model);
+
+		if (alreadyInserted) throw new Error(`InboundAudioTrack with id ${config.trackId} already exists`);
+
+		return new ObservedInboundTrack<K>(model, peerConnection, storageProvider);
+	}
+
+	private readonly _stats = new Map<number, ObservedInboundTrackStats<Kind>>();
+	private readonly _execute = createSingleExecutor();
+	
+	private _closed = false;
+	private _updated = Date.now();
+	private _remoteOutboundTrack?: ObservedOutboundTrack<Kind>;
+	public bitrate = -1;
+	public rttInMs = -1;
+	
+	private constructor(
+		private readonly _model: Models.InboundTrack,
+		public readonly peerConnection: ObservedPeerConnection,
+		private readonly _storageProvider: StorageProvider,
+	) {
+		super();
+	}
+
+	public get serviceId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.serviceId!;
+	}
+
+	public get roomId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.roomId!;
+	}
+
+	public get callId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.callId!;
+	}
+
+	public get clientId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.clientId!;
+	}
+
+	public get mediaUnitId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.mediaUnitId!;
+	}
+
+	public get peerConnectionId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.peerConnectionId!;
+	}
+
+	public get trackId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.trackId!;
+	}
+
+	public get kind(): Kind {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.kind! as Kind;
+	}
+
+	public get sfuStreamId() {
+		return this._model.sfuStreamId;
+	}
+
+	public get sfuSinkId() {
+		return this._model.sfuSinkId;
+	}
+
+	public get updated() {
+		return this._updated;
+	}
+
+	public get stats(): ReadonlyMap<number, ObservedInboundTrackStats<Kind>> {
+		return this._stats;
+	}
+
+	public get reports() {
+		return this.peerConnection.reports;
+	}
+
+	public set remoteOutboundTrack(track: ObservedOutboundTrack<Kind> | undefined) {
+		if (this._closed) return;
+		if (this._remoteOutboundTrack) return;
+		if (!track) return;
+		track?.once('close', () => {
+			this._remoteOutboundTrack = undefined;
+		});
+		this._remoteOutboundTrack = track;
+		this.emit('remoteoutboundtrack', track);
+	}
+
+	public get remoteOutboundTrack() {
+		return this._remoteOutboundTrack;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public close() {
+		if (this._closed) return;
+
+		this._closed = true;
+
+		this._execute(() => this._storageProvider.inboundTrackStorage.remove(this.trackId))
+			.catch(() => void 0)
+			.finally(() => this.emit('close'));
+	}
+
+	public async update(sample: ObservedInboundTrackStatsUpdate<Kind>, timestamp: number) {
+		if (this._closed) return;
+		let executeSave = false;
+
+		const report: InboundAudioTrackReport | InboundVideoTrackReport = {
+			serviceId: this.peerConnection.client.call.serviceId,
+			roomId: this.peerConnection.client.call.roomId,
+			callId: this.peerConnection.client.call.callId,
+			clientId: this.peerConnection.client.clientId,
+			userId: this.peerConnection.client.userId,
+			mediaUnitId: this.peerConnection.client.mediaUnitId,
+			peerConnectionId: this.peerConnection.peerConnectionId,
+			...sample,
+			timestamp,
+			sampleSeq: -1,
+		};
+
+		if (this.kind === 'audio') this.reports.addInboundAudioTrackReport(report);
+		else if (this.kind === 'video') this.reports.addInboundVideoTrackReport(report);
+		
+		if (!this._model.sfuStreamId && sample.sfuStreamId) {
+			this._model.sfuStreamId = sample.sfuStreamId;
+			executeSave = true;
+		}
+
+		if (!this._model.sfuSinkId && sample.sfuSinkId) {
+			this._model.sfuSinkId = sample.sfuSinkId;
+			executeSave = true;
+		}
+
+		const elapsedTimeInMs = Math.max(1, timestamp - this._updated);
+		const lastStat = this._stats.get(sample.ssrc);
+		const rttInMs = sample.roundTripTime ? sample.roundTripTime * 1000 : undefined;
+		const bitrate = ((sample.bytesReceived ?? 0) - (lastStat?.bytesReceived ?? 0)) * 8 / (elapsedTimeInMs / 1000);
+		const lostPackets = (sample.packetsLost ?? 0) - (lastStat?.packetsLost ?? 0);
+		const receivedPackets = (sample.packetsReceived ?? 0) - (lastStat?.packetsReceived ?? 0);
+		const fractionLost = 0 < receivedPackets && 0 < lostPackets ? (lostPackets / (receivedPackets + lostPackets)) : 0;
+		const stats: ObservedInboundTrackStats<Kind> = {
+			...sample,
+			fractionLost,
+			rttInMs,
+			bitrate,
+			ssrc: sample.ssrc,
+		};
+
+		this._stats.set(sample.ssrc, stats);
+
+		this.bitrate = [ ...this._stats.values() ].reduce((acc, stat) => acc + stat.bitrate, 0);
+		this.rttInMs = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.rttInMs ?? 0), 0) / (this._stats.size || 1);
+		
+		if (executeSave) await this._save();
+
+		this._updated = timestamp;
+		this.emit('update');
+	}
+
+	private async _save() {
+		if (this._closed) throw new Error(`OutboundTrack ${this.trackId} is closed`);
+		
+		return this._storageProvider.inboundTrackStorage.set(this.trackId, this._model);
+	}
+}

package/src/ObservedOutboundTrack.ts

@@ -0,0 +1,205 @@
+import { EventEmitter } from 'events';
+import { StorageProvider } from './storages/StorageProvider';
+import * as Models from './models/Models';
+import { ObservedPeerConnection } from './ObservedPeerConnection';
+import { OutboundAudioTrack, OutboundVideoTrack } from '@observertc/sample-schemas-js';
+import { ObservedInboundTrack } from './ObservedInboundTrack';
+import { OutboundAudioTrackReport, OutboundVideoTrackReport } from '@observertc/report-schemas-js';
+import { MediaKind } from './common/types';
+import { createSingleExecutor } from './common/SingleExecutor';
+
+export type ObservedOutboundTrackConfig<K extends MediaKind> = {
+	trackId: string;
+	kind: K;
+	sfuStreamId?: string;
+}
+
+export type ObservedOutboundTrackEvents = {
+	update: [],
+	close: [],
+};
+
+export type ObservedOutboundTrackStatsUpdate<K extends MediaKind> = K extends 'audio' ? OutboundAudioTrack : OutboundVideoTrack;
+
+export type ObservedOutboundTrackStats<K extends MediaKind> = ObservedOutboundTrackStatsUpdate<K> & {
+	ssrc: number;
+	bitrate: number;
+	rttInMs?: number;
+};
+
+// export type ObservedOutboundTrackStatsUpdate<K extends MediaKind> = {
+// 	[Property in keyof ObservedOutboundTrackStats<K>]: ObservedOutboundTrackStats<K>[Property];
+// }
+
+export declare interface ObservedOutboundTrack<Kind extends MediaKind> {
+	on<U extends keyof ObservedOutboundTrackEvents>(event: U, listener: (...args: ObservedOutboundTrackEvents[U]) => void): this;
+	off<U extends keyof ObservedOutboundTrackEvents>(event: U, listener: (...args: ObservedOutboundTrackEvents[U]) => void): this;
+	once<U extends keyof ObservedOutboundTrackEvents>(event: U, listener: (...args: ObservedOutboundTrackEvents[U]) => void): this;
+	emit<U extends keyof ObservedOutboundTrackEvents>(event: U, ...args: ObservedOutboundTrackEvents[U]): boolean;
+	update(sample: ObservedOutboundTrackStatsUpdate<Kind>, timestamp: number): void;
+}
+
+export class ObservedOutboundTrack<Kind extends MediaKind> extends EventEmitter	{
+	public static async create<K extends MediaKind>(
+		config: ObservedOutboundTrackConfig<K>,
+		peerConnection: ObservedPeerConnection,
+		storageProvider: StorageProvider,
+	) {
+		const model = new Models.OutboundTrack({
+			serviceId: peerConnection.client.serviceId,
+			roomId: peerConnection.client.roomId,
+			callId: peerConnection.client.callId,
+			clientId: peerConnection.client.clientId,
+			mediaUnitId: peerConnection.client.mediaUnitId,
+			peerConnectionId: peerConnection.peerConnectionId,
+			trackId: config.trackId,
+			kind: config.kind,
+			sfuStreamId: config.sfuStreamId,
+		});
+
+		const alreadyInserted = await storageProvider.outboundTrackStorage.insert(config.trackId, model);
+
+		if (alreadyInserted) throw new Error(`OutboundAudioTrack with id ${config.trackId} already exists`);
+
+		return new ObservedOutboundTrack<K>(model, peerConnection, storageProvider);
+	}
+
+	public bitrate?: number;
+	public rttInMs?: number;
+
+	private readonly _stats = new Map<number, ObservedOutboundTrackStats<Kind>>();
+	private readonly _execute = createSingleExecutor();
+	
+	private _closed = false;
+	private _updated = Date.now();
+	private _remoteInboundTracks = new Map<string, ObservedInboundTrack<Kind>>();
+
+	private constructor(
+		private readonly _model: Models.OutboundTrack,
+		public readonly peerConnection: ObservedPeerConnection,
+		private readonly _storageProvider: StorageProvider,
+	) {
+		super();
+	}
+
+	public get kind(): Kind {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.kind! as Kind;
+	}
+	
+	public get trackId() {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.trackId!;
+	}
+
+	public get sfuStreamId() {
+		return this._model.sfuStreamId;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public get remoteInboundTracks(): ReadonlyMap<string, ObservedInboundTrack<Kind>> {
+		return this._remoteInboundTracks;
+	}
+
+	public get reports() {
+		return this.peerConnection.reports;
+	}
+
+	public get updated() {
+		return this._updated;
+	}
+
+	public close() {
+		if (this._closed) return;
+
+		this._closed = true;
+
+		this._execute(() => this._storageProvider.inboundTrackStorage.remove(this.trackId))
+			.catch(() => void 0)
+			.finally(() => this.emit('close'));
+	}
+
+	public get stats(): ReadonlyMap<number, ObservedOutboundTrackStats<Kind>> {
+		return this._stats;
+	}
+
+	public async update(sample: ObservedOutboundTrackStatsUpdate<Kind>, timestamp: number): Promise<void> {
+		if (this._closed) return;
+		let executeSave = false;
+
+		const report: OutboundAudioTrackReport | OutboundVideoTrackReport = {
+			serviceId: this.peerConnection.client.serviceId,
+			roomId: this.peerConnection.client.call.roomId,
+			callId: this.peerConnection.client.call.callId,
+			clientId: this.peerConnection.client.clientId,
+			userId: this.peerConnection.client.userId,
+			mediaUnitId: this.peerConnection.client.mediaUnitId,
+			peerConnectionId: this.peerConnection.peerConnectionId,
+			...sample,
+			timestamp,
+			sampleSeq: -1,
+		};
+
+		if (this.kind === 'audio') this.reports.addOutboundAudioTrackReport(report);
+		else if (this.kind === 'video') this.reports.addOutboundVideoTrackReport(report);
+
+		const elapsedTimeInMs = Math.max(1, timestamp - this._updated);
+		const lastStat = this._stats.get(sample.ssrc);
+		const rttInMs = sample.roundTripTime ? sample.roundTripTime * 1000 : undefined;
+		const bitrate = ((sample.bytesSent ?? 0) - (lastStat?.bytesSent ?? 0)) * 8 / (elapsedTimeInMs / 1000);
+		// const lostPackets = (sample.packetsLost ?? 0) - (lastStat?.packetsLost ?? 0);
+		// const sentPackets = (sample.packetsSent ?? 0) - (lastStat?.packetsSent ?? 0);
+		const stats: ObservedOutboundTrackStats<Kind> = {
+			...sample,
+			rttInMs,
+			bitrate,
+			ssrc: sample.ssrc,
+		};
+
+		this._stats.set(sample.ssrc, stats);
+
+		this.bitrate = [ ...this._stats.values() ].reduce((acc, stat) => acc + stat.bitrate, 0);
+		this.rttInMs = [ ...this._stats.values() ].reduce((acc, stat) => acc + (stat.rttInMs ?? 0), 0) / (this._stats.size || 1);
+
+		// setting up sfu connection as it is not always available at the first sample
+		if (sample.sfuStreamId && !this._model.sfuStreamId) {
+			this._model.sfuStreamId = sample.sfuStreamId;
+		
+			this.once('close', () => {
+				if (!this._model.sfuStreamId) return;
+				if (this.kind === 'audio') this.peerConnection.client.call.sfuStreamIdToOutboundAudioTrack.delete(this._model.sfuStreamId);
+				else if (this.kind === 'video') this.peerConnection.client.call.sfuStreamIdToOutboundVideoTrack.delete(this._model.sfuStreamId);
+			});
+
+			if (this.kind === 'audio') this.peerConnection.client.call.sfuStreamIdToOutboundAudioTrack.set(this._model.sfuStreamId, this as ObservedOutboundTrack<'audio'>);
+			else if (this.kind === 'video') this.peerConnection.client.call.sfuStreamIdToOutboundVideoTrack.set(this._model.sfuStreamId, this as ObservedOutboundTrack<'video'>);
+
+			executeSave = true;
+		}
+
+		if (executeSave) await this._save();
+
+		this._updated = timestamp;
+		this.emit('update');
+	}
+
+	public connectInboundTrack(track: ObservedInboundTrack<Kind>) {
+		if (this._closed) return;
+
+		track.remoteOutboundTrack = this;
+		track.once('close', () => {
+			this._remoteInboundTracks.delete(track.trackId);
+		});
+
+		this._remoteInboundTracks.set(track.trackId, track);
+	}
+
+	private async _save() {
+		if (this._closed) throw new Error(`OutboundTrack ${this.trackId} is closed`);
+		
+		return this._storageProvider.outboundTrackStorage.set(this.trackId, this._model);
+	}
+}

package/src/ObservedPeerConnection.ts

@@ -0,0 +1,249 @@
+import { EventEmitter } from 'events';
+import * as Models from './models/Models';
+import { StorageProvider } from './storages/StorageProvider';
+import { PeerConnectionTransport } from '@observertc/sample-schemas-js';
+import { ObservedClient } from './ObservedClient';
+import { ObservedInboundTrack, ObservedInboundTrackConfig } from './ObservedInboundTrack';
+import { ObservedOutboundTrack, ObservedOutboundTrackConfig } from './ObservedOutboundTrack';
+import { PeerConnectionTransportReport } from '@observertc/report-schemas-js';
+import { createSingleExecutor } from './common/SingleExecutor';
+
+export type ObservedPeerConnectionEvents = {
+	update: [],
+	close: [],
+	newinboudaudiotrack: [ObservedInboundTrack<'audio'>],
+	newinboudvideotrack: [ObservedInboundTrack<'video'>],
+	newoutboundaudiotrack: [ObservedOutboundTrack<'audio'>],
+	newoutboundvideotrack: [ObservedOutboundTrack<'video'>],
+};
+
+export type ObservedPeerConnectionConfig = {
+	peerConnectionId: string;
+};
+
+export type ObservedPeerConnectionStats = Omit<PeerConnectionTransport, 'transportId' | 'label'>;
+
+export declare interface ObservedPeerConnection {
+	on<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
+	off<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
+	once<U extends keyof ObservedPeerConnectionEvents>(event: U, listener: (...args: ObservedPeerConnectionEvents[U]) => void): this;
+	emit<U extends keyof ObservedPeerConnectionEvents>(event: U, ...args: ObservedPeerConnectionEvents[U]): boolean;
+}
+
+export class ObservedPeerConnection extends EventEmitter {
+	public static async create(
+		config: ObservedPeerConnectionConfig,
+		client: ObservedClient,
+		storageProvider: StorageProvider,
+	): Promise<ObservedPeerConnection> {
+		const model = new Models.PeerConnection({
+			roomId: client.roomId,
+			serviceId: client.serviceId,
+			callId: client.callId,
+			clientId: client.clientId,
+			peerConnectionId: config.peerConnectionId,
+		});
+
+		const alreadyInserted = await storageProvider.peerConnectionStorage.insert(config.peerConnectionId, model);
+
+		if (alreadyInserted) throw new Error(`PeerConnection with id ${config.peerConnectionId} already exists`);
+
+		return new ObservedPeerConnection(model, client, storageProvider);
+	}
+
+	private _closed = false;
+	private _updated = Date.now();
+	private _sample?: ObservedPeerConnectionStats;
+
+	private readonly _inboundAudioTracks = new Map<string, ObservedInboundTrack<'audio'>>();
+	private readonly _inboundVideoTracks = new Map<string, ObservedInboundTrack<'video'>>();
+	private readonly _outboundAudioTracks = new Map<string, ObservedOutboundTrack<'audio'>>();
+	private readonly _outboundVideoTracks = new Map<string, ObservedOutboundTrack<'video'>>();
+	private readonly _execute = createSingleExecutor();
+	
+	private constructor(
+		private readonly _model: Models.PeerConnection,
+		public readonly client: ObservedClient,
+		private readonly _storageProvider: StorageProvider,
+	) {
+		super();
+	}
+
+	public get peerConnectionId(): string {
+		// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+		return this._model.peerConnectionId!;
+	}
+
+	public get reports() {
+		return this.client.reports;
+	}
+
+	public get stats(): ObservedPeerConnectionStats | undefined {
+		return this._sample;
+	}
+
+	public get updated(): number {
+		return this._updated;
+	}
+
+	public get inboundAudioTracks(): ReadonlyMap<string, ObservedInboundTrack<'audio'>> {
+		return this._inboundAudioTracks;
+	}
+
+	public get inboundVideoTracks(): ReadonlyMap<string, ObservedInboundTrack<'video'>> {
+		return this._inboundVideoTracks;
+	}
+
+	public get outboundAudioTracks(): ReadonlyMap<string, ObservedOutboundTrack<'audio'>> {
+		return this._outboundAudioTracks;
+	}
+
+	public get outboundVideoTracks(): ReadonlyMap<string, ObservedOutboundTrack<'video'>> {
+		return this._outboundVideoTracks;
+	}
+
+	public get closed() {
+		return this._closed;
+	}
+
+	public 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')); 
+	}
+
+	public update(sample: PeerConnectionTransport, timestamp: number) {
+		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: PeerConnectionTransportReport = {
+			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, // deprecated
+		};
+
+		this.reports.addPeerConnectionTransportReports(report);
+		
+		this._updated = timestamp;
+		this.emit('update');
+	}
+
+	public async createInboundAudioTrack(config: Omit<ObservedInboundTrackConfig<'audio'>, 'kind'>): Promise<ObservedInboundTrack<'audio'>> {
+		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+
+		const result = await ObservedInboundTrack.create<'audio'>({
+			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<string>([ ...this._model.inboundTrackIds, result.trackId ])) ];
+		await this._save();
+
+		this.emit('newinboudaudiotrack', result);
+
+		return result;
+	}
+
+	public async createInboundVideoTrack(config: Omit<ObservedInboundTrackConfig<'video'>, 'kind'>): Promise<ObservedInboundTrack<'video'>> {
+		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+
+		const result = await ObservedInboundTrack.create<'video'>({
+			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<string>([ ...this._model.inboundTrackIds, result.trackId ])) ];
+		await this._save();
+
+		this.emit('newinboudvideotrack', result);	
+		
+		return result;
+	}
+
+	public async createOutboundAudioTrack(config: Omit<ObservedOutboundTrackConfig<'audio'>, 'kind'>): Promise<ObservedOutboundTrack<'audio'>> {
+		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+		
+		const result = await ObservedOutboundTrack.create<'audio'>({
+			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<string>([ ...this._model.outboundTrackIds, result.trackId ])) ];
+		
+		result.sfuStreamId && this.client.call.sfuStreamIdToOutboundAudioTrack.set(result.sfuStreamId, result);
+		await this._save();
+
+		this.emit('newoutboundaudiotrack', result);
+
+		return result;
+	}
+
+	public async createOutboundVideoTrack(config: Omit<ObservedOutboundTrackConfig<'video'>, 'kind'>): Promise<ObservedOutboundTrack<'video'>> {
+		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+		
+		const result = await ObservedOutboundTrack.create<'video'>({
+			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<string>([ ...this._model.outboundTrackIds, result.trackId ])) ];
+		await this._save();
+
+		this.emit('newoutboundvideotrack', result);
+		
+		return result;
+	}
+
+	private async _save() {
+		if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+		
+		return this._execute(async () => {
+			if (this._closed) throw new Error(`PeerConnection ${this.peerConnectionId} is closed`);
+			await this._storageProvider.peerConnectionStorage.set(this.peerConnectionId, this._model);
+		});
+	}
+}