@stream-io/video-client 1.59.0 → 1.60.0

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

package/src/reporting/ClientEventReporter.ts

@@ -45,6 +45,13 @@ export type ReportedIceState = 'CONNECTED' | 'FAILED' | 'NOT_CONNECTED';
 export type JoinReason =
   'first-attempt' | 'network-available' | 'migration' | 'full-rejoin';
 
+/**
+ * What triggered an automatic join, reported as `source` on the call's
+ * CoordinatorJoin events. `ring-ws` is a ring WebSocket event, `ring-poll-api`
+ * is the ring state poller.
+ */
+export type JoinSource = 'ring-ws' | 'ring-poll-api';
+
 export type ClientEventStandardCode =
   | 'CLIENT_ABORTED'
   | 'BACKEND_LEAVE'
@@ -67,6 +74,9 @@ export type ClientEventReporterOptions = {
   enabled?: boolean;
 };
 
+// TODO OL: update OpenAPI
+type ReportedClientEvent = ClientEvent & { source?: JoinSource };
+
 type StageError = {
   reason: string;
   code: string;
@@ -78,6 +88,7 @@ type StagePairState = {
   startedAt: number;
   joinAttemptIdSnapshot?: string;
   joinReasonSnapshot?: JoinReason;
+  joinSourceSnapshot?: JoinSource;
   userIdSnapshot?: string;
   lastError?: StageError;
 };
@@ -104,6 +115,7 @@ export class ClientEventReporter {
   private callContexts = new Map<string, CallReportContext>();
   private joinAttemptIds = new Map<string, string>();
   private joinReasons = new Map<string, JoinReason>();
+  private joinSources = new Map<string, JoinSource>();
   private coordinatorPairs = new Map<string, StagePairState>();
   private wsPairs = new Map<string, StagePairState>();
 
@@ -238,6 +250,7 @@ export class ClientEventReporter {
     this.callContexts.delete(cid);
     this.joinAttemptIds.delete(cid);
     this.joinReasons.delete(cid);
+    this.joinSources.delete(cid);
     this.coordinatorPairs.delete(cid);
     this.wsPairs.delete(cid);
 
@@ -269,15 +282,22 @@ export class ClientEventReporter {
 
   withJoinLifecycle = async <T>(
     cid: string,
-    joinReason: JoinReason,
+    options: { joinReason: JoinReason; joinSource?: JoinSource },
     op: () => Promise<T>,
   ): Promise<T> => {
+    const { joinReason, joinSource } = options;
+
+    if (joinSource) this.joinSources.set(cid, joinSource);
+    else this.joinSources.delete(cid);
+
     this.startCorrelation(cid, joinReason);
     try {
       return await op();
     } catch (err) {
       this.closeCallPairs(cid);
       throw err;
+    } finally {
+      this.joinSources.delete(cid);
     }
   };
 
@@ -436,6 +456,7 @@ export class ClientEventReporter {
         startedAt: Date.now(),
         joinAttemptIdSnapshot: this.joinAttemptIds.get(cid),
         joinReasonSnapshot: this.joinReasons.get(cid),
+        joinSourceSnapshot: this.joinSources.get(cid),
       };
       this.coordinatorPairs.set(cid, pair);
       this.sendForCall(cid, {
@@ -443,6 +464,7 @@ export class ClientEventReporter {
         ...(pair.joinReasonSnapshot && {
           join_reason: pair.joinReasonSnapshot,
         }),
+        ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
         event_type: 'initiated',
       });
     }
@@ -457,6 +479,7 @@ export class ClientEventReporter {
       ...this.buildCommon(cid, 'CoordinatorJoin', pair),
       ...this.sessionIdField(cid),
       ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
+      ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
       event_type: 'completed',
       outcome: 'success',
       retry_count_attempt: pair.attempts - 1,
@@ -476,6 +499,7 @@ export class ClientEventReporter {
       ...this.buildCommon(cid, 'CoordinatorJoin', pair),
       ...this.sessionIdField(cid),
       ...(pair.joinReasonSnapshot && { join_reason: pair.joinReasonSnapshot }),
+      ...(pair.joinSourceSnapshot && { source: pair.joinSourceSnapshot }),
       event_type: 'completed',
       outcome: 'failure',
       retry_count_attempt: pair.attempts - 1,
@@ -705,17 +729,19 @@ export class ClientEventReporter {
     };
   };
 
-  private send = (body: ClientEvent) => {
+  private send = (body: ReportedClientEvent) => {
     if (!this.enabled) return;
     void this.sendWithRetry(body);
   };
 
-  private sendForCall = (cid: string, body: ClientEvent) => {
+  private sendForCall = (cid: string, body: ReportedClientEvent) => {
     if (!this.callContexts.has(cid)) return;
     this.send(body);
   };
 
-  private sendWithRetry = async (body: ClientEvent): Promise<boolean> => {
+  private sendWithRetry = async (
+    body: ReportedClientEvent,
+  ): Promise<boolean> => {
     for (let attempt = 0; attempt < 5; attempt++) {
       try {
         await this.streamClient.doAxiosRequest<