@stream-io/video-client 0.2.3 → 0.3.1

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

@@ -1,69 +1,9 @@
 import { describe, expect, it } from 'vitest';
 import { CallState } from '../../store';
-import {
-  watchCallGrantsUpdated,
-  watchCallPermissionsUpdated,
-} from '../call-permissions';
+import { watchCallGrantsUpdated } from '../call-permissions';
 import { OwnCapability } from '../../gen/coordinator';
-import { ConnectionQuality } from '../../gen/video/sfu/models/models';
 
 describe('Call Permission Events', () => {
-  it('handles call.permissions_updated', () => {
-    const state = new CallState();
-    state.setParticipants([
-      {
-        userId: 'test',
-        name: 'test',
-        sessionId: 'test',
-        isDominantSpeaker: false,
-        isSpeaking: false,
-        audioLevel: 0,
-        image: '',
-        publishedTracks: [],
-        connectionQuality: ConnectionQuality.EXCELLENT,
-        roles: [],
-        trackLookupPrefix: '',
-        isLocalParticipant: true,
-      },
-    ]);
-    const handler = watchCallPermissionsUpdated(state);
-    handler({
-      type: 'call.permissions_updated',
-      created_at: '',
-      call_cid: 'development:12345',
-      own_capabilities: [OwnCapability.SEND_AUDIO, OwnCapability.SEND_VIDEO],
-      user: {
-        id: 'test',
-        created_at: '',
-        role: '',
-        updated_at: '',
-        custom: {},
-        teams: [],
-      },
-    });
-
-    expect(state.ownCapabilities).toEqual([
-      OwnCapability.SEND_AUDIO,
-      OwnCapability.SEND_VIDEO,
-    ]);
-
-    handler({
-      type: 'call.permissions_updated',
-      created_at: '',
-      call_cid: 'development:12345',
-      own_capabilities: [OwnCapability.SEND_VIDEO],
-      user: {
-        id: 'test',
-        created_at: '',
-        role: '',
-        updated_at: '',
-        custom: {},
-        teams: [],
-      },
-    });
-    expect(state.ownCapabilities).toEqual([OwnCapability.SEND_VIDEO]);
-  });
-
   it('handles sfu.callGrantsUpdated', () => {
     const state = new CallState();
     const handler = watchCallGrantsUpdated(state);

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

@@ -1,60 +1,15 @@
 import { describe, expect, it, vi } from 'vitest';
-import {
-  CallingState,
-  CallState,
-  StreamVideoWriteableStateStore,
-} from '../../store';
-import {
-  watchCallAccepted,
-  watchCallEnded,
-  watchCallRejected,
-  watchCallUpdated,
-} from '../call';
+import { CallingState, StreamVideoWriteableStateStore } from '../../store';
+import { watchCallAccepted, watchCallEnded, watchCallRejected } from '../call';
 import {
   CallAcceptedEvent,
   CallEndedEvent,
   CallResponse,
-  CallUpdatedEvent,
 } from '../../gen/coordinator';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
 
 describe('Call ringing events', () => {
-  describe('call.updated', () => {
-    it(`will update the call's metadata`, () => {
-      const state = new CallState();
-      const handler = watchCallUpdated(state);
-      const event: CallUpdatedEvent = {
-        type: 'call.updated',
-        call_cid: 'development:12345',
-        // @ts-expect-error
-        call: {
-          cid: 'development:12345',
-        },
-      };
-
-      // @ts-ignore
-      handler(event);
-      expect(state.metadata).toEqual(event.call);
-    });
-
-    it(`will ignore unknown events`, () => {
-      const state = new CallState();
-      const handler = watchCallUpdated(state);
-      const event = {
-        type: 'call.updated.unknown',
-        call_cid: 'development:12345',
-        call: {
-          cid: 'development:12345',
-        },
-      };
-
-      // @ts-ignore
-      handler(event);
-      expect(state.metadata).toBeUndefined();
-    });
-  });
-
   describe(`call.accepted`, () => {
     it(`will ignore events from the current user`, async () => {
       const call = fakeCall();
@@ -96,7 +51,7 @@ describe('Call ringing events', () => {
   describe(`call.rejected`, () => {
     it(`caller will leave the call if all callees have rejected`, async () => {
       const call = fakeCall({ currentUserId: 'm1' });
-      call.state.setMetadata({
+      call.state.updateFromCallResponse({
         ...fakeMetadata(),
         // @ts-ignore
         created_by: { id: 'm1' },
@@ -141,7 +96,7 @@ describe('Call ringing events', () => {
 
     it(`caller will not leave the call if only one callee rejects`, async () => {
       const call = fakeCall();
-      call.state.setMetadata({
+      call.state.updateFromCallResponse({
         ...fakeMetadata(),
         // @ts-ignore
         created_by: { id: 'm0' },
@@ -182,7 +137,7 @@ describe('Call ringing events', () => {
 
     it('callee will leave the call if caller rejects', async () => {
       const call = fakeCall({ currentUserId: 'm1' });
-      call.state.setMetadata({
+      call.state.updateFromCallResponse({
         ...fakeMetadata(),
         // @ts-ignore
         created_by: { id: 'm0' },

package/src/events/call-permissions.ts

@@ -1,21 +1,7 @@
-import { StreamVideoEvent } from '../coordinator/connection/types';
 import { CallState } from '../store';
 import { SfuEvent } from '../gen/video/sfu/event/events';
 import { OwnCapability } from '../gen/coordinator';
 
-/**
- * Event handler that watches for `call.permissions_updated` events
- */
-export const watchCallPermissionsUpdated = (state: CallState) => {
-  return function onCallPermissionsUpdated(event: StreamVideoEvent) {
-    if (event.type !== 'call.permissions_updated') return;
-    const { localParticipant } = state;
-    if (event.user.id === localParticipant?.userId) {
-      state.setOwnCapabilities(event.own_capabilities);
-    }
-  };
-};
-
 /**
  * Event handler that watches for `callGrantsUpdated` events.
  *

package/src/events/call.ts

@@ -1,4 +1,4 @@
-import { CallingState, CallState } from '../store';
+import { CallingState } from '../store';
 import { StreamVideoEvent } from '../coordinator/connection/types';
 import { Call } from '../Call';
 
@@ -76,24 +76,13 @@ export const watchCallRejected = (call: Call) => {
 export const watchCallEnded = (call: Call) => {
   return async function onCallCancelled(event: StreamVideoEvent) {
     if (event.type !== 'call.ended') return;
+    const { callingState } = call.state;
     if (
-      call.state.callingState === CallingState.RINGING ||
-      call.state.callingState === CallingState.JOINED ||
-      call.state.callingState === CallingState.JOINING
+      callingState === CallingState.RINGING ||
+      callingState === CallingState.JOINED ||
+      callingState === CallingState.JOINING
     ) {
-      call.state.setMetadata(event.call);
       await call.leave();
     }
   };
 };
-
-/**
- * An event handler which listens to `call.updated` events
- * and updates the given call state accordingly.
- */
-export const watchCallUpdated = (state: CallState) => {
-  return function onCallUpdated(event: StreamVideoEvent) {
-    if (event.type !== 'call.updated') return;
-    state.setMetadata(event.call);
-  };
-};

package/src/events/callEventHandlers.ts

@@ -3,31 +3,14 @@ import { Dispatcher } from '../rtc';
 import { CallState } from '../store';
 import {
   watchAudioLevelChanged,
-  watchBlockedUser,
   watchCallAccepted,
-  watchCallBroadcastingStarted,
-  watchCallBroadcastingStopped,
   watchCallEnded,
   watchCallGrantsUpdated,
-  watchCallLiveStarted,
-  watchCallMemberAdded,
-  watchCallMemberRemoved,
-  watchCallMemberUpdated,
-  watchCallMemberUpdatedPermission,
-  watchCallPermissionsUpdated,
-  watchCallRecordingStarted,
-  watchCallRecordingStopped,
   watchCallRejected,
-  watchCallSessionEnded,
-  watchCallSessionParticipantJoined,
-  watchCallSessionParticipantLeft,
-  watchCallSessionStarted,
-  watchCallUpdated,
   watchChangePublishQuality,
   watchConnectionQualityChanged,
   watchDominantSpeakerChanged,
   watchLiveEnded,
-  watchNewReactions,
   watchParticipantCountChanged,
   watchParticipantJoined,
   watchParticipantLeft,
@@ -35,7 +18,6 @@ import {
   watchSfuErrorReports,
   watchTrackPublished,
   watchTrackUnpublished,
-  watchUnblockedUser,
 } from '../events';
 import {
   CallEventTypes,
@@ -47,16 +29,6 @@ type RingCallEvents = Extract<
   'call.accepted' | 'call.rejected'
 >;
 
-type AllCallEvents = Exclude<
-  CallEventTypes,
-  | 'call.created' // handled by StreamVideoClient
-  | 'call.ring' // handled by StreamVideoClient
-  | 'call.notification' // not used currently
-  | 'call.permission_request' // should be handled by the SDK component
-  | 'custom' // integrators should handle custom events
-  | RingCallEvents // handled by registerRingingCallEventHandlers
->;
-
 /**
  * Registers the default event handlers for a call during its lifecycle.
  *
@@ -69,31 +41,9 @@ export const registerEventHandlers = (
   state: CallState,
   dispatcher: Dispatcher,
 ) => {
-  const coordinatorEvents: {
-    [key in AllCallEvents]: (e: StreamCallEvent) => any;
-  } = {
-    'call.blocked_user': watchBlockedUser(state),
-    'call.broadcasting_started': watchCallBroadcastingStarted(state),
-    'call.broadcasting_stopped': watchCallBroadcastingStopped(state),
-    'call.ended': watchCallEnded(call),
-    'call.live_started': watchCallLiveStarted(state),
-    'call.member_added': watchCallMemberAdded(state),
-    'call.member_removed': watchCallMemberRemoved(state),
-    'call.member_updated': watchCallMemberUpdated(state),
-    'call.member_updated_permission': watchCallMemberUpdatedPermission(state),
-    'call.permissions_updated': watchCallPermissionsUpdated(state),
-    'call.reaction_new': watchNewReactions(state),
-    'call.recording_started': watchCallRecordingStarted(state),
-    'call.recording_stopped': watchCallRecordingStopped(state),
-    'call.session_started': watchCallSessionStarted(state),
-    'call.session_ended': watchCallSessionEnded(state),
-    'call.session_participant_joined': watchCallSessionParticipantJoined(state),
-    'call.session_participant_left': watchCallSessionParticipantLeft(state),
-    'call.unblocked_user': watchUnblockedUser(state),
-    'call.updated': watchCallUpdated(state),
-    'call.user_muted': () => console.log('call.user_muted received'),
-  };
   const eventHandlers = [
+    call.on('call.ended', watchCallEnded(call)),
+
     watchLiveEnded(dispatcher, call),
     watchSfuErrorReports(dispatcher),
     watchChangePublishQuality(dispatcher, call),
@@ -113,11 +63,6 @@ export const registerEventHandlers = (
     call.on('pinsUpdated', watchPinsUpdated(state)),
   ];
 
-  Object.keys(coordinatorEvents).forEach((event) => {
-    const eventName = event as AllCallEvents;
-    eventHandlers.push(call.on(eventName, coordinatorEvents[eventName]));
-  });
-
   if (call.ringing) {
     // these events are only relevant when the call is ringing
     eventHandlers.push(registerRingingCallEventHandlers(call));

package/src/events/index.ts

@@ -1,11 +1,5 @@
-export * from './backstage';
 export * from './call';
 export * from './call-permissions';
 export * from './internal';
-export * from './members';
 export * from './participant';
-export * from './reactions';
-export * from './recording';
 export * from './speaker';
-export * from './sessions';
-export * from './moderation';

package/src/rtc/Dispatcher.ts

@@ -1,4 +1,4 @@
-import { CallEventTypes, Logger } from '../coordinator/connection/types';
+import { EventTypes, Logger } from '../coordinator/connection/types';
 import type { SfuEvent } from '../gen/video/sfu/event/events';
 import { getLogger } from '../logger';
 
@@ -26,7 +26,7 @@ const sfuEventKinds: { [key in SfuEventKinds]: undefined } = {
 };
 
 export const isSfuEvent = (
-  eventName: SfuEventKinds | CallEventTypes,
+  eventName: SfuEventKinds | EventTypes,
 ): eventName is SfuEventKinds => {
   return Object.prototype.hasOwnProperty.call(sfuEventKinds, eventName);
 };

package/src/rtc/Publisher.ts

@@ -50,7 +50,6 @@ export type PublisherOpts = {
 export class Publisher {
   private pc: RTCPeerConnection;
   private readonly state: CallState;
-  private readonly dispatcher: Dispatcher;
 
   private readonly transceiverRegistry: {
     [key in TrackType]: RTCRtpTransceiver | undefined;
@@ -129,7 +128,6 @@ export class Publisher {
     this.pc = this.createPeerConnection(connectionConfig);
     this.sfuClient = sfuClient;
     this.state = state;
-    this.dispatcher = dispatcher;
     this.isDtxEnabled = isDtxEnabled;
     this.isRedEnabled = isRedEnabled;
     this.preferredVideoCodec = preferredVideoCodec;
@@ -234,8 +232,8 @@ export class Publisher {
     };
 
     if (!transceiver) {
-      const metadata = this.state.metadata;
-      const targetResolution = metadata?.settings.video.target_resolution;
+      const { settings } = this.state;
+      const targetResolution = settings?.video.target_resolution;
       const videoEncodings =
         trackType === TrackType.VIDEO
           ? findOptimalVideoLayers(track, targetResolution)
@@ -608,8 +606,8 @@ export class Publisher {
       return String(media.mid);
     };
 
-    const metadata = this.state.metadata;
-    const targetResolution = metadata?.settings.video.target_resolution;
+    const { settings } = this.state;
+    const targetResolution = settings?.video.target_resolution;
     return this.pc
       .getTransceivers()
       .filter((t) => t.direction === 'sendonly' && t.sender.track)