@simplito/privmx-webendpoint 2.6.5 → 2.7.2

package/dist/webStreams/WebRtcClient.js

@@ -0,0 +1,437 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebRtcClient = void 0;
+const WebWorkerHelper_1 = require("./WebWorkerHelper");
+const WebRtcConfig_1 = require("./WebRtcConfig");
+const KeyStore_1 = require("./KeyStore");
+const PeerConnectionsManager_1 = require("./PeerConnectionsManager");
+const Logger_1 = require("./Logger");
+const Queue_1 = require("./Queue");
+const LocalAudioLevelMeter_1 = require("./audio/LocalAudioLevelMeter");
+const ActiveSpeakerDetector_1 = require("./audio/ActiveSpeakerDetector");
+const EventDispatcher_1 = require("../service/EventDispatcher");
+class WebRtcClient {
+    assetsDir;
+    uniqId;
+    e2eeWorker;
+    webWorkerApi;
+    dataChannels = [];
+    configuration;
+    keyStore = new KeyStore_1.KeyStore();
+    publishStreamHandle;
+    // to moze byc uzyte kiedy wymagany jest update credentials (jak straca waznosc)
+    peerCredentials;
+    remoteStreamsListeners = new Map();
+    peerConnectionsManager;
+    streamsApiInterface;
+    activeSpeakerDetector;
+    audioLevelCallback;
+    // private mediaServerAvailPublishers: {[publisherId: number]: Publisher} = {};
+    encByReceiver = new WeakMap();
+    logger = Logger_1.Logger.get();
+    peerConnectionReconfigureQueue;
+    lastProcessedAnswer = {};
+    lastMeasuredLocalRMS = -99;
+    eventsDispatcher = new EventDispatcher_1.StateChangeDispatcher();
+    localAudioLevelMeters = new Map();
+    constructor(assetsDir) {
+        this.assetsDir = assetsDir;
+        this.uniqId = "" + Math.random() + "-" + Math.random();
+        this.peerConnectionsManager = new PeerConnectionsManager_1.PeerConnectionManager((roomId) => {
+            return this.createPeerConnectionMultiForRoom(roomId, this.getPeerConnectionConfiguration());
+        }, (sessionId, candidate) => {
+            return this.streamsApiInterface.trickle(sessionId, candidate);
+        });
+        this.peerConnectionReconfigureQueue = new Queue_1.Queue();
+        this.peerConnectionReconfigureQueue.assignProcessorFunc(async (_item) => {
+            // await this.reconfigure(_item);
+            await this.reconfigureSingle(_item._room, _item.offer);
+        });
+        this.activeSpeakerDetector = new ActiveSpeakerDetector_1.ActiveSpeakerDetector(ActiveSpeakerDetector_1.DEFAULTS);
+    }
+    async ensureLocalAudioLevelMeter(track) {
+        if (this.localAudioLevelMeters.has(track.id)) {
+            return;
+        }
+        const worker = await this.getWorker();
+        const meter = new LocalAudioLevelMeter_1.LocalAudioLevelMeter(track, (onRms) => {
+            worker.postMessage({ operation: "rms", rms: onRms });
+            this.lastMeasuredLocalRMS = onRms;
+        });
+        this.localAudioLevelMeters.set(track.id, meter);
+        try {
+            await meter.init(this.assetsDir + "/rms-processor.js");
+        }
+        catch (e) {
+            this.localAudioLevelMeters.delete(track.id);
+            meter.stop();
+            throw e;
+        }
+    }
+    stopLocalAudioLevelMeter(track) {
+        const meter = this.localAudioLevelMeters.get(track.id);
+        if (!meter) {
+            return;
+        }
+        this.localAudioLevelMeters.delete(track.id);
+        meter.stop();
+    }
+    setAudioLevelCallback(func) {
+        this.audioLevelCallback = func;
+    }
+    bindApiInterface(streamsApiInterface) {
+        this.streamsApiInterface = streamsApiInterface;
+    }
+    addRemoteStreamListener(listener) {
+        let listeners = this.remoteStreamsListeners.get(listener.streamRoomId) || [];
+        const exists = listeners.find((x) => x.streamId === listener.streamId);
+        if (exists) {
+            throw new Error("RemoteStreamListener with given params already exists.");
+        }
+        listeners.push(listener);
+        this.remoteStreamsListeners.set(listener.streamRoomId, listeners);
+    }
+    getStreamStateChangeDispatcher() {
+        return this.eventsDispatcher;
+    }
+    getConnectionManager() {
+        if (!this.peerConnectionsManager) {
+            throw new Error("No peerConnectionManager initialized.");
+        }
+        return this.peerConnectionsManager;
+    }
+    getWebRtcEventDispatcher() {
+        return this.eventsDispatcher;
+    }
+    getEncKey() {
+        return this.keyStore.getEncriptionKey();
+    }
+    async getWorker() {
+        if (!this.e2eeWorker) {
+            const workerApi = await this.getWorkerApi();
+            this.e2eeWorker = workerApi.getWorker();
+        }
+        if (!this.e2eeWorker) {
+            throw new Error("Worker not initialized.");
+        }
+        return this.e2eeWorker;
+    }
+    async initPipeline(receiverTrackId, publisherId) {
+        const worker = await this.getWorker();
+        const waitPromise = new Promise((resolve) => {
+            const listener = (ev) => {
+                if (ev.data.operation === "init-pipeline" && ev.data.id === receiverTrackId) {
+                    worker.removeEventListener("message", listener);
+                    resolve();
+                }
+            };
+            worker.addEventListener("message", listener);
+            worker.postMessage({
+                operation: "init-pipeline",
+                id: receiverTrackId,
+                publisherId: publisherId,
+            });
+        });
+        return waitPromise;
+    }
+    async getWorkerApi() {
+        if (!this.webWorkerApi) {
+            this.webWorkerApi = new WebWorkerHelper_1.WebWorker(this.assetsDir, (frameInfo) => {
+                if (this.audioLevelCallback && typeof this.audioLevelCallback === "function") {
+                    // report local rms to activeSpeakerDetector to have notifications for local streams
+                    this.activeSpeakerDetector.onFrame({
+                        id: 0,
+                        rms: this.lastMeasuredLocalRMS,
+                        timestamp: Date.now(),
+                    });
+                    const speakers = this.activeSpeakerDetector.onFrame({
+                        id: frameInfo.publisherId,
+                        rms: frameInfo.rms,
+                        timestamp: Date.now(),
+                    });
+                    // if (laudestParticipant === frameInfo.publisherId) {
+                    this.audioLevelCallback({ levels: speakers });
+                    // }
+                }
+            });
+            await this.webWorkerApi.init_e2ee();
+        }
+        return this.webWorkerApi;
+    }
+    getPeerConnectionConfiguration() {
+        if (!this.configuration) {
+            // throw new Error("No peerConnectionConfiguration created");
+            this.configuration = WebRtcConfig_1.WebRtcConfig.generateTurnConfiguration(this.peerCredentials);
+        }
+        return this.configuration;
+    }
+    async setTurnCredentials(turnCredentials) {
+        this.peerCredentials = turnCredentials;
+    }
+    async createPeerConnectionWithLocalStream(streamHandle, streamRoomId, stream) {
+        this.publishStreamHandle = streamHandle;
+        this.configuration = WebRtcConfig_1.WebRtcConfig.generateTurnConfiguration(this.peerCredentials);
+        const peerConnManager = this.getConnectionManager();
+        peerConnManager.initialize(streamRoomId, "publisher");
+        const pc = this.getConnectionManager().getConnectionWithSession(streamRoomId, "publisher").pc;
+        if (stream.getTracks().length > 0) {
+            const tracks = stream.getTracks();
+            this.e2eeWorker = await this.getWorker();
+            for (const track of tracks) {
+                if (track.kind === "audio") {
+                    // add RMSProcessor
+                    await this.ensureLocalAudioLevelMeter(track);
+                }
+                const streamSender = pc.addTrack(track, stream);
+                this.setupSenderTransform(streamSender);
+            }
+        }
+        return pc;
+    }
+    removeSenderPeerConnectionOnUnpublish(streamRoomId, stream) {
+        const peerConnManager = this.getConnectionManager();
+        const session = peerConnManager.getConnectionWithSession(streamRoomId, "publisher");
+        for (const track of stream.getAudioTracks()) {
+            this.stopLocalAudioLevelMeter(track);
+        }
+        session.pc.close();
+        session.pc = undefined;
+    }
+    async updatePeerConnectionWithLocalStream(streamRoomId, localStream, tracksToAdd, tracksToRemove) {
+        this.configuration = WebRtcConfig_1.WebRtcConfig.generateTurnConfiguration(this.peerCredentials);
+        const peerConnManager = this.getConnectionManager();
+        peerConnManager.initialize(streamRoomId, "publisher");
+        const pc = this.getConnectionManager().getConnectionWithSession(streamRoomId, "publisher").pc;
+        if (tracksToAdd.length > 0) {
+            this.e2eeWorker = await this.getWorker();
+            for (const track of tracksToAdd) {
+                if (track.kind === "audio") {
+                    await this.ensureLocalAudioLevelMeter(track);
+                }
+                const videoSender = pc.addTrack(track, localStream);
+                if (window.RTCRtpScriptTransform) {
+                    const options = {
+                        operation: "encode",
+                    };
+                    videoSender.transform = new RTCRtpScriptTransform(this.e2eeWorker, options);
+                }
+                else {
+                    const senderStreams = videoSender.createEncodedStreams();
+                    this.e2eeWorker.postMessage({
+                        operation: "encode",
+                        readableStream: senderStreams.readable,
+                        writableStream: senderStreams.writable,
+                    }, [senderStreams.readable, senderStreams.writable]);
+                }
+            }
+        }
+        if (tracksToRemove.length > 0) {
+            const senders = pc.getSenders();
+            for (const oldTrack of tracksToRemove) {
+                if (oldTrack.kind === "audio") {
+                    this.stopLocalAudioLevelMeter(oldTrack);
+                }
+                const sender = senders.find((s) => s.track === oldTrack);
+                if (sender) {
+                    pc.removeTrack(sender);
+                }
+            }
+        }
+        return pc;
+    }
+    createPeerConnectionMultiForRoom(roomId, configuration, _handle, _session) {
+        const extConf = configuration;
+        extConf.encodedInsertableStreams = true;
+        const connection = new RTCPeerConnection(extConf);
+        // gethering state change
+        connection.addEventListener("icegatheringstatechange", (event) => {
+            this.logger.log("info", "on ice state change: ", event);
+        });
+        // ice candidate error
+        connection.addEventListener("icecandidateerror", (event) => {
+            this.logger.log("info", "on ice error: ", event);
+        });
+        connection.addEventListener("connectionstatechange", (event) => {
+            this.logger.log("info", "connectionstatechange: ", event);
+            if (connection.connectionState === "connected") {
+                this.logger.log("important-only", "Peers connected!");
+            }
+            else {
+                this.logger.log("info", "connection state: ", connection.connectionState);
+            }
+            this.eventsDispatcher.emit({
+                streamHandle: this.publishStreamHandle,
+                state: connection.connectionState,
+            });
+        });
+        connection.addEventListener("iceconnectionstatechange", (event) => {
+            this.logger.log("info", "iceconnectionstatechange: ", event);
+        });
+        connection.addEventListener("negotiationneeded", async (event) => {
+            this.logger.log("info", "negotiationneeded: ", event);
+            // await this.startNegotiationMulti(connection);
+        });
+        connection.addEventListener("signalingstatechange", (event) => {
+            this.logger.log("info", "signalingstatechange: ", event);
+        });
+        connection.addEventListener("track", async (event) => {
+            await this.addRemoteTrack(roomId, event /*, mappedPublisher*/);
+        });
+        return connection;
+    }
+    async updateKeys(_streamRoomId, keys) {
+        this.keyStore.setKeys(keys);
+        (await this.getWorkerApi()).setKeys(keys);
+    }
+    setupSenderTransform(videoSender) {
+        if (window.RTCRtpScriptTransform) {
+            const options = {
+                operation: "encode",
+            };
+            videoSender.transform = new RTCRtpScriptTransform(this.e2eeWorker, options);
+        }
+        else {
+            this.logger.log("important-only", "Worker - encoding frames using EncodedStreams");
+            const senderStreams = videoSender.createEncodedStreams();
+            this.e2eeWorker.postMessage({
+                operation: "encode",
+                readableStream: senderStreams.readable,
+                writableStream: senderStreams.writable,
+            }, [senderStreams.readable, senderStreams.writable]);
+        }
+    }
+    async setupReceiverTransform(receiver, publisherId, worker) {
+        if ("RTCRtpScriptTransform" in window && !receiver.transform) {
+            this.logger.log("important-only", "-> using RtpScriptTransform");
+            const id = receiver.track.id;
+            receiver.transform = new window.RTCRtpScriptTransform(worker, {
+                operation: "decode",
+                id,
+                publisherId,
+            });
+            return;
+        }
+        this.logger.log("important-only", "-> using EncodedStreams");
+        // Fallback: Encoded Streams
+        if (!this.encByReceiver.has(receiver) &&
+            "createEncodedStreams" in receiver &&
+            typeof receiver.createEncodedStreams === "function") {
+            this.logger.log("important-only", "-> call for createEncodedStreams()");
+            const { readable, writable } = await receiver.createEncodedStreams();
+            const enc = {
+                readable,
+                writable,
+                id: receiver.track.id,
+                publisherId: publisherId,
+                posted: false,
+            };
+            this.encByReceiver.set(receiver, enc);
+            this.logger.log("important-only", "-> posting EncodedStreams to worker (should happen only once)");
+            await this.initPipeline(enc.id, enc.publisherId);
+            worker.postMessage({
+                operation: "decode",
+                id: enc.id,
+                publisherId: enc.publisherId,
+                readableStream: enc.readable,
+                writableStream: enc.writable,
+            }, [enc.readable, enc.writable]);
+        }
+        else {
+            this.logger.log("important-only", "-> EncodedStreams posted to worker already.");
+        }
+    }
+    async waitUntilConnected(pc) {
+        if (pc.iceConnectionState === "connected" || pc.iceConnectionState === "completed")
+            return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const onChange = () => {
+                if (pc.iceConnectionState === "connected" ||
+                    pc.iceConnectionState === "completed") {
+                    // pc.removeEventListener('iceconnectionstatechange', onChange);
+                    resolve();
+                }
+                else if (pc.iceConnectionState === "failed" ||
+                    pc.connectionState === "failed" ||
+                    pc.connectionState === "closed") {
+                    pc.removeEventListener("iceconnectionstatechange", onChange);
+                    reject(new Error("ICE/DTLS not connected"));
+                }
+            };
+            pc.addEventListener("iceconnectionstatechange", onChange);
+        });
+    }
+    async teardownReceiver(receiver, worker) {
+        const enc = this.encByReceiver.get(receiver);
+        if (enc) {
+            worker.postMessage({ operation: "stop", id: enc.id });
+            this.encByReceiver.delete(receiver);
+        }
+    }
+    async addRemoteTrack(roomId, event /*, mappedPublisher: Publisher*/) {
+        const worker = await this.getWorker();
+        const track = event.track;
+        const receiver = event.receiver;
+        const publisherId = Number(event.streams[0].id);
+        const key = this.getEncKey();
+        const peerConnection = this.getConnectionManager().getConnectionWithSession(roomId, "subscriber").pc;
+        this.logger.log("important-only", "waitUntilConnected...");
+        await this.waitUntilConnected(peerConnection);
+        this.logger.log("important-only", "setupReceiverTransform...");
+        await this.setupReceiverTransform(receiver, publisherId, worker);
+        track.addEventListener("ended", async () => await this.teardownReceiver(receiver, worker));
+        this.callRegisteredListeners(roomId, event);
+    }
+    callRegisteredListeners(roomId, event) {
+        const remoteStreamId = Number(event.streams[0].id);
+        const listeners = this.remoteStreamsListeners.get(roomId);
+        if (!listeners) {
+            this.logger.log("info", "No remoteTrack listener registered for room: " + roomId);
+            return;
+        }
+        const filteredListeners = listeners.filter((x) => x.streamId === remoteStreamId || x.streamId === undefined);
+        for (const listener of filteredListeners) {
+            if (listener.onRemoteStreamTrack &&
+                typeof listener.onRemoteStreamTrack === "function") {
+                listener.onRemoteStreamTrack(event);
+            }
+        }
+    }
+    // test
+    async onSubscriptionUpdated(_room, offer) {
+        if (!this.peerConnectionReconfigureQueue) {
+            throw new Error("ReconfigureQueue does not exist.");
+        }
+        this.peerConnectionReconfigureQueue.enqueue({
+            taskId: Math.floor(1 + Math.random() * 10000),
+            _room,
+            offer,
+        });
+        try {
+            await this.peerConnectionReconfigureQueue.processAll();
+        }
+        catch (e) {
+            console.error("Error on onSubscriberAttached", e);
+        }
+    }
+    async onSubscriptionUpdatedSingle(_room, offer) {
+        return this.reconfigureSingle(_room, offer);
+    }
+    async reconfigureSingle(room, offer) {
+        if (!this.configuration) {
+            throw new Error("Configuration missing.");
+        }
+        const janusConnection = this.getConnectionManager().getConnectionWithSession(room, "subscriber");
+        const peerConnection = janusConnection.pc;
+        this.logger.log("important-only", "1. Setting up remoteDescription...");
+        await peerConnection.setRemoteDescription(new RTCSessionDescription({ type: offer.type, sdp: offer.sdp }));
+        this.logger.log("important-only", "offer from Janus: ", JSON.stringify(offer, null, 2));
+        this.logger.log("important-only", "2. Creating an answer...", "peerConnection state", peerConnection.connectionState);
+        const answer = await peerConnection.createAnswer();
+        this.logger.log("important-only", "3. Setting up localDescription...");
+        await peerConnection.setLocalDescription(new RTCSessionDescription(answer));
+        // this.subscriberAttachedProcessing = false
+        this.lastProcessedAnswer[room] = answer;
+        return answer;
+    }
+}
+exports.WebRtcClient = WebRtcClient;

package/dist/webStreams/WebRtcClientTypes.d.ts

@@ -0,0 +1,64 @@
+import { NewPublisherEvent } from "../service/WebRtcInterface";
+import { StreamRoomId } from "./types/ApiTypes";
+export declare class RTCRtpScriptTransform {
+    constructor(worker: any, options: any);
+    transform: (frame: any, controller: any) => void;
+}
+export interface PeerCredentials {
+    username: string;
+    password: string;
+    expirationTime: number;
+}
+export interface EncKey {
+    key: Buffer;
+    iv: Buffer;
+}
+export interface InitOptions {
+    signalingServer: string;
+    appServer: string;
+    mediaServer: string;
+    turnUrls?: string[];
+    iceTransportPolicy?: RTCIceTransportPolicy;
+    encKey?: string;
+}
+export interface VideoStream {
+    stream: MediaStream;
+    isLocal: boolean;
+    id: string;
+}
+export type PluginHandleId = number & {
+    _pluginHandleId: never;
+};
+export type PluginId = string & {
+    _pluginId: never;
+};
+export type SessionId = number & {
+    _sessionId: never;
+};
+export interface JanusPluginHandle {
+    id: PluginHandleId;
+    pluginId: PluginId;
+}
+export interface JanusSession {
+    id: SessionId;
+}
+export interface Publisher extends NewPublisherEvent {
+    attached: boolean;
+    room: StreamRoomId;
+}
+export type EncPair = {
+    readable: ReadableStream<any>;
+    writable: WritableStream<any>;
+    id: string;
+    publisherId: number;
+    posted: boolean;
+};
+export interface RTCEncodedStream {
+    readable: ReadableStream<EncodedAudioChunk | EncodedVideoChunk>;
+    writable: WritableStream<EncodedAudioChunk | EncodedVideoChunk>;
+}
+export interface QueueItem {
+    taskId: number;
+    _room: StreamRoomId;
+    offer: any;
+}

package/dist/webStreams/WebRtcClientTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/webStreams/WebRtcConfig.d.ts

@@ -0,0 +1,20 @@
+import { TurnCredentials } from "../Types";
+export declare class WebRtcConfig {
+    private static iv;
+    private static key;
+    private static iceTransportPolicy;
+    private static appServer;
+    static getIV(): string;
+    static getKey(): string;
+    static getTurnServers(): string[];
+    static getRTCIceTransportPolicy(): RTCIceTransportPolicy;
+    static generateTurnConfiguration(credentials: TurnCredentials[]): {
+        iceServers: {
+            urls: string;
+            username: string;
+            credential: string;
+        }[];
+        iceTransportPolicy: RTCIceTransportPolicy;
+    };
+    static getAppServerAddress(): string;
+}

package/dist/webStreams/WebRtcConfig.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebRtcConfig = void 0;
+class WebRtcConfig {
+    // TMP IV
+    static iv = "uMuF0aaCZ6+kLrwp";
+    // TMP key
+    static key = "7c4ba0c3e256369f7c4ba0c3e256369f";
+    static iceTransportPolicy = "all";
+    static appServer = "localhost:8810";
+    static getIV() {
+        return this.iv;
+    }
+    static getKey() {
+        return this.key;
+    }
+    // Default turn servers
+    static getTurnServers() {
+        return ["turn:172.16.238.1:3478"];
+    }
+    static getRTCIceTransportPolicy() {
+        return this.iceTransportPolicy;
+    }
+    // public static generateTurnConfiguration(credentials: PeerCredentials|undefined) {
+    //     const servers: RTCIceServer[] = this.getTurnServers().map(x => (
+    //         {
+    //             urls: x,
+    //             username: credentials && credentials.username ? credentials.username : undefined,
+    //             credential: credentials && credentials.password ? credentials.password : undefined
+    //         }
+    //     ));
+    //     return {
+    //         iceServers: servers,
+    //         iceTransportPolicy: this.iceTransportPolicy
+    //     }
+    // }
+    static generateTurnConfiguration(credentials) {
+        return {
+            iceServers: credentials.map((x) => {
+                return {
+                    urls: x.url,
+                    username: x.username,
+                    credential: x.password,
+                };
+            }),
+            iceTransportPolicy: this.iceTransportPolicy,
+        };
+    }
+    static getAppServerAddress() {
+        return this.appServer;
+    }
+}
+exports.WebRtcConfig = WebRtcConfig;

package/dist/webStreams/WebRtcInterfaceImpl.d.ts

@@ -0,0 +1,28 @@
+/*!
+PrivMX Endpoint.
+Copyright © 2024 Simplito sp. z o.o.
+
+This file is part of the PrivMX Platform (https://privmx.dev).
+This software is Licensed under the PrivMX Free License.
+
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+import { RoomModel, SdpWithRoomModel, SetAnswerAndSetRemoteDescriptionModel, UpdateKeysModel, WebRtcInterface } from "../service/WebRtcInterface";
+import { ConnectionType } from "./PeerConnectionsManager";
+import { StreamRoomId } from "./types/ApiTypes";
+import { WebRtcClient } from "./WebRtcClient";
+export declare class WebRtcInterfaceImpl implements WebRtcInterface {
+    private webRtcClient;
+    constructor(webRtcClient: WebRtcClient);
+    private methodsMap;
+    isMainThread(): boolean;
+    getClient(): WebRtcClient;
+    methodCall(name: string, params: any): Promise<any>;
+    createOfferAndSetLocalDescription(model: RoomModel): Promise<string>;
+    createAnswerAndSetDescriptions(model: SdpWithRoomModel): Promise<string>;
+    setAnswerAndSetRemoteDescription(model: SetAnswerAndSetRemoteDescriptionModel): Promise<void>;
+    close(roomId: StreamRoomId): Promise<void>;
+    updateKeys(model: UpdateKeysModel): Promise<void>;
+    updateSessionId(streamRoomId: StreamRoomId, sessionId: number, connectionType: ConnectionType): Promise<void>;
+}