@stream-io/video-client 1.59.1 → 1.60.0

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

@@ -0,0 +1,71 @@
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { fromPartial } from '@total-typescript/shoehorn';
+import { Call } from '../Call';
+import { StreamClient } from '../coordinator/connection/client';
+import { ClientEventReporter } from '../reporting';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { CallingState, StreamVideoWriteableStateStore } from '../store';
+import { CallSessionResponse } from '../gen/coordinator';
+
+const ME = 'jane';
+
+// `resolveOwnRingOutcome` owns the decision and is tested on its own. This
+// covers the effect around it: that it runs for a ringing call and that the
+// `ringing` guard keeps it off every other call.
+describe('Leaving a call settled by the current user', () => {
+  let call: Call;
+
+  const createCall = async (ringing: boolean) => {
+    const clientStore = new StreamVideoWriteableStateStore();
+    const streamClient = new StreamClient('abc');
+    call = new Call({
+      type: 'test',
+      id: generateUUIDv4(),
+      streamClient,
+      clientEventReporter: new ClientEventReporter({ streamClient }),
+      clientStore,
+      ringing,
+    });
+
+    clientStore.setConnectedUser(fromPartial({ id: ME }));
+    vi.spyOn(call, 'leave').mockResolvedValue(undefined);
+    await call.setup();
+    return call;
+  };
+
+  const settleByMe = () =>
+    call.state['sessionSubject'].next(
+      fromPartial<CallSessionResponse>({
+        id: 'session-1',
+        accepted_by: {},
+        rejected_by: { [ME]: new Date().toISOString() },
+        missed_by: {},
+        participants: [],
+        participants_count_by_role: {},
+      }),
+    );
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('leaves a ringing call the current user rejected', async () => {
+    await createCall(true);
+    expect(call.state.callingState).toBe(CallingState.RINGING);
+
+    settleByMe();
+
+    expect(call.leave).toHaveBeenCalled();
+  });
+
+  it('ignores the same session on a call that is not ringing', async () => {
+    await createCall(false);
+    expect(call.state.callingState).toBe(CallingState.IDLE);
+
+    settleByMe();
+
+    expect(call.leave).not.toHaveBeenCalled();
+  });
+});

package/src/__tests__/StreamSfuClient.test.ts

@@ -3,6 +3,8 @@ import { StreamSfuClient } from '../StreamSfuClient';
 import { Dispatcher } from '../rtc';
 import { StreamClient } from '../coordinator/connection/client';
 import { getTimers } from '../timers';
+import { getSdkInfo, setSdkInfo } from '../helpers/client-details';
+import { SdkType } from '../gen/video/sfu/models/models';
 
 /**
  * Minimal `WebSocket` stub used to drive `StreamSfuClient.close()` while the
@@ -431,3 +433,49 @@ describe('StreamSfuClient.leaveAndClose()', () => {
     expect(notifyLeaveSpy).not.toHaveBeenCalled();
   });
 });
+
+describe('StreamSfuClient RPC headers', () => {
+  beforeEach(() => {
+    CapturingWebSocket.instances = [];
+    vi.stubGlobal('WebSocket', CapturingWebSocket);
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.restoreAllMocks();
+  });
+
+  it('identifies the SDK and its version in every RPC request', async () => {
+    const sdkInfo = getSdkInfo();
+    setSdkInfo({
+      type: SdkType.REACT,
+      major: '1',
+      minor: '2',
+      patch: '3',
+    });
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValue(
+        new Response('{}', { headers: { 'content-type': 'application/json' } }),
+      );
+    vi.stubGlobal('fetch', fetchMock);
+
+    try {
+      const sfuClient = buildSfuClient();
+      (
+        sfuClient as unknown as {
+          joinResponseTask: { resolve: (v: unknown) => void };
+        }
+      ).joinResponseTask.resolve({});
+
+      await sfuClient.startNoiseCancellation();
+
+      const [, init] = fetchMock.mock.calls[0];
+      expect(new Headers(init.headers).get('x-stream-client')).toBe(
+        'stream-video-react-v1.2.3',
+      );
+    } finally {
+      setSdkInfo(sdkInfo!);
+    }
+  });
+});

package/src/coordinator/connection/types.ts

@@ -200,6 +200,18 @@ export type Logger = (
   ...args: unknown[]
 ) => void;
 
+export type RingStatePollingOptions = {
+  /**
+   * Quiet time after the ring starts, before the first poll. Defaults to 15_000.
+   */
+  startAfterMs?: number;
+
+  /**
+   * The interval between polls. Defaults to 5_000.
+   */
+  intervalMs?: number;
+};
+
 export type StreamClientOptions = Partial<AxiosRequestConfig> & {
   /**
    * Used to disable warnings that are triggered by using connectUser or connectAnonymousUser server-side.
@@ -305,6 +317,13 @@ export type StreamClientOptions = Partial<AxiosRequestConfig> & {
    */
   rejectCallWhenBusy?: boolean;
 
+  /**
+   * Caller-side polling for the ring outcome, used when the `call.accepted`,
+   * `call.rejected` or `call.missed` event never arrives. Enabled by default;
+   * set to `false` to disable, or pass an object to tune the timings.
+   */
+  ringStatePolling?: false | RingStatePollingOptions;
+
   /**
    * Device persistence preference options (web only).
    */

package/src/events/__tests__/call.test.ts

@@ -1,16 +1,8 @@
 import { describe, expect, it, vi } from 'vitest';
-import { fromPartial } from '@total-typescript/shoehorn';
 import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { watchCallEnded, watchSfuCallEnded } from '../call';
 import {
-  watchCallAccepted,
-  watchCallEnded,
-  watchCallRejected,
-  watchSfuCallEnded,
-} from '../call';
-import {
-  CallAcceptedEvent,
   CallEndedEvent,
-  CallResponse,
   OwnCapability,
   RejectCallResponse,
 } from '../../gen/coordinator';
@@ -20,189 +12,7 @@ import { ClientEventReporter } from '../../reporting';
 import { SfuEvent } from '../../gen/video/sfu/event/events';
 import { CallEndedReason } from '../../gen/video/sfu/models/models';
 
-describe('Call ringing events', () => {
-  describe(`call.accepted`, () => {
-    it(`will ignore events from the current user`, async () => {
-      const call = fakeCall();
-      vi.spyOn(call, 'join');
-      const handler = watchCallAccepted(call);
-      const event: CallAcceptedEvent = {
-        type: 'call.accepted',
-        // @ts-expect-error incomplete data
-        user: { id: 'test-user-id' },
-      };
-      await handler(event);
-
-      expect(call.join).not.toHaveBeenCalled();
-    });
-
-    it(`will join the call for the caller if atleast one callee has accepted`, async () => {
-      const call = fakeCall({ currentUserId: 'test-user' });
-      vi.spyOn(call, 'join').mockImplementation(async () => {
-        console.log(`TEST: join() called`);
-      });
-      const handler = watchCallAccepted(call);
-      const event: CallAcceptedEvent = {
-        type: 'call.accepted',
-        // @ts-expect-error incomplete data
-        user: { id: 'test-user-id-callee' },
-        // @ts-expect-error incomplete data
-        call: { created_by: { id: 'test-user' } },
-      };
-      await handler(event);
-
-      expect(call.join).toHaveBeenCalled();
-    });
-  });
-
-  it('will not join the call for the other callee automatically when someone accepts', async () => {
-    const call = fakeCall({ currentUserId: 'test-user-id-callee-2' });
-    vi.spyOn(call, 'join').mockImplementation(async () => {
-      console.log(`TEST: join() called`);
-    });
-    const handler = watchCallAccepted(call);
-    const event: CallAcceptedEvent = {
-      type: 'call.accepted',
-      // @ts-expect-error incomplete data
-      user: { id: 'test-user-id-callee-1' },
-      // @ts-expect-error incomplete data
-      call: { created_by: { id: 'test-user-id-caller' } },
-    };
-
-    await handler(event);
-
-    expect(call.join).not.toHaveBeenCalled();
-  });
-
-  describe(`call.rejected`, () => {
-    it(`caller will leave the call if all callees have rejected`, async () => {
-      const call = fakeCall({ currentUserId: 'm1' });
-      call.state.updateFromCallResponse({
-        ...fakeMetadata(),
-        // @ts-expect-error type issue
-        created_by: { id: 'm1' },
-      });
-      call.state.setMembers([
-        // @ts-expect-error incomplete data
-        { user_id: 'm1' },
-        // @ts-expect-error incomplete data
-        { user_id: 'm2' },
-        // @ts-expect-error incomplete data
-        { user_id: 'm3' },
-      ]);
-      call.state.setCallingState(CallingState.RINGING);
-      vi.spyOn(call, 'leave').mockImplementation(async () => {
-        console.log(`TEST: leave() called`);
-      });
-
-      const handler = watchCallRejected(call);
-      // all members reject the call
-      await handler({
-        type: 'call.rejected',
-        // @ts-expect-error type issue
-        user: {
-          id: 'm2',
-        },
-        call: {
-          // @ts-expect-error type issue
-          created_by: {
-            id: 'm1',
-          },
-          // @ts-expect-error type issue
-          session: {
-            rejected_by: {
-              m2: new Date().toISOString(),
-              m3: new Date().toISOString(),
-            },
-          },
-        },
-      });
-      expect(call.leave).toHaveBeenCalledWith({
-        reject: true,
-        reason: 'cancel',
-        message: 'ring: everyone rejected',
-      });
-    });
-
-    it(`caller will not leave the call if only one callee rejects`, async () => {
-      const call = fakeCall();
-      call.state.updateFromCallResponse({
-        ...fakeMetadata(),
-        // @ts-expect-error type issue
-        created_by: { id: 'm0' },
-      });
-      // @ts-expect-error incomplete data
-      call.state.setMembers([{ user_id: 'm1' }, { user_id: 'm2' }]);
-      vi.spyOn(call, 'leave').mockImplementation(async () => {
-        console.log(`TEST: leave() called`);
-      });
-      const handler = watchCallRejected(call);
-
-      // only one member rejects the call
-      const event: CallAcceptedEvent = {
-        type: 'call.rejected',
-        // @ts-expect-error type issue
-        user: {
-          id: 'm2',
-        },
-        call: {
-          // @ts-expect-error type issue
-          created_by: {
-            id: 'm0',
-          },
-          // @ts-expect-error type issue
-          session: {
-            rejected_by: {
-              m2: new Date().toISOString(),
-            },
-          },
-        },
-      };
-      await handler(event);
-
-      expect(call.leave).not.toHaveBeenCalled();
-    });
-
-    it('callee will leave the call if caller rejects', async () => {
-      const call = fakeCall({ currentUserId: 'm1' });
-      call.state.updateFromCallResponse({
-        ...fakeMetadata(),
-        // @ts-expect-error type issue
-        created_by: { id: 'm0' },
-      });
-      // @ts-expect-error incomplete data
-      call.state.setMembers([{ user_id: 'm1' }, { user_id: 'm2' }]);
-      vi.spyOn(call, 'leave').mockImplementation(async () => {
-        console.log(`TEST: leave() called`);
-      });
-      const handler = watchCallRejected(call);
-
-      // only one member rejects the call
-      const event: CallAcceptedEvent = {
-        type: 'call.rejected',
-        // @ts-expect-error type issue
-        user: {
-          id: 'm0',
-        },
-        call: {
-          // @ts-expect-error type issue
-          created_by: {
-            id: 'm0',
-          },
-          // @ts-expect-error type issue
-          session: {
-            rejected_by: {
-              m0: new Date().toISOString(),
-            },
-          },
-        },
-      };
-      await handler(event);
-
-      expect(call.leave).toHaveBeenCalled();
-    });
-  });
-
+describe('Call lifecycle events', () => {
   describe(`call.ended`, () => {
     it(`will leave the call unless joined`, async () => {
       const call = fakeCall();
@@ -377,28 +187,3 @@ const fakeCall = ({ ring = true, currentUserId = 'test-user-id' } = {}) => {
     ringing: ring,
   });
 };
-
-const fakeMetadata = (): CallResponse => {
-  return fromPartial({
-    id: '12345',
-    type: 'development',
-    cid: 'development:12345',
-
-    created_by: {
-      id: 'test-user-id',
-    },
-    blocked_user_ids: [],
-    egress: {},
-
-    settings: {
-      ring: {
-        auto_cancel_timeout_ms: 30000,
-        incoming_call_timeout_ms: 30000,
-        missed_call_timeout_ms: 30000,
-      },
-      screensharing: {
-        target_resolution: undefined,
-      },
-    },
-  });
-};

package/src/events/call.ts

@@ -1,81 +1,9 @@
 import { CallingState } from '../store';
 import { Call } from '../Call';
-import {
-  CallAcceptedEvent,
-  CallRejectedEvent,
-  OwnCapability,
-} from '../gen/coordinator';
+import { OwnCapability } from '../gen/coordinator';
 import { CallEnded } from '../gen/video/sfu/event/events';
 import { CallEndedReason } from '../gen/video/sfu/models/models';
 
-/**
- * Event handler that watched the delivery of `call.accepted`.
- * Once the event is received, the call is joined.
- */
-export const watchCallAccepted = (call: Call) => {
-  return async function onCallAccepted(event: CallAcceptedEvent) {
-    // We want to discard the event if it's from the current user
-    if (event.user.id === call.currentUserId) return;
-    const { state } = call;
-    if (
-      event.call.created_by.id === call.currentUserId &&
-      state.callingState === CallingState.RINGING
-    ) {
-      await call.join();
-    }
-  };
-};
-
-/**
- * Event handler that watches delivery of `call.rejected` Websocket event.
- * Once the event is received, the call is left.
- */
-export const watchCallRejected = (call: Call) => {
-  return async function onCallRejected(event: CallRejectedEvent) {
-    // We want to discard the event if it's from the current user
-    if (event.user.id === call.currentUserId) return;
-    const { call: eventCall } = event;
-    const { session: callSession } = eventCall;
-
-    if (!callSession) {
-      call.logger.warn(
-        'No call session provided. Ignoring call.rejected event.',
-        event,
-      );
-      return;
-    }
-
-    const rejectedBy = callSession.rejected_by;
-    const { members, callingState } = call.state;
-    if (callingState !== CallingState.RINGING) {
-      call.logger.info(
-        'Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.',
-        event,
-      );
-      return;
-    }
-    if (call.isCreatedByMe) {
-      const everyoneElseRejected = members
-        .filter((m) => m.user_id !== call.currentUserId)
-        .every((m) => rejectedBy[m.user_id]);
-      if (everyoneElseRejected) {
-        call.logger.info('everyone rejected, leaving the call');
-        await call.leave({
-          reject: true,
-          reason: 'cancel',
-          message: 'ring: everyone rejected',
-        });
-      }
-    } else {
-      if (rejectedBy[eventCall.created_by.id]) {
-        call.logger.info('call creator rejected, leaving call');
-        globalThis.streamRNVideoSDK?.callingX?.endCall(call, 'remote');
-        await call.leave({ message: 'ring: creator rejected' });
-      }
-    }
-  };
-};
-
 /**
  * Event handler that watches the delivery of `call.ended` Websocket event.
  */

package/src/events/callEventHandlers.ts

@@ -1,12 +1,11 @@
 import { Call } from '../Call';
+import { reconcileRingState } from '../ringing';
 import { Dispatcher } from '../rtc';
 import {
   handleRemoteSoftMute,
   watchAudioLevelChanged,
-  watchCallAccepted,
   watchCallEnded,
   watchCallGrantsUpdated,
-  watchCallRejected,
   watchConnectionQualityChanged,
   watchDominantSpeakerChanged,
   watchInboundStateNotification,
@@ -21,16 +20,6 @@ import {
   watchTrackPublished,
   watchTrackUnpublished,
 } from '../events';
-import {
-  AllCallEvents,
-  AllClientCallEvents,
-  CallEventListener,
-} from '../coordinator/connection/types';
-
-type RingCallEvents = Extract<
-  AllClientCallEvents,
-  'call.accepted' | 'call.rejected' | 'call.missed'
->;
 
 /**
  * Registers the default event handlers for a call during its lifecycle.
@@ -83,19 +72,19 @@ export const registerEventHandlers = (call: Call, dispatcher: Dispatcher) => {
  * @param call the call to register event handlers for.
  */
 export const registerRingingCallEventHandlers = (call: Call) => {
-  const coordinatorRingEvents: {
-    [key in RingCallEvents]: (
-      call: Call,
-    ) => CallEventListener<AllCallEvents[key]>;
-  } = {
-    'call.accepted': watchCallAccepted(call),
-    'call.rejected': watchCallRejected(call),
+  const reconcile = () => {
+    reconcileRingState(call, 'ring-ws').catch((err) => {
+      call.logger.error('Failed to reconcile the ring state', err);
+    });
   };
 
-  const eventHandlers = Object.keys(coordinatorRingEvents).map((event) => {
-    const eventName = event as RingCallEvents;
-    return call.on(eventName, coordinatorRingEvents[eventName]);
-  });
+  // each event needs its own closure. `call.missed` is deliberately absent:
+  // nothing in the reconciler acts on `missed_by`, so the auto-drop owns the
+  // "nobody answered" case until the server-owned ring timeout lands.
+  const eventHandlers = [
+    call.on('call.accepted', () => reconcile()),
+    call.on('call.rejected', () => reconcile()),
+  ];
 
   return () => {
     eventHandlers.forEach((unsubscribe) => unsubscribe());

package/src/gen/coordinator/index.ts

@@ -5130,6 +5130,73 @@ export interface GetCallResponse {
    */
   own_capabilities: Array<OwnCapability>;
 }
+/**
+ * The ring state of a call session: who accepted, rejected, or missed the ring.
+ * @export
+ * @interface GetCallRingStateResponse
+ */
+export interface GetCallRingStateResponse {
+  /**
+   * Users that accepted the call, mapped to when they accepted
+   * @type {{ [key: string]: string; }}
+   * @memberof GetCallRingStateResponse
+   */
+  accepted_by: { [key: string]: string };
+  /**
+   * The CID of the call
+   * @type {string}
+   * @memberof GetCallRingStateResponse
+   */
+  call_cid: string;
+  /**
+   * When the call ended
+   * @type {string}
+   * @memberof GetCallRingStateResponse
+   */
+  call_ended_at?: string;
+  /**
+   * The user that created the call, i.e. the caller
+   * @type {string}
+   * @memberof GetCallRingStateResponse
+   */
+  created_by_user_id: string;
+  /**
+   * Duration of the request in milliseconds
+   * @type {string}
+   * @memberof GetCallRingStateResponse
+   */
+  duration: string;
+  /**
+   * Users that missed the call, mapped to when they were marked as missed
+   * @type {{ [key: string]: string; }}
+   * @memberof GetCallRingStateResponse
+   */
+  missed_by: { [key: string]: string };
+  /**
+   * Users that rejected the call, mapped to when they rejected
+   * @type {{ [key: string]: string; }}
+   * @memberof GetCallRingStateResponse
+   */
+  rejected_by: { [key: string]: string };
+  /**
+   * When the call session ended
+   * @type {string}
+   * @memberof GetCallRingStateResponse
+   */
+  session_ended_at?: string;
+  /**
+   * The call session this state belongs to, empty when the call has never rung
+   * @type {string}
+   * @memberof GetCallRingStateResponse
+   */
+  session_id: string;
+  /**
+   * When the call session started
+   * @type {string}
+   * @memberof GetCallRingStateResponse
+   */
+  session_started_at?: string;
+}
 /**
  * Basic response information
  * @export