@stream-io/video-client 1.58.0 → 2.0.0-beta.0

package/src/Call.ts

@@ -39,6 +39,7 @@ import {
   BlockUserResponse,
   CallRingEvent,
   CallSettingsResponse,
+  CallStateResponseFields,
   CollectUserFeedbackRequest,
   CollectUserFeedbackResponse,
   Credentials,
@@ -178,7 +179,11 @@ import {
   SpeakerManager,
 } from './devices';
 import { normalize } from './devices/devicePersistence';
-import { hasPending, withoutConcurrency } from './helpers/concurrency';
+import {
+  hasPending,
+  singleFlight,
+  withoutConcurrency,
+} from './helpers/concurrency';
 import { ensureExhausted } from './helpers/ensureExhausted';
 import { pushToIfMissing } from './helpers/array';
 import {
@@ -753,7 +758,10 @@ export class Call {
           }
         }
       }
-      globalThis.streamRNVideoSDK?.callingX?.endCall(this);
+      globalThis.streamRNVideoSDK?.callingX?.endCall(
+        this,
+        reason === 'ended' ? 'remote' : undefined,
+      );
 
       this.statsReporter?.stop();
       this.statsReporter = undefined;
@@ -936,8 +944,19 @@ export class Call {
     // const calls = useCalls().filter((c) => c.ringing);
     const calls = this.clientStore.calls.filter((c) => c.cid !== this.cid);
     this.clientStore.setCalls([this, ...calls]);
-    const skipSpeakerApply = isReactNative();
-    await this.applyDeviceConfig(settings, false, skipSpeakerApply);
+    await this.applyDeviceConfig(settings, { publish: false });
+  };
+
+  /**
+   * Applies a backend-provided call state snapshot
+   * (call, members, own capabilities) to this instance.
+   *
+   * @internal an internal method and should not be used outside the SDK.
+   */
+  updateFromCallStateResponse = (response: CallStateResponseFields) => {
+    this.state.updateFromCallResponse(response.call);
+    this.state.setMembers(response.members);
+    this.state.setOwnCapabilities(response.own_capabilities);
   };
 
   /**
@@ -961,9 +980,7 @@ export class Call {
       params,
     );
 
-    this.state.updateFromCallResponse(response.call);
-    this.state.setMembers(response.members);
-    this.state.setOwnCapabilities(response.own_capabilities);
+    this.updateFromCallStateResponse(response);
 
     if (params?.ring) {
       this.ringingSubject.next(true);
@@ -973,13 +990,7 @@ export class Call {
       this.watching = true;
       this.clientStore.registerOrUpdateCall(this);
     }
-    // Skip speaker setup on RN if ringing was requested or the call is already ringing
-    const skipSpeakerApply = isReactNative();
-    await this.applyDeviceConfig(
-      response.call.settings,
-      false,
-      skipSpeakerApply,
-    );
+    await this.applyDeviceConfig(response.call.settings, { publish: false });
 
     return response;
   };
@@ -997,9 +1008,7 @@ export class Call {
       GetOrCreateCallRequest
     >(this.streamClientBasePath, data);
 
-    this.state.updateFromCallResponse(response.call);
-    this.state.setMembers(response.members);
-    this.state.setOwnCapabilities(response.own_capabilities);
+    this.updateFromCallStateResponse(response);
 
     if (data?.ring) {
       this.ringingSubject.next(true);
@@ -1010,13 +1019,7 @@ export class Call {
       this.clientStore.registerOrUpdateCall(this);
     }
 
-    // Skip speaker setup on RN if ringing was requested or the call is already ringing
-    const skipSpeakerApply = isReactNative();
-    await this.applyDeviceConfig(
-      response.call.settings,
-      false,
-      skipSpeakerApply,
-    );
+    await this.applyDeviceConfig(response.call.settings, { publish: false });
 
     return response;
   };
@@ -1103,112 +1106,113 @@ export class Call {
    *
    * @returns a promise which resolves once the call join-flow has finished.
    */
-  join = async ({
-    maxJoinRetries = 3,
-    joinResponseTimeout,
-    rpcRequestTimeout,
-    allowOwnTracksLoopback = false,
-    ...data
-  }: JoinCallData & {
-    maxJoinRetries?: number;
-    joinResponseTimeout?: number;
-    rpcRequestTimeout?: number;
-    allowOwnTracksLoopback?: boolean;
-  } = {}): Promise<void> => {
-    const callingState = this.state.callingState;
+  join = singleFlight(
+    async ({
+      maxJoinRetries = 3,
+      joinResponseTimeout,
+      rpcRequestTimeout,
+      allowOwnTracksLoopback = false,
+      ...data
+    }: JoinCallData & {
+      maxJoinRetries?: number;
+      joinResponseTimeout?: number;
+      rpcRequestTimeout?: number;
+      allowOwnTracksLoopback?: boolean;
+    } = {}): Promise<void> => {
+      const callingState = this.state.callingState;
 
-    if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
-      throw new Error(`Illegal State: call.join() shall be called only once`);
-    }
+      if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
+        throw new Error(`Illegal State: call.join() shall be called only once`);
+      }
 
-    // we need this to be set before the callingx.joinCall() is
-    // called to avoid registering the test call in the CallKit/Telecom
-    this.allowOwnTracksLoopback = allowOwnTracksLoopback;
+      // we need this to be set before the callingx.joinCall() is
+      // called to avoid registering the test call in the CallKit/Telecom
+      this.allowOwnTracksLoopback = allowOwnTracksLoopback;
 
-    if (data?.ring) {
-      this.ringingSubject.next(true);
-    }
+      if (data?.ring) {
+        this.ringingSubject.next(true);
+      }
 
-    const callingX = globalThis.streamRNVideoSDK?.callingX;
-    if (callingX) {
-      // for Android/iOS, we need to start the call in the callingx library as soon as possible
-      await callingX.joinCall(this, this.clientStore.calls);
-    }
+      const callingX = globalThis.streamRNVideoSDK?.callingX;
+      if (callingX) {
+        // for Android/iOS, we need to start the call in the callingx library as soon as possible
+        await callingX.joinCall(this, this.clientStore.calls);
+      }
 
-    await this.setup();
+      await this.setup();
 
-    this.clientEventReporter.registerCall(this.cid, {
-      callType: this.type,
-      callId: this.id,
-      getCallSessionId: () => this.state.session?.id ?? '',
-      getSfuId: () => this.credentials?.server.edge_name ?? '',
-      getUserSessionId: () => this.sfuClient?.sessionId ?? '',
-    });
+      this.clientEventReporter.registerCall(this.cid, {
+        callType: this.type,
+        callId: this.id,
+        getCallSessionId: () => this.state.session?.id ?? '',
+        getSfuId: () => this.credentials?.server.edge_name ?? '',
+      });
 
-    this.joinResponseTimeout = joinResponseTimeout;
-    this.rpcRequestTimeout = rpcRequestTimeout;
-    // we will count the number of join failures per SFU.
-    // once the number of failures reaches 2, we will piggyback on the `migrating_from`
-    // field to force the coordinator to provide us another SFU
-    const sfuJoinFailures = new Map<string, number>();
-    const joinData: JoinCallData = data;
-    maxJoinRetries = Math.max(maxJoinRetries, 1);
-    try {
-      await this.clientEventReporter.withJoinLifecycle(
-        this.cid,
-        'first-attempt',
-        async () => {
-          for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
-            try {
-              this.logger.trace(`Joining call (${attempt})`, this.cid);
-              await this.doJoin(data);
-              delete joinData.migrating_from;
-              delete joinData.migrating_from_list;
-              return;
-            } catch (err) {
-              this.logger.warn(`Failed to join call (${attempt})`, this.cid);
-              if (
-                (err instanceof ErrorFromResponse && err.unrecoverable) ||
-                (err instanceof SfuJoinError && err.unrecoverable)
-              ) {
-                throw err;
-              }
+      this.joinResponseTimeout = joinResponseTimeout;
+      this.rpcRequestTimeout = rpcRequestTimeout;
+      // we will count the number of join failures per SFU.
+      // once the number of failures reaches 2, we will piggyback on the `migrating_from`
+      // field to force the coordinator to provide us another SFU
+      const sfuJoinFailures = new Map<string, number>();
+      const joinData: JoinCallData = data;
+      maxJoinRetries = Math.max(maxJoinRetries, 1);
+      try {
+        await this.clientEventReporter.withJoinLifecycle(
+          this.cid,
+          'first-attempt',
+          async () => {
+            for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+              try {
+                this.logger.trace(`Joining call (${attempt})`, this.cid);
+                await this.doJoin(data);
+                delete joinData.migrating_from;
+                delete joinData.migrating_from_list;
+                return;
+              } catch (err) {
+                this.logger.warn(`Failed to join call (${attempt})`, this.cid);
+                if (
+                  (err instanceof ErrorFromResponse && err.unrecoverable) ||
+                  (err instanceof SfuJoinError && err.unrecoverable)
+                ) {
+                  throw err;
+                }
 
-              const switchSfu =
-                err instanceof SfuJoinError &&
-                SfuJoinError.isJoinErrorCode(err.errorEvent);
-
-              const sfuId = this.credentials?.server.edge_name;
-              if (sfuId) {
-                const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
-                sfuJoinFailures.set(sfuId, failures);
-                if (switchSfu || failures >= 2) {
-                  joinData.migrating_from = sfuId;
-                  joinData.migrating_from_list = Array.from(
-                    sfuJoinFailures.keys(),
-                  );
-                  if (attempt < maxJoinRetries - 1) {
-                    this.clientEventReporter.startCorrelation(
-                      this.cid,
-                      'first-attempt',
+                const switchSfu =
+                  err instanceof SfuJoinError &&
+                  SfuJoinError.isJoinErrorCode(err.errorEvent);
+
+                const sfuId = this.credentials?.server.edge_name;
+                if (sfuId) {
+                  const failures = (sfuJoinFailures.get(sfuId) || 0) + 1;
+                  sfuJoinFailures.set(sfuId, failures);
+                  if (switchSfu || failures >= 2) {
+                    joinData.migrating_from = sfuId;
+                    joinData.migrating_from_list = Array.from(
+                      sfuJoinFailures.keys(),
                     );
+                    if (attempt < maxJoinRetries - 1) {
+                      this.clientEventReporter.startCorrelation(
+                        this.cid,
+                        'first-attempt',
+                      );
+                    }
                   }
                 }
-              }
 
-              if (attempt === maxJoinRetries - 1) {
-                throw err;
+                if (attempt === maxJoinRetries - 1) {
+                  throw err;
+                }
               }
+              await sleep(retryInterval(attempt));
             }
-            await sleep(retryInterval(attempt));
-          }
-        },
-      );
-    } catch (error) {
-      callingX?.endCall(this, 'error');
-      throw error;
-    }
-  };
+          },
+        );
+      } catch (error) {
+        callingX?.endCall(this, 'error');
+        throw error;
+      }
+    },
+  );
 
   /**
    * Will make a single attempt to watch for call related WebSocket events
@@ -1431,7 +1435,10 @@ export class Call {
       this.state.settings &&
       !supersededByLeave()
     ) {
-      await this.applyDeviceConfig(this.state.settings, true, false);
+      await this.applyDeviceConfig(this.state.settings, {
+        publish: true,
+        skipSpeakerApply: false,
+      });
       this.deviceSettingsAppliedOnce = true;
     }
 
@@ -2411,12 +2418,18 @@ export class Call {
       const streamStateProp = trackTypeToParticipantStreamKey(trackType);
       if (!streamStateProp) continue;
 
-      this.state.updateParticipant(sessionId, (p) => ({
-        publishedTracks: mediaStream
-          ? pushToIfMissing([...p.publishedTracks], trackType)
-          : p.publishedTracks.filter((t) => t !== trackType),
-        [streamStateProp]: mediaStream,
-      }));
+      this.state.updateParticipant(sessionId, (p) => {
+        const currentStream = p[streamStateProp];
+        const isEchoedStream =
+          this.subscriber?.isSelfSubscribedStream(currentStream);
+
+        return {
+          publishedTracks: mediaStream
+            ? pushToIfMissing([...p.publishedTracks], trackType)
+            : p.publishedTracks.filter((t) => t !== trackType),
+          [streamStateProp]: isEchoedStream ? currentStream : mediaStream,
+        };
+      });
     }
   };
 
@@ -3367,20 +3380,29 @@ export class Call {
    */
   applyDeviceConfig = async (
     settings: CallSettingsResponse,
-    publish: boolean,
-    skipSpeakerApply: boolean,
+    opts: {
+      publish: boolean;
+      skipSpeakerApply?: boolean;
+      withDisabledDevices?: boolean;
+    },
   ) => {
+    const {
+      publish,
+      // Skip speaker setup on RN until joining (explicitly passed as false during join())
+      skipSpeakerApply = isReactNative(),
+      withDisabledDevices,
+    } = opts;
     if (!skipSpeakerApply) {
-      await this.speaker.apply(settings).catch((err) => {
-        this.logger.warn('Speaker init failed', err);
-      });
+      await this.speaker
+        .apply(settings)
+        .catch((err) => this.logger.warn('Speaker init failed', err));
     }
-    await this.camera.apply(settings.video, publish).catch((err) => {
-      this.logger.warn('Camera init failed', err);
-    });
-    await this.microphone.apply(settings.audio, publish).catch((err) => {
-      this.logger.warn('Mic init failed', err);
-    });
+    await this.camera
+      .apply(settings.video, publish, withDisabledDevices)
+      .catch((err) => this.logger.warn('Camera init failed', err));
+    await this.microphone
+      .apply(settings.audio, publish, withDisabledDevices)
+      .catch((err) => this.logger.warn('Mic init failed', err));
   };
 
   /**

package/src/StreamVideoClient.ts

@@ -39,7 +39,6 @@ import {
   getInstanceKey,
 } from './helpers/clientUtils';
 import { logToConsole, ScopedLogger, videoLoggerSystem } from './logger';
-import { isReactNative } from './helpers/platforms';
 import { withoutConcurrency } from './helpers/concurrency';
 import { enableTimerWorker } from './timers';
 import { ClientEventReporter } from './reporting';
@@ -211,6 +210,7 @@ export class StreamVideoClient {
               await call.reject('busy');
             } else {
               await call.updateFromRingingEvent(e as CallRingEvent);
+              await call.get();
             }
           } else {
             call.state.updateFromCallResponse(e.call);
@@ -248,6 +248,17 @@ export class StreamVideoClient {
     }
   };
 
+  /**
+   * Queries the API for calls matching the given filters.
+   * @param data the query data.
+   */
+  private doQueryCalls = (data: QueryCallsRequest) => {
+    return this.streamClient.post<QueryCallsResponse, QueryCallsRequest>(
+      '/calls',
+      data,
+    );
+  };
+
   /**
    * Rewatches the given calls with retry logic.
    * @param callsToReWatch array of call IDs to rewatch
@@ -261,11 +272,22 @@ export class StreamVideoClient {
           `Rewatching calls ${callsToReWatch.join(', ')} attempt ${attempt + 1}`,
         );
 
-        await this.queryCalls({
+        const response = await this.doQueryCalls({
           watch: true,
           filter_conditions: { cid: { $in: callsToReWatch } },
         });
 
+        for (const c of response.calls) {
+          const call = this.writeableStateStore.findCall(
+            c.call.type,
+            c.call.id,
+          );
+
+          if (call) {
+            call.updateFromCallStateResponse(c);
+          }
+        }
+
         return;
       } catch (err) {
         if (err instanceof ErrorFromResponse && err.unrecoverable) {
@@ -452,12 +474,14 @@ export class StreamVideoClient {
    * Will query the API for calls matching the given filters.
    *
    * @param data the query data.
+   * @param opts additional options, for tweaking the API behavior.
    */
-  queryCalls = async (data: QueryCallsRequest = {}) => {
-    const response = await this.streamClient.post<
-      QueryCallsResponse,
-      QueryCallsRequest
-    >('/calls', data);
+  queryCalls = async (
+    data: QueryCallsRequest = {},
+    opts: { withDisabledDevices?: boolean } = {},
+  ) => {
+    const { withDisabledDevices = true } = opts;
+    const response = await this.doQueryCalls(data);
     const calls = [];
     for (const c of response.calls) {
       const call = new Call({
@@ -471,7 +495,10 @@ export class StreamVideoClient {
         clientStore: this.writeableStateStore,
       });
       call.state.updateFromCallResponse(c.call);
-      await call.applyDeviceConfig(c.call.settings, false, isReactNative());
+      await call.applyDeviceConfig(c.call.settings, {
+        publish: false,
+        withDisabledDevices,
+      });
       if (data.watch) {
         await call.setup();
         this.writeableStateStore.registerCall(call);

package/src/__tests__/Call.lifecycle.test.ts

@@ -4,27 +4,38 @@
 
 import '../rtc/__tests__/mocks/webrtc.mocks';
 
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { Call } from '../Call';
 import { StreamClient } from '../coordinator/connection/client';
 import { ClientEventReporter } from '../reporting';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
 import { StreamVideoWriteableStateStore } from '../store';
+import { promiseWithResolvers } from '../helpers/promise';
 
 describe('Call lifecycle wiring', () => {
   let call: Call;
 
   beforeEach(() => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      headers: { get: () => 'AMS1-P2' },
+    } as Response);
     const streamClient = new StreamClient('abc');
     call = new Call({
       type: 'test',
       id: generateUUIDv4(),
       streamClient,
-      clientEventReporter: new ClientEventReporter({ streamClient }),
+      clientEventReporter: new ClientEventReporter({
+        streamClient,
+        enabled: false,
+      }),
       clientStore: new StreamVideoWriteableStateStore(),
     });
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   // Regression guard for the Call-owned helper teardown chain. Each of
   // these helpers holds a resource (timer, listener, AudioContext) that
   // leaks across calls if teardown is dropped during a refactor.
@@ -67,4 +78,24 @@ describe('Call lifecycle wiring', () => {
     expect(trackSubOrder).toBeLessThan(audioBindingsOrder);
     expect(audioBindingsOrder).toBeLessThan(dynascaleOrder);
   });
+
+  it('call.join() shares an in-flight join flow', async () => {
+    const joinTask = promiseWithResolvers<void>();
+    vi.spyOn(call, 'setup').mockResolvedValue(undefined);
+    const doJoin = vi
+      .spyOn(call as unknown as { doJoin: Call['join'] }, 'doJoin')
+      .mockReturnValue(joinTask.promise);
+
+    const firstJoin = call.join();
+    const secondJoin = call.join();
+
+    await Promise.resolve();
+    expect(doJoin).toHaveBeenCalledTimes(1);
+
+    joinTask.resolve();
+    await expect(Promise.all([firstJoin, secondJoin])).resolves.toEqual([
+      undefined,
+      undefined,
+    ]);
+  });
 });

package/src/__tests__/Call.publishing.test.ts

@@ -2,7 +2,7 @@ import '../rtc/__tests__/mocks/webrtc.mocks';
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { Call } from '../Call';
-import { Publisher } from '../rtc';
+import { Publisher, Subscriber } from '../rtc';
 import { StreamClient } from '../coordinator/connection/client';
 import { ClientEventReporter } from '../reporting';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
@@ -183,6 +183,47 @@ describe('Publishing and Unpublishing tracks', () => {
       expect(participant!.audioStream).toEqual(mediaStream);
     });
 
+    it('keeps a stream the SFU already echoed back instead of the capture one', async () => {
+      // `allowOwnTracksLoopback`: the echo can land on the participant before
+      // publishing gets to write the capture stream to the same field.
+      const echoedStream = new MediaStream();
+      call.subscriber = {
+        isSelfSubscribedStream: (stream: MediaStream | undefined) =>
+          stream === echoedStream,
+      } as unknown as Subscriber;
+      call.state.updateParticipant(sessionId, { audioStream: echoedStream });
+
+      const track = new MediaStreamTrack();
+      const captureStream = new MediaStream();
+      vi.spyOn(captureStream, 'getAudioTracks').mockReturnValue([track]);
+
+      await call.publish(captureStream, TrackType.AUDIO);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant!.publishedTracks).toEqual([TrackType.AUDIO]);
+      expect(participant!.audioStream).toBe(echoedStream);
+    });
+
+    it('keeps an echoed stream when the track is unpublished', async () => {
+      // a device switch unpublishes and republishes; the echoed track goes
+      // briefly silent but is never replaced, so the reference has to survive
+      const echoedStream = new MediaStream();
+      call.subscriber = {
+        isSelfSubscribedStream: (stream: MediaStream | undefined) =>
+          stream === echoedStream,
+      } as unknown as Subscriber;
+      call.state.updateParticipant(sessionId, {
+        audioStream: echoedStream,
+        publishedTracks: [TrackType.AUDIO],
+      });
+
+      await call.stopPublish(TrackType.AUDIO);
+
+      const participant = call.state.findParticipantBySessionId(sessionId);
+      expect(participant!.publishedTracks).toEqual([]);
+      expect(participant!.audioStream).toBe(echoedStream);
+    });
+
     it('publish screen share stream', async () => {
       const track = new MediaStreamTrack();
       const mediaStream = new MediaStream();

package/src/__tests__/StreamVideoClient.api.test.ts

@@ -9,6 +9,8 @@ import {
 } from 'vitest';
 import { StreamVideoClient } from '../StreamVideoClient';
 import { Call } from '../Call';
+import { CameraManager } from '../devices/CameraManager';
+import { MicrophoneManager } from '../devices/MicrophoneManager';
 import { CallCreatedPayload } from './data';
 import { generateUUIDv4 } from '../coordinator/connection/utils';
 import type { StreamClient } from '../coordinator/connection/client';
@@ -73,6 +75,37 @@ describe('StreamVideoClient - coordinator API', () => {
     expect(call.cid).toBe(CallCreatedPayload.call.cid);
   });
 
+  it('query calls keeps devices disabled by default', async () => {
+    const response: QueryCallsResponse = {
+      duration: '1ms',
+      calls: [
+        {
+          call: CallCreatedPayload.call,
+          members: CallCreatedPayload.members,
+          own_capabilities: [],
+        },
+      ],
+    };
+    post.mockResolvedValue(response);
+    const applyCamera = vi
+      .spyOn(CameraManager.prototype, 'apply')
+      .mockResolvedValue();
+    const applyMicrophone = vi
+      .spyOn(MicrophoneManager.prototype, 'apply')
+      .mockResolvedValue();
+
+    await client.queryCalls();
+    await client.queryCalls({}, {});
+    await client.queryCalls({}, { withDisabledDevices: false });
+
+    expect(
+      applyCamera.mock.calls.map(([, , forceDisabled]) => forceDisabled),
+    ).toEqual([true, true, false]);
+    expect(
+      applyMicrophone.mock.calls.map(([, , forceDisabled]) => forceDisabled),
+    ).toEqual([true, true, false]);
+  });
+
   it('query calls - ongoing', async () => {
     post.mockResolvedValue({ duration: '1ms', calls: [] });