livekit-client 2.1.2 → 2.1.4

package/src/room/RTCEngine.ts

@@ -9,6 +9,7 @@ import {
   DisconnectReason,
   type JoinResponse,
   type LeaveRequest,
+  LeaveRequest_Action,
   ParticipantInfo,
   ReconnectReason,
   type ReconnectResponse,
@@ -435,7 +436,9 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.emit(EngineEvent.MediaTrackAdded, ev.track, ev.streams[0], ev.receiver);
     };
 
-    this.createDataChannels();
+    if (!supportOptionalDatachannel(joinResponse.serverInfo?.protocol)) {
+      this.createDataChannels();
+    }
   }
 
   private setupSignalClientCallbacks() {
@@ -504,16 +507,28 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       this.handleDisconnect('signal', ReconnectReason.RR_SIGNAL_DISCONNECTED);
     };
 
-    this.client.onLeave = (leave?: LeaveRequest) => {
-      if (leave?.canReconnect) {
-        this.fullReconnectOnNext = true;
-        // reconnect immediately instead of waiting for next attempt
-        this.handleDisconnect(leaveReconnect);
-      } else {
-        this.emit(EngineEvent.Disconnected, leave?.reason);
-        this.close();
-      }
+    this.client.onLeave = (leave: LeaveRequest) => {
       this.log.debug('client leave request', { ...this.logContext, reason: leave?.reason });
+      if (leave.regions && this.regionUrlProvider) {
+        this.log.debug('updating regions', this.logContext);
+        this.regionUrlProvider.setServerReportedRegions(leave.regions);
+      }
+      switch (leave.action) {
+        case LeaveRequest_Action.DISCONNECT:
+          this.emit(EngineEvent.Disconnected, leave?.reason);
+          this.close();
+          break;
+        case LeaveRequest_Action.RECONNECT:
+          this.fullReconnectOnNext = true;
+          // reconnect immediately instead of waiting for next attempt
+          this.handleDisconnect(leaveReconnect);
+          break;
+        case LeaveRequest_Action.RESUME:
+          // reconnect immediately instead of waiting for next attempt
+          this.handleDisconnect(leaveReconnect);
+        default:
+          break;
+      }
     };
   }
 
@@ -1103,11 +1118,21 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       throw new ConnectionError(`${transportName} connection not set`);
     }
 
+    let needNegotiation = false;
+    if (!subscriber && !this.dataChannelForKind(kind, subscriber)) {
+      this.createDataChannels();
+      needNegotiation = true;
+    }
+
     if (
+      !needNegotiation &&
       !subscriber &&
       !this.pcManager.publisher.isICEConnected &&
       this.pcManager.publisher.getICEConnectionState() !== 'checking'
     ) {
+      needNegotiation = true;
+    }
+    if (needNegotiation) {
       // start negotiation
       this.negotiate();
     }
@@ -1168,6 +1193,14 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
       }
 
       this.pcManager.requirePublisher();
+      // don't negotiate without any transceivers or data channel, it will generate sdp without ice frag then negotiate failed
+      if (
+        this.pcManager.publisher.getTransceivers().length == 0 &&
+        !this.lossyDC &&
+        !this.reliableDC
+      ) {
+        this.createDataChannels();
+      }
 
       const abortController = new AbortController();
 
@@ -1378,3 +1411,7 @@ export type EngineEventCallbacks = {
   remoteMute: (trackSid: string, muted: boolean) => void;
   offline: () => void;
 };
+
+function supportOptionalDatachannel(protocol: number | undefined): boolean {
+  return protocol !== undefined && protocol > 13;
+}

package/src/room/RegionUrlProvider.ts

@@ -75,6 +75,11 @@ export class RegionUrlProvider {
       );
     }
   }
+
+  setServerReportedRegions(regions: RegionSettings) {
+    this.regionSettings = regions;
+    this.lastUpdateAt = Date.now();
+  }
 }
 
 function getCloudConfigUrl(serverUrl: URL) {

package/src/room/Room.ts

@@ -4,6 +4,7 @@ import {
   DisconnectReason,
   JoinResponse,
   LeaveRequest,
+  LeaveRequest_Action,
   ParticipantInfo,
   ParticipantInfo_State,
   ParticipantPermission,
@@ -859,7 +860,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
             onLeave(
               new LeaveRequest({
                 reason: DisconnectReason.CLIENT_INITIATED,
-                canReconnect: true,
+                action: LeaveRequest_Action.RECONNECT,
               }),
             );
           }
@@ -876,7 +877,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           },
         });
         break;
-
+      case 'leave-full-reconnect':
+        req = new SimulateScenario({
+          scenario: {
+            case: 'leaveRequestFullReconnect',
+            value: true,
+          },
+        });
       default:
     }
     if (req) {

package/src/room/participant/LocalParticipant.ts

@@ -54,6 +54,7 @@ import { trackPermissionToProto } from './ParticipantTrackPermission';
 import {
   computeTrackBackupEncodings,
   computeVideoEncodings,
+  getDefaultDegradationPreference,
   mediaTrackToLocalTrack,
 } from './publishUtils';
 
@@ -857,6 +858,11 @@ export default class LocalParticipant extends Participant {
 
     track.sender = await this.engine.createSender(track, opts, encodings);
 
+    if (track instanceof LocalVideoTrack) {
+      opts.degradationPreference ??= getDefaultDegradationPreference(track);
+      track.setDegradationPreference(opts.degradationPreference);
+    }
+
     if (encodings) {
       if (isFireFox() && track.kind === Track.Kind.Audio) {
         /* Refer to RFC https://datatracker.ietf.org/doc/html/rfc7587#section-6.1,
@@ -880,8 +886,7 @@ export default class LocalParticipant extends Participant {
             maxbr: encodings[0]?.maxBitrate ? encodings[0].maxBitrate / 1000 : 0,
           });
         }
-      } else if (track.codec && track.codec == 'av1' && encodings[0]?.maxBitrate) {
-        // AV1 requires setting x-start-bitrate in SDP
+      } else if (track.codec && isSVCCodec(track.codec) && encodings[0]?.maxBitrate) {
         this.engine.pcManager.publisher.setTrackCodecBitrate({
           cid: req.cid,
           codec: track.codec,
@@ -890,20 +895,6 @@ export default class LocalParticipant extends Participant {
       }
     }
 
-    if (track.kind === Track.Kind.Video && track.source === Track.Source.ScreenShare) {
-      // a few of reasons we are forcing this setting without allowing overrides:
-      // 1. without this, Chrome seems to aggressively resize the SVC video stating `quality-limitation: bandwidth` even when BW isn't an issue
-      // 2. since we are overriding contentHint to motion (to workaround L1T3 publishing), it overrides the default degradationPreference to `balanced`
-      try {
-        this.log.debug(`setting degradationPreference to maintain-resolution`);
-        const params = track.sender.getParameters();
-        params.degradationPreference = 'maintain-resolution';
-        await track.sender.setParameters(params);
-      } catch (e) {
-        this.log.warn(`failed to set degradationPreference: ${e}`);
-      }
-    }
-
     await this.engine.negotiate();
 
     if (track instanceof LocalVideoTrack) {

package/src/room/participant/publishUtils.ts

@@ -19,6 +19,7 @@ import {
   isReactNative,
   isSVCCodec,
   isSafari,
+  unwrapConstraint,
 } from '../utils';
 
 /** @internal */
@@ -171,6 +172,11 @@ export function computeVideoEncodings(
       });
     }
 
+    if (original.encoding.priority) {
+      encodings[0].priority = original.encoding.priority;
+      encodings[0].networkPriority = original.encoding.priority;
+    }
+
     log.debug(`using svc encoding`, { encodings });
     return encodings;
   }
@@ -435,3 +441,17 @@ export class ScalabilityMode {
     return `L${this.spatial}T${this.temporal}${this.suffix ?? ''}`;
   }
 }
+
+export function getDefaultDegradationPreference(track: LocalVideoTrack): RTCDegradationPreference {
+  // a few of reasons we have different default paths:
+  // 1. without this, Chrome seems to aggressively resize the SVC video stating `quality-limitation: bandwidth` even when BW isn't an issue
+  // 2. since we are overriding contentHint to motion (to workaround L1T3 publishing), it overrides the default degradationPreference to `balanced`
+  if (
+    track.source === Track.Source.ScreenShare ||
+    (track.constraints.height && unwrapConstraint(track.constraints.height) >= 1080)
+  ) {
+    return 'maintain-resolution';
+  } else {
+    return 'balanced';
+  }
+}

package/src/room/track/LocalTrack.ts

@@ -15,8 +15,17 @@ const defaultDimensionsTimeout = 1000;
 export default abstract class LocalTrack<
   TrackKind extends Track.Kind = Track.Kind,
 > extends Track<TrackKind> {
+  protected _sender?: RTCRtpSender;
+
   /** @internal */
-  sender?: RTCRtpSender;
+  get sender(): RTCRtpSender | undefined {
+    return this._sender;
+  }
+
+  /** @internal */
+  set sender(sender: RTCRtpSender | undefined) {
+    this._sender = sender;
+  }
 
   /** @internal */
   codec?: VideoCodec;
@@ -43,6 +52,8 @@ export default abstract class LocalTrack<
 
   protected audioContext?: AudioContext;
 
+  protected manuallyStopped: boolean = false;
+
   private restartLock: Mutex;
 
   /**
@@ -259,6 +270,7 @@ export default abstract class LocalTrack<
   }
 
   protected async restart(constraints?: MediaTrackConstraints) {
+    this.manuallyStopped = false;
     const unlock = await this.restartLock.lock();
     try {
       if (!constraints) {
@@ -296,8 +308,14 @@ export default abstract class LocalTrack<
 
       await this.setMediaStreamTrack(newTrack);
       this._constraints = constraints;
-
       this.emit(TrackEvent.Restarted, this);
+      if (this.manuallyStopped) {
+        this.log.warn(
+          'track was stopped during a restart, stopping restarted track',
+          this.logContext,
+        );
+        this.stop();
+      }
       return this;
     } finally {
       unlock();
@@ -361,6 +379,7 @@ export default abstract class LocalTrack<
   };
 
   stop() {
+    this.manuallyStopped = true;
     super.stop();
 
     this._mediaStreamTrack.removeEventListener('ended', this.handleEnded);

package/src/room/track/LocalVideoTrack.ts

@@ -53,6 +53,15 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
   // a missing `getParameter` call.
   private senderLock: Mutex;
 
+  private degradationPreference: RTCDegradationPreference = 'balanced';
+
+  override set sender(sender: RTCRtpSender | undefined) {
+    this._sender = sender;
+    if (this.degradationPreference) {
+      this.setDegradationPreference(this.degradationPreference);
+    }
+  }
+
   /**
    *
    * @param mediaTrack
@@ -273,6 +282,20 @@ export default class LocalVideoTrack extends LocalTrack<Track.Kind.Video> {
     }
   }
 
+  async setDegradationPreference(preference: RTCDegradationPreference) {
+    this.degradationPreference = preference;
+    if (this.sender) {
+      try {
+        this.log.debug(`setting degradationPreference to ${preference}`, this.logContext);
+        const params = this.sender.getParameters();
+        params.degradationPreference = preference;
+        this.sender.setParameters(params);
+      } catch (e: any) {
+        this.log.warn(`failed to set degradationPreference`, { error: e, ...this.logContext });
+      }
+    }
+  }
+
   addSimulcastTrack(
     codec: VideoCodec,
     encodings?: RTCRtpEncodingParameters[],

package/src/room/track/RemoteTrack.ts

@@ -2,6 +2,7 @@ import { TrackEvent } from '../events';
 import { monitorFrequency } from '../stats';
 import type { LoggerOptions } from '../types';
 import { Track } from './Track';
+import { supportsSynchronizationSources } from './utils';
 
 export default abstract class RemoteTrack<
   TrackKind extends Track.Kind = Track.Kind,
@@ -77,7 +78,9 @@ export default abstract class RemoteTrack<
     if (!this.monitorInterval) {
       this.monitorInterval = setInterval(() => this.monitorReceiver(), monitorFrequency);
     }
-    this.registerTimeSyncUpdate();
+    if (supportsSynchronizationSources()) {
+      this.registerTimeSyncUpdate();
+    }
   }
 
   protected abstract monitorReceiver(): void;
@@ -85,10 +88,13 @@ export default abstract class RemoteTrack<
   registerTimeSyncUpdate() {
     const loop = () => {
       this.timeSyncHandle = requestAnimationFrame(() => loop());
-      const newTime = this.receiver?.getSynchronizationSources()[0]?.rtpTimestamp;
-      if (newTime && this.rtpTimestamp !== newTime) {
-        this.emit(TrackEvent.TimeSyncUpdate, newTime);
-        this.rtpTimestamp = newTime;
+      const sources = this.receiver?.getSynchronizationSources()[0];
+      if (sources) {
+        const { timestamp, rtpTimestamp } = sources;
+        if (rtpTimestamp && this.rtpTimestamp !== rtpTimestamp) {
+          this.emit(TrackEvent.TimeSyncUpdate, { timestamp, rtpTimestamp });
+          this.rtpTimestamp = rtpTimestamp;
+        }
       }
     };
     loop();

package/src/room/track/Track.ts

@@ -525,5 +525,5 @@ export type TrackEventCallbacks = {
   upstreamResumed: (track: any) => void;
   trackProcessorUpdate: (processor?: TrackProcessor<Track.Kind, any>) => void;
   audioTrackFeatureUpdate: (track: any, feature: AudioTrackFeature, enabled: boolean) => void;
-  timeSyncUpdate: (timestamp: number) => void;
+  timeSyncUpdate: (update: { timestamp: number; rtpTimestamp: number }) => void;
 };

package/src/room/track/options.ts

@@ -64,6 +64,11 @@ export interface TrackPublishDefaults {
    */
   scalabilityMode?: ScalabilityMode;
 
+  /**
+   * degradation preference
+   */
+  degradationPreference?: RTCDegradationPreference;
+
   /**
    * Up to two additional simulcast layers to publish in addition to the original
    * Track.

package/src/room/track/utils.ts

@@ -239,3 +239,7 @@ export function getLogContextFromTrack(track: Track | TrackPublication): Record<
     };
   }
 }
+
+export function supportsSynchronizationSources(): boolean {
+  return typeof RTCRtpReceiver !== 'undefined' && 'getSynchronizationSources' in RTCRtpReceiver;
+}

package/src/room/types.ts

@@ -49,7 +49,9 @@ export type SimulationScenario =
   // to disable congestion control entirely (by setting bandwidth to 100Mbps)
   | 'subscriber-bandwidth'
   | 'disconnect-signal-on-resume'
-  | 'disconnect-signal-on-resume-no-messages';
+  | 'disconnect-signal-on-resume-no-messages'
+  // instructs the server to send a full reconnect reconnect action to the client
+  | 'leave-full-reconnect';
 
 export type LoggerOptions = {
   loggerName?: string;

package/src/room/utils.ts

@@ -491,8 +491,10 @@ export function isVideoCodec(maybeCodec: string): maybeCodec is VideoCodec {
   return videoCodecs.includes(maybeCodec as VideoCodec);
 }
 
-export function unwrapConstraint(constraint: ConstrainDOMString): string {
-  if (typeof constraint === 'string') {
+export function unwrapConstraint(constraint: ConstrainDOMString): string;
+export function unwrapConstraint(constraint: ConstrainULong): number;
+export function unwrapConstraint(constraint: ConstrainDOMString | ConstrainULong): string | number {
+  if (typeof constraint === 'string' || typeof constraint === 'number') {
     return constraint;
   }
 

package/src/version.ts

@@ -1,4 +1,4 @@
 import { version as v } from '../package.json';
 
 export const version = v;
-export const protocolVersion = 12;
+export const protocolVersion = 13;