@stream-io/video-client 1.16.0 → 1.16.2

package/dist/index.cjs.js

@@ -3898,6 +3898,8 @@ class StreamVideoWriteableStateStore {
          * @param call the call to remove
          */
         this.unregisterCall = (call) => {
+            const logger = getLogger(['client-state']);
+            logger('trace', `Unregistering call: ${call.cid}`);
             return this.setCalls((calls) => calls.filter((c) => c !== call));
         };
         /**
@@ -5183,11 +5185,14 @@ class BasePeerConnection {
      */
     constructor(peerType, { sfuClient, connectionConfig, state, dispatcher, onUnrecoverableError, logTag, }) {
         this.isIceRestarting = false;
+        this.isDisposed = false;
         this.subscriptions = [];
         /**
          * Disposes the `RTCPeerConnection` instance.
          */
         this.dispose = () => {
+            this.onUnrecoverableError = undefined;
+            this.isDisposed = true;
             this.detachEventHandlers();
             this.pc.close();
         };
@@ -5198,6 +5203,8 @@ class BasePeerConnection {
         this.on = (event, fn) => {
             this.subscriptions.push(this.dispatcher.on(event, (e) => {
                 withoutConcurrency(`pc.${event}`, async () => fn(e)).catch((err) => {
+                    if (this.isDisposed)
+                        return;
                     this.logger('warn', `Error handling ${event}`, err);
                 });
             }));
@@ -5213,6 +5220,8 @@ class BasePeerConnection {
             this.unsubscribeIceTrickle?.();
             this.unsubscribeIceTrickle = createSafeAsyncSubscription(observable, async (candidate) => {
                 return this.pc.addIceCandidate(candidate).catch((e) => {
+                    if (this.isDisposed)
+                        return;
                     this.logger('warn', `ICE candidate error`, e, candidate);
                 });
             });
@@ -5245,7 +5254,11 @@ class BasePeerConnection {
             const iceCandidate = this.toJSON(candidate);
             this.sfuClient
                 .iceTrickle({ peerType: this.peerType, iceCandidate })
-                .catch((err) => this.logger('warn', `ICETrickle failed`, err));
+                .catch((err) => {
+                if (this.isDisposed)
+                    return;
+                this.logger('warn', `ICETrickle failed`, err);
+            });
         };
         /**
          * Converts the ICE candidate to a JSON string.
@@ -5274,6 +5287,8 @@ class BasePeerConnection {
             if (state === 'failed' || state === 'disconnected') {
                 this.logger('debug', `Attempting to restart ICE`);
                 this.restartIce().catch((e) => {
+                    if (this.isDisposed)
+                        return;
                     this.logger('error', `ICE restart failed`, e);
                     this.onUnrecoverableError?.();
                 });
@@ -5325,6 +5340,8 @@ class BasePeerConnection {
         this.pc.removeEventListener('icecandidateerror', this.onIceCandidateError);
         this.pc.removeEventListener('signalingstatechange', this.onSignalingChange);
         this.pc.removeEventListener('iceconnectionstatechange', this.onIceConnectionStateChange);
+        // cancel any ongoing ICE restart process
+        withCancellation('onIceConnectionStateChange', () => Promise.resolve());
         this.pc.removeEventListener('icegatheringstatechange', this.onIceGatherChange);
         this.unsubscribeIceTrickle?.();
         this.subscriptions.forEach((unsubscribe) => unsubscribe());
@@ -5840,10 +5857,12 @@ class Publisher extends BasePeerConnection {
             await this.negotiate({ iceRestart: true });
         };
         this.onNegotiationNeeded = () => {
-            withoutConcurrency('publisher.negotiate', () => this.negotiate()).catch((err) => {
+            withCancellation('publisher.negotiate', (signal) => this.negotiate().catch((err) => {
+                if (signal.aborted)
+                    return;
                 this.logger('error', `Negotiation failed.`, err);
                 this.onUnrecoverableError?.();
-            });
+            }));
         };
         /**
          * Initiates a new offer/answer exchange with the currently connected SFU.
@@ -5970,6 +5989,8 @@ class Publisher extends BasePeerConnection {
     detachEventHandlers() {
         super.detachEventHandlers();
         this.pc.removeEventListener('negotiationneeded', this.onNegotiationNeeded);
+        // abort any ongoing negotiation
+        withCancellation('publisher.negotiate', () => Promise.resolve());
     }
 }
 
@@ -7394,7 +7415,7 @@ const aggregate = (stats) => {
     return report;
 };
 
-const version = "1.16.0";
+const version = "1.16.2";
 const [major, minor, patch] = version.split('.');
 let sdkInfo = {
     type: SdkType.PLAIN_JAVASCRIPT,
@@ -9251,10 +9272,34 @@ class CameraManager extends InputMediaDeviceManager {
      */
     async selectDirection(direction) {
         if (this.isDirectionSupportedByDevice()) {
-            this.state.setDirection(direction);
-            // Providing both device id and direction doesn't work, so we deselect the device
-            this.state.setDevice(undefined);
-            await this.applySettingsToStream();
+            if (isReactNative()) {
+                const videoTrack = this.getTracks()[0];
+                if (!videoTrack)
+                    return;
+                // @ts-expect-error _switchCamera() is only present in react-native-webrtc 124 and below
+                if (typeof videoTrack._switchCamera === 'function') {
+                    // @ts-expect-error for older versions of react-native-webrtc support
+                    videoTrack._switchCamera();
+                }
+                else {
+                    const constraints = {
+                        facingMode: direction === 'front' ? 'user' : 'environment',
+                    };
+                    await videoTrack.applyConstraints(constraints);
+                }
+                this.state.setDirection(direction);
+                this.state.setDevice(undefined);
+            }
+            else {
+                // web mobile
+                this.state.setDirection(direction);
+                // Providing both device id and direction doesn't work, so we deselect the device
+                this.state.setDevice(undefined);
+                this.getTracks().forEach((track) => {
+                    track.stop();
+                });
+                await this.unmuteStream();
+            }
         }
         else {
             this.logger('warn', 'Camera direction ignored for desktop devices');
@@ -12975,7 +13020,7 @@ class StreamClient {
             return await this.wsConnection.connect(this.defaultWSTimeout);
         };
         this.getUserAgent = () => {
-            const version = "1.16.0";
+            const version = "1.16.2";
             return (this.userAgent ||
                 `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${version}`);
         };