@stream-io/video-client 1.52.1-beta.0 → 1.53.1

package/src/rtc/Publisher.ts

@@ -39,7 +39,6 @@ export class Publisher extends BasePeerConnection {
   private readonly transceiverCache = new TransceiverCache();
   private readonly clonedTracks = new Set<MediaStreamTrack>();
   private publishOptions: PublishOption[];
-  private readonly selfSubEnabled: boolean;
 
   /**
    * Constructs a new `Publisher` instance.
@@ -47,11 +46,9 @@ export class Publisher extends BasePeerConnection {
   constructor(
     baseOptions: BasePeerConnectionOpts,
     publishOptions: PublishOption[],
-    opts: { selfSubEnabled?: boolean } = {},
   ) {
     super(PeerType.PUBLISHER_UNSPECIFIED, baseOptions);
     this.publishOptions = publishOptions;
-    this.selfSubEnabled = opts.selfSubEnabled ?? false;
 
     this.on('iceRestart', (iceRestart) => {
       if (iceRestart.peerType !== PeerType.PUBLISHER_UNSPECIFIED) return;
@@ -579,7 +576,6 @@ export class Publisher extends BasePeerConnection {
       muted: !isTrackLive,
       codec: publishOption.codec,
       publishOptionId: publishOption.id,
-      selfSubAudioVideo: this.selfSubEnabled,
     };
   };
 

package/src/rtc/Subscriber.ts

@@ -14,14 +14,6 @@ import { enableStereo, removeCodecsExcept } from './helpers/sdp';
  * @internal
  */
 export class Subscriber extends BasePeerConnection {
-  /**
-   * Remote streams received from the SFU. For a self-sub case
-   * we need to be able to distinguish between the local capture stream.
-   * The map will never contain local streams so we can safely use it to
-   * check if the stream is remote and dispose it when needed.
-   */
-  private trackedStreams: WeakSet<MediaStream> = new WeakSet();
-
   /**
    * Constructs a new `Subscriber` instance.
    */
@@ -83,7 +75,6 @@ export class Subscriber extends BasePeerConnection {
     const participantToUpdate = this.state.participants.find(
       (p) => p.trackLookupPrefix === trackId,
     );
-    const isSelfSub = !!participantToUpdate?.isLocalParticipant;
     this.logger.debug(
       `[onTrack]: Got remote ${rawTrackType} track for userId: ${participantToUpdate?.userId}`,
       track.id,
@@ -103,6 +94,7 @@ export class Subscriber extends BasePeerConnection {
     track.addEventListener('unmute', () => {
       this.logger.info(`[onTrack]: Track unmuted: ${trackDebugInfo}`);
       this.setRemoteTrackInterrupted(trackId, trackType, false);
+      this.onRemoteTrackUnmute?.(trackType, track.id);
     });
     track.addEventListener('ended', () => {
       this.logger.info(`[onTrack]: Track ended: ${trackDebugInfo}`);
@@ -116,10 +108,6 @@ export class Subscriber extends BasePeerConnection {
 
     this.trackIdToTrackType.set(track.id, trackType);
 
-    if (isSelfSub) {
-      this.trackedStreams.add(primaryStream);
-    }
-
     if (!participantToUpdate) {
       this.logger.warn(
         `[onTrack]: Received track for unknown participant: ${trackId}`,
@@ -140,13 +128,6 @@ export class Subscriber extends BasePeerConnection {
       return;
     }
 
-    // Self-sub loopback audio routes to the speaker by default, which
-    // would echo the local user's voice. Default-mute here; consumers
-    // (the loopback recording hook) re-enable explicitly when needed.
-    if (isSelfSub && e.track.kind === 'audio') {
-      e.track.enabled = false;
-    }
-
     // get the previous stream to dispose it later
     // usually this happens during migration, when the stream is replaced
     // with a new one but the old one is still in the state
@@ -157,15 +138,8 @@ export class Subscriber extends BasePeerConnection {
       [streamKindProp]: primaryStream,
     });
 
+    // now, dispose the previous stream if it exists
     if (previousStream) {
-      if (isSelfSub && !this.trackedStreams.has(previousStream)) {
-        // this is the local capture stream, we don't want to dispose it
-        this.logger.debug(
-          `[onTrack]: Skipping cleanup of previous ${e.track.kind} stream for userId: ${participantToUpdate.userId} because it is not tracked`,
-        );
-        return;
-      }
-
       this.logger.info(
         `[onTrack]: Cleaning up previous remote ${track.kind} tracks for userId: ${participantToUpdate.userId}`,
       );

package/src/rtc/__tests__/Call.reconnect.test.ts

@@ -3,6 +3,7 @@ import './mocks/webrtc.mocks';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { Call } from '../../Call';
 import { StreamClient } from '../../coordinator/connection/client';
+import { ClientEventReporter } from '../../reporting';
 import { StreamVideoWriteableStateStore } from '../../store';
 import { CallingState } from '../../store';
 import { NegotiationError } from '../NegotiationError';
@@ -30,6 +31,7 @@ const makeCall = () => {
     type: 'default',
     id: 'test-call',
     streamClient,
+    clientEventReporter: new ClientEventReporter({ streamClient }),
     clientStore,
     ringing: false,
     watching: false,
@@ -585,6 +587,7 @@ describe('Call reconnect wiring (PC event → leave)', () => {
       type: 'default',
       id: 'test-call',
       streamClient,
+      clientEventReporter: new ClientEventReporter({ streamClient }),
       clientStore,
       ringing: false,
       watching: false,

package/src/rtc/types.ts

@@ -2,6 +2,7 @@ import {
   AudioBitrateProfile,
   PeerType,
   PublishOption,
+  TrackType,
   WebsocketReconnectStrategy,
 } from '../gen/video/sfu/models/models';
 import { StreamSfuClient } from '../StreamSfuClient';
@@ -53,6 +54,37 @@ export type OnReconnectionNeeded = (
  */
 export type OnIceConnected = (peerType: PeerType) => void;
 
+/**
+ * Snapshot of the peer connection's ICE and DTLS state surfaced to telemetry
+ * consumers (e.g. `ClientEventReporter`). Fired on every transition of
+ * either `iceConnectionState` or `peerConnectionState`.
+ */
+export type PeerConnectionStateChangeEvent =
+  | {
+      peerType: PeerType;
+      stateType: 'ice';
+      state: RTCIceConnectionState;
+    }
+  | {
+      peerType: PeerType;
+      stateType: 'peerConnection';
+      state: RTCPeerConnectionState;
+    };
+
+export type OnPeerConnectionStateChange = (
+  event: PeerConnectionStateChangeEvent,
+) => void;
+
+/**
+ * Fired when a remote track starts receiving media (`unmute`). Used by
+ * telemetry to report the `FirstVideoFrame` / `FirstAudioFrame` stage; the
+ * consumer decides which track types are relevant.
+ */
+export type OnRemoteTrackUnmute = (
+  trackType: TrackType,
+  trackId: string,
+) => void;
+
 export type BasePeerConnectionOpts = {
   sfuClient: StreamSfuClient;
   state: CallState;
@@ -60,6 +92,8 @@ export type BasePeerConnectionOpts = {
   dispatcher: Dispatcher;
   onReconnectionNeeded?: OnReconnectionNeeded;
   onIceConnected?: OnIceConnected;
+  onPeerConnectionStateChange?: OnPeerConnectionStateChange;
+  onRemoteTrackUnmute?: OnRemoteTrackUnmute;
   tag: string;
   enableTracing: boolean;
   iceRestartDelay?: number;

package/src/types.ts

@@ -14,6 +14,7 @@ import type {
   StartRecordingResponse,
 } from './gen/coordinator';
 import type { StreamClient } from './coordinator/connection/client';
+import type { ClientEventReporter } from './reporting';
 import type {
   RejectReason,
   StreamClientOptions,
@@ -311,6 +312,11 @@ export type CallConstructor = {
    */
   streamClient: StreamClient;
 
+  /**
+   * The shared client event reporter, owned by `StreamVideoClient`.
+   */
+  clientEventReporter: ClientEventReporter;
+
   /**
    * The Call type.
    */
@@ -474,6 +480,18 @@ export type StreamRNVideoSDKGlobals = {
      * Stops the in call manager.
      */
     stop({ isRingingTypeCall }: StreamRNVideoSDKCallManagerRingingParams): void;
+
+    /**
+     * iOS-only. Keeps the audio engine's microphone-input (voice-processing)
+     * chain prepared while the mic is muted, so the `AVAudioEngine` stays full-duplex
+     * meaning: mic going out and speaker coming in, simultaneously
+     *
+     * Without this, joining muted builds an output-only engine under the
+     * `PlayAndRecord`/`VoiceChat` (VPIO) session, which makes the remote audio
+     * not audible when joining muted. As echo cancellation expects the mic to be
+     * prepared.
+     */
+    setMutedRecordingPrepared?(enabled: boolean): void;
   };
   permissions: {
     /**