@kaltura-sdk/rtc-core 1.25.0

package/src/lib/media/GetUserMediaManager.d.ts

@@ -0,0 +1,178 @@
+import { GetUserMediaEveObj, MediaSourceStreamObj, MediaSourceType, userMediaStatus } from '../media/types';
+import { MediaSources, TrackKind } from './MediaSources';
+import { DeviceManager } from '../devices/DevicesManager';
+import { AudioProcessingModes } from './media-processing/AudioProcessingModes';
+export declare const MAX_GET_USER_MEDIA_ATTEMPTS = 5;
+/**
+ * Callback for updating peer connection senders with new track
+ * Handles track replacement in all active peer connections with simulcast support
+ *
+ * MATCHES ORIGINAL: Logic from mdReplaceStopSenderTrack with simulcast handling
+ *
+ * @param trackKind - 'audio' or 'video'
+ * @param newTrack - New track to replace with
+ * @returns Promise<boolean> - True if track was replaced successfully
+ */
+export type UpdatePeerConnectionSendersCallback = (trackKind: 'audio' | 'video', newTrack: MediaStreamTrack, isInitial: boolean, shouldStopTrack: boolean, addIfNotExist: boolean) => Promise<boolean>;
+/**
+ * Callback for complete media device release
+ * Handles full device release flow including PC senders, stream cleanup, and processing stop
+ *
+ * MATCHES ORIGINAL: releaseMediaDevice function from production code
+ *
+ * @param deviceType - 'audio' or 'video'
+ * @param replaceWithEmptyTracks - If true, replace with silent/dummy track in PC
+ * @returns Promise<void>
+ */
+export type ReleaseMediaDeviceCallback = (deviceType: 'audio' | 'video', replaceWithEmptyTracks: boolean, detachSoundInd: boolean) => Promise<void>;
+/**
+ * Callback to restart audio analysis after audio track changes
+ * Called when g_audioAnalysisTrack is updated (device change, NR toggle, etc.)
+ */
+export type RestartAudioAnalysisCallback = () => void;
+/**
+ * Callback to update debug audio loopback after audio track changes
+ * Called when g_pubAudioInputTrack is updated (device change, NR toggle, etc.)
+ */
+export type UpdateAudioLoopbackCallback = () => void;
+export declare class GetUserMediaManager {
+    private logger;
+    private gumMutex;
+    private mediaSources;
+    private devicesManager;
+    audioProcessingModes: AudioProcessingModes;
+    private onAudioContextErrorCallback;
+    private updatePeerConnectionSendersCallback;
+    private releaseMediaDeviceCallback;
+    private restartAudioAnalysisCallback;
+    private updateAudioLoopbackCallback;
+    private alwaysSendMicSilence;
+    constructor(mediaSources: MediaSources, devicesManager: DeviceManager, onAudioContextError: () => Promise<any>, updatePeerConnectionSenders: UpdatePeerConnectionSendersCallback, releaseMediaDevice: ReleaseMediaDeviceCallback, restartAudioAnalysis: RestartAudioAnalysisCallback, updateAudioLoopback: UpdateAudioLoopbackCallback, alwaysSendMicSilence: boolean);
+    awaitGetUserMediaOver(): Promise<boolean>;
+    /**
+     * Update audio analysis track with new track
+     * Clones the raw audio track for speaking indicator analysis
+     * @param audioInTrack - Raw audio track from getUserMedia
+     * @param processAudioInTrack - Processed track (after NR) for logging only
+     * @private
+     */
+    private updateAudioAnalysisTrack;
+    /**
+     * Process audio track through noise cancellation if enabled
+     *
+     * CRITICAL: Use resetContext=false for device changes to keep worklet alive!
+     * Only use resetContext=true when enabling/disabling NC or changing modes.
+     *
+     * @param rawTrack - Raw audio track from getUserMedia
+     * @param resetContext - If true, recreate worklet/context. If false, just reconnect audio graph.
+     * @returns Processed audio track if NC enabled, or raw track if NC disabled/failed
+     */
+    createProcessAudioTrack(rawTrack: MediaStreamTrack | null, resetContext?: boolean): Promise<MediaStreamTrack | null>;
+    getUserMedia(config: any, constraints: MediaStreamConstraints, attempt?: number): Promise<GetUserMediaEveObj>;
+    private convertDevicesInConstraints;
+    handleGetUserMediaSuccess(gumWebcamFailed: boolean, webcamTrack: MediaStreamTrack, gumAudioInFailed: boolean, audioInTrack: MediaStreamTrack, config: any): Promise<{
+        status: userMediaStatus;
+        reason: string;
+    }>;
+    private validateDevicesAfterGUM;
+    createGetUserMediaRequest(mediaSourceType: MediaSourceType, constraints: boolean | MediaTrackConstraints): {
+        gumPromise: Promise<unknown>;
+        mediaSrc: MediaSourceStreamObj;
+    };
+    getSingleUserMedia(mediaSrc: MediaSourceStreamObj): Promise<{
+        status: boolean;
+        mediaSource: MediaSourceStreamObj;
+    }>;
+    handleSingleGetUserMediaError(mediaSrc: MediaSourceStreamObj, err: {
+        name: string;
+        message?: string;
+    }): Promise<{
+        status: boolean;
+        mediaSource: MediaSourceStreamObj;
+    }>;
+    handleSingleMediaOverConstraintsError(mediaSrc: MediaSourceStreamObj, err: {
+        name: string;
+        message?: string | undefined;
+        constraint?: any;
+    }): Promise<{
+        status: boolean;
+        mediaSource: MediaSourceStreamObj;
+    }>;
+    userConfirmedMediaDevices(checkAudio?: boolean, checkVideo?: boolean): Promise<boolean>;
+    removeConstraintByType(constraint: string, constraints: unknown, type: string): void;
+    /**
+     * Detects the current echoCancellation constraint value
+     * @param constraints The media track constraints object
+     * @returns 'all', true, or null depending on the echoCancellation value
+     */
+    private getEchoCancellationValue;
+    /**
+     * Checks if browser supports latency constraint
+     * @returns true if latency constraint is supported by the browser
+     */
+    private isLatencyConstraintSupported;
+    /**
+     * Checks if latency constraint is present in constraints
+     * @param constraints The media track constraints object
+     * @returns true if latency constraint exists
+     */
+    private hasLatencyConstraint;
+    handleSingleMediaDeviceErrors(mediaSrc: MediaSourceStreamObj, err: {
+        name: string;
+        message?: string | undefined;
+        constraint?: string;
+    }): Promise<{
+        status: boolean;
+        mediaSource: MediaSourceStreamObj;
+    }>;
+    changeConstraintsDeviceToNextDeviceByType(constraints: {
+        audio?: any | boolean;
+        video?: any | boolean;
+    }, type: 'audio' | 'video'): {
+        audio?: any | boolean;
+        video?: any | boolean;
+    };
+    getWebcamMicNullUserMedia(requestAudio?: boolean, requestVideo?: boolean): Promise<true | undefined>;
+    handleInitialMediaRequest(config: {
+        videoDisabledByDefault: boolean;
+        audioDisabledByDefault: boolean;
+        shouldStartStreaming: boolean;
+        peerConnection: any;
+    }, gumWebcamFailed: boolean, webcamTrack: MediaStreamTrack, webcamProcessTrack: MediaStreamTrack, gumAudioInFailed: boolean, audioInTrack: MediaStreamTrack, processAudioInTrack: MediaStreamTrack | null): Promise<void>;
+    handleDeviceChangedStreams(config: {
+        videoDisabledByDefault?: boolean;
+        audioDisabledByDefault?: boolean;
+        shouldStartStreaming?: boolean;
+        peerConnection?: any;
+    }, gumWebcamFailed: boolean, webcamTrack: MediaStreamTrack | null, webcamProcessTrack: MediaStreamTrack | null, gumAudioInFailed: boolean, audioInTrack: MediaStreamTrack | null, processAudioInTrack: MediaStreamTrack | null): Promise<void>;
+    updateStreamTracks(initial: boolean, config: {
+        videoDisabledByDefault?: boolean;
+        audioDisabledByDefault?: boolean;
+        shouldStartStreaming?: boolean;
+        audioDeviceId?: any;
+        videoDeviceId?: any;
+    }, disableWebcam: boolean, disableAudio: boolean, audioInTrack: MediaStreamTrack | null, processAudioInTrack: MediaStreamTrack | null, newWebcamTrack: MediaStreamTrack | null, newTransWebcamTrack: MediaStreamTrack | null): Promise<void>;
+    initTracksMuteEventListeners(stream: MediaStream): void;
+    handleTrackMute(trackType: string): void;
+    handleTrackUnmute(trackType: string): void;
+    onTrackMutedStateChanged(payload: {
+        muted: boolean;
+        track: MediaStreamTrack;
+    }): Promise<void>;
+    checkMutedTracks(audioTrack: MediaStreamTrack, videoTrack: MediaStreamTrack): void;
+    initPublisherTracksEndEventListeners(stream: MediaStream): void;
+    handlePublisherTrackEnd(track: MediaStreamTrack): void;
+    checkPublisherTracksReadyState(stream: MediaStream): void;
+    stopAudioTrackProcessing(): Promise<void>;
+    /**
+     * Generic method to mute a track by stopping it and optionally replacing with a dummy track
+     */
+    muteTrack(trackKind: TrackKind, useDummyTrack?: boolean): Promise<boolean>;
+    /**
+     * Generic method to unmute a track by updating state
+     * Note: Actual getUserMedia call should come from EselfSession to preserve constraints
+     * @param trackKind - TrackKind.AUDIO or TrackKind.VIDEO
+     * @returns Promise<boolean> - true if successful
+     */
+    unmuteTrack(trackKind: TrackKind): Promise<boolean>;
+}

package/src/lib/media/MediaSources.d.ts

@@ -0,0 +1,105 @@
+import { AudioProcessing } from './media-processing/AudioProcessing';
+import { DimensionsObj, GetUserMediaEveObj, GetUserMediaSuccessResponse, MediaSourceStreamObj, MediaSourceType, userMediaErrors } from './types';
+export declare enum TrackState {
+    ACTIVE = "ACTIVE",
+    STOPPED = "STOPPED"
+}
+export declare enum TrackKind {
+    AUDIO = "audio",
+    VIDEO = "video"
+}
+export declare class MediaSources {
+    private logger;
+    private audioTrackState;
+    private videoTrackState;
+    private mediaSourceUniqueId;
+    g_gumAudioInputTrack: MediaStreamTrack | null;
+    g_gumAudioInFailed: boolean | null;
+    g_audioProcessingObj: AudioProcessing | null;
+    g_pubAudioInputTrack: MediaStreamTrack | null;
+    g_audioAnalysisTrack: MediaStreamTrack | null;
+    g_gumWebcamTrack: MediaStreamTrack | null;
+    g_gumWebcamFailed: boolean;
+    g_pubVideoTrack: MediaStreamTrack | ReadableStream | null;
+    g_pubVideoTrackWidth: number | null;
+    g_pubVideoTrackHeight: number | null;
+    g_pubVideoTrackFps: number | null;
+    g_pubAudioVideoStream: MediaStream | null;
+    g_desktopStream: MediaStream | null;
+    g_audioProcessingPipelineFailure: boolean;
+    g_audioProcessingPipelineInitialized: boolean;
+    g_videoProcessingPipelineFailure: boolean;
+    g_videoProcessingPipelineInitialized: boolean;
+    g_videoProcessingPipelineFallbackPipe: boolean;
+    g_videoProcessingPipelineWebGlFailure: boolean;
+    g_videoProcessingFallbackNumTries: number;
+    g_videoDeviceMsProcessor: ReadableStream | null;
+    g_videoDeviceMsGenerator: WritableStream | null;
+    g_fallbackWebcamVideoElement: HTMLVideoElement | null;
+    g_fallbackOutputFrameCanvas: HTMLCanvasElement | null;
+    g_fallbackVideoDeviceTrack: MediaStreamTrack | null;
+    g_fallbackTimerId: number | null;
+    g_dummyBlackVideoInputTrack: MediaStreamTrack | null;
+    g_silentAudioInputTrack: MediaStreamTrack | null;
+    private mediaSources;
+    constructor();
+    handleFinalGetUserMediaResults(gumSuccessResponse: GetUserMediaSuccessResponse, videoMediaSrc: MediaSourceStreamObj, audioMediaSrc: MediaSourceStreamObj): GetUserMediaEveObj;
+    returnGumGeneralFailureResult(webcamFailed: boolean, audioInFailed: boolean, failErr: userMediaErrors, failReason: string, failErrName: string): GetUserMediaEveObj;
+    returnGumActiveResult(webcamFailed: boolean, audioInFailed: boolean): GetUserMediaEveObj;
+    addGetMediaSource(type: MediaSourceType, constraints: any): MediaSourceStreamObj;
+    getMediaSource(type: MediaSourceType): MediaSourceStreamObj | null;
+    mediaSrcLogStr(mediaSrc: MediaSourceStreamObj): string;
+    webcamTrackIsGenerator(track: MediaStreamTrack | ReadableStream): boolean;
+    videoStreamIsTrackGenerator(stream: MediaStream): boolean;
+    getWebcamMaxSize(videoTrack: MediaStreamTrack): DimensionsObj;
+    getAudioTrackState(): TrackState;
+    getVideoTrackState(): TrackState;
+    isAudioMuted(): boolean;
+    isVideoMuted(): boolean;
+    setAudioTrackState(state: TrackState): void;
+    setVideoTrackState(state: TrackState): void;
+    getDummyBlackVideoInputTrack(): MediaStreamTrack;
+    getSilentAudioInputTrack(stopSilentTrack?: boolean): MediaStreamTrack;
+    isTrackAudioDestNode(track: MediaStreamTrack): boolean;
+    /**
+     * Check if track is a dummy track
+     */
+    trackIsDummy(track: MediaStreamTrack | null): boolean;
+    trackStopAllowed(track: MediaStreamTrack): boolean;
+    /**
+     * Stop a media track with proper cleanup
+     * This respects track stop policies (won't stop dummy tracks or audio processing destination tracks)
+     * @param track The track to stop
+     */
+    mdStopTrack(track: MediaStreamTrack | null): void;
+    /**
+     * Stop and remove all tracks from a stream
+     * @param stream The stream to remove tracks from
+     * @param trackKind Optional track kind filter ('audio' or 'video')
+     * @returns true if any tracks were removed
+     */
+    mdStopAndRemoveStreamTracks(stream: MediaStream | null, trackKind: string | null): boolean;
+    /**
+     * Stop and replace a track in an existing stream
+     * @param existingStream The stream to modify
+     * @param newTrack The new track to add
+     * @param addIfNotExist Whether to add the track if it doesn't exist
+     * @param toStop Whether to stop the existing track
+     */
+    mdStopAndReplaceStreamTrack(existingStream: MediaStream, newTrack: MediaStreamTrack, addIfNotExist: boolean, toStop: boolean): void;
+    /**
+     * Replace and optionally stop a sender track in a peer connection
+     * @param pc The RTCPeerConnection
+     * @param newTrack The new track to use
+     * @param shouldStopTrack Whether to stop the previous track
+     * @param addIfNotExist Whether to add the track if no sender exists
+     * @param addToPcStream The stream to add the track to if adding
+     * @returns Promise<boolean> indicating if the track was replaced
+     */
+    mdReplaceStopSenderTrack(pc: RTCPeerConnection, newTrack: MediaStreamTrack, shouldStopTrack: boolean, addIfNotExist: boolean, addToPcStream: MediaStream | null): Promise<boolean>;
+    /**
+     * Clean up audio analysis track
+     * Called when stopping audio analysis or destroying session
+     */
+    cleanupAudioAnalysisTrack(): void;
+}

package/src/lib/media/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './MediaSources';
+export * from './AudioAnalyzer';
+export * from './media-processing';

package/src/lib/media/media-processing/AudioProcessing.d.ts

@@ -0,0 +1,42 @@
+import { AudioProcessingModes } from './AudioProcessingModes';
+import { AudioNrMode } from './types';
+import { MediaSources } from '../MediaSources';
+export declare enum AudioProcessingEvents {
+    noiseReductionDisabled = "noiseReductionDisabled"
+}
+/**
+ * Callback for audio processing context errors that need getUserMedia retry
+ */
+export type AudioProcessingErrorCallback = () => Promise<any>;
+declare class AudioProcessing {
+    private logger;
+    private modesManager;
+    private mediaSources;
+    private onErrorCallback;
+    private audioContext;
+    private workletNode;
+    private audioInStream;
+    private audioSrcStream;
+    private audioDestStream;
+    private outputAudioTrack;
+    private nrMode;
+    private contextErrorsCount;
+    constructor(modesManager: AudioProcessingModes, mediaSources: MediaSources, onErrorCallback?: AudioProcessingErrorCallback);
+    /**
+     * Load worklet module with automatic fallback to production CDN on failure
+     * @param audioContext - The audio context to load the worklet into
+     * @param workletPath - Primary worklet path to attempt loading from
+     * @param nrMode - The noise reduction mode (used to get filename for fallback)
+     */
+    private loadWorkletWithFallback;
+    /**
+     * Thoroughly cleanup audio worklet and context to prevent memory leaks
+     * Removes event handlers, closes message ports, disconnects nodes, and closes context
+     */
+    private cleanupAudioProcessing;
+    private initializeModel;
+    init(audioTrack: MediaStreamTrack, modeNr: AudioNrMode, resetContext: boolean): Promise<MediaStreamTrack>;
+    isTrackAudioDestNode(track: MediaStreamTrack | null): boolean;
+    stop(): Promise<void>;
+}
+export { AudioProcessing };

package/src/lib/media/media-processing/AudioProcessingModes.d.ts

@@ -0,0 +1,76 @@
+import { AudioNrMode } from './types';
+/**
+ * Manages audio processing modes, configuration, and browser compatibility
+ * Based on original audioProcessingModes from kme-web-sdk
+ */
+export declare class AudioProcessingModes {
+    private logger;
+    private currentNrEnableState;
+    private currentMode;
+    private workletBasePath;
+    private browserSupported;
+    constructor();
+    /**
+     * Determine the worklet base path based on the current environment
+     * - localhost: Load from local repo worklets
+     * - QA (URL contains .qa.kaltura): Load from QA CDN
+     * - Production (default): Load from production CDN
+     * - Fallback: Always fallback to production on error
+     */
+    private determineWorkletBasePath;
+    /**
+     * Check if the browser supports AudioWorklet for noise reduction
+     */
+    private checkBrowserSupport;
+    /**
+     * Get current noise reduction mode
+     * Replaces original: session.modeNr
+     */
+    getNrMode(): AudioNrMode;
+    /**
+     * Get whether noise reduction is enabled
+     * Replaces original: session.enableNr
+     */
+    getNrEnabled(): boolean;
+    /**
+     * Set noise reduction mode and enabled state
+     * MATCHES ORIGINAL SIGNATURE: setNrMode(nrEnabled: boolean, nrMode: AudioNrModes)
+     * This is the primary method from production code
+     */
+    setNrMode(nrEnabled: boolean, nrMode: AudioNrMode): void;
+    /**
+     * Set noise reduction enabled state
+     * Calls setNrMode with current mode (matches original behavior)
+     */
+    setNrEnabled(nrEnabled: boolean): void;
+    /**
+     * Set noise reduction enabled state
+     * Calls setNrMode with current mode (matches original behavior)
+     */
+    setMode(nrMode: AudioNrMode): void;
+    /**
+     * Check if noise reduction can be enabled in this browser
+     */
+    canEnableNoiseReduction(): boolean;
+    /**
+     * Get the worklet file name for a specific mode
+     * MATCHES ORIGINAL: getAudioWorkletFileName()
+     */
+    private getAudioWorkletFileName;
+    /**
+     * Get the worklet file path for a specific mode
+     * The path is determined by the environment (localhost, QA, or production)
+     * Note: If loading from the returned path fails, AudioProcessing will automatically
+     * fallback to the production CDN
+     * In original: getAudioProcessingWorkletUrlPath()
+     */
+    getWorkletPath(nrMode: AudioNrMode): string;
+    /**
+     * Get just the worklet file name (for external use)
+     */
+    getWorkletFileName(mode: AudioNrMode): string;
+    /**
+     * Set the worklet base path (for serving worklets from custom location)
+     */
+    setWorkletBasePath(path: string): void;
+}

package/src/lib/media/media-processing/index.d.ts

@@ -0,0 +1,4 @@
+export { AudioProcessing } from './AudioProcessing';
+export { AudioProcessingModes } from './AudioProcessingModes';
+export { AudioNrMode, AudioProcessingConstants } from './types';
+export type { AudioProcessingConfig, AudioProcessingState } from './types';

package/src/lib/media/media-processing/types.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Audio Noise Reduction Mode Enum
+ * Defines available RNN noise reduction modes
+ */
+export declare enum AudioNrMode {
+    Off = -1,
+    Mode11 = 11,// NewFullTry - production mode
+    Mode13 = 13,// NewFullTry_1 - with rn disabling code
+    Mode14 = 14,// NewFull_12 - new model with improved quality (30/1/25)
+    Mode15 = 15,// NewFull_12_small - smaller model for low bandwidth (30/1/25 small)
+    Default = 13
+}
+/**
+ * Configuration for Audio Processing
+ */
+export interface AudioProcessingConfig {
+    /**
+     * Base path for worklet files
+     * If not provided, will use default path based on package structure
+     */
+    workletBasePath?: string;
+    /**
+     * Enable noise reduction by default
+     */
+    enabled?: boolean;
+    /**
+     * Default noise reduction mode
+     */
+    mode?: AudioNrMode;
+}
+/**
+ * Audio Processing state
+ */
+export interface AudioProcessingState {
+    enabled: boolean;
+    mode: AudioNrMode;
+    initialized: boolean;
+    failed: boolean;
+}
+/**
+ * Constants for audio processing
+ */
+export declare const AudioProcessingConstants: {
+    /**
+     * Message type sent from worklet when performance issues detected
+     */
+    readonly WORKLET_DELAY_MSG: "delay";
+    /**
+     * Message type to reset noise suppression state
+     */
+    readonly WORKLET_RESET_MSG: "resetNs";
+    /**
+     * Maximum number of audio context errors before permanent disable
+     */
+    readonly MAX_CONTEXT_ERRORS: 5;
+    /**
+     * PCM frequency for audio processing (48kHz)
+     */
+    readonly PCM_FREQUENCY: 48000;
+    /**
+     * Timeout for audio context resume operation (5 seconds)
+     */
+    readonly RESUME_TIMEOUT_MS: 5000;
+    /**
+     * Worklet base paths for different environments
+     */
+    readonly WORKLET_BASE_PATHS: {
+        readonly PRODUCTION: "https://flow-assets.avatar.us.kaltura.ai/static";
+        readonly QA: "https://flow-assets.avatar.qa.kaltura.ai/static";
+        readonly LOCAL: "./public/worklets";
+    };
+    /**
+     * localStorage keys
+     */
+    readonly STORAGE_KEYS: {
+        readonly NR_ENABLED: "unisphere_nr_enabled";
+        readonly NR_MODE: "unisphere_nr_mode";
+    };
+};
+/**
+ * Worklet file names by mode
+ */
+export declare const WorkletFiles: Record<AudioNrMode, string>;

package/src/lib/media/types.d.ts

@@ -0,0 +1,73 @@
+export declare enum StreamLockType {
+    RESOLUTION = "1",
+    FPS = "2"
+}
+export declare enum MediaSourceType {
+    Webcam = "Webcam",
+    Desktop = "Desktop",
+    AudioIn = "AudioIn",
+    AudioOut = "AudioOut"
+}
+export declare enum MediaSourceStatus {
+    NotInitialized = 0,
+    Active = 1,
+    Failed = 2
+}
+export declare enum userMediaErrors {
+    permissionsError = "permissionsError",
+    deviceError = "deviceError",
+    streamingError = "streamingError",
+    noMediaError = "noMediaError",
+    otherGumActive = "otherGumActive",
+    generalErr = "generalErr",
+    none = ""
+}
+export type MediaSourceStreamObj = {
+    id: number;
+    type: MediaSourceType;
+    constraints: any;
+    mediaKind: getUserMediaEveMediaKindsType;
+    attempt: number;
+    stream: MediaStream | null;
+    track: MediaStreamTrack | null;
+    Status: MediaSourceStatus;
+    failureReason: string;
+    failureError: userMediaErrors;
+    failureErrName: string;
+};
+export type DimensionsObj = {
+    width: number;
+    height: number;
+};
+export type SelectedDevicesObj = {
+    audioDevice: MediaDeviceInfo | null;
+    videoDevice: MediaDeviceInfo | null;
+    audioOutputDevice: MediaDeviceInfo | null;
+};
+export type MediaDeviceNameObj = string;
+export declare enum userMediaStatus {
+    success = "success",
+    fail = "fail",
+    partial = "partial"
+}
+export declare enum getUserMediaEveRequestType {
+    singular = "singular",
+    multiple = "multiple"
+}
+export declare enum getUserMediaEveMediaKindsType {
+    video = "video",
+    audio = "audio"
+}
+export type GetUserMediaEveObj = {
+    status: userMediaStatus;
+    requestType: getUserMediaEveRequestType;
+    failedMediaTypes: getUserMediaEveMediaKindsType[];
+    succeedMediaTypes: getUserMediaEveMediaKindsType[];
+    failReasons: string[];
+    failErrors: userMediaErrors[];
+    errNames: string[];
+};
+export type GetUserMediaSuccessResponse = {
+    status: userMediaStatus;
+    reason: string;
+};

package/src/lib/peer-connection/IceHandler.d.ts

@@ -0,0 +1,60 @@
+import { UnisphereLoggerType } from '@unisphere/core/src/lib/logger/types';
+import { IceCandidateDataObj } from './types';
+export type IceDisconnectionObj = {
+    disconnectionTime: number;
+    disconnectReason: number;
+    duration: number;
+    totalBytes: number;
+    wasConnected: boolean;
+};
+export type IceCandidateInfoObj = {
+    round: number;
+    c: RTCIceCandidate;
+};
+type OnConnectionFail = (iceFailure: boolean, reason: number, subReason: number, reasonStr: string) => void;
+type OnIceCandidate = (iceCandidate: IceCandidateDataObj | null) => void;
+declare class IceHandler {
+    private logger;
+    private streamerId;
+    iceStatsAllStr: string;
+    private iceStatsTimerCheckId;
+    iceStatsGatheringStartTime: number;
+    iceStatsConnState: string;
+    iceStatsIceConnState: string;
+    iceStatsIceGatherState: string;
+    private iceStatsSuggestDisconnectStr;
+    iceStatsSuggestDisconnectTime: number;
+    iceStatsNewChangeTime: number;
+    iceDisconnections: IceDisconnectionObj[];
+    iceStatsNumGatheredCands: number;
+    private iceStatsCandidates;
+    private iceStatsGatheringRound;
+    private iceStatsNumCandsUntilLastRound;
+    iceStatsGatheringDoneTime: number;
+    iceStatsGatheringToFirstTime: number;
+    private iceNoCandidatesChecked;
+    private kIceStatsSecStatesNew;
+    private onConnectionFail;
+    private onIceCandidate?;
+    kIceStatsLogEveryCoonState: boolean;
+    constructor(streamerId: string, logger: UnisphereLoggerType, onConnectionFail: OnConnectionFail, onIceCandidate?: OnIceCandidate);
+    disconnectionReasonIsIceRelated(disconnectReason: number): boolean;
+    updateStreamId(streamKey: string): void;
+    numNetworkDisconn(deltaMs: number, currentTime: number): number;
+    connectionStateToNumber(connectionStateStr: string): number;
+    private getIceGatheringStateNumber;
+    resetIceGatheringStats(): void;
+    iceStatsCollect(peerConnected: boolean, callOnReset: boolean, callByTimer: boolean, endReasonStr: string, logOnly: boolean): void;
+    clearIceStatsTimer(): void;
+    startIceGatheringRound(): void;
+    handleICECandidateEvent(event: any): void;
+    handleIceCandidateError(event: any): void;
+    /**
+     * Add a remote ICE candidate to the peer connection
+     * Used for trickle ICE to add candidates as they arrive from the remote peer
+     * @param peerConnection - The RTCPeerConnection instance
+     * @param iceCandidate - The ICE candidate data, or null to signal end of candidates
+     */
+    addRemoteIceCandidate(peerConnection: RTCPeerConnection, iceCandidate: IceCandidateDataObj | null): Promise<void>;
+}
+export default IceHandler;