@stream-io/video-client 1.41.0 → 1.41.1

package/dist/index.es.js

@@ -6189,7 +6189,7 @@ const getSdkVersion = (sdk) => {
     return sdk ? `${sdk.major}.${sdk.minor}.${sdk.patch}` : '0.0.0-development';
 };
 
-const version = "1.41.0";
+const version = "1.41.1";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -9373,12 +9373,13 @@ class DynascaleManager {
     /**
      * Creates a new DynascaleManager instance.
      */
-    constructor(callState, speaker) {
+    constructor(callState, speaker, tracer) {
         /**
          * The viewport tracker instance.
          */
         this.viewportTracker = new ViewportTracker();
         this.logger = videoLoggerSystem.getLogger('DynascaleManager');
+        this.useWebAudio = isSafari();
         this.pendingSubscriptionsUpdate = null;
         this.videoTrackSubscriptionOverridesSubject = new BehaviorSubject({});
         this.videoTrackSubscriptionOverrides$ = this.videoTrackSubscriptionOverridesSubject.asObservable();
@@ -9418,6 +9419,10 @@ class DynascaleManager {
             }
         };
         this.setVideoTrackSubscriptionOverrides = (override, sessionIds) => {
+            this.tracer.trace('setVideoTrackSubscriptionOverrides', [
+                override,
+                sessionIds,
+            ]);
             if (!sessionIds) {
                 return setCurrentValue(this.videoTrackSubscriptionOverridesSubject, override ? { [globalOverrideKey]: override } : {});
             }
@@ -9499,6 +9504,18 @@ class DynascaleManager {
         this.setViewport = (element) => {
             return this.viewportTracker.setViewport(element);
         };
+        /**
+         * Sets whether to use WebAudio API for audio playback.
+         * Must be set before joining the call.
+         *
+         * @internal
+         *
+         * @param useWebAudio whether to use WebAudio API.
+         */
+        this.setUseWebAudio = (useWebAudio) => {
+            this.tracer.trace('setUseWebAudio', useWebAudio);
+            this.useWebAudio = useWebAudio;
+        };
         /**
          * Binds a DOM <video> element to the given session id.
          * This method will make sure that the video element will play
@@ -9714,6 +9731,7 @@ class DynascaleManager {
                         // we will play audio directly through the audio element in other browsers
                         audioElement.muted = false;
                         audioElement.play().catch((e) => {
+                            this.tracer.trace('audioPlaybackError', e.message);
                             this.logger.warn(`Failed to play audio stream`, e);
                         });
                     }
@@ -9748,32 +9766,57 @@ class DynascaleManager {
             };
         };
         this.getOrCreateAudioContext = () => {
-            if (this.audioContext || !isSafari())
+            if (!this.useWebAudio)
+                return;
+            if (this.audioContext)
                 return this.audioContext;
             const context = new AudioContext();
+            this.tracer.trace('audioContext.create', context.state);
             if (context.state === 'suspended') {
                 document.addEventListener('click', this.resumeAudioContext);
             }
-            // @ts-expect-error audioSession is available in Safari only
+            context.addEventListener('statechange', () => {
+                this.tracer.trace('audioContext.state', context.state);
+                if (context.state === 'interrupted') {
+                    this.resumeAudioContext();
+                }
+            });
             const audioSession = navigator.audioSession;
             if (audioSession) {
                 // https://github.com/w3c/audio-session/blob/main/explainer.md
                 audioSession.type = 'play-and-record';
+                let isSessionInterrupted = false;
+                audioSession.addEventListener('statechange', () => {
+                    this.tracer.trace('audioSession.state', audioSession.state);
+                    if (audioSession.state === 'interrupted') {
+                        isSessionInterrupted = true;
+                    }
+                    else if (isSessionInterrupted) {
+                        this.resumeAudioContext();
+                        isSessionInterrupted = false;
+                    }
+                });
             }
             return (this.audioContext = context);
         };
         this.resumeAudioContext = () => {
-            if (this.audioContext?.state === 'suspended') {
-                this.audioContext
-                    .resume()
-                    .catch((err) => this.logger.warn(`Can't resume audio context`, err))
-                    .then(() => {
+            if (!this.audioContext)
+                return;
+            const { state } = this.audioContext;
+            if (state === 'suspended' || state === 'interrupted') {
+                const tag = 'audioContext.resume';
+                this.audioContext.resume().then(() => {
+                    this.tracer.trace(tag, this.audioContext?.state);
                     document.removeEventListener('click', this.resumeAudioContext);
+                }, (err) => {
+                    this.tracer.trace(`${tag}Error`, this.audioContext?.state);
+                    this.logger.warn(`Can't resume audio context`, err);
                 });
             }
         };
         this.callState = callState;
         this.speaker = speaker;
+        this.tracer = tracer;
     }
     setSfuClient(sfuClient) {
         this.sfuClient = sfuClient;
@@ -11993,6 +12036,37 @@ class SpeakerManager {
         this.state = new SpeakerState(call.tracer);
         this.setup();
     }
+    apply(settings) {
+        if (!isReactNative()) {
+            return;
+        }
+        /// Determines if the speaker should be enabled based on a priority hierarchy of
+        /// settings.
+        ///
+        /// The priority order is as follows:
+        /// 1. If video camera is set to be on by default, speaker is enabled
+        /// 2. If audio speaker is set to be on by default, speaker is enabled
+        /// 3. If the default audio device is set to speaker, speaker is enabled
+        ///
+        /// This ensures that the speaker state aligns with the most important user
+        /// preference or system requirement.
+        const speakerOnWithSettingsPriority = settings.video.camera_default_on ||
+            settings.audio.speaker_default_on ||
+            settings.audio.default_device ===
+                AudioSettingsRequestDefaultDeviceEnum.SPEAKER;
+        const defaultDevice = speakerOnWithSettingsPriority
+            ? AudioSettingsRequestDefaultDeviceEnum.SPEAKER
+            : AudioSettingsRequestDefaultDeviceEnum.EARPIECE;
+        if (this.defaultDevice !== defaultDevice) {
+            this.call.logger.debug('SpeakerManager: setting default device', {
+                defaultDevice,
+            });
+            this.defaultDevice = defaultDevice;
+            globalThis.streamRNVideoSDK?.callManager.setup({
+                defaultDevice,
+            });
+        }
+    }
     setup() {
         if (this.areSubscriptionsSetUp) {
             return;
@@ -13934,9 +14008,7 @@ class Call {
          * @internal
          */
         this.applyDeviceConfig = async (settings, publish) => {
-            globalThis.streamRNVideoSDK?.callManager.setup({
-                default_device: settings.audio.default_device,
-            });
+            this.speaker.apply(settings);
             await this.camera.apply(settings.video, publish).catch((err) => {
                 this.logger.warn('Camera init failed', err);
             });
@@ -14106,7 +14178,7 @@ class Call {
         this.microphone = new MicrophoneManager(this);
         this.speaker = new SpeakerManager(this);
         this.screenShare = new ScreenShareManager(this);
-        this.dynascaleManager = new DynascaleManager(this.state, this.speaker);
+        this.dynascaleManager = new DynascaleManager(this.state, this.speaker, this.tracer);
     }
     /**
      * A flag indicating whether the call is "ringing" type of call.
@@ -15248,7 +15320,7 @@ class StreamClient {
         this.getUserAgent = () => {
             if (!this.cachedUserAgent) {
                 const { clientAppIdentifier = {} } = this.options;
-                const { sdkName = 'js', sdkVersion = "1.41.0", ...extras } = clientAppIdentifier;
+                const { sdkName = 'js', sdkVersion = "1.41.1", ...extras } = clientAppIdentifier;
                 this.cachedUserAgent = [
                     `stream-video-${sdkName}-v${sdkVersion}`,
                     ...Object.entries(extras).map(([key, value]) => `${key}=${value}`),