@kaltura-sdk/rtc-core 1.25.0

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@kaltura-sdk/rtc-core",
+  "version": "1.25.0",
+  "author": "kaltura",
+  "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kaltura/rtc"
+  },
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@unisphere/core": "^1.91.1",
+    "bowser": "^2.13.1",
+    "emittery": "^1.2.0",
+    "webrtc-adapter": "^9.0.3"
+  },
+  "module": "./index.esm.js",
+  "type": "module",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  }
+}

package/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from './lib/unisphere-sample';
+export * from './lib/media';
+export * from './lib/core-utils';
+export * from './lib/session';
+export * from './lib/devices';
+export * from './lib/peer-connection';

package/src/lib/core-utils/BrowserDetector.d.ts

@@ -0,0 +1,101 @@
+import Bowser from 'bowser';
+/**
+ * Browser detection and information utility
+ * Uses Bowser library to parse user agent and provide browser/platform information
+ *
+ * @example
+ * import { browserDetector } from '@kaltura-corp/unisphere-rtc-core';
+ *
+ * if (browserDetector.isChrome()) {
+ *   console.log('Running in Chrome');
+ * }
+ *
+ * if (browserDetector.isMobile()) {
+ *   console.log('Running on mobile device');
+ * }
+ */
+declare class BrowserDetector {
+    private browser;
+    private parsedData;
+    constructor();
+    /**
+     * Check if current browser is Chrome
+     * @returns true if Chrome, false otherwise
+     */
+    isChrome(): boolean;
+    /**
+     * Check if current browser is Firefox
+     * @returns true if Firefox, false otherwise
+     */
+    isFirefox(): boolean;
+    /**
+     * Check if current browser is Safari
+     * @returns true if Safari, false otherwise
+     */
+    isSafari(): boolean;
+    /**
+     * Check if current browser is Microsoft Edge
+     * @returns true if Edge, false otherwise
+     */
+    isEdge(): boolean;
+    /**
+     * Check if running on mobile platform
+     * @returns true if mobile, false otherwise
+     */
+    isMobile(): boolean;
+    /**
+     * Check if running on desktop platform
+     * @returns true if desktop, false otherwise
+     */
+    isDesktop(): boolean;
+    /**
+     * Check if running in Electron
+     * @returns true if Electron, false otherwise
+     */
+    isElectron(): boolean;
+    /**
+     * Check if browser version satisfies given constraints
+     * @param constraints - Browser version constraints (e.g., { chrome: '>=65', firefox: '>=59' })
+     * @returns true if browser satisfies constraints, false otherwise
+     *
+     * @example
+     * browserDetector.satisfies({ chrome: '>=65', firefox: '>=59', safari: '>=15' })
+     */
+    satisfies(constraints: Bowser.Parser.checkTree): boolean;
+    /**
+     * Get browser name
+     * @returns Browser name (e.g., 'Chrome', 'Firefox', 'Safari') or undefined if not detected
+     */
+    getBrowserName(): string | undefined;
+    /**
+     * Get browser version
+     * @returns Browser version string or undefined if not detected
+     */
+    getBrowserVersion(): string | undefined;
+    /**
+     * Get OS name
+     * @returns OS name (e.g., 'macOS', 'Windows', 'iOS', 'Android') or undefined if not detected
+     */
+    getOSName(): string | undefined;
+    /**
+     * Get platform type
+     * @returns Platform type ('desktop', 'mobile', 'tablet') or undefined if not detected
+     */
+    getPlatformType(): string | undefined;
+    /**
+     * Get full parsed browser data
+     * @returns Parsed result containing browser, OS, and platform information
+     */
+    getParsedData(): Bowser.Parser.ParsedResult | null;
+    /**
+     * Check if browser detection is available
+     * @returns true if browser detection succeeded, false otherwise
+     */
+    isAvailable(): boolean;
+}
+/**
+ * Singleton instance of BrowserDetector
+ * Use this to access browser detection functionality throughout the application
+ */
+export declare const browserDetector: BrowserDetector;
+export {};

package/src/lib/core-utils/DevicesUtils.d.ts

@@ -0,0 +1 @@
+export declare function isTrackFromDevice(track: MediaStreamTrack, deviceId: string): boolean;

package/src/lib/core-utils/GlobalEventEmitter.d.ts

@@ -0,0 +1 @@
+export declare const GlobalEmmiter: any;

package/src/lib/core-utils/MediaUtils.d.ts

@@ -0,0 +1,45 @@
+import { StreamLockType } from '../media/types';
+export declare function getVideoTrackInfo(track: MediaStreamTrack | null, userId: string): {
+    deviceId: string | null;
+    label: string | null;
+    height: number;
+    width: number;
+    fps: number | null;
+    logStr: string;
+};
+export declare function getStreamTracks(stream: MediaStream | null, trackType?: string | null): MediaStreamTrack[] | null;
+type DefaultVideoMediaConstraintsType = {
+    desiredWidth: number;
+    desiredHeight: number;
+    desiredFrameRate: number;
+    bwPercentage: number;
+    streamLock: StreamLockType;
+    facingMode?: string;
+};
+export declare const defaultGetUserMediaConstraints: DefaultVideoMediaConstraintsType;
+export declare function getStreamTracksLogStr(stream: MediaStream, userId: string, addLabels?: boolean): string;
+export declare function getAudioTrackInfo(track: MediaStreamTrack, userId: string): {
+    deviceId: string | null;
+    label: string | null;
+    enabled: boolean | null;
+    muted: boolean | null;
+    readyState: MediaStreamTrackState | null;
+    logStr: string;
+};
+export declare function getFirstStreamTrack(stream: MediaStream | null): MediaStreamTrack | null;
+export declare function trackChanged(prevTrack: MediaStreamTrack | null, newTrack: MediaStreamTrack | null): boolean;
+export declare function fixDimensionsByTrack(dimensions: {
+    width: number;
+    height: number;
+}, maxDimensions: {
+    height: number;
+    width: number;
+}): {
+    width: number;
+    height: number;
+};
+export declare function stopTrack(track: MediaStreamTrack | null, isBrowserSafari?: boolean): void;
+export declare function removeStreamTracks(stream: MediaStream | null): void;
+export declare function getPeerSendersTracks(peer: RTCPeerConnection, trackType: string): RTCRtpSender[] | null;
+export declare function isTrackFromDevice(track: MediaStreamTrack | null, deviceId: string): boolean;
+export {};

package/src/lib/core-utils/Mutex.d.ts

@@ -0,0 +1,8 @@
+export declare class Mutex {
+    private locked;
+    private waitingQueue;
+    acquire(): Promise<() => void>;
+    private release;
+    runExclusive<T>(fn: () => Promise<T> | T): Promise<T>;
+    isLocked(): boolean;
+}

package/src/lib/core-utils/SdpUtils.d.ts

@@ -0,0 +1,25 @@
+import { UnisphereLoggerType } from '@unisphere/core';
+export declare enum JanusSdpMunge {
+    publicIp = "publicIp",
+    privateIp = "privateIp",
+    priority = "priority"
+}
+export interface OpusAttributes {
+    stereo?: number;
+    'sprop-stereo'?: number;
+    maxaveragebitrate?: number;
+    maxplaybackrate?: number;
+    cbr?: number;
+    useinbandfec?: number;
+    usedtx?: number;
+    maxptime?: number;
+}
+export declare function setDTX(sdp: string): string;
+export declare function sdpForceCodec(which: 'audio' | 'video', codec: string, sdp: string | undefined): string;
+export interface SdpManipulateResult {
+    sdp: string;
+    janusPrivateIp: string | null;
+}
+export declare function sdpManipulateJanusSdp(sdp: string, SdpMungeType: JanusSdpMunge, janusPublicIp: string, logger: UnisphereLoggerType): SdpManipulateResult;
+export declare function sdpLimitBw(sdp: string, bwKbps: number, bwAudioKbps: number, userId: string | number, isFirefox: boolean, logger: UnisphereLoggerType): string;
+export declare function NumCandidatesInSdp(sdp: string): number;

package/src/lib/core-utils/UserBrowserUtils.d.ts

@@ -0,0 +1,37 @@
+import { browserDetector } from './BrowserDetector';
+/**
+ * Check if current platform is mobile
+ * @returns true if mobile browser, false otherwise
+ */
+export declare function isMobileBrowser(): boolean;
+/**
+ * Check if current browser is Firefox
+ * @returns true if Firefox, false otherwise
+ */
+export declare function isFirefoxBrowser(): boolean;
+/**
+ * Check if current browser is Safari
+ * @returns true if Safari, false otherwise
+ */
+export declare function isSafariBrowser(): boolean;
+/**
+ * Check if current browser is Chrome
+ * @returns true if Chrome, false otherwise
+ */
+export declare function isChromeBrowser(): boolean;
+/**
+ * Check if current browser is Microsoft Edge
+ * @returns true if Edge, false otherwise
+ */
+export declare function isEdgeBrowser(): boolean;
+/**
+ * Check if running in Electron
+ * @returns true if Electron, false otherwise
+ */
+export declare function isElectron(): boolean;
+/**
+ * Check if running on desktop platform
+ * @returns true if desktop, false otherwise
+ */
+export declare function isDesktopBrowser(): boolean;
+export { browserDetector };

package/src/lib/core-utils/UtilityFunctions.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Check if provided object is empty
+ *
+ * @param {Object} obj target object
+ * @returns {boolean} result
+ */
+export declare function isObjectEmpty(obj: object): boolean;
+/**
+ * Extract the base URL from a full URL or path
+ * For CDN URLs (http/https), extracts protocol + host + first path segment
+ * For local paths, removes the filename
+ *
+ * @example
+ * getBaseUrl('https://cdn.example.com/static/file.js') // 'https://cdn.example.com/static'
+ * getBaseUrl('./worklets/file.js') // './worklets'
+ *
+ * @param {string} path - The full URL or path
+ * @returns {string} The base URL/path without the filename
+ */
+export declare function getBaseUrl(path: string): string;
+export declare function truncToNDecimalDigits(num: number, n: number): number;

package/src/lib/core-utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './UserBrowserUtils';
+export * from './BrowserDetector';
+export * from './GlobalEventEmitter';
+export * from './UtilityFunctions';

package/src/lib/core-utils/webrtcAudioStats.d.ts

@@ -0,0 +1,56 @@
+import { publisherQualityCheckStageType } from '../simulcast/simulcastCommonPublisher';
+export type AudioMixIntervalStatsObj = {
+    time: number;
+    totalPackets: number;
+    totalBytes: number;
+    packetsLost: number;
+    jitter: number;
+    audioLevel: number;
+    totalAudioEnergy: number;
+    totalSamplesDuration: number;
+    totalRtt: number;
+    numRttMeasurements: number;
+    outRtt?: number;
+    outRemoteAudioJitter?: number;
+    deltaKbps?: number;
+    deltaLostPct?: number;
+    deltaNormEnergyDelta?: number;
+};
+export type AudioStatsObj = {
+    time: number;
+    iceRtt: number;
+    incoming: AudioMixIntervalStatsObj | null;
+    outgoing: AudioMixIntervalStatsObj | null;
+};
+export declare const kBandwidthAlertThresholdMsec: number;
+export declare const kAudioAlertThresholdMsec: number;
+export type AudioStatsResObj = {
+    stats: AudioStatsObj;
+    logStr: string;
+};
+export declare enum AudioAlerts {
+    PacketsLoss = "PacketsLoss",
+    HighRtt = "HighRtt",
+    HighJitter = "HighJitter",// High jitter or rtt
+    Distortion = "Distortion"
+}
+export type ErrAudioQualityAlertObj = {
+    alertType?: AudioAlerts;
+    alertValue?: number;
+};
+export type CheckStatsResObj = {
+    incoming: ErrAudioQualityAlertObj | null;
+    outgoing: ErrAudioQualityAlertObj | null;
+};
+export declare function checkAudioStats(audioStats: AudioStatsObj, streamId: string): CheckStatsResObj;
+export declare function prepareAudioStats(curTime: number, prevStats: AudioStatsObj, curStats: AudioStatsObj, activeIceInfo: any, isMainAudioMix: boolean, checkStage: publisherQualityCheckStageType, noLogStrHeaders: boolean): AudioStatsResObj;
+export declare function getAudioStats(statsReport: any[], isPublisher: boolean, bDirectional: boolean): AudioStatsObj;
+export declare function getAudioTrackRTCStats(statsReport: any): {
+    concealedSamples: any;
+    totalSamplesReceived: any;
+    silentConcealedSamples: any;
+};
+export declare function getAudioSourceStats(statsReport: any): {
+    totalAudioEnergy: any;
+    audioLevel: any;
+};

package/src/lib/core-utils/webrtcStatsTypes.d.ts

@@ -0,0 +1,76 @@
+import { AudioStatsResObj, CheckStatsResObj } from './webrtcAudioStats';
+export type StreamRidType = string;
+export declare const k_singleRID: StreamRidType;
+export declare const kQcMsecDefault: number;
+export declare const kQcStartAfterConnected: number;
+export type VideoStreamStatsCommonObj = {
+    width: number;
+    height: number;
+    totalPackets: number;
+    totalBytes: number;
+    totalPacketsLost: number;
+    nacks: number;
+    pliCount: number;
+    firCount: number;
+    jitter: number;
+    curRtt: number;
+    framesEncDec: number;
+    deltaPackets: number;
+    deltaLostPct: number;
+    deltaNacks: number;
+    deltaNackPct: number;
+    deltaBytes: number;
+    deltaVideoKbps: number;
+    deltaFramesEncDec: number;
+    deltaPlis: number;
+    deltaPliPct: number;
+};
+export type ViewerStatsObj = {
+    time: number;
+    durationMsec: number;
+    statsAvailBitrateKbps: number;
+    streamStats: VideoStreamStatsCommonObj;
+    framesReceived: number;
+    inFramesDropped: number;
+    inFreezeCount: number;
+    inTotalFreezeDuration: number;
+    inJitterBufDelay: number;
+    deltaFreezeDuration: number;
+    deltaAudioKbps: number;
+    deltaFps: number;
+    videoScoreStr: string;
+    audioStats: AudioStatsResObj | null;
+    audioStatsCheck: CheckStatsResObj | null;
+    deltaAudioBytes: number;
+};
+export declare class QualityLimitationDurations {
+    none: number;
+    bandwidth: number;
+    cpu: number;
+    other: number;
+    constructor(none?: number, bandwidth?: number, cpu?: number, other?: number);
+}
+export type PublisherVideoStreamStatsObj = {
+    active: boolean;
+    available: boolean;
+    rid: string;
+    genStats?: VideoStreamStatsCommonObj;
+    framesSent?: number;
+    currentFps?: number;
+    deltaFramesSent?: number;
+};
+export type PublisherStatsObj = {
+    time: number;
+    durationMsec: number;
+    availBitrateKbps: number;
+    streamsStats: PublisherVideoStreamStatsObj[];
+    qualityLimitationReason: string;
+    qualityLimitationDurationsStr: string;
+    qualityLimitationDurations: QualityLimitationDurations;
+    videoScoreStr: string;
+    totalDeltaVideoBytes: number;
+    audioStats: AudioStatsResObj | null;
+    lastAudioErr: CheckStatsResObj | null;
+    lastAudioErrTime: number;
+    deltaAudioBytes: number;
+};

package/src/lib/core-utils/webrtcVideoStats.d.ts

@@ -0,0 +1,6 @@
+export declare let g_qualityLimLogCount: number;
+export declare function getVideoStats(statsReport: any, isPublisher: any): any;
+export declare function getVideoTrackRTCStats(statsReport: any): {
+    framesDropped: any;
+    framesReceived: any;
+};

package/src/lib/devices/DevicesManager.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Device Manager
+ * Extracted from src/components/media-devices.js
+ * Manages media device enumeration, selection, and getUserMedia operations
+ */
+import { UserMediaManager, UserMediaConfig, DefaultVideoMediaConstraintsType } from './UserMediaManager';
+export type EnumerateDevicesResult = {
+    audioDevices: Record<string, MediaDeviceInfo>;
+    videoDevices: Record<string, MediaDeviceInfo>;
+    audioOutputDevices: Record<string, MediaDeviceInfo>;
+    unclassifiedDevices: Record<string, MediaDeviceInfo>;
+};
+export type UserDevicesType = Pick<DeviceEnumerationResult, 'availableDevices' | 'selectedDevices'>;
+export interface DeviceManagerConfig {
+    storage?: {
+        getItem: (key: string) => string | null;
+        setItem: (key: string, value: string) => void;
+    };
+}
+export interface InitialConstraintsConfig {
+    audio?: {
+        echoCancellation?: boolean;
+        autoGainControl?: boolean;
+        noiseReduction?: boolean;
+    };
+    video?: boolean;
+}
+export declare enum DevicesEvents {
+    deviceListChanged = "deviceListChanged",
+    deviceChanged = "deviceChanged",
+    deviceDisappeared = "deviceDisappeared"
+}
+export interface DeviceEnumerationResult {
+    availableDevices: EnumerateDevicesResult;
+    selectedDevices: {
+        audioDevice: MediaDeviceInfo | null;
+        videoDevice: MediaDeviceInfo | null;
+        audioOutputDevice: MediaDeviceInfo | null;
+    };
+    enumeratedDevices: MediaDeviceInfo[];
+    devicesCount: {
+        audioInput: number;
+        videoInput: number;
+        audioOutput: number;
+        unclassified: number;
+    };
+    prevDevices: {
+        audioDevice: MediaDeviceInfo | null;
+        videoDevice: MediaDeviceInfo | null;
+        audioOutputDevice: MediaDeviceInfo | null;
+    };
+}
+export declare enum DeviceType {
+    AudioInput = "audioinput",
+    VideoInput = "videoinput",
+    AudioOutput = "audiooutput"
+}
+export declare class DeviceManager {
+    private logger;
+    private storage;
+    availableDevices: EnumerateDevicesResult;
+    selectedDevices: {
+        audioDevice: MediaDeviceInfo | null;
+        videoDevice: MediaDeviceInfo | null;
+        audioOutputDevice: MediaDeviceInfo | null;
+    };
+    failedDevices: {
+        audioDevices: string[];
+        videoDevices: string[];
+        audioOutputDevices: string[];
+        unclassifiedDevices: string[];
+    };
+    userMediaManager: UserMediaManager;
+    private currentVideoConstraints;
+    constructor(config: DeviceManagerConfig, initialUserMediaConfig: UserMediaConfig);
+    private getOndevicechangeHandler;
+    resetAvailableDevices(): void;
+    resetSelectedDevices(): void;
+    resetFailedDevices(): void;
+    /**
+     * Enumerate all available media devices
+     */
+    enumerateDevices(): Promise<DeviceEnumerationResult | null>;
+    private handleDeviceEnumeration;
+    /**
+     * Set default devices (from storage if available)
+     */
+    private setDefaultDevices;
+    /**
+     * Change device selection
+     */
+    changeDeviceSelection(deviceType: DeviceType, device: string, isRevalidate?: boolean): void;
+    private revalidateDefaultDevice;
+    /**
+     * Convert 'default' device ID to actual device ID
+     */
+    convertDefaultDeviceToDeviceId(deviceList: Record<string, MediaDeviceInfo>, deviceId: string): string | null;
+    /**
+     * Get device info from device label
+     */
+    getDeviceInfoFromDeviceLabel(type: DeviceType, label: string): MediaDeviceInfo | null;
+    addFailedDevice(deviceType: DeviceType, deviceId: string): void;
+    checkFailedDevice(deviceType: DeviceType, deviceId: string): boolean;
+    associateTrackWithDevice(mediaTrack: MediaStreamTrack | null): void;
+    /**
+     * Change audio output device (speaker) for all media elements
+     * @param deviceId - Device ID to switch to
+     * @returns Promise<boolean> - Success status
+     */
+    changeAudioOutput(deviceId?: string): Promise<boolean>;
+    private setElementsSinkId;
+    /**
+     * Helper method to set sinkId on a media element with retry logic
+     * @param element - HTML media element
+     * @param deviceId - Device ID to set
+     * @param attempt - Current attempt number
+     */
+    private setElementSinkId;
+    buildMediaConstraints(config?: {
+        video: {
+            shouldRequestVideo: boolean;
+            constraints?: DefaultVideoMediaConstraintsType | {
+                facingMode: {
+                    exact: 'user';
+                };
+            };
+            deviceId?: string;
+        };
+        audio: {
+            shouldRequestAudio: boolean;
+            deviceId?: string;
+        };
+        audioDeviceId?: string;
+        videoDeviceId?: string;
+    }): MediaStreamConstraints;
+}
+export default DeviceManager;

package/src/lib/devices/UserMediaManager.d.ts

@@ -0,0 +1,52 @@
+import { StreamLockType } from '../media/types';
+export interface UserMediaConfig {
+    audio: {
+        echoCancellation: boolean;
+        autoGainControl: boolean;
+        noiseSuppression: boolean;
+    };
+    video: boolean;
+}
+export type DefaultVideoMediaConstraintsType = {
+    desiredWidth: number;
+    desiredHeight: number;
+    desiredFrameRate: number;
+    bwPercentage: number;
+    streamLock: StreamLockType;
+    facingMode?: string;
+};
+export declare class UserMediaManager {
+    defaultConstrains: UserMediaConfig;
+    private logger;
+    constructor(initialConstraintsConfig: UserMediaConfig);
+    private isStreamProcessingNeeded;
+    private isSimulcastRoom;
+    buildMediaConstraintsInternal(config?: {
+        video: {
+            shouldRequestVideo: boolean;
+            constraints?: DefaultVideoMediaConstraintsType | {
+                facingMode: {
+                    exact: 'user';
+                };
+            };
+            deviceId?: string;
+        };
+        audio: {
+            shouldRequestAudio: boolean;
+            deviceId?: string;
+        };
+        audioDeviceId?: string;
+        videoDeviceId?: string;
+    }): MediaStreamConstraints;
+    buildAudioConstraints(config: {
+        audio: {
+            shouldRequestAudio: boolean;
+            deviceId?: string;
+        };
+    }): boolean | MediaTrackConstraints;
+    buildVideoConstraints(config?: {
+        shouldRequestVideo: boolean;
+        constraints: DefaultVideoMediaConstraintsType;
+    }, deviceId?: string): boolean | MediaTrackConstraints;
+    removeUnsupportedConstraints(constraints: MediaStreamConstraints): void;
+}

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

@@ -0,0 +1,2 @@
+export * from './DevicesManager';
+export * from './UserMediaManager';

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

@@ -0,0 +1,60 @@
+declare global {
+    interface Window {
+        globalAudioContext?: AudioContext;
+    }
+}
+/**
+ * AudioAnalyzer: Pure audio analysis class using Web Audio API
+ * Samples audio track and detects volume levels for speaking indication
+ * Based on kme-web-sdk sound-indicator.js but stripped to pure audio logic
+ */
+export declare class AudioAnalyzer {
+    private logger;
+    private audioContext;
+    private analyser;
+    private source;
+    private dataArray;
+    private sampleTimerId;
+    private audioTrack;
+    private readonly fftSize;
+    private readonly smoothingTimeConstant;
+    private readonly minDecibels;
+    private readonly maxDecibels;
+    private readonly sampleIntervalMs;
+    private threshold;
+    private isSpeaking;
+    private hasStateListeners;
+    private hasVolumeListeners;
+    constructor();
+    /**
+     * Start analyzing audio from a track
+     * @param track - Audio track to analyze (MUST be a clone that stays unmuted)
+     * @param threshold - Optional volume threshold for speaking detection (default: 300)
+     */
+    start(track: MediaStreamTrack, threshold?: number): void;
+    /**
+     * Stop analyzing audio
+     */
+    stop(): void;
+    /**
+     * Check if analyzer is currently running
+     */
+    isRunning(): boolean;
+    /**
+     * Set speaking threshold
+     * @param threshold - Volume threshold for speaking detection
+     */
+    setThreshold(threshold: number): void;
+    /**
+     * Update listener status for performance optimization
+     * Called by CoreRTCSession when listeners are added/removed
+     * @param hasStateListeners - Whether there are speakingStateChanged listeners
+     * @param hasVolumeListeners - Whether there are audioVolumeLevel listeners
+     */
+    updateListenerStatus(hasStateListeners: boolean, hasVolumeListeners: boolean): void;
+    /**
+     * Sample audio and emit events (if listeners exist)
+     * Called every 50ms by setInterval
+     */
+    private sampleAudio;
+}