@textrp/briij-js-sdk 41.0.0

package/src/webrtc/stats/callStatsReportGatherer.ts

@@ -0,0 +1,219 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { ConnectionStats } from "./connectionStats.ts";
+import { type StatsReportEmitter } from "./statsReportEmitter.ts";
+import { type ByteSend, type ByteSentStatsReport, type TrackID } from "./statsReport.ts";
+import { ConnectionStatsBuilder } from "./connectionStatsBuilder.ts";
+import { TransportStatsBuilder } from "./transportStatsBuilder.ts";
+import { MediaSsrcHandler } from "./media/mediaSsrcHandler.ts";
+import { MediaTrackHandler } from "./media/mediaTrackHandler.ts";
+import { MediaTrackStatsHandler } from "./media/mediaTrackStatsHandler.ts";
+import { TrackStatsBuilder } from "./trackStatsBuilder.ts";
+import { ConnectionStatsReportBuilder } from "./connectionStatsReportBuilder.ts";
+import { ValueFormatter } from "./valueFormatter.ts";
+import { type CallStatsReportSummary } from "./callStatsReportSummary.ts";
+import { logger } from "../../logger.ts";
+import { CallFeedStatsReporter } from "./callFeedStatsReporter.ts";
+
+export class CallStatsReportGatherer {
+    private isActive = true;
+    private previousStatsReport: RTCStatsReport | undefined;
+    private currentStatsReport: RTCStatsReport | undefined;
+    private readonly connectionStats = new ConnectionStats();
+
+    private readonly trackStats: MediaTrackStatsHandler;
+
+    public constructor(
+        public readonly callId: string,
+        private opponentMemberId: string,
+        private readonly pc: RTCPeerConnection,
+        private readonly emitter: StatsReportEmitter,
+        private readonly isFocus = true,
+    ) {
+        pc.addEventListener("signalingstatechange", this.onSignalStateChange.bind(this));
+        this.trackStats = new MediaTrackStatsHandler(new MediaSsrcHandler(), new MediaTrackHandler(pc));
+    }
+
+    public async processStats(groupCallId: string, localUserId: string): Promise<CallStatsReportSummary> {
+        const summary = {
+            isFirstCollection: this.previousStatsReport === undefined,
+            receivedMedia: 0,
+            receivedAudioMedia: 0,
+            receivedVideoMedia: 0,
+            audioTrackSummary: { count: 0, muted: 0, maxPacketLoss: 0, maxJitter: 0, concealedAudio: 0, totalAudio: 0 },
+            videoTrackSummary: { count: 0, muted: 0, maxPacketLoss: 0, maxJitter: 0, concealedAudio: 0, totalAudio: 0 },
+        } as CallStatsReportSummary;
+        if (this.isActive) {
+            const statsPromise = this.pc.getStats();
+            if (typeof statsPromise?.then === "function") {
+                return statsPromise
+                    .then((report) => {
+                        // @ts-ignore
+                        this.currentStatsReport = typeof report?.result === "function" ? report.result() : report;
+
+                        try {
+                            this.processStatsReport(groupCallId, localUserId);
+                        } catch (error) {
+                            this.handleError(error);
+                            return summary;
+                        }
+
+                        this.previousStatsReport = this.currentStatsReport;
+                        summary.receivedMedia = this.connectionStats.bitrate.download;
+                        summary.receivedAudioMedia = this.connectionStats.bitrate.audio?.download || 0;
+                        summary.receivedVideoMedia = this.connectionStats.bitrate.video?.download || 0;
+                        const trackSummary = TrackStatsBuilder.buildTrackSummary(
+                            Array.from(this.trackStats.getTrack2stats().values()),
+                        );
+                        return {
+                            ...summary,
+                            audioTrackSummary: trackSummary.audioTrackSummary,
+                            videoTrackSummary: trackSummary.videoTrackSummary,
+                        };
+                    })
+                    .catch((error) => {
+                        this.handleError(error);
+                        return summary;
+                    });
+            }
+            this.isActive = false;
+        }
+        return Promise.resolve(summary);
+    }
+
+    private processStatsReport(groupCallId: string, localUserId: string): void {
+        const byteSentStatsReport: ByteSentStatsReport = new Map<TrackID, ByteSend>() as ByteSentStatsReport;
+        byteSentStatsReport.callId = this.callId;
+        byteSentStatsReport.opponentMemberId = this.opponentMemberId;
+
+        this.currentStatsReport?.forEach((now) => {
+            const before = this.previousStatsReport ? this.previousStatsReport.get(now.id) : null;
+            // RTCIceCandidatePairStats - https://w3c.github.io/webrtc-stats/#candidatepair-dict*
+            if (now.type === "candidate-pair" && now.nominated && now.state === "succeeded") {
+                this.connectionStats.bandwidth = ConnectionStatsBuilder.buildBandwidthReport(now);
+                this.connectionStats.transport = TransportStatsBuilder.buildReport(
+                    this.currentStatsReport,
+                    now,
+                    this.connectionStats.transport,
+                    this.isFocus,
+                );
+
+                // RTCReceivedRtpStreamStats
+                // https://w3c.github.io/webrtc-stats/#receivedrtpstats-dict*
+                // RTCSentRtpStreamStats
+                // https://w3c.github.io/webrtc-stats/#sentrtpstats-dict*
+            } else if (now.type === "inbound-rtp" || now.type === "outbound-rtp") {
+                const trackStats = this.trackStats.findTrack2Stats(
+                    now,
+                    now.type === "inbound-rtp" ? "remote" : "local",
+                );
+                if (!trackStats) {
+                    return;
+                }
+
+                if (before) {
+                    TrackStatsBuilder.buildPacketsLost(trackStats, now, before);
+                }
+
+                // Get the resolution and framerate for only remote video sources here. For the local video sources,
+                // 'track' stats will be used since they have the updated resolution based on the simulcast streams
+                // currently being sent. Promise based getStats reports three 'outbound-rtp' streams and there will be
+                // more calculations needed to determine what is the highest resolution stream sent by the client if the
+                // 'outbound-rtp' stats are used.
+                if (now.type === "inbound-rtp") {
+                    TrackStatsBuilder.buildFramerateResolution(trackStats, now);
+                    if (before) {
+                        TrackStatsBuilder.buildBitrateReceived(trackStats, now, before);
+                    }
+                    const ts = this.trackStats.findTransceiverByTrackId(trackStats.trackId);
+                    TrackStatsBuilder.setTrackStatsState(trackStats, ts);
+                    TrackStatsBuilder.buildJitter(trackStats, now);
+                    TrackStatsBuilder.buildAudioConcealment(trackStats, now);
+                } else if (before) {
+                    byteSentStatsReport.set(trackStats.trackId, ValueFormatter.getNonNegativeValue(now.bytesSent));
+                    TrackStatsBuilder.buildBitrateSend(trackStats, now, before);
+                }
+                TrackStatsBuilder.buildCodec(this.currentStatsReport, trackStats, now);
+            } else if (now.type === "track" && now.kind === "video" && !now.remoteSource) {
+                const trackStats = this.trackStats.findLocalVideoTrackStats(now);
+                if (!trackStats) {
+                    return;
+                }
+                TrackStatsBuilder.buildFramerateResolution(trackStats, now);
+                TrackStatsBuilder.calculateSimulcastFramerate(
+                    trackStats,
+                    now,
+                    before,
+                    this.trackStats.mediaTrackHandler.getActiveSimulcastStreams(),
+                );
+            }
+        });
+
+        this.emitter.emitByteSendReport(byteSentStatsReport);
+        this.emitter.emitCallFeedReport(
+            CallFeedStatsReporter.buildCallFeedReport(this.callId, this.opponentMemberId, this.pc),
+        );
+        this.processAndEmitConnectionStatsReport();
+    }
+
+    public setActive(isActive: boolean): void {
+        this.isActive = isActive;
+    }
+
+    public getActive(): boolean {
+        return this.isActive;
+    }
+
+    private handleError(error: any): void {
+        this.isActive = false;
+        logger.warn(`CallStatsReportGatherer ${this.callId} processStatsReport fails and set to inactive ${error}`);
+    }
+
+    private processAndEmitConnectionStatsReport(): void {
+        const report = ConnectionStatsReportBuilder.build(this.trackStats.getTrack2stats());
+        report.callId = this.callId;
+        report.opponentMemberId = this.opponentMemberId;
+
+        this.connectionStats.bandwidth = report.bandwidth;
+        this.connectionStats.bitrate = report.bitrate;
+        this.connectionStats.packetLoss = report.packetLoss;
+
+        this.emitter.emitConnectionStatsReport({
+            ...report,
+            transport: this.connectionStats.transport,
+        });
+
+        this.connectionStats.transport = [];
+    }
+
+    public stopProcessingStats(): void {}
+
+    private onSignalStateChange(): void {
+        if (this.pc.signalingState === "stable") {
+            if (this.pc.currentRemoteDescription) {
+                this.trackStats.mediaSsrcHandler.parse(this.pc.currentRemoteDescription.sdp, "remote");
+            }
+            if (this.pc.currentLocalDescription) {
+                this.trackStats.mediaSsrcHandler.parse(this.pc.currentLocalDescription.sdp, "local");
+            }
+        }
+    }
+
+    public setOpponentMemberId(id: string): void {
+        this.opponentMemberId = id;
+    }
+}

package/src/webrtc/stats/callStatsReportSummary.ts

@@ -0,0 +1,30 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+    http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+export interface CallStatsReportSummary {
+    receivedMedia: number;
+    receivedAudioMedia: number;
+    receivedVideoMedia: number;
+    audioTrackSummary: TrackSummary;
+    videoTrackSummary: TrackSummary;
+
+    isFirstCollection: boolean;
+}
+
+export interface TrackSummary {
+    count: number;
+    muted: number;
+    maxJitter: number;
+    maxPacketLoss: number;
+    concealedAudio: number;
+    totalAudio: number;
+}

package/src/webrtc/stats/connectionStats.ts

@@ -0,0 +1,47 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { type TransportStats } from "./transportStats.ts";
+import { type Bitrate } from "./media/mediaTrackStats.ts";
+
+export interface ConnectionStatsBandwidth {
+    /**
+     * bytes per second
+     */
+    download: number;
+    /**
+     * bytes per second
+     */
+    upload: number;
+}
+
+export interface ConnectionStatsBitrate extends Bitrate {
+    audio?: Bitrate;
+    video?: Bitrate;
+}
+
+export interface PacketLoss {
+    total: number;
+    download: number;
+    upload: number;
+}
+
+export class ConnectionStats {
+    public bandwidth: ConnectionStatsBitrate = {} as ConnectionStatsBitrate;
+    public bitrate: ConnectionStatsBitrate = {} as ConnectionStatsBitrate;
+    public packetLoss: PacketLoss = {} as PacketLoss;
+    public transport: TransportStats[] = [];
+}

package/src/webrtc/stats/connectionStatsBuilder.ts

@@ -0,0 +1,28 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { type Bitrate } from "./media/mediaTrackStats.ts";
+
+export class ConnectionStatsBuilder {
+    public static buildBandwidthReport(now: RTCIceCandidatePairStats): Bitrate {
+        const availableIncomingBitrate = now.availableIncomingBitrate;
+        const availableOutgoingBitrate = now.availableOutgoingBitrate;
+
+        return {
+            download: availableIncomingBitrate ? Math.round(availableIncomingBitrate / 1000) : 0,
+            upload: availableOutgoingBitrate ? Math.round(availableOutgoingBitrate / 1000) : 0,
+        };
+    }
+}

package/src/webrtc/stats/connectionStatsReportBuilder.ts

@@ -0,0 +1,140 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import {
+    type AudioConcealment,
+    type CodecMap,
+    type ConnectionStatsReport,
+    type FramerateMap,
+    type ResolutionMap,
+    type TrackID,
+} from "./statsReport.ts";
+import { type MediaTrackStats, type Resolution } from "./media/mediaTrackStats.ts";
+
+export class ConnectionStatsReportBuilder {
+    public static build(stats: Map<TrackID, MediaTrackStats>): ConnectionStatsReport {
+        const report = {} as ConnectionStatsReport;
+
+        // process stats
+        const totalPackets = {
+            download: 0,
+            upload: 0,
+        };
+        const lostPackets = {
+            download: 0,
+            upload: 0,
+        };
+        let bitrateDownload = 0;
+        let bitrateUpload = 0;
+        const resolutions: ResolutionMap = {
+            local: new Map<TrackID, Resolution>(),
+            remote: new Map<TrackID, Resolution>(),
+        };
+        const framerates: FramerateMap = { local: new Map<TrackID, number>(), remote: new Map<TrackID, number>() };
+        const codecs: CodecMap = { local: new Map<TrackID, string>(), remote: new Map<TrackID, string>() };
+        const jitter = new Map<TrackID, number>();
+        const audioConcealment = new Map<TrackID, AudioConcealment>();
+
+        let audioBitrateDownload = 0;
+        let audioBitrateUpload = 0;
+        let videoBitrateDownload = 0;
+        let videoBitrateUpload = 0;
+
+        let totalConcealedAudio = 0;
+        let totalAudioDuration = 0;
+
+        for (const [trackId, trackStats] of stats) {
+            // process packet loss stats
+            const loss = trackStats.getLoss();
+            const type = loss.isDownloadStream ? "download" : "upload";
+
+            totalPackets[type] += loss.packetsTotal;
+            lostPackets[type] += loss.packetsLost;
+
+            // process bitrate stats
+            bitrateDownload += trackStats.getBitrate().download;
+            bitrateUpload += trackStats.getBitrate().upload;
+
+            // collect resolutions and framerates
+            if (trackStats.kind === "audio") {
+                // process audio quality stats
+                const audioConcealmentForTrack = trackStats.getAudioConcealment();
+                totalConcealedAudio += audioConcealmentForTrack.concealedAudio;
+                totalAudioDuration += audioConcealmentForTrack.totalAudioDuration;
+
+                audioBitrateDownload += trackStats.getBitrate().download;
+                audioBitrateUpload += trackStats.getBitrate().upload;
+            } else {
+                videoBitrateDownload += trackStats.getBitrate().download;
+                videoBitrateUpload += trackStats.getBitrate().upload;
+            }
+
+            resolutions[trackStats.getType()].set(trackId, trackStats.getResolution());
+            framerates[trackStats.getType()].set(trackId, trackStats.getFramerate());
+            codecs[trackStats.getType()].set(trackId, trackStats.getCodec());
+            if (trackStats.getType() === "remote") {
+                jitter.set(trackId, trackStats.getJitter());
+                if (trackStats.kind === "audio") {
+                    audioConcealment.set(trackId, trackStats.getAudioConcealment());
+                }
+            }
+
+            trackStats.resetBitrate();
+        }
+
+        report.bitrate = {
+            upload: bitrateUpload,
+            download: bitrateDownload,
+        };
+
+        report.bitrate.audio = {
+            upload: audioBitrateUpload,
+            download: audioBitrateDownload,
+        };
+
+        report.bitrate.video = {
+            upload: videoBitrateUpload,
+            download: videoBitrateDownload,
+        };
+
+        report.packetLoss = {
+            total: ConnectionStatsReportBuilder.calculatePacketLoss(
+                lostPackets.download + lostPackets.upload,
+                totalPackets.download + totalPackets.upload,
+            ),
+            download: ConnectionStatsReportBuilder.calculatePacketLoss(lostPackets.download, totalPackets.download),
+            upload: ConnectionStatsReportBuilder.calculatePacketLoss(lostPackets.upload, totalPackets.upload),
+        };
+        report.audioConcealment = audioConcealment;
+        report.totalAudioConcealment = {
+            concealedAudio: totalConcealedAudio,
+            totalAudioDuration,
+        };
+
+        report.framerate = framerates;
+        report.resolution = resolutions;
+        report.codec = codecs;
+        report.jitter = jitter;
+        return report;
+    }
+
+    private static calculatePacketLoss(lostPackets: number, totalPackets: number): number {
+        if (!totalPackets || totalPackets <= 0 || !lostPackets || lostPackets <= 0) {
+            return 0;
+        }
+
+        return Math.round((lostPackets / totalPackets) * 100);
+    }
+}

package/src/webrtc/stats/groupCallStats.ts

@@ -0,0 +1,93 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { CallStatsReportGatherer } from "./callStatsReportGatherer.ts";
+import { StatsReportEmitter } from "./statsReportEmitter.ts";
+import { type CallStatsReportSummary } from "./callStatsReportSummary.ts";
+import { SummaryStatsReportGatherer } from "./summaryStatsReportGatherer.ts";
+import { logger } from "../../logger.ts";
+
+export class GroupCallStats {
+    private timer: undefined | ReturnType<typeof setTimeout>;
+    private readonly gatherers: Map<string, CallStatsReportGatherer> = new Map<string, CallStatsReportGatherer>();
+    public readonly reports = new StatsReportEmitter();
+    private readonly summaryStatsReportGatherer = new SummaryStatsReportGatherer(this.reports);
+
+    public constructor(
+        private groupCallId: string,
+        private userId: string,
+        private interval: number = 10000,
+    ) {}
+
+    public start(): void {
+        if (this.timer === undefined && this.interval > 0) {
+            this.timer = setInterval(() => {
+                this.processStats();
+            }, this.interval);
+        }
+    }
+
+    public stop(): void {
+        if (this.timer !== undefined) {
+            clearInterval(this.timer);
+            this.gatherers.forEach((c) => c.stopProcessingStats());
+        }
+    }
+
+    public hasStatsReportGatherer(callId: string): boolean {
+        return this.gatherers.has(callId);
+    }
+
+    public addStatsReportGatherer(
+        callId: string,
+        opponentMemberId: string,
+        peerConnection: RTCPeerConnection,
+    ): boolean {
+        if (this.hasStatsReportGatherer(callId)) {
+            return false;
+        }
+        this.gatherers.set(callId, new CallStatsReportGatherer(callId, opponentMemberId, peerConnection, this.reports));
+        return true;
+    }
+
+    public removeStatsReportGatherer(callId: string): boolean {
+        return this.gatherers.delete(callId);
+    }
+
+    public getStatsReportGatherer(callId: string): CallStatsReportGatherer | undefined {
+        return this.hasStatsReportGatherer(callId) ? this.gatherers.get(callId) : undefined;
+    }
+
+    public updateOpponentMember(callId: string, opponentMember: string): void {
+        this.getStatsReportGatherer(callId)?.setOpponentMemberId(opponentMember);
+    }
+
+    private processStats(): void {
+        const summary: Promise<CallStatsReportSummary>[] = [];
+        this.gatherers.forEach((c) => {
+            summary.push(c.processStats(this.groupCallId, this.userId));
+        });
+
+        Promise.all(summary)
+            .then((s: Awaited<CallStatsReportSummary>[]) => this.summaryStatsReportGatherer.build(s))
+            .catch((err) => {
+                logger.error("Could not build summary stats report", err);
+            });
+    }
+
+    public setInterval(interval: number): void {
+        this.interval = interval;
+    }
+}

package/src/webrtc/stats/media/mediaSsrcHandler.ts

@@ -0,0 +1,57 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+import { parse as parseSdp } from "sdp-transform";
+
+export type Mid = string;
+export type Ssrc = string;
+export type MapType = "local" | "remote";
+
+export class MediaSsrcHandler {
+    private readonly ssrcToMid = { local: new Map<Mid, Ssrc[]>(), remote: new Map<Mid, Ssrc[]>() };
+
+    public findMidBySsrc(ssrc: Ssrc, type: "local" | "remote"): Mid | undefined {
+        let mid: Mid | undefined;
+        this.ssrcToMid[type].forEach((ssrcs, m) => {
+            if (ssrcs.find((s) => s == ssrc)) {
+                mid = m;
+                return;
+            }
+        });
+        return mid;
+    }
+
+    public parse(description: string, type: MapType): void {
+        const sdp = parseSdp(description);
+        const ssrcToMid = new Map<Mid, Ssrc[]>();
+        sdp.media.forEach((m) => {
+            if ((!!m.mid && m.type === "video") || m.type === "audio") {
+                const ssrcs: Ssrc[] = [];
+                m.ssrcs?.forEach((ssrc) => {
+                    if (ssrc.attribute === "cname") {
+                        ssrcs.push(`${ssrc.id}`);
+                    }
+                });
+                ssrcToMid.set(`${m.mid}`, ssrcs);
+            }
+        });
+        this.ssrcToMid[type] = ssrcToMid;
+    }
+
+    public getSsrcToMidMap(type: MapType): Map<Mid, Ssrc[]> {
+        return this.ssrcToMid[type];
+    }
+}

package/src/webrtc/stats/media/mediaTrackHandler.ts

@@ -0,0 +1,70 @@
+/*
+Copyright 2023 The Matrix.org Foundation C.I.C.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+export type TrackId = string;
+
+export class MediaTrackHandler {
+    public constructor(private readonly pc: RTCPeerConnection) {}
+
+    public getLocalTracks(kind: "audio" | "video"): MediaStreamTrack[] {
+        const isNotNullAndKind = (track: MediaStreamTrack | null): boolean => {
+            return track !== null && track.kind === kind;
+        };
+        return this.pc
+            .getTransceivers()
+            .filter((t) => t.currentDirection === "sendonly" || t.currentDirection === "sendrecv")
+            .filter((t) => t.sender !== null)
+            .map((t) => t.sender)
+            .map((s) => s.track)
+            .filter(isNotNullAndKind) as MediaStreamTrack[];
+    }
+
+    public getTackById(trackId: string): MediaStreamTrack | undefined {
+        return this.pc
+            .getTransceivers()
+            .map((t) => {
+                if (t?.sender.track !== null && t.sender.track.id === trackId) {
+                    return t.sender.track;
+                }
+                if (t?.receiver.track !== null && t.receiver.track.id === trackId) {
+                    return t.receiver.track;
+                }
+                return undefined;
+            })
+            .find((t) => t !== undefined);
+    }
+
+    public getLocalTrackIdByMid(mid: string): string | undefined {
+        const transceiver = this.pc.getTransceivers().find((t) => t.mid === mid);
+        return transceiver?.sender?.track?.id;
+    }
+
+    public getRemoteTrackIdByMid(mid: string): string | undefined {
+        const transceiver = this.pc.getTransceivers().find((t) => t.mid === mid);
+        return transceiver?.receiver?.track?.id;
+    }
+
+    public getActiveSimulcastStreams(): number {
+        //@TODO implement this right.. Check how many layer configured
+        return 3;
+    }
+
+    public getTransceiverByTrackId(trackId: TrackId): RTCRtpTransceiver | undefined {
+        return this.pc.getTransceivers().find((t) => {
+            return t.receiver.track.id === trackId || (t.sender.track !== null && t.sender.track.id === trackId);
+        });
+    }
+}