@stream-io/video-client 0.0.2-alpha.6 → 0.0.2-alpha.8

package/dist/src/Call.d.ts

@@ -115,6 +115,10 @@ export declare class Call {
     private waitForJoinResponse;
     /**
      * Loads the information about the call.
+     *
+     * @param params.ring if set to true, a `call.ring` event will be sent to the call members.
+     * @param params.notify if set to true, a `call.notification` event will be sent to the call members.
+     * @param params.members_limit the members limit.
      */
     get: (params?: {
         ring?: boolean;
@@ -127,20 +131,38 @@ export declare class Call {
      * @param data the data to create the call with.
      */
     getOrCreate: (data?: GetOrCreateCallRequest) => Promise<GetOrCreateCallResponse>;
+    /**
+     * A shortcut for {@link Call.get} with `ring` parameter set to `true`.
+     * Will send a `call.ring` event to the call members.
+     */
     ring: () => Promise<GetCallResponse>;
+    /**
+     * A shortcut for {@link Call.get} with `notify` parameter set to `true`.
+     * Will send a `call.notification` event to the call members.
+     */
     notify: () => Promise<GetCallResponse>;
     /**
-     * Will start to watch for call related WebSocket events and initiate a call session with the server.
+     * Marks the incoming call as accepted.
      *
-     * @returns a promise which resolves once the call join-flow has finished.
+     * This method should be used only for "ringing" call flows.
+     * {@link Call.join} invokes this method automatically for you when joining a call.
+     * Unless you are implementing a custom "ringing" flow, you should not use this method.
      */
-    join: (data?: JoinCallData) => Promise<void>;
+    accept: () => Promise<AcceptCallResponse>;
     /**
-     * Will update the call members.
+     * Marks the incoming call as rejected.
      *
-     * @param data the request data.
+     * This method should be used only for "ringing" call flows.
+     * {@link Call.leave} invokes this method automatically for you when you leave or reject this call.
+     * Unless you are implementing a custom "ringing" flow, you should not use this method.
      */
-    updateCallMembers: (data: UpdateCallMembersRequest) => Promise<UpdateCallMembersResponse>;
+    reject: () => Promise<RejectCallResponse>;
+    /**
+     * Will start to watch for call related WebSocket events and initiate a call session with the server.
+     *
+     * @returns a promise which resolves once the call join-flow has finished.
+     */
+    join: (data?: JoinCallData) => Promise<void>;
     /**
      * Starts publishing the given video stream to the call.
      * The stream will be stopped if the user changes an input device, or if the user leaves the call.
@@ -385,6 +407,12 @@ export declare class Call {
      * @returns
      */
     queryMembers: (request: Omit<QueryMembersRequest, 'type' | 'id'>) => Promise<QueryMembersResponse>;
+    /**
+     * Will update the call members.
+     *
+     * @param data the request data.
+     */
+    updateCallMembers: (data: UpdateCallMembersRequest) => Promise<UpdateCallMembersResponse>;
     private scheduleAutoDrop;
     /**
      * Retrieves the list of recordings for the current call or call session.
@@ -411,6 +439,4 @@ export declare class Call {
     sendEvent: (event: SendEventRequest & {
         type: StreamCallEvent['type'];
     }) => Promise<SendEventResponse>;
-    accept: () => Promise<AcceptCallResponse>;
-    reject: () => Promise<RejectCallResponse>;
 }

package/dist/src/StreamVideoClient.d.ts

@@ -13,6 +13,7 @@ export declare class StreamVideoClient {
     readonly readOnlyStateStore: StreamVideoReadOnlyStateStore;
     private readonly writeableStateStore;
     streamClient: StreamClient;
+    private eventHandlersToUnregister;
     /**
      * You should create only one instance of `StreamVideoClient`.
      * @param apiKey your Stream API key

package/dist/src/events/callEventHandlers.d.ts

@@ -1,5 +1,17 @@
 import { Call } from '../Call';
 import { Dispatcher } from '../rtc';
 import { CallState } from '../store';
+/**
+ * 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 declare const registerEventHandlers: (call: Call, state: CallState, dispatcher: Dispatcher) => () => void;
+/**
+ * Registers event handlers for a call that is of ringing type.
+ *
+ * @param call the call to register event handlers for.
+ */
 export declare const registerRingingCallEventHandlers: (call: Call) => () => void;

package/dist/src/gen/coordinator/index.d.ts

@@ -707,6 +707,12 @@ export interface CallNotificationEvent {
      * @memberof CallNotificationEvent
      */
     created_at: string;
+    /**
+     * Call members
+     * @type {Array<MemberResponse>}
+     * @memberof CallNotificationEvent
+     */
+    members: Array<MemberResponse>;
     /**
      * Call session ID
      * @type {string}
@@ -1104,6 +1110,12 @@ export interface CallRingEvent {
      * @memberof CallRingEvent
      */
     created_at: string;
+    /**
+     * Call members
+     * @type {Array<MemberResponse>}
+     * @memberof CallRingEvent
+     */
+    members: Array<MemberResponse>;
     /**
      * Call session ID
      * @type {string}
@@ -3237,12 +3249,6 @@ export interface RingSettings {
      * @memberof RingSettings
      */
     auto_cancel_timeout_ms: number;
-    /**
-     *
-     * @type {number}
-     * @memberof RingSettings
-     */
-    auto_reject_timeout_ms: number;
     /**
      *
      * @type {number}
@@ -3262,12 +3268,6 @@ export interface RingSettingsRequest {
      * @memberof RingSettingsRequest
      */
     auto_cancel_timeout_ms?: number;
-    /**
-     *
-     * @type {number}
-     * @memberof RingSettingsRequest
-     */
-    auto_reject_timeout_ms?: number;
     /**
      *
      * @type {number}

package/dist/src/store/stateStore.d.ts

@@ -71,6 +71,13 @@ export declare class StreamVideoWriteableStateStore {
      * @param call the call to remove
      */
     unregisterCall: (call: Call) => Call[];
+    /**
+     * Finds a {@link Call} object in the list of {@link Call} objects created/tracked by this client.
+     *
+     * @param type the type of call to find.
+     * @param id the id of the call to find.
+     */
+    findCall: (type: string, id: string) => Call | undefined;
     /**
      * A list of objects describing incoming calls.
      * @deprecated derive from calls$ instead.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.0.2-alpha.6",
+  "version": "0.0.2-alpha.8",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Call.ts

@@ -375,12 +375,10 @@ export class Call {
       if (this.isCreatedByMe && !hasOtherParticipants) {
         // Signals other users that I have cancelled my call to them
         // before they accepted it.
-        // Causes the `call.ended` event to be emitted to all the call members.
-        await this.endCall();
+        await this.reject();
       } else if (reject && callingState === CallingState.RINGING) {
         // Signals other users that I have rejected the incoming call.
-        // Causes the `call.rejected` event to be emitted to all the call members.
-        await this.sendEvent({ type: 'call.rejected' });
+        await this.reject();
       }
     }
 
@@ -450,6 +448,10 @@ export class Call {
 
   /**
    * Loads the information about the call.
+   *
+   * @param params.ring if set to true, a `call.ring` event will be sent to the call members.
+   * @param params.notify if set to true, a `call.notification` event will be sent to the call members.
+   * @param params.members_limit the members limit.
    */
   get = async (params?: {
     ring?: boolean;
@@ -460,6 +462,11 @@ export class Call {
       this.streamClientBasePath,
       params,
     );
+
+    if (params?.ring && !this.ringing) {
+      this.ringingSubject.next(true);
+    }
+
     this.state.setMetadata(response.call);
     this.state.setMembers(response.members);
 
@@ -482,6 +489,10 @@ export class Call {
       GetOrCreateCallRequest
     >(this.streamClientBasePath, data);
 
+    if (data?.ring && !this.ringing) {
+      this.ringingSubject.next(true);
+    }
+
     this.state.setMetadata(response.call);
     this.state.setMembers(response.members);
 
@@ -493,14 +504,48 @@ export class Call {
     return response;
   };
 
+  /**
+   * A shortcut for {@link Call.get} with `ring` parameter set to `true`.
+   * Will send a `call.ring` event to the call members.
+   */
   ring = async (): Promise<GetCallResponse> => {
     return await this.get({ ring: true });
   };
 
+  /**
+   * A shortcut for {@link Call.get} with `notify` parameter set to `true`.
+   * Will send a `call.notification` event to the call members.
+   */
   notify = async (): Promise<GetCallResponse> => {
     return await this.get({ notify: true });
   };
 
+  /**
+   * Marks the incoming call as accepted.
+   *
+   * This method should be used only for "ringing" call flows.
+   * {@link Call.join} invokes this method automatically for you when joining a call.
+   * Unless you are implementing a custom "ringing" flow, you should not use this method.
+   */
+  accept = async () => {
+    return this.streamClient.post<AcceptCallResponse>(
+      `${this.streamClientBasePath}/accept`,
+    );
+  };
+
+  /**
+   * Marks the incoming call as rejected.
+   *
+   * This method should be used only for "ringing" call flows.
+   * {@link Call.leave} invokes this method automatically for you when you leave or reject this call.
+   * Unless you are implementing a custom "ringing" flow, you should not use this method.
+   */
+  reject = async () => {
+    return this.streamClient.post<RejectCallResponse>(
+      `${this.streamClientBasePath}/reject`,
+    );
+  };
+
   /**
    * Will start to watch for call related WebSocket events and initiate a call session with the server.
    *
@@ -518,6 +563,15 @@ export class Call {
     const previousCallingState = this.state.callingState;
     this.state.setCallingState(CallingState.JOINING);
 
+    if (data?.ring && !this.ringing) {
+      this.ringingSubject.next(true);
+    }
+
+    if (this.ringing && !this.isCreatedByMe) {
+      // signals other users that I have accepted the incoming call.
+      await this.accept();
+    }
+
     let sfuServer: SFUResponse;
     let sfuToken: string;
     let connectionConfig: RTCConfiguration | undefined;
@@ -759,20 +813,6 @@ export class Call {
     }
   };
 
-  /**
-   * Will update the call members.
-   *
-   * @param data the request data.
-   */
-  updateCallMembers = async (
-    data: UpdateCallMembersRequest,
-  ): Promise<UpdateCallMembersResponse> => {
-    return this.streamClient.post<
-      UpdateCallMembersResponse,
-      UpdateCallMembersRequest
-    >(`${this.streamClientBasePath}/members`, data);
-  };
-
   /**
    * Starts publishing the given video stream to the call.
    * The stream will be stopped if the user changes an input device, or if the user leaves the call.
@@ -1410,7 +1450,22 @@ export class Call {
     );
   };
 
+  /**
+   * Will update the call members.
+   *
+   * @param data the request data.
+   */
+  updateCallMembers = async (
+    data: UpdateCallMembersRequest,
+  ): Promise<UpdateCallMembersResponse> => {
+    return this.streamClient.post<
+      UpdateCallMembersResponse,
+      UpdateCallMembersRequest
+    >(`${this.streamClientBasePath}/members`, data);
+  };
+
   private scheduleAutoDrop = () => {
+    if (this.dropTimeout) clearTimeout(this.dropTimeout);
     const subscription = this.state.metadata$
       .pipe(
         pairwise(),
@@ -1426,8 +1481,8 @@ export class Call {
                 currentMeta.settings.ring.auto_cancel_timeout_ms,
               ]
             : [
-                prevMeta?.settings.ring.auto_reject_timeout_ms,
-                currentMeta.settings.ring.auto_reject_timeout_ms,
+                prevMeta?.settings.ring.incoming_call_timeout_ms,
+                currentMeta.settings.ring.incoming_call_timeout_ms,
               ];
           if (typeof timeoutMs === 'undefined' || timeoutMs === prevTimeoutMs)
             return;
@@ -1497,16 +1552,4 @@ export class Call {
       event,
     );
   };
-
-  accept = async () => {
-    return this.streamClient.post<AcceptCallResponse>(
-      `${this.streamClientBasePath}/accept`,
-    );
-  };
-
-  reject = async () => {
-    return this.streamClient.post<RejectCallResponse>(
-      `${this.streamClientBasePath}/reject`,
-    );
-  };
 }

package/src/StreamVideoClient.ts

@@ -24,7 +24,6 @@ import type {
   EventHandler,
   EventTypes,
   StreamClientOptions,
-  StreamVideoEvent,
   TokenOrProvider,
   User,
 } from './coordinator/connection/types';
@@ -40,6 +39,8 @@ export class StreamVideoClient {
   private readonly writeableStateStore: StreamVideoWriteableStateStore;
   streamClient: StreamClient;
 
+  private eventHandlersToUnregister: Array<() => void> = [];
+
   /**
    * You should create only one instance of `StreamVideoClient`.
    * @param apiKey your Stream API key
@@ -73,52 +74,83 @@ export class StreamVideoClient {
       user,
       tokenOrProvider,
     );
+    this.writeableStateStore.setConnectedUser(user);
 
-    // FIXME OL: unregister the event listeners.
-    this.on('connection.changed', (e) => {
-      const event = e as ConnectionChangedEvent;
-      if (event.online) {
-        const callsToReWatch = this.writeableStateStore.calls
-          .filter((call) => call.watching)
-          .map((call) => call.cid);
+    this.eventHandlersToUnregister.push(
+      this.on('connection.changed', (e) => {
+        const event = e as ConnectionChangedEvent;
+        if (event.online) {
+          const callsToReWatch = this.writeableStateStore.calls
+            .filter((call) => call.watching)
+            .map((call) => call.cid);
 
-        if (callsToReWatch.length > 0) {
-          this.queryCalls({
-            watch: true,
-            filter_conditions: {
-              cid: { $in: callsToReWatch },
-            },
-            sort: [{ field: 'cid', direction: 1 }],
-          }).catch((err) => {
-            console.warn('Failed to re-watch calls', err);
-          });
+          if (callsToReWatch.length > 0) {
+            this.queryCalls({
+              watch: true,
+              filter_conditions: {
+                cid: { $in: callsToReWatch },
+              },
+              sort: [{ field: 'cid', direction: 1 }],
+            }).catch((err) => {
+              console.warn('Failed to re-watch calls', err);
+            });
+          }
         }
-      }
-    });
+      }),
+    );
 
-    // FIXME: OL: unregister the event listeners.
-    this.on('call.created', (event: StreamVideoEvent) => {
-      if (event.type !== 'call.created') return;
-      const { call, members } = event;
-      if (user.id === call.created_by.id) {
-        console.warn('Received `call.created` sent by the current user');
-        return;
-      }
+    this.eventHandlersToUnregister.push(
+      this.on('call.created', (event) => {
+        if (event.type !== 'call.created') return;
+        const { call, members } = event;
+        if (user.id === call.created_by.id) {
+          console.warn('Received `call.created` sent by the current user');
+          return;
+        }
 
-      this.writeableStateStore.registerCall(
-        new Call({
-          streamClient: this.streamClient,
-          type: call.type,
-          id: call.id,
-          metadata: call,
-          members,
-          ringing: false, //TODO: remove ringing from here
-          clientStore: this.writeableStateStore,
-        }),
-      );
-    });
+        this.writeableStateStore.registerCall(
+          new Call({
+            streamClient: this.streamClient,
+            type: call.type,
+            id: call.id,
+            metadata: call,
+            members,
+            clientStore: this.writeableStateStore,
+          }),
+        );
+      }),
+    );
 
-    this.writeableStateStore.setConnectedUser(user);
+    this.eventHandlersToUnregister.push(
+      this.on('call.ring', async (event) => {
+        if (event.type !== 'call.ring') return;
+        const { call, members } = event;
+        if (user.id === call.created_by.id) {
+          console.warn('Received `call.ring` sent by the current user');
+          return;
+        }
+
+        // The call might already be tracked by the client,
+        // if `call.created` was received before `call.ring`.
+        // In that case, we just reuse the already tracked call.
+        let theCall = this.writeableStateStore.findCall(call.type, call.id);
+        if (!theCall) {
+          // otherwise, we create a new call
+          theCall = new Call({
+            streamClient: this.streamClient,
+            type: call.type,
+            id: call.id,
+            members,
+            clientStore: this.writeableStateStore,
+            ringing: true,
+          });
+        }
+
+        // we fetch the latest metadata for the call from the server
+        await theCall.get({ ring: true });
+        this.writeableStateStore.registerCall(theCall);
+      }),
+    );
 
     return connectUserResponse;
   };
@@ -147,6 +179,8 @@ export class StreamVideoClient {
    */
   disconnectUser = async (timeout?: number) => {
     await this.streamClient.disconnectUser(timeout);
+    this.eventHandlersToUnregister.forEach((unregister) => unregister());
+    this.eventHandlersToUnregister = [];
     this.writeableStateStore.setConnectedUser(undefined);
   };