@stream-io/video-client 1.41.3 → 1.42.1

package/dist/index.es.js

@@ -4790,7 +4790,7 @@ const hasVideo = (p) => p.publishedTracks.includes(TrackType.VIDEO);
  *
  * @param p the participant to check.
  */
-const hasAudio = (p) => p.publishedTracks.includes(TrackType.AUDIO);
+const hasAudio$1 = (p) => p.publishedTracks.includes(TrackType.AUDIO);
 /**
  * Check if a participant is screen sharing.
  *
@@ -4891,8 +4891,8 @@ const publishingVideo = (a, b) => {
  * @param b the second participant.
  */
 const publishingAudio = (a, b) => {
-    const hasA = hasAudio(a);
-    const hasB = hasAudio(b);
+    const hasA = hasAudio$1(a);
+    const hasB = hasAudio$1(b);
     if (hasA && !hasB)
         return -1;
     if (!hasA && hasB)
@@ -6189,7 +6189,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.41.3";
+const version = "1.42.1";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -10380,7 +10380,7 @@ const getAudioStream = async (trackConstraints, tracer) => {
             videoLoggerSystem
                 .getLogger('devices')
                 .warn('Failed to get audio stream, will try again with relaxed constraints', { error, constraints, relaxedConstraints });
-            return getAudioStream(relaxedConstraints);
+            return getAudioStream(relaxedConstraints, tracer);
         }
         videoLoggerSystem.getLogger('devices').error('Failed to get audio stream', {
             error,
@@ -11377,9 +11377,6 @@ class MicrophoneManagerState extends AudioDeviceManagerState {
     }
 }
 
-const DETECTION_FREQUENCY_IN_MS = 500;
-const AUDIO_LEVEL_THRESHOLD = 150;
-const FFT_SIZE = 128;
 /**
  * Creates a new sound detector.
  *
@@ -11389,7 +11386,7 @@ const FFT_SIZE = 128;
  * @returns a clean-up function which once invoked stops the sound detector.
  */
 const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options = {}) => {
-    const { detectionFrequencyInMs = DETECTION_FREQUENCY_IN_MS, audioLevelThreshold = AUDIO_LEVEL_THRESHOLD, fftSize = FFT_SIZE, destroyStreamOnStop = true, } = options;
+    const { detectionFrequencyInMs = 500, audioLevelThreshold = 150, fftSize = 128, destroyStreamOnStop = true, } = options;
     const audioContext = new AudioContext();
     const analyser = audioContext.createAnalyser();
     analyser.fftSize = fftSize;
@@ -11430,6 +11427,101 @@ const createSoundDetector = (audioStream, onSoundDetectedStateChanged, options =
     };
 };
 
+/**
+ * Analyzes frequency data to determine if audio is being captured.
+ */
+const hasAudio = (analyser, threshold) => {
+    const data = new Uint8Array(analyser.frequencyBinCount);
+    analyser.getByteFrequencyData(data);
+    return data.some((value) => value > threshold);
+};
+/** Helper for "no event" transitions */
+const noEmit = (nextState) => ({
+    shouldEmit: false,
+    nextState,
+});
+/** Helper for event-emitting transitions */
+const emit = (capturesAudio, nextState) => ({ shouldEmit: true, nextState, capturesAudio });
+/**
+ * State transition function - computes next state and whether to emit an event.
+ */
+const transitionState = (state, audioDetected, options) => {
+    if (audioDetected) {
+        return state.kind === 'IDLE' || state.kind === 'EMITTING'
+            ? emit(true, state)
+            : noEmit(state);
+    }
+    const { noAudioThresholdMs, emitIntervalMs } = options;
+    const now = Date.now();
+    switch (state.kind) {
+        case 'IDLE':
+            return noEmit({ kind: 'DETECTING', noAudioStartTime: now });
+        case 'DETECTING': {
+            const { noAudioStartTime } = state;
+            const elapsed = now - noAudioStartTime;
+            return elapsed >= noAudioThresholdMs
+                ? emit(false, { kind: 'EMITTING', noAudioStartTime, lastEmitTime: now })
+                : noEmit(state);
+        }
+        case 'EMITTING': {
+            const timeSinceLastEmit = now - state.lastEmitTime;
+            return timeSinceLastEmit >= emitIntervalMs
+                ? emit(false, { ...state, lastEmitTime: now })
+                : noEmit(state);
+        }
+    }
+};
+/**
+ * Creates and configures an audio analyzer for the given stream.
+ */
+const createAudioAnalyzer = (audioStream, fftSize) => {
+    const audioContext = new AudioContext();
+    const analyser = audioContext.createAnalyser();
+    analyser.fftSize = fftSize;
+    const microphone = audioContext.createMediaStreamSource(audioStream);
+    microphone.connect(analyser);
+    return { audioContext, analyser };
+};
+/**
+ * Creates a new no-audio detector that monitors continuous absence of audio on an audio stream.
+ *
+ * @param audioStream the audio stream to observe.
+ * @param options custom options for the no-audio detector.
+ * @returns a cleanup function which once invoked stops the no-audio detector.
+ */
+const createNoAudioDetector = (audioStream, options) => {
+    const { detectionFrequencyInMs = 350, audioLevelThreshold = 0, fftSize = 256, onCaptureStatusChange, } = options;
+    let state = { kind: 'IDLE' };
+    const { audioContext, analyser } = createAudioAnalyzer(audioStream, fftSize);
+    const detectionIntervalId = setInterval(() => {
+        const [audioTrack] = audioStream.getAudioTracks();
+        if (!audioTrack?.enabled || audioTrack.readyState === 'ended') {
+            state = { kind: 'IDLE' };
+            return;
+        }
+        const audioDetected = hasAudio(analyser, audioLevelThreshold);
+        const transition = transitionState(state, audioDetected, options);
+        state = transition.nextState;
+        if (!transition.shouldEmit)
+            return;
+        const { capturesAudio } = transition;
+        onCaptureStatusChange(capturesAudio);
+        if (capturesAudio) {
+            stop().catch((err) => {
+                const logger = videoLoggerSystem.getLogger('NoAudioDetector');
+                logger.error('Error stopping no-audio detector', err);
+            });
+        }
+    }, detectionFrequencyInMs);
+    async function stop() {
+        clearInterval(detectionIntervalId);
+        if (audioContext.state !== 'closed') {
+            await audioContext.close();
+        }
+    }
+    return stop;
+};
+
 class RNSpeechDetector {
     constructor(externalAudioStream) {
         this.pc1 = new RTCPeerConnection({});
@@ -11441,16 +11533,10 @@ class RNSpeechDetector {
      */
     async start(onSoundDetectedStateChanged) {
         try {
-            let audioStream;
-            if (this.externalAudioStream != null) {
-                audioStream = this.externalAudioStream;
-            }
-            else {
-                audioStream = await navigator.mediaDevices.getUserMedia({
-                    audio: true,
-                });
-                this.audioStream = audioStream;
-            }
+            const audioStream = this.externalAudioStream != null
+                ? this.externalAudioStream
+                : await navigator.mediaDevices.getUserMedia({ audio: true });
+            this.audioStream = audioStream;
             this.pc1.addEventListener('icecandidate', async (e) => {
                 await this.pc2.addIceCandidate(e.candidate);
             });
@@ -11474,9 +11560,9 @@ class RNSpeechDetector {
             const answer = await this.pc2.createAnswer();
             await this.pc1.setRemoteDescription(answer);
             await this.pc2.setLocalDescription(answer);
-            const unsub = this.onSpeakingDetectedStateChange(onSoundDetectedStateChanged);
+            const unsubscribe = this.onSpeakingDetectedStateChange(onSoundDetectedStateChanged);
             return () => {
-                unsub();
+                unsubscribe();
                 this.stop();
             };
         }
@@ -11516,7 +11602,7 @@ class RNSpeechDetector {
         const silenceTimeout = 5000; // Reset baseline after 5 seconds of silence
         const checkAudioLevel = async () => {
             try {
-                const stats = (await this.pc1.getStats());
+                const stats = await this.pc1.getStats();
                 const report = flatten(stats);
                 // Audio levels are present inside stats of type `media-source` and of kind `audio`
                 const audioMediaSourceStats = report.find((stat) => stat.type === 'media-source' &&
@@ -11570,8 +11656,7 @@ class RNSpeechDetector {
                 logger.error('error checking audio level from stats', error);
             }
         };
-        // Call checkAudioLevel periodically (every 100ms)
-        const intervalId = setInterval(checkAudioLevel, 100);
+        const intervalId = setInterval(checkAudioLevel, 250);
         return () => {
             clearInterval(intervalId);
             clearTimeout(speechTimer);
@@ -11597,15 +11682,19 @@ class MicrophoneManager extends AudioDeviceManager {
         super(call, new MicrophoneManagerState(disableMode), TrackType.AUDIO);
         this.speakingWhileMutedNotificationEnabled = true;
         this.soundDetectorConcurrencyTag = Symbol('soundDetectorConcurrencyTag');
+        this.silenceThresholdMs = 5000;
     }
     setup() {
+        if (this.areSubscriptionsSetUp)
+            return;
         super.setup();
         this.subscriptions.push(createSafeAsyncSubscription(combineLatest([
             this.call.state.callingState$,
             this.call.state.ownCapabilities$,
             this.state.selectedDevice$,
             this.state.status$,
-        ]), async ([callingState, ownCapabilities, deviceId, status]) => {
+            this.state.browserPermissionState$,
+        ]), async ([callingState, ownCapabilities, deviceId, status, permissionState,]) => {
             try {
                 if (callingState === CallingState.LEFT) {
                     await this.stopSpeakingWhileMutedDetection();
@@ -11615,7 +11704,8 @@ class MicrophoneManager extends AudioDeviceManager {
                 if (!this.speakingWhileMutedNotificationEnabled)
                     return;
                 if (ownCapabilities.includes(OwnCapability.SEND_AUDIO)) {
-                    if (status === 'disabled') {
+                    const hasPermission = await this.hasPermission(permissionState);
+                    if (hasPermission && status !== 'enabled') {
                         await this.startSpeakingWhileMutedDetection(deviceId);
                     }
                     else {
@@ -11664,6 +11754,40 @@ class MicrophoneManager extends AudioDeviceManager {
                 });
             }
         }));
+        if (!isReactNative()) {
+            const unsubscribe = createSafeAsyncSubscription(combineLatest([this.state.status$, this.state.mediaStream$]), async ([status, mediaStream]) => {
+                if (this.noAudioDetectorCleanup) {
+                    const cleanup = this.noAudioDetectorCleanup;
+                    this.noAudioDetectorCleanup = undefined;
+                    await cleanup().catch((err) => {
+                        this.logger.warn('Failed to stop no-audio detector', err);
+                    });
+                }
+                if (status !== 'enabled' || !mediaStream)
+                    return;
+                if (this.silenceThresholdMs <= 0)
+                    return;
+                const deviceId = this.state.selectedDevice;
+                const devices = getCurrentValue(this.listDevices());
+                const label = devices.find((d) => d.deviceId === deviceId)?.label;
+                this.noAudioDetectorCleanup = createNoAudioDetector(mediaStream, {
+                    noAudioThresholdMs: this.silenceThresholdMs,
+                    emitIntervalMs: this.silenceThresholdMs,
+                    onCaptureStatusChange: (capturesAudio) => {
+                        const event = {
+                            type: 'mic.capture_report',
+                            call_cid: this.call.cid,
+                            capturesAudio,
+                            deviceId,
+                            label,
+                        };
+                        this.call.tracer.trace('mic.capture_report', event);
+                        this.call.streamClient.dispatchEvent(event);
+                    },
+                });
+            });
+            this.subscriptions.push(unsubscribe);
+        }
     }
     /**
      * Enables noise cancellation for the microphone.
@@ -11761,6 +11885,45 @@ class MicrophoneManager extends AudioDeviceManager {
         this.speakingWhileMutedNotificationEnabled = false;
         await this.stopSpeakingWhileMutedDetection();
     }
+    /**
+     * Sets the silence threshold in milliseconds for no-audio detection.
+     * When the microphone is enabled but produces no audio for this duration,
+     * a 'mic.capture_report' event will be emitted.
+     *
+     * @param thresholdMs the threshold in milliseconds (default: 5000).
+     *   Set to 0 or a negative value to disable no-audio detection.
+     */
+    setSilenceThreshold(thresholdMs) {
+        this.silenceThresholdMs = thresholdMs;
+    }
+    /**
+     * Performs audio capture test on a specific microphone.
+     *
+     * This method is only available in browser environments (not React Native).
+     *
+     * @param deviceId The device ID to test.
+     * @param options Optional test configuration.
+     * @returns Promise that resolves with the test result (true or false).
+     */
+    async performTest(deviceId, options) {
+        if (isReactNative())
+            throw new Error('Not available in React Native');
+        const stream = await this.getStream({ deviceId: { exact: deviceId } });
+        const { testDurationMs = 3000 } = options || {};
+        const { promise, resolve } = promiseWithResolvers();
+        const cleanup = createNoAudioDetector(stream, {
+            noAudioThresholdMs: testDurationMs,
+            emitIntervalMs: testDurationMs,
+            onCaptureStatusChange: async (capturesAudio) => {
+                resolve(capturesAudio);
+                await cleanup().catch((err) => {
+                    this.logger.warn('Failed to stop detector during test', err);
+                });
+                disposeOfMediaStream(stream);
+            },
+        });
+        return promise;
+    }
     /**
      * Applies the audio settings to the microphone.
      * @param settings the audio settings to apply.
@@ -11809,13 +11972,12 @@ class MicrophoneManager extends AudioDeviceManager {
     }
     async startSpeakingWhileMutedDetection(deviceId) {
         await withoutConcurrency(this.soundDetectorConcurrencyTag, async () => {
-            await this.stopSpeakingWhileMutedDetection();
             if (isReactNative()) {
                 this.rnSpeechDetector = new RNSpeechDetector();
                 const unsubscribe = await this.rnSpeechDetector.start((event) => {
                     this.state.setSpeakingWhileMuted(event.isSoundDetected);
                 });
-                this.soundDetectorCleanup = () => {
+                this.soundDetectorCleanup = async () => {
                     unsubscribe();
                     this.rnSpeechDetector = undefined;
                 };
@@ -11823,6 +11985,7 @@ class MicrophoneManager extends AudioDeviceManager {
             else {
                 // Need to start a new stream that's not connected to publisher
                 const stream = await this.getStream({
+                    ...this.state.defaultConstraints,
                     deviceId: { exact: deviceId },
                 });
                 this.soundDetectorCleanup = createSoundDetector(stream, (event) => {
@@ -11841,6 +12004,20 @@ class MicrophoneManager extends AudioDeviceManager {
             await soundDetectorCleanup();
         });
     }
+    async hasPermission(permissionState) {
+        if (!isReactNative())
+            return permissionState === 'granted';
+        const nativePermissions = globalThis.streamRNVideoSDK?.permissions;
+        if (!nativePermissions)
+            return true; // assume granted
+        try {
+            return await nativePermissions.check('microphone');
+        }
+        catch (err) {
+            this.logger.warn('Failed to check permission', err);
+            return false;
+        }
+    }
 }
 
 class ScreenShareState extends AudioDeviceManagerState {
@@ -11902,6 +12079,8 @@ class ScreenShareManager extends AudioDeviceManager {
         super(call, new ScreenShareState(), TrackType.SCREEN_SHARE);
     }
     setup() {
+        if (this.areSubscriptionsSetUp)
+            return;
         super.setup();
         this.subscriptions.push(createSubscription(this.call.state.settings$, (settings) => {
             const maybeTargetResolution = settings?.screensharing.target_resolution;
@@ -12248,6 +12427,9 @@ class Call {
                 this.leaveCallHooks.add(registerEventHandlers(this, this.dispatcher));
                 this.registerEffects();
                 this.registerReconnectHandlers();
+                // Set up the device managers again. Although this is already done
+                // in the DeviceManager's constructor, they'll need to be re-set up
+                // in the cases where a call instance is recycled (join -> leave -> join).
                 this.camera.setup();
                 this.microphone.setup();
                 this.screenShare.setup();
@@ -15345,7 +15527,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.41.3", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.42.1", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -15981,5 +16163,5 @@ const humanize = (n) => {
     return String(n);
 };
 
-export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RNSpeechDetector, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, withParticipantSource };
+export { AudioSettingsRequestDefaultDeviceEnum, AudioSettingsResponseDefaultDeviceEnum, browsers as Browsers, Call, CallRecordingFailedEventRecordingTypeEnum, CallRecordingReadyEventRecordingTypeEnum, CallRecordingStartedEventRecordingTypeEnum, CallRecordingStoppedEventRecordingTypeEnum, CallState, CallType, CallTypes, CallingState, CameraManager, CameraManagerState, CreateDeviceRequestPushProviderEnum, DebounceType, DeviceManager, DeviceManagerState, DynascaleManager, ErrorFromResponse, FrameRecordingSettingsRequestModeEnum, FrameRecordingSettingsRequestQualityEnum, FrameRecordingSettingsResponseModeEnum, IndividualRecordingSettingsRequestModeEnum, IndividualRecordingSettingsResponseModeEnum, IngressAudioEncodingOptionsRequestChannelsEnum, IngressSourceRequestFpsEnum, IngressVideoLayerRequestCodecEnum, LayoutSettingsRequestNameEnum, MicrophoneManager, MicrophoneManagerState, NoiseCancellationSettingsModeEnum, OwnCapability, RNSpeechDetector, RTMPBroadcastRequestQualityEnum, RTMPSettingsRequestQualityEnum, RawRecordingSettingsRequestModeEnum, RawRecordingSettingsResponseModeEnum, RecordSettingsRequestModeEnum, RecordSettingsRequestQualityEnum, rxUtils as RxUtils, ScreenShareManager, ScreenShareState, events as SfuEvents, SfuJoinError, models as SfuModels, SpeakerManager, SpeakerState, StartClosedCaptionsRequestLanguageEnum, StartTranscriptionRequestLanguageEnum, StreamSfuClient, StreamVideoClient, StreamVideoReadOnlyStateStore, StreamVideoWriteableStateStore, TranscriptionSettingsRequestClosedCaptionModeEnum, TranscriptionSettingsRequestLanguageEnum, TranscriptionSettingsRequestModeEnum, TranscriptionSettingsResponseClosedCaptionModeEnum, TranscriptionSettingsResponseLanguageEnum, TranscriptionSettingsResponseModeEnum, VideoSettingsRequestCameraFacingEnum, VideoSettingsResponseCameraFacingEnum, ViewportTracker, VisibilityState, checkIfAudioOutputChangeSupported, combineComparators, conditional, createSoundDetector, defaultSortPreset, descending, deviceIds$, disposeOfMediaStream, dominantSpeaker, getAudioBrowserPermission, getAudioDevices, getAudioOutputDevices, getAudioStream, getClientDetails, getDeviceState, getScreenShareStream, getSdkInfo, getVideoBrowserPermission, getVideoDevices, getVideoStream, getWebRTCInfo, hasAudio$1 as hasAudio, hasPausedTrack, hasScreenShare, hasScreenShareAudio, hasVideo, humanize, isPinned, livestreamOrAudioRoomSortPreset, logToConsole, name, noopComparator, paginatedLayoutSortPreset, pinned, publishingAudio, publishingVideo, reactionType, resolveDeviceId, role, screenSharing, setDeviceInfo, setOSInfo, setPowerState, setSdkInfo, setThermalState, setWebRTCInfo, speakerLayoutSortPreset, speaking, videoLoggerSystem, withParticipantSource };
 //# sourceMappingURL=index.es.js.map