@stream-io/video-client 1.59.1 → 1.61.0

package/src/Call.ts

@@ -50,6 +50,7 @@ import {
   EndCallResponse,
   GetCallReportResponse,
   GetCallResponse,
+  GetCallRingStateResponse,
   GetCallSessionParticipantStatsDetailsResponse,
   GetOrCreateCallRequest,
   GetOrCreateCallResponse,
@@ -152,7 +153,7 @@ import {
   StatsReporter,
   Tracer,
 } from './stats';
-import type { ClientEventReporter, JoinReason } from './reporting';
+import type { ClientEventReporter, JoinReason, JoinSource } from './reporting';
 import { AudioBindingsWatchdog } from './helpers/AudioBindingsWatchdog';
 import { BlockedAudioTracker } from './helpers/BlockedAudioTracker';
 import { TrackSubscriptionManager } from './helpers/TrackSubscriptionManager';
@@ -160,6 +161,7 @@ import { DynascaleManager } from './helpers/DynascaleManager';
 import { createFirstVideoFrameDetector } from './helpers/firstVideoFrame';
 import { ViewportTracker } from './helpers/ViewportTracker';
 import { PermissionsContext } from './permissions';
+import { RingStatePoller, RingTimeout, resolveOwnRingOutcome } from './ringing';
 import { CallTypes } from './CallType';
 import { StreamClient } from './coordinator/connection/client';
 import { retryInterval, sleep } from './coordinator/connection/utils';
@@ -302,7 +304,8 @@ export class Call {
   private statsReporter?: StatsReporter;
   private sfuStatsReporter?: SfuStatsReporter;
   private lastStatsOptions?: StatsOptions;
-  private dropTimeout: ReturnType<typeof setTimeout> | undefined;
+  private ringTimeout: RingTimeout | undefined;
+  private ringStatePoller: RingStatePoller | undefined;
 
   private readonly clientStore: StreamVideoWriteableStateStore;
   public readonly streamClient: StreamClient;
@@ -537,33 +540,20 @@ export class Call {
       createSubscription(this.state.session$, (session) => {
         if (!this.ringing) return;
 
-        const receiverId = this.clientStore.connectedUser?.id;
-        if (!receiverId) return;
-
-        const isAcceptedByMe = Boolean(session?.accepted_by[receiverId]);
-        const isRejectedByMe = Boolean(session?.rejected_by[receiverId]);
-
-        if (isAcceptedByMe || isRejectedByMe) {
-          this.cancelAutoDrop();
-        }
-
-        const isAcceptedElsewhere =
-          isAcceptedByMe && this.state.callingState === CallingState.RINGING;
+        const { settledByMe, leaveReason } = resolveOwnRingOutcome({
+          session,
+          currentUserId: this.currentUserId,
+          callingState: this.state.callingState,
+        });
+        if (settledByMe) this.cancelAutoDrop();
+        if (!leaveReason || hasPending(this.joinLeaveConcurrencyTag)) return;
 
-        if (
-          (isAcceptedElsewhere || isRejectedByMe) &&
-          !hasPending(this.joinLeaveConcurrencyTag)
-        ) {
-          globalThis.streamRNVideoSDK?.callingX?.endCall(
-            this,
-            isAcceptedElsewhere ? 'answeredElsewhere' : 'rejected',
+        globalThis.streamRNVideoSDK?.callingX?.endCall(this, leaveReason);
+        this.leave().catch(() => {
+          this.logger.error(
+            'Could not leave a call that was accepted or rejected elsewhere',
           );
-          this.leave().catch(() => {
-            this.logger.error(
-              'Could not leave a call that was accepted or rejected elsewhere',
-            );
-          });
-        }
+        });
       }),
     );
   };
@@ -608,6 +598,7 @@ export class Call {
         this.state.setCallingState(CallingState.RINGING);
       }
       this.scheduleAutoDrop();
+      this.scheduleRingStatePolling();
       this.leaveCallHooks.add(registerRingingCallEventHandlers(this));
     }
   };
@@ -713,6 +704,13 @@ export class Call {
       throw new Error('Cannot leave call that has already been left.');
     }
 
+    // before the first await: the calling state stays RINGING well into the
+    // teardown, so pause both watchdogs before they can race this leave. They
+    // keep their deadlines, so a failed leave resumes them without handing the
+    // ring another window.
+    this.ringTimeout?.pause();
+    this.ringStatePoller?.pause();
+
     await withoutConcurrency(this.joinLeaveConcurrencyTag, async () => {
       const callingState = this.state.callingState;
 
@@ -796,6 +794,11 @@ export class Call {
       await this.dynascaleManager?.dispose();
 
       this.state.setCallingState(CallingState.LEFT);
+      // `ringingSubject` is cleared further down, so this still reads true for
+      // a call that was ringing.
+      if (this.ringing) {
+        globalThis.streamRNVideoSDK?.ringingCallLifecycle?.onLeave(this);
+      }
       this.state.setParticipants([]);
       this.state.dispose();
 
@@ -821,6 +824,7 @@ export class Call {
       this.unifiedSessionId = undefined;
       this.ringingSubject.next(false);
       this.cancelAutoDrop();
+      this.cancelRingStatePolling();
       this.clientStore.unregisterCall(this);
 
       globalThis.streamRNVideoSDK?.callManager.stop({
@@ -863,6 +867,17 @@ export class Call {
             this.logger.warn('Failed to dispose media engine', err);
           });
       }
+    }).catch((err) => {
+      if (
+        !hasPending(this.joinLeaveConcurrencyTag) &&
+        this.state.callingState === CallingState.RINGING
+      ) {
+        // resume, never re-arm: a fresh watchdog would restart the ring
+        // window this leave was already most of the way through
+        this.ringTimeout?.start();
+        this.ringStatePoller?.resume();
+      }
+      throw err;
     });
   };
 
@@ -973,12 +988,14 @@ export class Call {
     members_limit?: number;
     video?: boolean;
   }): Promise<GetCallResponse> => {
+    const getLeaveGeneration = this.leaveGeneration;
     await this.setup();
 
     const response = await this.streamClient.get<GetCallResponse>(
       this.streamClientBasePath,
       params,
     );
+    if (this.leaveGeneration !== getLeaveGeneration) return response;
 
     this.updateFromCallStateResponse(response);
 
@@ -1056,6 +1073,27 @@ export class Call {
     );
   };
 
+  /**
+   * Returns who accepted, rejected or missed the ring for a call session.
+   * Safe to poll: it performs no writes and emits no events.
+   *
+   * @param callSessionId the call session to read. Defaults to the current one.
+   * Pass it explicitly to read a session that has already ended, as ending a
+   * call clears its current session.
+   */
+  getRingState = async (
+    callSessionId?: string,
+  ): Promise<GetCallRingStateResponse> => {
+    const sessionId = callSessionId ?? this.state.session?.id;
+    if (!sessionId) {
+      throw new Error('Cannot read the ring state: the call has no session');
+    }
+    return this.streamClient.get<GetCallRingStateResponse>(
+      `${this.streamClientBasePath}/ring_state`,
+      { call_session_id: sessionId },
+    );
+  };
+
   /**
    * A shortcut for {@link Call.get} with `notify` parameter set to `true`.
    * Will send a `call.notification` event to the call members.
@@ -1104,6 +1142,10 @@ export class Call {
   /**
    * Will start to watch for call related WebSocket events and initiate a call session with the server.
    *
+   * One instance is one call flow: discard it after leaving, cancelling, or a
+   * failed join, and create a fresh one for a later flow. Reconnection inside a
+   * live call is handled here and needs no new instance.
+   *
    * @returns a promise which resolves once the call join-flow has finished.
    */
   join = singleFlight(
@@ -1112,19 +1154,30 @@ export class Call {
       joinResponseTimeout,
       rpcRequestTimeout,
       allowOwnTracksLoopback = false,
+      joinSource,
       ...data
     }: JoinCallData & {
       maxJoinRetries?: number;
       joinResponseTimeout?: number;
       rpcRequestTimeout?: number;
       allowOwnTracksLoopback?: boolean;
+      joinSource?: JoinSource;
     } = {}): Promise<void> => {
       const callingState = this.state.callingState;
 
+      // Ahead of the failure boundary below on purpose: a duplicate join on a
+      // live call is refused without tearing that call down.
       if ([CallingState.JOINED, CallingState.JOINING].includes(callingState)) {
         throw new Error(`Illegal State: call.join() shall be called only once`);
       }
 
+      // snapshot before the first await: a leave() landing at any point from
+      // here on supersedes this join, and the retry loop must bail out instead
+      // of resurrecting a call that leave() already tore down.
+      const joinLeaveGeneration = this.leaveGeneration;
+      const supersededByLeave = () =>
+        this.leaveGeneration !== joinLeaveGeneration;
+
       // we need this to be set before the callingx.joinCall() is
       // called to avoid registering the test call in the CallKit/Telecom
       this.allowOwnTracksLoopback = allowOwnTracksLoopback;
@@ -1133,35 +1186,67 @@ export class Call {
         this.ringingSubject.next(true);
       }
 
+      // A ringing call is joined by the SDK rather than by app code, so React
+      // Native prepares it from in here - there is no earlier point at which the
+      // app holds the call. Read after `data.ring` above, which is what makes an
+      // outgoing call ringing in the first place.
+      const ringingLifecycle = this.ringing
+        ? globalThis.streamRNVideoSDK?.ringingCallLifecycle
+        : undefined;
       const callingX = globalThis.streamRNVideoSDK?.callingX;
-      if (callingX) {
-        // for Android/iOS, we need to start the call in the callingx library as soon as possible
-        await callingX.joinCall(this, this.clientStore.calls);
-      }
+      try {
+        if (ringingLifecycle) {
+          await ringingLifecycle.beforeJoin(this);
+          if (supersededByLeave()) {
+            this.logger.debug('Join superseded by leave; not joining');
+            return;
+          }
+        }
+
+        if (callingX) {
+          // for Android/iOS, we need to start the call in the callingx library as soon as possible
+          await callingX.joinCall(
+            this,
+            this.clientStore.calls,
+            supersededByLeave,
+          );
+          if (supersededByLeave()) {
+            this.logger.debug('Join superseded by leave; not setting up');
+            return;
+          }
+        }
 
-      await this.setup();
+        await this.setup();
+        if (supersededByLeave()) {
+          this.logger.debug('Join superseded by leave; not registering');
+          return;
+        }
 
-      this.clientEventReporter.registerCall(this.cid, {
-        callType: this.type,
-        callId: this.id,
-        getCallSessionId: () => this.state.session?.id ?? '',
-        getSfuId: () => this.credentials?.server.edge_name ?? '',
-      });
+        this.clientEventReporter.registerCall(this.cid, {
+          callType: this.type,
+          callId: this.id,
+          getCallSessionId: () => this.state.session?.id ?? '',
+          getSfuId: () => this.credentials?.server.edge_name ?? '',
+        });
 
-      this.joinResponseTimeout = joinResponseTimeout;
-      this.rpcRequestTimeout = rpcRequestTimeout;
-      // we will count the number of join failures per SFU.
-      // once the number of failures reaches 2, we will piggyback on the `migrating_from`
-      // field to force the coordinator to provide us another SFU
-      const sfuJoinFailures = new Map<string, number>();
-      const joinData: JoinCallData = data;
-      maxJoinRetries = Math.max(maxJoinRetries, 1);
-      try {
+        this.joinResponseTimeout = joinResponseTimeout;
+        this.rpcRequestTimeout = rpcRequestTimeout;
+        // we will count the number of join failures per SFU.
+        // once the number of failures reaches 2, we will piggyback on the `migrating_from`
+        // field to force the coordinator to provide us another SFU
+        const sfuJoinFailures = new Map<string, number>();
+        const joinData: JoinCallData = data;
+        maxJoinRetries = Math.max(maxJoinRetries, 1);
         await this.clientEventReporter.withJoinLifecycle(
           this.cid,
-          'first-attempt',
+          { joinReason: 'first-attempt', joinSource },
           async () => {
             for (let attempt = 0; attempt < maxJoinRetries; attempt++) {
+              // Also covers a leave that lands during the backoff below.
+              if (supersededByLeave()) {
+                this.logger.debug('Join superseded by leave; not attempting');
+                return;
+              }
               try {
                 this.logger.trace(`Joining call (${attempt})`, this.cid);
                 await this.doJoin(data);
@@ -1169,6 +1254,10 @@ export class Call {
                 delete joinData.migrating_from_list;
                 return;
               } catch (err) {
+                if (supersededByLeave()) {
+                  this.logger.debug('Join superseded by leave; not retrying');
+                  return;
+                }
                 this.logger.warn(`Failed to join call (${attempt})`, this.cid);
                 if (
                   (err instanceof ErrorFromResponse && err.unrecoverable) ||
@@ -1209,6 +1298,9 @@ export class Call {
         );
       } catch (error) {
         callingX?.endCall(this, 'error');
+        // Ends the failed ringing flow and releases what its setup installed.
+        // Never rejects, so `error` is what the caller sees.
+        await ringingLifecycle?.onJoinFailed(this);
         throw error;
       }
     },
@@ -1237,6 +1329,10 @@ export class Call {
     // globals resolve to the call's factory. Idempotent across
     // reconnect/migration attempts.
     await this.ensureMediaFactory();
+    if (supersededByLeave()) {
+      this.logger.debug('Join superseded by leave; not wiring media');
+      return;
+    }
 
     const callingX = globalThis.streamRNVideoSDK?.callingX;
     if (callingX) {
@@ -1264,10 +1360,17 @@ export class Call {
           'CoordinatorJoin',
           () => this.doJoinRequest(data),
         );
+        if (!joinResponse || supersededByLeave()) {
+          this.logger.debug(
+            'Join superseded by leave; not creating SFU client',
+          );
+          return;
+        }
         this.credentials = joinResponse.credentials;
         statsOptions = joinResponse.stats_options;
         this.lastStatsOptions = statsOptions;
       } catch (error) {
+        if (supersededByLeave()) return;
         // prevent triggering reconnect flow if the state is OFFLINE
         const avoidRestoreState =
           this.state.callingState === CallingState.OFFLINE;
@@ -1322,6 +1425,10 @@ export class Call {
         getGenericSdp('recvonly', dangerouslyForceCodec, subscriberFmtpLine),
         getGenericSdp('sendonly', dangerouslyForceCodec, fmtpLine),
       ]);
+      if (supersededByLeave()) {
+        this.logger.debug('Join superseded by leave; not joining SFU');
+        return;
+      }
       const isReconnecting =
         this.reconnectStrategy !== WebsocketReconnectStrategy.UNSPECIFIED;
       const reconnectDetails = isReconnecting
@@ -1355,6 +1462,12 @@ export class Call {
               source: ParticipantSource.WEBRTC_UNSPECIFIED,
             }),
           );
+        if (supersededByLeave()) {
+          this.logger.debug(
+            'Join superseded by leave; not applying SFU response',
+          );
+          return;
+        }
 
         this.currentPublishOptions = publishOptions;
         this.fastReconnectDeadlineSeconds = fastReconnectDeadlineSeconds;
@@ -1366,6 +1479,10 @@ export class Call {
           );
         }
       } catch (error) {
+        if (supersededByLeave()) {
+          this.logger.debug('Join superseded by leave; ignoring SFU failure');
+          return;
+        }
         this.logger.warn('Join SFU request failed', error);
         sfuClient.close(
           StreamSfuClient.JOIN_FAILED,
@@ -1377,8 +1494,8 @@ export class Call {
       }
     }
 
-    // If the user left while this join was in flight, bail before re-setting JOINED and before
-    // peer-connection setup below (both run synchronously after this, so one check covers them).
+    // If the user left while this join was in flight, bail before re-setting JOINED
+    // or starting peer-connection setup below.
     if (supersededByLeave()) {
       this.logger.debug('Join superseded by leave; aborting join flow');
       return;
@@ -1408,6 +1525,10 @@ export class Call {
         unifiedSessionId: this.unifiedSessionId,
       });
     }
+    if (supersededByLeave()) {
+      this.logger.debug('Join superseded by leave; not completing join flow');
+      return;
+    }
 
     // make sure we only track connection timing if we are not calling this method as part of a reconnection flow
     if (!performingRejoin && !performingFastReconnect && !performingMigration) {
@@ -1593,6 +1714,7 @@ export class Call {
     closePreviousInstances: boolean;
     unifiedSessionId: string;
   }) => {
+    const joinLeaveGeneration = this.leaveGeneration;
     const {
       sfuClient,
       connectionConfig,
@@ -1609,10 +1731,12 @@ export class Call {
     // Flush the previous reporter's final sample while its peer connections are
     // still alive, before we dispose them below. Awaits only the sampling step.
     await this.sfuStatsReporter?.flush();
+    if (this.leaveGeneration !== joinLeaveGeneration) return;
     this.sfuStatsReporter?.stop();
     this.sfuStatsReporter = undefined;
     if (closePreviousInstances && this.subscriber) {
       await this.subscriber.dispose();
+      if (this.leaveGeneration !== joinLeaveGeneration) return;
       this.state.removeAllOrphanedTracks();
     }
     const basePeerConnectionOptions: BasePeerConnectionOpts = {
@@ -1659,6 +1783,7 @@ export class Call {
     if (!isAnonymous) {
       if (closePreviousInstances && this.publisher) {
         await this.publisher.dispose();
+        if (this.leaveGeneration !== joinLeaveGeneration) return;
       }
       this.publisher = new Publisher(
         basePeerConnectionOptions,
@@ -1702,9 +1827,19 @@ export class Call {
    *
    * @internal
    * @param data the join call data.
+   * @returns The coordinator response, or undefined if leave superseded the request before it was sent.
    */
-  doJoinRequest = async (data?: JoinCallData): Promise<JoinCallResponse> => {
+  doJoinRequest = async (
+    data?: JoinCallData,
+  ): Promise<JoinCallResponse | undefined> => {
+    const joinLeaveGeneration = this.leaveGeneration;
     const location = await this.streamClient.getLocationHint();
+    if (this.leaveGeneration !== joinLeaveGeneration) {
+      this.logger.debug(
+        'Join superseded by leave; not sending coordinator request',
+      );
+      return;
+    }
     const e2ee = !!this.e2eeManager;
     const request: JoinCallRequest = { ...data, location, e2ee };
     const joinResponse = await this.streamClient.post<
@@ -1712,6 +1847,13 @@ export class Call {
       JoinCallRequest
     >(`${this.streamClientBasePath}/join`, request);
 
+    if (this.leaveGeneration !== joinLeaveGeneration) {
+      this.logger.debug(
+        'Join superseded by leave; not applying coordinator response',
+      );
+      return joinResponse;
+    }
+
     this.state.updateFromCallResponse(joinResponse.call);
     this.state.setMembers(joinResponse.members);
     this.state.setOwnCapabilities(joinResponse.own_capabilities);
@@ -1726,6 +1868,7 @@ export class Call {
     if (!isReconnecting && this.ringing && !this.isCreatedByMe) {
       // signals other users that I have accepted the incoming call.
       await this.accept();
+      if (this.leaveGeneration !== joinLeaveGeneration) return joinResponse;
     }
 
     if (this.streamClient._hasConnectionID()) {
@@ -1830,6 +1973,7 @@ export class Call {
       callingState === CallingState.JOINING ||
       callingState === CallingState.RECONNECTING ||
       callingState === CallingState.MIGRATING ||
+      callingState === CallingState.LEFT ||
       callingState === CallingState.RECONNECTING_FAILED
     )
       return;
@@ -1840,19 +1984,26 @@ export class Call {
     // `POST /join` per entry) once the call is already healthy again.
     if (hasPending(this.reconnectConcurrencyTag)) return;
 
+    const reconnectLeaveGeneration = this.leaveGeneration;
+    const supersededByLeave = () =>
+      this.leaveGeneration !== reconnectLeaveGeneration;
     return withoutConcurrency(this.reconnectConcurrencyTag, async () => {
+      if (supersededByLeave()) return;
       const reconnectStartTime = Date.now();
       this.reconnectStrategy = strategy;
       this.reconnectReason = reason;
       const sfuRejoinFailures = new Map<string, number>();
 
       const markAsReconnectingFailed = async () => {
+        if (supersededByLeave()) return;
         try {
           // attempt to fetch the call data from the server, as the call
           // state might have changed while we were reconnecting or were offline
           await this.get();
         } finally {
-          this.state.setCallingState(CallingState.RECONNECTING_FAILED);
+          if (!supersededByLeave()) {
+            this.state.setCallingState(CallingState.RECONNECTING_FAILED);
+          }
         }
       };
 
@@ -1922,6 +2073,7 @@ export class Call {
         try {
           // wait until the network is available
           await this.networkAvailableTask?.promise;
+          if (supersededByLeave()) return;
 
           this.logger.info(
             `[Reconnect] Reconnecting with strategy ${
@@ -1972,6 +2124,7 @@ export class Call {
           this.consecutiveNegotiationFailures = 0;
           break; // do-while loop, reconnection worked, exit the loop
         } catch (error) {
+          if (supersededByLeave()) return;
           if (attemptedStrategy === WebsocketReconnectStrategy.REJOIN) {
             const failedSfu = this.credentials?.server.edge_name;
             if (failedSfu) {
@@ -2015,6 +2168,7 @@ export class Call {
 
           // exponential backoff with jitter, capped at 5 s
           await sleep(retryInterval(attempt));
+          if (supersededByLeave()) return;
 
           const wasMigrating =
             this.reconnectStrategy === WebsocketReconnectStrategy.MIGRATE;
@@ -2045,6 +2199,7 @@ export class Call {
           );
         }
       } while (
+        !supersededByLeave() &&
         this.state.callingState !== CallingState.JOINED &&
         this.state.callingState !== CallingState.RECONNECTING_FAILED &&
         this.state.callingState !== CallingState.LEFT
@@ -2058,10 +2213,12 @@ export class Call {
    * @internal
    */
   private reconnectFast = async () => {
+    const reconnectLeaveGeneration = this.leaveGeneration;
     const reconnectStartTime = Date.now();
     this.reconnectStrategy = WebsocketReconnectStrategy.FAST;
     this.state.setCallingState(CallingState.RECONNECTING);
     await this.doJoin(this.joinCallData);
+    if (this.leaveGeneration !== reconnectLeaveGeneration) return;
     await this.get(); // fetch the latest call state, as it might have changed
     this.sfuStatsReporter?.sendReconnectionTime(
       WebsocketReconnectStrategy.FAST,
@@ -2074,6 +2231,7 @@ export class Call {
    * @internal
    */
   private reconnectRejoin = async () => {
+    const reconnectLeaveGeneration = this.leaveGeneration;
     const reconnectStartTime = Date.now();
     this.reconnectStrategy = WebsocketReconnectStrategy.REJOIN;
     this.state.setCallingState(CallingState.RECONNECTING);
@@ -2081,10 +2239,14 @@ export class Call {
       this.reconnectReason === ReconnectReason.NETWORK_BACK_ONLINE
         ? 'network-available'
         : 'full-rejoin';
-    await this.clientEventReporter.withJoinLifecycle(this.cid, joinReason, () =>
-      this.doJoin(this.joinCallData),
+    await this.clientEventReporter.withJoinLifecycle(
+      this.cid,
+      { joinReason },
+      () => this.doJoin(this.joinCallData),
     );
+    if (this.leaveGeneration !== reconnectLeaveGeneration) return;
     await this.restorePublishedTracks();
+    if (this.leaveGeneration !== reconnectLeaveGeneration) return;
     this.restoreSubscribedTracks();
     this.sfuStatsReporter?.sendReconnectionTime(
       WebsocketReconnectStrategy.REJOIN,
@@ -2097,6 +2259,7 @@ export class Call {
    * @internal
    */
   private reconnectMigrate = async () => {
+    const reconnectLeaveGeneration = this.leaveGeneration;
     const reconnectStartTime = Date.now();
     const currentSfuClient = this.sfuClient;
     if (!currentSfuClient) {
@@ -2114,32 +2277,35 @@ export class Call {
     const migrationTask = makeSafePromise(currentSfuClient.enterMigration());
 
     try {
-      const currentSfu = currentSfuClient.edgeName;
-      await this.clientEventReporter.withJoinLifecycle(
-        this.cid,
-        'migration',
-        () =>
-          this.doJoin({
-            ...this.joinCallData,
-            migrating_from: currentSfu,
-            migrating_from_list: [currentSfu],
-          }),
-      );
-    } finally {
-      // cleanup the migration_from field after the migration is complete or failed
-      // as we don't want to keep dirty data in the join call data
-      delete this.joinCallData?.migrating_from;
-      delete this.joinCallData?.migrating_from_list;
-    }
+      try {
+        const currentSfu = currentSfuClient.edgeName;
+        await this.clientEventReporter.withJoinLifecycle(
+          this.cid,
+          { joinReason: 'migration' },
+          () =>
+            this.doJoin({
+              ...this.joinCallData,
+              migrating_from: currentSfu,
+              migrating_from_list: [currentSfu],
+            }),
+        );
+      } finally {
+        // cleanup the migration_from field after the migration is complete or failed
+        // as we don't want to keep dirty data in the join call data
+        delete this.joinCallData?.migrating_from;
+        delete this.joinCallData?.migrating_from_list;
+      }
 
-    await this.restorePublishedTracks();
-    this.restoreSubscribedTracks();
+      if (this.leaveGeneration !== reconnectLeaveGeneration) return;
+      await this.restorePublishedTracks();
+      if (this.leaveGeneration !== reconnectLeaveGeneration) return;
+      this.restoreSubscribedTracks();
 
-    try {
       // Wait for the migration to complete, then close the previous SFU client
       // and the peer connection instances. In case of failure, the migration
       // task would throw an error and REJOIN would be attempted.
       await migrationTask();
+      if (this.leaveGeneration !== reconnectLeaveGeneration) return;
 
       // in MIGRATE, we can consider the call as joined only after
       // `participantMigrationComplete` event is received, signaled by
@@ -2473,10 +2639,11 @@ export class Call {
    * Must be called before {@link join} so the RTCPeerConnection can be
    * configured for E2EE.
    *
-   * The manager is kept across {@link leave} so a rejoin of this same instance
-   * stays encrypted: do not dispose it while this call may be joined again.
-   * A disposed manager throws from `encrypt`/`decrypt` rather than silently
-   * publishing nothing, so re-attach a fresh one instead of reusing it.
+   * The application owns the manager's lifetime - the SDK never disposes it, and
+   * closing the peer connections does not release it. Discard the manager
+   * together with this call instance once its flow has ended, and create a fresh
+   * pair for a later flow: a disposed manager throws from `encrypt`/`decrypt`
+   * rather than silently publishing nothing.
    *
    * @param e2ee - Any `E2EEManager`. Use `EncryptionManager.create()` for the
    *         built-in AES-GCM scheme, or pass your own implementation.
@@ -3114,42 +3281,39 @@ export class Call {
    */
   private scheduleAutoDrop = () => {
     this.cancelAutoDrop();
-
-    const settings = this.state.settings;
-    if (!settings) return;
-    // ignore if the call is not ringing
-    if (this.state.callingState !== CallingState.RINGING) return;
-
-    const timeoutInMs = this.isCreatedByMe
-      ? settings.ring.auto_cancel_timeout_ms
-      : settings.ring.incoming_call_timeout_ms;
-
-    // 0 means no auto-drop
-    if (timeoutInMs <= 0) return;
-    this.dropTimeout = setTimeout(() => {
-      // the call might have stopped ringing by this point,
-      // e.g. it was already accepted and joined
-      if (this.state.callingState !== CallingState.RINGING) return;
-      this.leave({
-        reject: true,
-        reason: 'timeout',
-        message: `ringing timeout - ${
-          this.isCreatedByMe
-            ? 'no one accepted'
-            : `user didn't interact with incoming call screen`
-        }`,
-      }).catch((err) => {
-        this.logger.error('Failed to drop call', err);
-      });
-    }, timeoutInMs);
+    this.ringTimeout = new RingTimeout(this);
+    this.ringTimeout.start();
   };
 
   /**
    * Cancels a scheduled auto-drop timeout.
    */
   private cancelAutoDrop = () => {
-    clearTimeout(this.dropTimeout);
-    this.dropTimeout = undefined;
+    this.ringTimeout?.stop();
+    this.ringTimeout = undefined;
+  };
+
+  /**
+   * Starts polling for the ring outcome. Applicable only to ringing calls the
+   * current user created.
+   */
+  private scheduleRingStatePolling = () => {
+    this.cancelRingStatePolling();
+
+    if (!this.isCreatedByMe) return;
+    const options = this.streamClient.options.ringStatePolling;
+    if (options === false) return;
+
+    this.ringStatePoller = new RingStatePoller(this, options);
+    this.ringStatePoller.start();
+  };
+
+  /**
+   * Cancels the ring state polling.
+   */
+  private cancelRingStatePolling = () => {
+    this.ringStatePoller?.stop();
+    this.ringStatePoller = undefined;
   };
 
   /**