@stream-io/video-client 1.46.1 → 1.48.0

package/dist/index.cjs.js

@@ -6304,7 +6304,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.46.1";
+const version = "1.48.0";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -10885,8 +10885,14 @@ class DeviceManager {
             this.handleDisconnectedOrReplacedDevices();
         }
         if (this.devicePersistence.enabled) {
-            this.subscriptions.push(createSubscription(rxjs.combineLatest([this.state.selectedDevice$, this.state.status$]), ([selectedDevice, status]) => {
-                if (!status)
+            this.subscriptions.push(createSubscription(rxjs.combineLatest([
+                this.state.selectedDevice$,
+                this.state.status$,
+                this.state.browserPermissionState$,
+            ]), ([selectedDevice, status, browserPermissionState]) => {
+                if (!status ||
+                    (this.isTrackStoppedDueToTrackEnd && status === 'disabled') ||
+                    browserPermissionState !== 'granted')
                     return;
                 this.persistPreference(selectedDevice, status);
             }));
@@ -11651,7 +11657,10 @@ class CameraManager extends DeviceManager {
         const shouldApplyDefaults = this.state.status === undefined &&
             this.state.optimisticStatus === undefined;
         let persistedPreferencesApplied = false;
-        if (shouldApplyDefaults && this.devicePersistence.enabled) {
+        const permissionState = await rxjs.firstValueFrom(this.state.browserPermissionState$);
+        if (shouldApplyDefaults &&
+            this.devicePersistence.enabled &&
+            permissionState === 'granted') {
             persistedPreferencesApplied =
                 await this.applyPersistedPreferences(enabledInCallType);
         }
@@ -11943,192 +11952,6 @@ const createNoAudioDetector = (audioStream, options) => {
     return stop;
 };
 
-class RNSpeechDetector {
-    constructor(externalAudioStream) {
-        this.pc1 = new RTCPeerConnection({});
-        this.pc2 = new RTCPeerConnection({});
-        this.isStopped = false;
-        this.externalAudioStream = externalAudioStream;
-    }
-    /**
-     * Starts the speech detection.
-     */
-    async start(onSoundDetectedStateChanged) {
-        let detachListeners;
-        let unsubscribe;
-        try {
-            this.isStopped = false;
-            const audioStream = this.externalAudioStream != null
-                ? this.externalAudioStream
-                : await navigator.mediaDevices.getUserMedia({ audio: true });
-            this.audioStream = audioStream;
-            const onPc1IceCandidate = (e) => {
-                this.forwardIceCandidate(this.pc2, e.candidate);
-            };
-            const onPc2IceCandidate = (e) => {
-                this.forwardIceCandidate(this.pc1, e.candidate);
-            };
-            const onTrackPc2 = (e) => {
-                e.streams[0].getTracks().forEach((track) => {
-                    // In RN, the remote track is automatically added to the audio output device
-                    // so we need to mute it to avoid hearing the audio back
-                    // @ts-expect-error _setVolume is a private method in react-native-webrtc
-                    track._setVolume(0);
-                });
-            };
-            this.pc1.addEventListener('icecandidate', onPc1IceCandidate);
-            this.pc2.addEventListener('icecandidate', onPc2IceCandidate);
-            this.pc2.addEventListener('track', onTrackPc2);
-            detachListeners = () => {
-                this.pc1.removeEventListener('icecandidate', onPc1IceCandidate);
-                this.pc2.removeEventListener('icecandidate', onPc2IceCandidate);
-                this.pc2.removeEventListener('track', onTrackPc2);
-            };
-            audioStream
-                .getTracks()
-                .forEach((track) => this.pc1.addTrack(track, audioStream));
-            const offer = await this.pc1.createOffer({});
-            await this.pc2.setRemoteDescription(offer);
-            await this.pc1.setLocalDescription(offer);
-            const answer = await this.pc2.createAnswer();
-            await this.pc1.setRemoteDescription(answer);
-            await this.pc2.setLocalDescription(answer);
-            unsubscribe = this.onSpeakingDetectedStateChange(onSoundDetectedStateChanged);
-            return () => {
-                detachListeners?.();
-                unsubscribe?.();
-                this.stop();
-            };
-        }
-        catch (error) {
-            detachListeners?.();
-            unsubscribe?.();
-            this.stop();
-            const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
-            logger.error('error handling permissions: ', error);
-            return () => { };
-        }
-    }
-    /**
-     * Stops the speech detection and releases all allocated resources.
-     */
-    stop() {
-        if (this.isStopped)
-            return;
-        this.isStopped = true;
-        this.pc1.close();
-        this.pc2.close();
-        if (this.externalAudioStream != null) {
-            this.externalAudioStream = undefined;
-        }
-        else {
-            this.cleanupAudioStream();
-        }
-    }
-    /**
-     * Public method that detects the audio levels and returns the status.
-     */
-    onSpeakingDetectedStateChange(onSoundDetectedStateChanged) {
-        const initialBaselineNoiseLevel = 0.13;
-        let baselineNoiseLevel = initialBaselineNoiseLevel;
-        let speechDetected = false;
-        let speechTimer;
-        let silenceTimer;
-        const audioLevelHistory = []; // Store recent audio levels for smoother detection
-        const historyLength = 10;
-        const silenceThreshold = 1.1;
-        const resetThreshold = 0.9;
-        const speechTimeout = 500; // Speech is set to true after 500ms of audio detection
-        const silenceTimeout = 5000; // Reset baseline after 5 seconds of silence
-        const checkAudioLevel = async () => {
-            try {
-                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' &&
-                    stat.kind === 'audio');
-                if (audioMediaSourceStats) {
-                    const { audioLevel } = audioMediaSourceStats;
-                    if (audioLevel) {
-                        // Update audio level history (with max historyLength sized array)
-                        audioLevelHistory.push(audioLevel);
-                        if (audioLevelHistory.length > historyLength) {
-                            audioLevelHistory.shift();
-                        }
-                        // Calculate average audio level
-                        const avgAudioLevel = audioLevelHistory.reduce((a, b) => a + b, 0) /
-                            audioLevelHistory.length;
-                        // Update baseline (if necessary) based on silence detection
-                        if (avgAudioLevel < baselineNoiseLevel * silenceThreshold) {
-                            if (!silenceTimer) {
-                                silenceTimer = setTimeout(() => {
-                                    baselineNoiseLevel = Math.min(avgAudioLevel * resetThreshold, initialBaselineNoiseLevel);
-                                }, silenceTimeout);
-                            }
-                        }
-                        else {
-                            clearTimeout(silenceTimer);
-                            silenceTimer = undefined;
-                        }
-                        // Speech detection with hysteresis
-                        if (avgAudioLevel > baselineNoiseLevel * 1.5) {
-                            if (!speechDetected) {
-                                speechDetected = true;
-                                onSoundDetectedStateChanged({
-                                    isSoundDetected: true,
-                                    audioLevel,
-                                });
-                            }
-                            clearTimeout(speechTimer);
-                            speechTimer = setTimeout(() => {
-                                speechDetected = false;
-                                onSoundDetectedStateChanged({
-                                    isSoundDetected: false,
-                                    audioLevel: 0,
-                                });
-                            }, speechTimeout);
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
-                logger.error('error checking audio level from stats', error);
-            }
-        };
-        const intervalId = setInterval(checkAudioLevel, 250);
-        return () => {
-            clearInterval(intervalId);
-            clearTimeout(speechTimer);
-            clearTimeout(silenceTimer);
-        };
-    }
-    cleanupAudioStream() {
-        if (!this.audioStream) {
-            return;
-        }
-        this.audioStream.getTracks().forEach((track) => track.stop());
-        if (
-        // @ts-expect-error release() is present in react-native-webrtc
-        typeof this.audioStream.release === 'function') {
-            // @ts-expect-error called to dispose the stream in RN
-            this.audioStream.release();
-        }
-    }
-    forwardIceCandidate(destination, candidate) {
-        if (this.isStopped ||
-            !candidate ||
-            destination.signalingState === 'closed') {
-            return;
-        }
-        destination.addIceCandidate(candidate).catch(() => {
-            // silently ignore the error
-            const logger = videoLoggerSystem.getLogger('RNSpeechDetector');
-            logger.info('cannot add ice candidate - ignoring');
-        });
-    }
-}
-
 class MicrophoneManager extends AudioDeviceManager {
     constructor(call, devicePersistence, disableMode = 'stop-tracks') {
         super(call, new MicrophoneManagerState(disableMode, call.tracer), TrackType.AUDIO, devicePersistence);
@@ -12393,7 +12216,10 @@ class MicrophoneManager extends AudioDeviceManager {
         const shouldApplyDefaults = this.state.status === undefined &&
             this.state.optimisticStatus === undefined;
         let persistedPreferencesApplied = false;
-        if (shouldApplyDefaults && this.devicePersistence.enabled) {
+        const permissionState = await rxjs.firstValueFrom(this.state.browserPermissionState$);
+        if (shouldApplyDefaults &&
+            this.devicePersistence.enabled &&
+            permissionState === 'granted') {
             persistedPreferencesApplied = await this.applyPersistedPreferences(true);
         }
         const canPublish = this.call.permissionsContext.canPublish(this.trackType);
@@ -12438,13 +12264,16 @@ class MicrophoneManager extends AudioDeviceManager {
                 return;
             await this.teardownSpeakingWhileMutedDetection();
             if (isReactNative()) {
-                this.rnSpeechDetector = new RNSpeechDetector();
-                const unsubscribe = await this.rnSpeechDetector.start((event) => {
+                const speechActivity = globalThis.streamRNVideoSDK?.nativeEvents?.speechActivity;
+                if (!speechActivity) {
+                    this.logger.warn('Native speech activity not available, make sure the "@stream-io/react-native-webrtc" peer dependency version is satisfied');
+                    return;
+                }
+                const unsubscribe = speechActivity.subscribe((event) => {
                     this.state.setSpeakingWhileMuted(event.isSoundDetected);
                 });
                 this.soundDetectorCleanup = async () => {
                     unsubscribe();
-                    this.rnSpeechDetector = undefined;
                 };
             }
             else {
@@ -12777,7 +12606,12 @@ class SpeakerManager {
             }));
         }
         if (!isReactNative() && this.devicePersistence.enabled) {
-            this.subscriptions.push(createSubscription(this.state.selectedDevice$, (selectedDevice) => {
+            this.subscriptions.push(createSubscription(rxjs.combineLatest([
+                this.state.selectedDevice$,
+                getAudioBrowserPermission(this.call.tracer).asStateObservable(),
+            ]), ([selectedDevice, browserPermissionState]) => {
+                if (!selectedDevice || browserPermissionState !== 'granted')
+                    return;
                 this.persistSpeakerDevicePreference(selectedDevice);
             }));
         }
@@ -16152,7 +15986,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.46.1", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.48.0", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),
@@ -16827,7 +16661,6 @@ exports.MicrophoneManager = MicrophoneManager;
 exports.MicrophoneManagerState = MicrophoneManagerState;
 exports.NoiseCancellationSettingsModeEnum = NoiseCancellationSettingsModeEnum;
 exports.OwnCapability = OwnCapability;
-exports.RNSpeechDetector = RNSpeechDetector;
 exports.RTMPBroadcastRequestQualityEnum = RTMPBroadcastRequestQualityEnum;
 exports.RTMPSettingsRequestQualityEnum = RTMPSettingsRequestQualityEnum;
 exports.RawRecordingSettingsRequestModeEnum = RawRecordingSettingsRequestModeEnum;