@simplito/privmx-webendpoint/dist/webStreams/WebRtcClient.d.ts

PrivMX Web Endpoint library

import { SessionId } from "./WebRtcClientTypes";
import { WebWorker } from "./WebWorkerHelper";
import { Key, TurnCredentials, StreamHandle, RemoteStreamListener } from "../Types";
import { KeyStore } from "./KeyStore";
import { PeerConnectionManager } from "./PeerConnectionsManager";
import { StreamId, StreamRoomId } from "./types/ApiTypes";
import { Jsep } from "../service/WebRtcInterface";
import { SpeakerState } from "./audio/ActiveSpeakerDetector";
import { StateChangeDispatcher } from "../service/EventDispatcher";
import { StreamTrack } from "../service/StreamApi";
export declare class RTCRtpScriptTransform {
    constructor(worker: any, options: any);
    transform: (frame: any, controller: any) => void;
}
export interface StreamsCallbackInterface {
    trickle(sessionId: SessionId, candidate: RTCIceCandidate): Promise<void>;
    acceptOffer(sessionId: SessionId, sdp: Jsep): Promise<void>;
}
export interface UserAudioStats {
    streamId: number;
    rms: number;
    active: boolean;
}
export interface WebRtcStateEvents {
    connected: {
        streamId: StreamId;
    };
}
export interface AudioLevelsStats {
    levels: SpeakerState[];
}
type AudioLevelFuncCallback = (changes: AudioLevelsStats) => void;
export declare class WebRtcClient {
    private assetsDir;
    uniqId: string;
    private e2eeWorker;
    private webWorkerApi;
    private configuration;
    private keyStore;
    private publishStreamHandle;
    private peerCredentials;
    private remoteStreamsListeners;
    private sequenceNumberByRemoteStreamId;
    private dataChannelByRemoteStreamId;
    private dataChannelCryptor;
    private sequenceNumberOfSender;
    private peerConnectionsManager;
    private streamsApiInterface;
    private activeSpeakerDetector;
    private audioLevelCallback;
    private encByReceiver;
    private logger;
    private peerConnectionReconfigureQueue;
    lastProcessedAnswer: {
        [roomId: string]: Jsep;
    };
    private lastMeasuredLocalRMS;
    private eventsDispatcher;
    private localAudioLevelMeters;
    private bootstrapDataChannel;
    constructor(assetsDir: string);
    private ensureLocalAudioLevelMeter;
    private stopLocalAudioLevelMeter;
    setAudioLevelCallback(func: AudioLevelFuncCallback): void;
    bindApiInterface(streamsApiInterface: StreamsCallbackInterface): void;
    addRemoteStreamListener(listener: RemoteStreamListener): void;
    getStreamStateChangeDispatcher(): StateChangeDispatcher;
    getConnectionManager(): PeerConnectionManager;
    getWebRtcEventDispatcher(): StateChangeDispatcher;
    protected getWorker(): Promise<Worker>;
    protected initPipeline(receiverTrackId: string, publisherId: number): Promise<void>;
    protected getWorkerApi(): Promise<WebWorker>;
    protected getPeerConnectionConfiguration(): RTCConfiguration;
    setTurnCredentials(turnCredentials: TurnCredentials[]): Promise<void>;
    createPeerConnectionWithLocalStream(streamHandle: StreamHandle, streamRoomId: StreamRoomId, stream?: MediaStream, dataTracks?: StreamTrack[]): Promise<RTCPeerConnection>;
    removeSenderPeerConnectionOnUnpublish(streamRoomId: StreamRoomId, stream: MediaStream): void;
    updatePeerConnectionWithLocalStream(streamRoomId: StreamRoomId, localStream: MediaStream, tracksToAdd: MediaStreamTrack[], tracksToRemove: MediaStreamTrack[]): Promise<RTCPeerConnection>;
    encryptDataChannelData(data: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
    private createPeerConnectionMultiForRoom;
    private startNegotiationMulti;
    updateKeys(_streamRoomId: StreamRoomId, keys: Key[]): Promise<void>;
    getKeyStore(): KeyStore;
    private setupSenderTransform;
    private setupReceiverTransform;
    private waitUntilConnected;
    private teardownReceiver;
    private addRemoteTrack;
    private callRegisteredListeners;
    private callRegisteredListenersForDataChannel;
    onSubscriptionUpdated(_room: StreamRoomId, offer: {
        sdp: string;
        type: string;
    }): Promise<void>;
    onSubscriptionUpdatedSingle(_room: StreamRoomId, offer: any): Promise<Jsep>;
    private reconfigureSingle;
    private reconfigureSingleCreateOffer;
}
export {};