@stream-io/video-client 0.0.2-alpha.2 → 0.0.2-alpha.20

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

@@ -13,6 +13,7 @@ import {
 import {
   CallAcceptedEvent,
   CallEndedEvent,
+  CallResponse,
   CallUpdatedEvent,
 } from '../../gen/coordinator';
 import { Call } from '../../Call';
@@ -93,28 +94,58 @@ describe('Call ringing events', () => {
   });
 
   describe(`call.rejected`, () => {
-    it(`will leave the call if all callees have rejected`, async () => {
-      const call = fakeCall();
-      // @ts-expect-error
-      call.state.setMembers([{ user_id: 'm1' }, { user_id: 'm2' }]);
+    it(`caller will leave the call if all callees have rejected`, async () => {
+      const call = fakeCall({ currentUserId: 'm1' });
+      call.state.setMetadata({
+        ...fakeMetadata(),
+        // @ts-ignore
+        created_by: { id: 'm1' },
+      });
+      call.state.setMembers([
+        // @ts-expect-error
+        { user_id: 'm1' },
+        // @ts-expect-error
+        { user_id: 'm2' },
+        // @ts-expect-error
+        { 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
-      call.state.members.forEach(() => {
-        // @ts-ignore
-        const event: CallAcceptedEvent = { type: 'call.rejected' };
+      await handler({
+        type: 'call.rejected',
         // @ts-ignore
-        handler(event);
+        user: {
+          id: 'm2',
+        },
+        call: {
+          // @ts-ignore
+          created_by: {
+            id: 'm1',
+          },
+          // @ts-ignore
+          session: {
+            rejected_by: {
+              m2: new Date().toISOString(),
+              m3: new Date().toISOString(),
+            },
+          },
+        },
       });
-
       expect(call.leave).toHaveBeenCalled();
     });
 
-    it(`will not leave the call if only one callee rejects`, async () => {
+    it(`caller will not leave the call if only one callee rejects`, async () => {
       const call = fakeCall();
+      call.state.setMetadata({
+        ...fakeMetadata(),
+        // @ts-ignore
+        created_by: { id: 'm0' },
+      });
       // @ts-expect-error
       call.state.setMembers([{ user_id: 'm1' }, { user_id: 'm2' }]);
       vi.spyOn(call, 'leave').mockImplementation(async () => {
@@ -124,12 +155,71 @@ describe('Call ringing events', () => {
 
       // only one member rejects the call
       // @ts-ignore
-      const event: CallAcceptedEvent = { type: 'call.rejected' };
+      const event: CallAcceptedEvent = {
+        type: 'call.rejected',
+        // @ts-ignore
+        user: {
+          id: 'm2',
+        },
+        call: {
+          // @ts-ignore
+          created_by: {
+            id: 'm0',
+          },
+          // @ts-ignore
+          session: {
+            rejected_by: {
+              m2: new Date().toISOString(),
+            },
+          },
+        },
+      };
       // @ts-ignore
       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.setMetadata({
+        ...fakeMetadata(),
+        // @ts-ignore
+        created_by: { id: 'm0' },
+      });
+      // @ts-expect-error
+      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
+      // @ts-ignore
+      const event: CallAcceptedEvent = {
+        type: 'call.rejected',
+        // @ts-ignore
+        user: {
+          id: 'm0',
+        },
+        call: {
+          // @ts-ignore
+          created_by: {
+            id: 'm0',
+          },
+          // @ts-ignore
+          session: {
+            rejected_by: {
+              m0: new Date().toISOString(),
+            },
+          },
+        },
+      };
+      // @ts-ignore
+      await handler(event);
+
+      expect(call.leave).toHaveBeenCalled();
+    });
   });
 
   describe(`call.ended`, () => {
@@ -171,8 +261,7 @@ describe('Call ringing events', () => {
     });
 
     it(`will not leave the call if idle`, async () => {
-      const ringing = false;
-      const call = fakeCall(ringing);
+      const call = fakeCall({ ring: false });
       vi.spyOn(call, 'leave').mockImplementation(async () => {
         console.log(`TEST: leave() called`);
       });
@@ -189,10 +278,10 @@ describe('Call ringing events', () => {
   });
 });
 
-const fakeCall = (ring = true) => {
+const fakeCall = ({ ring = true, currentUserId = 'test-user-id' } = {}) => {
   const store = new StreamVideoWriteableStateStore();
   store.setConnectedUser({
-    id: 'test-user-id',
+    id: currentUserId,
   });
   const client = new StreamClient('api-key');
   return new Call({
@@ -203,3 +292,26 @@ const fakeCall = (ring = true) => {
     ringing: ring,
   });
 };
+
+const fakeMetadata = (): CallResponse => {
+  return {
+    id: '12345',
+    type: 'development',
+    cid: 'development:12345',
+
+    // @ts-ignore
+    created_by: {
+      id: 'test-user-id',
+    },
+    own_capabilities: [],
+    blocked_user_ids: [],
+
+    // @ts-ignore
+    settings: {
+      ring: {
+        auto_cancel_timeout_ms: 30000,
+        incoming_call_timeout_ms: 30000,
+      },
+    },
+  };
+};

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

@@ -24,7 +24,6 @@ describe('call.session events', () => {
 
     expect(state.metadata).toEqual({
       cid: 'cid',
-      own_capabilities: [],
       session: {
         id: 'session-id',
       },
@@ -46,7 +45,6 @@ describe('call.session events', () => {
     });
     expect(state.metadata).toEqual({
       cid: 'cid',
-      own_capabilities: [],
       session: {
         id: 'session-id',
       },

package/src/events/call-permissions.ts

@@ -22,10 +22,7 @@ export const watchCallPermissionsUpdated = (state: CallState) => {
     if (event.type !== 'call.permissions_updated') return;
     const { localParticipant } = state;
     if (event.user.id === localParticipant?.userId) {
-      state.setMetadata((metadata) => ({
-        ...metadata!,
-        own_capabilities: event.own_capabilities,
-      }));
+      state.setOwnCapabilities(event.own_capabilities);
     }
   };
 };
@@ -49,7 +46,7 @@ export const watchCallGrantsUpdated = (state: CallState) => {
         [OwnCapability.SCREENSHARE]: canScreenshare,
       };
 
-      const nextCapabilities = (state.metadata?.own_capabilities || []).filter(
+      const nextCapabilities = state.ownCapabilities.filter(
         (capability) => update[capability] !== false,
       );
       Object.entries(update).forEach(([capability, value]) => {
@@ -58,12 +55,7 @@ export const watchCallGrantsUpdated = (state: CallState) => {
         }
       });
 
-      state.setMetadata((metadata) => {
-        return {
-          ...metadata!,
-          own_capabilities: nextCapabilities,
-        };
-      });
+      state.setOwnCapabilities(nextCapabilities);
     }
   };
 };

package/src/events/call.ts

@@ -27,16 +27,39 @@ export const watchCallAccepted = (call: Call) => {
  * Once the event is received, the call is left.
  */
 export const watchCallRejected = (call: Call) => {
-  let totalRejections = 0;
   return async function onCallRejected(event: StreamVideoEvent) {
     if (event.type !== 'call.rejected') return;
-    totalRejections++;
-    const { state } = call;
-    if (
-      totalRejections >= state.members.length &&
-      state.callingState === CallingState.RINGING
-    ) {
-      await call.leave();
+    // 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) {
+      console.log('No call session provided. Ignoring call.rejected event.');
+      return;
+    }
+
+    const rejectedBy = callSession.rejected_by;
+    const { members, callingState } = call.state;
+    if (callingState !== CallingState.RINGING) {
+      console.log(
+        'Call is not in ringing mode (it is either accepted or rejected already). Ignoring call.rejected event.',
+      );
+      return;
+    }
+    if (call.isCreatedByMe) {
+      const everyoneElseRejected = members
+        .filter((m) => m.user_id !== call.currentUserId)
+        .every((m) => rejectedBy[m.user_id]);
+      if (everyoneElseRejected) {
+        console.log('everyone rejected, leaving the call');
+        await call.leave();
+      }
+    } else {
+      if (rejectedBy[eventCall.created_by.id]) {
+        console.log('call creator rejected, leaving call');
+        await call.leave();
+      }
     }
   };
 };

package/src/events/callEventHandlers.ts

@@ -45,13 +45,22 @@ type RingCallEvents = Extract<
   'call.accepted' | 'call.rejected'
 >;
 
-// call.created is handled by the StreamVideoClient
-// custom events should be handled by integrators
 type AllCallEvents = Exclude<
   CallEventTypes,
-  'call.created' | 'custom' | RingCallEvents
+  | 'call.created' // handled by StreamVideoClient
+  | 'call.ring' // handled by StreamVideoClient
+  | 'call.notification' // not used currently
+  | 'custom' // integrators should handle custom events
+  | RingCallEvents // handled by registerRingingCallEventHandlers
 >;
 
+/**
+ * Registers the default event handlers for a call during its lifecycle.
+ *
+ * @param call the call to register event handlers for.
+ * @param state the call state.
+ * @param dispatcher the dispatcher.
+ */
 export const registerEventHandlers = (
   call: Call,
   state: CallState,
@@ -80,10 +89,6 @@ export const registerEventHandlers = (
     'call.session_participant_left': watchCallSessionParticipantLeft(state),
     'call.unblocked_user': watchUnblockedUser(state),
     'call.updated': watchCallUpdated(state),
-    'call.notification': (event: StreamCallEvent) =>
-      console.log(`Received ${event.type} event`, event),
-    'call.ring': (event: StreamCallEvent) =>
-      console.log(`Received ${event.type} event`, event),
   };
   const eventHandlers = [
     watchChangePublishQuality(dispatcher, call),
@@ -117,6 +122,11 @@ export const registerEventHandlers = (
   };
 };
 
+/**
+ * Registers event handlers for a call that is of ringing type.
+ *
+ * @param call the call to register event handlers for.
+ */
 export const registerRingingCallEventHandlers = (call: Call) => {
   const coordinatorRingEvents: {
     [key in RingCallEvents]: (e: StreamCallEvent) => any;

package/src/events/sessions.ts

@@ -9,12 +9,7 @@ import { StreamVideoEvent } from '../coordinator/connection/types';
 export const watchCallSessionStarted = (state: CallState) => {
   return function onCallSessionStarted(event: StreamVideoEvent) {
     if (event.type !== 'call.session_started') return;
-    const { call } = event;
-    state.setMetadata((metadata) => ({
-      ...call,
-      // FIXME OL: temporary, until the backend sends the own_capabilities
-      own_capabilities: metadata?.own_capabilities || [],
-    }));
+    state.setMetadata(event.call);
   };
 };
 
@@ -26,12 +21,7 @@ export const watchCallSessionStarted = (state: CallState) => {
 export const watchCallSessionEnded = (state: CallState) => {
   return function onCallSessionEnded(event: StreamVideoEvent) {
     if (event.type !== 'call.session_ended') return;
-    const { call } = event;
-    state.setMetadata((metadata) => ({
-      ...call,
-      // FIXME OL: temporary, until the backend sends the own_capabilities
-      own_capabilities: metadata?.own_capabilities || [],
-    }));
+    state.setMetadata(event.call);
   };
 };
 

package/src/gen/coordinator/index.ts

@@ -708,6 +708,12 @@ export interface CallNotificationEvent {
    * @memberof CallNotificationEvent
    */
   created_at: string;
+  /**
+   * Call members
+   * @type {Array<MemberResponse>}
+   * @memberof CallNotificationEvent
+   */
+  members: Array<MemberResponse>;
   /**
    * Call session ID
    * @type {string}
@@ -1022,12 +1028,6 @@ export interface CallResponse {
    * @memberof CallResponse
    */
   ingress: CallIngressResponse;
-  /**
-   * The capabilities of the current user
-   * @type {Array<OwnCapability>}
-   * @memberof CallResponse
-   */
-  own_capabilities: Array<OwnCapability>;
   /**
    *
    * @type {boolean}
@@ -1101,6 +1101,12 @@ export interface CallRingEvent {
    * @memberof CallRingEvent
    */
   created_at: string;
+  /**
+   * Call members
+   * @type {Array<MemberResponse>}
+   * @memberof CallRingEvent
+   */
+  members: Array<MemberResponse>;
   /**
    * Call session ID
    * @type {string}
@@ -1463,6 +1469,12 @@ export interface CallStateResponseFields {
    * @memberof CallStateResponseFields
    */
   membership?: MemberResponse;
+  /**
+   *
+   * @type {Array<OwnCapability>}
+   * @memberof CallStateResponseFields
+   */
+  own_capabilities: Array<OwnCapability>;
 }
 /**
  *
@@ -2036,62 +2048,6 @@ export interface GeofenceSettingsRequest {
    */
   names?: Array<string>;
 }
-/**
- *
- * @export
- * @interface GetCallEdgeServerRequest
- */
-export interface GetCallEdgeServerRequest {
-  /**
-   *
-   * @type {{ [key: string]: Array<number>; }}
-   * @memberof GetCallEdgeServerRequest
-   */
-  latency_measurements: { [key: string]: Array<number> };
-}
-/**
- *
- * @export
- * @interface GetCallEdgeServerResponse
- */
-export interface GetCallEdgeServerResponse {
-  /**
-   *
-   * @type {Array<UserResponse>}
-   * @memberof GetCallEdgeServerResponse
-   */
-  blocked_users: Array<UserResponse>;
-  /**
-   *
-   * @type {CallResponse}
-   * @memberof GetCallEdgeServerResponse
-   */
-  call: CallResponse;
-  /**
-   *
-   * @type {Credentials}
-   * @memberof GetCallEdgeServerResponse
-   */
-  credentials: Credentials;
-  /**
-   * Duration of the request in human-readable format
-   * @type {string}
-   * @memberof GetCallEdgeServerResponse
-   */
-  duration: string;
-  /**
-   *
-   * @type {Array<MemberResponse>}
-   * @memberof GetCallEdgeServerResponse
-   */
-  members: Array<MemberResponse>;
-  /**
-   *
-   * @type {MemberResponse}
-   * @memberof GetCallEdgeServerResponse
-   */
-  membership?: MemberResponse;
-}
 /**
  *
  * @export
@@ -2128,6 +2084,12 @@ export interface GetCallResponse {
    * @memberof GetCallResponse
    */
   membership?: MemberResponse;
+  /**
+   *
+   * @type {Array<OwnCapability>}
+   * @memberof GetCallResponse
+   */
+  own_capabilities: Array<OwnCapability>;
 }
 /**
  *
@@ -2270,6 +2232,12 @@ export interface GetOrCreateCallResponse {
    * @memberof GetOrCreateCallResponse
    */
   membership?: MemberResponse;
+  /**
+   *
+   * @type {Array<OwnCapability>}
+   * @memberof GetOrCreateCallResponse
+   */
+  own_capabilities: Array<OwnCapability>;
 }
 /**
  *
@@ -2456,6 +2424,12 @@ export interface JoinCallResponse {
    * @memberof JoinCallResponse
    */
   membership?: MemberResponse;
+  /**
+   *
+   * @type {Array<OwnCapability>}
+   * @memberof JoinCallResponse
+   */
+  own_capabilities: Array<OwnCapability>;
 }
 /**
  *
@@ -3213,12 +3187,6 @@ export interface RingSettings {
    * @memberof RingSettings
    */
   auto_cancel_timeout_ms: number;
-  /**
-   *
-   * @type {number}
-   * @memberof RingSettings
-   */
-  auto_reject_timeout_ms: number;
   /**
    *
    * @type {number}
@@ -3238,12 +3206,6 @@ export interface RingSettingsRequest {
    * @memberof RingSettingsRequest
    */
   auto_cancel_timeout_ms?: number;
-  /**
-   *
-   * @type {number}
-   * @memberof RingSettingsRequest
-   */
-  auto_reject_timeout_ms?: number;
   /**
    *
    * @type {number}
@@ -3745,6 +3707,12 @@ export interface UpdateCallRequest {
  * @interface UpdateCallResponse
  */
 export interface UpdateCallResponse {
+  /**
+   *
+   * @type {Array<UserResponse>}
+   * @memberof UpdateCallResponse
+   */
+  blocked_users: Array<UserResponse>;
   /**
    *
    * @type {CallResponse}
@@ -3757,6 +3725,24 @@ export interface UpdateCallResponse {
    * @memberof UpdateCallResponse
    */
   duration: string;
+  /**
+   *
+   * @type {Array<MemberResponse>}
+   * @memberof UpdateCallResponse
+   */
+  members: Array<MemberResponse>;
+  /**
+   *
+   * @type {MemberResponse}
+   * @memberof UpdateCallResponse
+   */
+  membership?: MemberResponse;
+  /**
+   *
+   * @type {Array<OwnCapability>}
+   * @memberof UpdateCallResponse
+   */
+  own_capabilities: Array<OwnCapability>;
 }
 /**
  *

package/src/helpers/sound-detector.ts

@@ -27,6 +27,17 @@ export type SoundDetectorOptions = {
   destroyStreamOnStop?: boolean;
 };
 
+export type SoundDetectorState = {
+  isSoundDetected: boolean;
+  /**
+   * Represented as percentage (0-100) where 100% is defined by `audioLevelThreshold` property.
+   * Decrease time between samples (to 50-100ms) with `detectionFrequencyInMs` property.
+   */
+  audioLevel: number;
+};
+
+export type SoundStateChangeHandler = (state: SoundDetectorState) => void;
+
 const DETECTION_FREQUENCY_IN_MS = 500;
 const AUDIO_LEVEL_THRESHOLD = 150;
 const FFT_SIZE = 128;
@@ -41,14 +52,7 @@ const FFT_SIZE = 128;
  */
 export const createSoundDetector = (
   audioStream: MediaStream,
-  onSoundDetectedStateChanged: (
-    isSoundDetected: boolean,
-    /**
-     * Represented as percentage (0-100) where 100% is defined by `audioLevelThreshold` property.
-     * Decrease time between samples (to 50-100ms) with `detectionFrequencyInMs` property.
-     */
-    audioLevel: number,
-  ) => void,
+  onSoundDetectedStateChanged: SoundStateChangeHandler,
   options: SoundDetectorOptions = {},
 ) => {
   const {
@@ -78,7 +82,7 @@ export const createSoundDetector = (
         ? 100
         : Math.round((averagedDataValue / audioLevelThreshold) * 100);
 
-    onSoundDetectedStateChanged(isSoundDetected, percentage);
+    onSoundDetectedStateChanged({ isSoundDetected, audioLevel: percentage });
   }, detectionFrequencyInMs);
 
   return async function stop() {

package/src/rtc/flows/join.ts

@@ -24,13 +24,14 @@ export const join = async (
   await httpClient.connectionIdPromise;
 
   const joinCallResponse = await doJoin(httpClient, type, id, data);
-  const { call, credentials, members } = joinCallResponse;
+  const { call, credentials, members, own_capabilities } = joinCallResponse;
   return {
     connectionConfig: toRtcConfiguration(credentials.ice_servers),
     sfuServer: credentials.server,
     token: credentials.token,
     metadata: call,
     members,
+    ownCapabilities: own_capabilities,
   };
 };
 
@@ -68,15 +69,20 @@ const doJoin = async (
 
 const getLocationHint = async () => {
   const hintURL = `https://hint.stream-io-video.com/`;
+  const abortController = new AbortController();
+  const timeoutId = setTimeout(() => abortController.abort(), 1000);
   try {
     const response = await fetch(hintURL, {
       method: 'HEAD',
+      signal: abortController.signal,
     });
     const awsPop = response.headers.get('x-amz-cf-pop') || 'ERR';
     return awsPop.substring(0, 3); // AMS1-P2 -> AMS
   } catch (e) {
     console.error(`Failed to get location hint from ${hintURL}`, e);
     return 'ERR';
+  } finally {
+    clearTimeout(timeoutId);
   }
 };
 

package/src/rtc/publisher.ts

@@ -269,19 +269,14 @@ export class Publisher {
   };
 
   updateVideoPublishQuality = async (enabledRids: string[]) => {
-    console.log(
-      'Updating publish quality, qualities requested by SFU:',
-      enabledRids,
-    );
+    console.log('Update publish quality, requested rids by SFU:', enabledRids);
 
     const videoSender = this.transceiverRegistry[TrackType.VIDEO]?.sender;
-
     if (!videoSender) return;
 
     const params = videoSender.getParameters();
     let changed = false;
     params.encodings.forEach((enc) => {
-      console.log(enc.rid, enc.active);
       // flip 'active' flag only when necessary
       const shouldEnable = enabledRids.includes(enc.rid!);
       if (shouldEnable !== enc.active) {
@@ -294,6 +289,12 @@ export class Publisher {
         console.warn('No suitable video encoding quality found');
       }
       await videoSender.setParameters(params);
+      console.log(
+        `Update publish quality, enabled rids: ${params.encodings
+          .filter((e) => e.active)
+          .map((e) => e.rid)
+          .join(', ')}`,
+      );
     }
   };