@stream-io/video-client 1.60.0 → 1.61.1

package/src/__tests__/Call.ringingLifecycle.test.ts

@@ -0,0 +1,242 @@
+/**
+ * @vitest-environment happy-dom
+ */
+
+import '../rtc/__tests__/mocks/webrtc.mocks';
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { Call } from '../Call';
+import { CallingState } from '../store';
+import { StreamClient } from '../coordinator/connection/client';
+import { ClientEventReporter } from '../reporting';
+import { generateUUIDv4 } from '../coordinator/connection/utils';
+import { StreamVideoWriteableStateStore } from '../store';
+
+/**
+ * The core's whole part in the React Native ringing lifecycle: await RN's
+ * preparation inside the join, tell RN when a ringing join failed terminally or
+ * the call ended, and stop a join that a `leave()` overtook. What preparation
+ * and release actually do is RN's, and is tested there.
+ */
+
+const createCall = (ringing: boolean) => {
+  const streamClient = new StreamClient('abc');
+  return new Call({
+    type: 'test',
+    id: generateUUIDv4(),
+    ringing,
+    streamClient,
+    clientEventReporter: new ClientEventReporter({
+      streamClient,
+      enabled: false,
+    }),
+    clientStore: new StreamVideoWriteableStateStore(),
+  });
+};
+
+const install = (overrides: Record<string, unknown> = {}) => {
+  const beforeJoin = vi.fn(() => Promise.resolve());
+  const onJoinFailed = vi.fn(() => Promise.resolve());
+  const onLeave = vi.fn();
+  const callingX = { joinCall: vi.fn(), endCall: vi.fn() };
+  globalThis.streamRNVideoSDK = {
+    ringingCallLifecycle: { beforeJoin, onJoinFailed, onLeave },
+    callingX,
+    // `leave()` reaches this unconditionally; the globals object is all-or-nothing
+    callManager: { setup: vi.fn(), start: vi.fn(), stop: vi.fn() },
+    ...overrides,
+  } as any;
+  return { beforeJoin, onJoinFailed, onLeave, callingX };
+};
+
+describe('ringing call lifecycle integration', () => {
+  beforeEach(() => {
+    globalThis.streamRNVideoSDK = undefined;
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue({
+      headers: { get: () => 'AMS1-P2' },
+    } as Response);
+  });
+
+  afterEach(() => {
+    globalThis.streamRNVideoSDK = undefined;
+    vi.restoreAllMocks();
+  });
+
+  it('prepares a ringing call before it joins', async () => {
+    const { beforeJoin, callingX } = install();
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await call.join();
+
+    expect(beforeJoin).toHaveBeenCalledTimes(1);
+    expect(beforeJoin).toHaveBeenCalledBefore(callingX.joinCall);
+    expect(doJoin).toHaveBeenCalledTimes(1);
+  });
+
+  it('leaves ordinary calls to join themselves', async () => {
+    const { beforeJoin, onJoinFailed } = install();
+    const call = createCall(false);
+    vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await call.join();
+
+    expect(beforeJoin).not.toHaveBeenCalled();
+    expect(onJoinFailed).not.toHaveBeenCalled();
+  });
+
+  it('does not join when preparation fails, and reports the failure', async () => {
+    const { beforeJoin, onJoinFailed } = install();
+    beforeJoin.mockRejectedValue(new Error('no key'));
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await expect(call.join()).rejects.toThrow('no key');
+
+    expect(doJoin).not.toHaveBeenCalled();
+    expect(onJoinFailed).toHaveBeenCalledWith(call);
+  });
+
+  it('reports a terminal join failure, keeping the original error', async () => {
+    const { onJoinFailed } = install();
+    const call = createCall(true);
+    vi.spyOn(call as any, 'doJoin').mockRejectedValue(new Error('sfu down'));
+
+    await expect(call.join({ maxJoinRetries: 1 })).rejects.toThrow('sfu down');
+
+    expect(onJoinFailed).toHaveBeenCalledWith(call);
+  });
+
+  it('refuses a duplicate join on a live call without tearing it down', async () => {
+    const { beforeJoin, onJoinFailed, onLeave } = install();
+    const call = createCall(true);
+    vi.spyOn(call as any, 'doJoin').mockImplementation(async () => {
+      call.state.setCallingState(CallingState.JOINED);
+    });
+
+    await call.join();
+    await expect(call.join()).rejects.toThrow('Illegal State');
+
+    expect(beforeJoin).toHaveBeenCalledTimes(1);
+    // the guard sits ahead of the failure boundary, so nothing is released
+    expect(onJoinFailed).not.toHaveBeenCalled();
+    expect(onLeave).not.toHaveBeenCalled();
+  });
+
+  it('tells the owner when a ringing call ends', async () => {
+    const { onLeave } = install();
+    const call = createCall(true);
+
+    await call.leave();
+
+    expect(onLeave).toHaveBeenCalledWith(call);
+    expect(call.state.callingState).toBe(CallingState.LEFT);
+  });
+
+  it('does not tell the owner about an ordinary call', async () => {
+    const { onLeave } = install();
+
+    await createCall(false).leave();
+
+    expect(onLeave).not.toHaveBeenCalled();
+  });
+
+  it('keeps an app-owned manager across leave, as setE2EEManager promises', async () => {
+    install();
+    const call = createCall(true);
+    const manager = { encrypt: vi.fn(), decrypt: vi.fn() } as any;
+    call.setE2EEManager(manager);
+
+    await call.leave();
+
+    expect(call.e2eeManager).toBe(manager);
+  });
+
+  it('abandons a join that a leave overtook during native registration', async () => {
+    let finishRegistration: () => void = () => {};
+    const { callingX, onLeave, onJoinFailed } = install();
+    callingX.joinCall.mockImplementation(
+      () => new Promise<void>((resolve) => (finishRegistration = resolve)),
+    );
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    const joining = call.join();
+    await vi.waitFor(() => expect(callingX.joinCall).toHaveBeenCalled());
+    await call.leave({ reject: false });
+    finishRegistration();
+
+    // A superseding leave is not a join failure: the join settles quietly rather
+    // than rejecting, and the error path stays shut.
+    await expect(joining).resolves.toBeUndefined();
+    expect(onJoinFailed).not.toHaveBeenCalled();
+    expect(callingX.endCall).not.toHaveBeenCalledWith(call, 'error');
+    // Release still happens - `leave()` itself fires it, which is why the join
+    // does not need to.
+    expect(onLeave).toHaveBeenCalledTimes(1);
+    // `doJoin` captures the generation itself, so this check has to be here
+    expect(doJoin).not.toHaveBeenCalled();
+  });
+
+  it('does not resume the retry loop after a leave during backoff', async () => {
+    vi.useFakeTimers();
+    try {
+      install();
+      const call = createCall(true);
+      const doJoin = vi
+        .spyOn(call as any, 'doJoin')
+        .mockRejectedValue(new Error('recoverable'));
+
+      const joining = call.join().catch(() => {});
+      await vi.waitFor(() => expect(doJoin).toHaveBeenCalledTimes(1));
+      await call.leave({ reject: false });
+      await vi.advanceTimersByTimeAsync(30_000);
+      await joining;
+
+      expect(doJoin).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it('prepares an outgoing call that this join makes ringing', async () => {
+    const { beforeJoin } = install();
+    // a fresh instance, not ringing until its first join says so
+    const call = createCall(false);
+    vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    await call.join({ ring: true });
+
+    // reading `call.ringing` before applying `options.ring` would skip
+    // preparation entirely on this path
+    expect(beforeJoin).toHaveBeenCalledTimes(1);
+  });
+
+  it('stops a join that a leave overtook during preparation', async () => {
+    let releaseHook: () => void = () => {};
+    const { beforeJoin, onLeave, onJoinFailed } = install();
+    beforeJoin.mockImplementation(
+      () => new Promise<void>((resolve) => (releaseHook = resolve)),
+    );
+    const call = createCall(true);
+    const doJoin = vi.spyOn(call as any, 'doJoin').mockResolvedValue(undefined);
+
+    const joining = call.join();
+    await vi.waitFor(() => expect(beforeJoin).toHaveBeenCalled());
+    await call.leave({ reject: false });
+    releaseHook();
+
+    await expect(joining).resolves.toBeUndefined();
+    expect(onJoinFailed).not.toHaveBeenCalled();
+    // Whatever `beforeJoin` installed is released exactly once, by the `leave()`
+    // that overtook the join rather than by the join itself.
+    expect(onLeave).toHaveBeenCalledTimes(1);
+    expect(doJoin).not.toHaveBeenCalled();
+    expect(call.state.callingState).toBe(CallingState.LEFT);
+  });
+
+  it('is inert when no React Native globals are registered', async () => {
+    const call = createCall(true);
+    await expect(call.leave()).resolves.not.toThrow();
+  });
+});

package/src/reporting/ClientEventReporter.ts

@@ -597,11 +597,16 @@ export class ClientEventReporter {
     }
 
     if (event.state === 'failed') {
+      const iceConnected =
+        event.iceConnectionState === 'connected' ||
+        event.iceConnectionState === 'completed';
       this.emitPeerConnectionFailure(
         cid,
         role,
-        'DTLS_CONNECTIVITY_FAILED',
-        'DTLS connectivity checks failed',
+        iceConnected ? 'DTLS_CONNECTIVITY_FAILED' : 'ICE_CONNECTIVITY_FAILED',
+        iceConnected
+          ? 'DTLS connectivity checks failed'
+          : 'ICE connectivity checks failed',
       );
       return;
     }

package/src/reporting/__tests__/ClientEventReporter.test.ts

@@ -755,7 +755,7 @@ describe('ClientEventReporter', () => {
     });
   });
 
-  it('reports a DTLS failure with the real ICE state (never connected)', async () => {
+  it('reports an ICE failure when the peer connection fails before ICE connected', async () => {
     reporter.startCorrelation(cid, 'first-attempt');
     reportPeerConnectionState(
       PeerType.PUBLISHER_UNSPECIFIED,
@@ -779,7 +779,7 @@ describe('ClientEventReporter', () => {
     expect(completed[0]).toMatchObject({
       outcome: 'failure',
       peer_connection: 'publish',
-      retry_failure_code: 'DTLS_CONNECTIVITY_FAILED',
+      retry_failure_code: 'ICE_CONNECTIVITY_FAILED',
       ice_state: 'NOT_CONNECTED',
     });
   });

package/src/rtc/BasePeerConnection.ts

@@ -344,9 +344,14 @@ export abstract class BasePeerConnection {
 
     // we can't recover from a failed connection state (contrary to ICE)
     if (state === 'failed') {
+      const reason = this.iceHasEverConnected
+        ? ReconnectReason.CONNECTION_FAILED
+        : ReconnectReason.ICE_NEVER_CONNECTED;
+      clearTimeout(this.preConnectStuckTimeout);
+      this.preConnectStuckTimeout = undefined;
       this.onReconnectionNeeded?.(
         WebsocketReconnectStrategy.REJOIN,
-        ReconnectReason.CONNECTION_FAILED,
+        reason,
         this.peerType,
       );
       return;

package/src/rtc/Publisher.ts

@@ -150,7 +150,9 @@ export class Publisher extends BasePeerConnection {
     const sendEncodings = isSvcCodec(publishOption.codec?.name)
       ? toSvcEncodings(encodings)
       : encodings;
-    const transceiver = this.pc.addTransceiver(track, {
+    // An E2EE sender must never have media before its transform is attached,
+    // including when another track or an ICE restart negotiates this PC.
+    const transceiver = this.pc.addTransceiver(this.e2ee ? track.kind : track, {
       direction: 'sendonly',
       sendEncodings,
     });
@@ -161,23 +163,75 @@ export class Publisher extends BasePeerConnection {
     this.trackIdToTrackType.set(track.id, trackType);
     this.logger.debug(`Added ${TrackType[trackType]} transceiver`);
 
-    const params = transceiver.sender.getParameters();
-    params.degradationPreference =
-      toRTCDegradationPreference(publishOption.degradationPreference) ??
-      'maintain-framerate';
-    await transceiver.sender.setParameters(params);
     if (this.e2ee) {
-      this.e2ee.encrypt(
-        transceiver.sender,
-        publishOption.codec?.name.toLowerCase(),
-        TrackType[publishOption.trackType],
-      );
-      this.logger.debug('E2EE encryptor attached to sender');
+      await this.initEncryptedSender(transceiver, track, publishOption);
+    } else {
+      await this.setDegradationPreference(transceiver.sender, publishOption);
     }
 
     await this.negotiate();
   };
 
+  /**
+   * Attaches the encryptor, applies sender parameters, then attaches the track.
+   *
+   * `encrypt` must run before the first await: Chrome short-circuits a sender
+   * whose encoded streams aren't created in the task that created it, and the
+   * track goes on last so the sender has no media until both steps succeed.
+   */
+  private initEncryptedSender = async (
+    transceiver: RTCRtpTransceiver,
+    track: MediaStreamTrack,
+    publishOption: PublishOption,
+  ) => {
+    try {
+      const { sender } = transceiver;
+      const codec = publishOption.codec?.name.toLowerCase();
+      this.e2ee!.encrypt(sender, codec, TrackType[publishOption.trackType]);
+      this.logger.debug('E2EE encryptor attached to sender');
+      await this.setDegradationPreference(sender, publishOption);
+      await sender.replaceTrack(track);
+    } catch (err) {
+      this.retireTransceiver(transceiver, track);
+      throw err;
+    }
+  };
+
+  private setDegradationPreference = async (
+    sender: RTCRtpSender,
+    publishOption: PublishOption,
+  ) => {
+    const params = sender.getParameters();
+    params.degradationPreference =
+      toRTCDegradationPreference(publishOption.degradationPreference) ??
+      'maintain-framerate';
+    await sender.setParameters(params);
+  };
+
+  /**
+   * Discards a sender whose E2EE initialization failed.
+   *
+   * A partially initialized sender may carry no transform, so publish() must
+   * not reuse it: retiring it from the cache is what keeps a later publish or
+   * ICE restart from putting cleartext on the wire. Cleanup cannot throw, so
+   * the initialization failure is what reaches the caller.
+   */
+  private retireTransceiver = (
+    transceiver: RTCRtpTransceiver,
+    track: MediaStreamTrack,
+  ) => {
+    this.transceiverCache.remove(transceiver);
+    this.trackIdToTrackType.delete(track.id);
+    // on React Native a clone shares its native source, so stopping it here
+    // would stop the track the caller passed in. dispose() releases it.
+    if (!isReactNative()) this.stopTrack(track);
+    try {
+      transceiver.stop();
+    } catch (err) {
+      this.logger.debug('Failed to stop a retired transceiver', err);
+    }
+  };
+
   /**
    * Updates the transceiver with the given track and track type.
    */

package/src/rtc/TransceiverCache.ts

@@ -21,6 +21,23 @@ export class TransceiverCache {
     this.transceiverOrder.push(bundle.transceiver);
   };
 
+  /**
+   * Retires a failed sender from the reusable cache.
+   *
+   * A transceiver that never reached an m-section also leaves the creation
+   * history: once stopped, it is left out of every later offer, so counting
+   * it would shift the `mid` index of every transceiver added after it. One
+   * that is already associated keeps its slot, since its m-section survives
+   * as a rejected one.
+   */
+  remove = (transceiver: RTCRtpTransceiver) => {
+    const index = this.cache.findIndex((b) => b.transceiver === transceiver);
+    if (index !== -1) this.cache.splice(index, 1);
+    if (transceiver.mid) return;
+    const orderIndex = this.transceiverOrder.indexOf(transceiver);
+    if (orderIndex !== -1) this.transceiverOrder.splice(orderIndex, 1);
+  };
+
   /**
    * Gets the transceiver for the given publish option.
    */