livekit-client 1.8.0 → 1.9.1

package/src/room/RTCEngine.ts

@@ -22,6 +22,9 @@ import {
   SignalTarget,
   TrackPublishedResponse,
 } from '../proto/livekit_rtc';
+import PCTransport, { PCEvents } from './PCTransport';
+import type { ReconnectContext, ReconnectPolicy } from './ReconnectPolicy';
+import { RegionUrlProvider } from './RegionUrlProvider';
 import { roomConnectOptionDefaults } from './defaults';
 import {
   ConnectionError,
@@ -31,24 +34,21 @@ import {
   UnexpectedConnectionState,
 } from './errors';
 import { EngineEvent } from './events';
-import PCTransport, { PCEvents } from './PCTransport';
-import type { ReconnectContext, ReconnectPolicy } from './ReconnectPolicy';
 import CriticalTimers from './timers';
 import type LocalTrack from './track/LocalTrack';
 import type LocalVideoTrack from './track/LocalVideoTrack';
 import type { SimulcastTrackInfo } from './track/LocalVideoTrack';
-import type { TrackPublishOptions, VideoCodec } from './track/options';
 import { Track } from './track/Track';
+import type { TrackPublishOptions, VideoCodec } from './track/options';
 import {
+  Mutex,
   isCloud,
   isWeb,
-  Mutex,
   sleep,
   supportsAddTrack,
   supportsSetCodecPreferences,
   supportsTransceiver,
 } from './utils';
-import { RegionUrlProvider } from './RegionUrlProvider';
 
 const lossyDataChannel = '_lossy';
 const reliableDataChannel = '_reliable';
@@ -75,6 +75,8 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   peerConnectionTimeout: number = roomConnectOptionDefaults.peerConnectionTimeout;
 
+  fullReconnectOnNext: boolean = false;
+
   get isClosed() {
     return this._isClosed;
   }
@@ -118,8 +120,6 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
 
   private reconnectStart: number = 0;
 
-  private fullReconnectOnNext: boolean = false;
-
   private clientConfiguration?: ClientConfiguration;
 
   private attemptingReconnect: boolean = false;
@@ -879,11 +879,13 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
         throw new Error('simulated failure');
       }
 
-      await this.waitForPCReconnected();
       this.client.setReconnected();
+      this.emit(EngineEvent.SignalRestarted, joinResponse);
+
+      await this.waitForPCReconnected();
       this.regionUrlProvider?.resetAttempts();
       // reconnect success
-      this.emit(EngineEvent.Restarted, joinResponse);
+      this.emit(EngineEvent.Restarted);
     } catch (error) {
       const nextRegionUrl = await this.regionUrlProvider?.getNextBestRegionUrl();
       if (nextRegionUrl) {
@@ -992,7 +994,7 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     });
   }
 
-  async waitForPCReconnected() {
+  private async waitForPCReconnected() {
     const startTime = Date.now();
     let now = startTime;
     this.pcState = PCState.Reconnecting;
@@ -1022,6 +1024,24 @@ export default class RTCEngine extends (EventEmitter as new () => TypedEventEmit
     throw new ConnectionError('could not establish PC connection');
   }
 
+  waitForRestarted = () => {
+    return new Promise<void>((resolve, reject) => {
+      if (this.pcState === PCState.Connected) {
+        resolve();
+      }
+      const onRestarted = () => {
+        this.off(EngineEvent.Disconnected, onDisconnected);
+        resolve();
+      };
+      const onDisconnected = () => {
+        this.off(EngineEvent.Restarted, onRestarted);
+        reject();
+      };
+      this.once(EngineEvent.Restarted, onRestarted);
+      this.once(EngineEvent.Disconnected, onDisconnected);
+    });
+  };
+
   /* @internal */
   async sendDataPacket(packet: DataPacket, kind: DataPacket_Kind) {
     const msg = DataPacket.encode(packet).finish();
@@ -1246,8 +1266,9 @@ export type EngineEventCallbacks = {
   resuming: () => void;
   resumed: () => void;
   restarting: () => void;
-  restarted: (joinResp: JoinResponse) => void;
+  restarted: () => void;
   signalResumed: () => void;
+  signalRestarted: (joinResp: JoinResponse) => void;
   closing: () => void;
   mediaTrackAdded: (
     track: MediaStreamTrack,

package/src/room/RegionUrlProvider.ts

@@ -1,6 +1,6 @@
+import log from '../logger';
 import type { RegionInfo, RegionSettings } from '../proto/livekit_rtc';
 import { ConnectionError, ConnectionErrorReason } from './errors';
-import log from '../logger';
 import { isCloud } from './utils';
 
 export class RegionUrlProvider {

package/src/room/Room.ts

@@ -29,6 +29,9 @@ import {
   StreamStateUpdate,
   SubscriptionPermissionUpdate,
 } from '../proto/livekit_rtc';
+import DeviceManager from './DeviceManager';
+import RTCEngine from './RTCEngine';
+import { RegionUrlProvider } from './RegionUrlProvider';
 import {
   audioDefaults,
   publishDefaults,
@@ -36,14 +39,12 @@ import {
   roomOptionDefaults,
   videoDefaults,
 } from './defaults';
-import DeviceManager from './DeviceManager';
 import { ConnectionError, ConnectionErrorReason, UnsupportedServer } from './errors';
 import { EngineEvent, ParticipantEvent, RoomEvent, TrackEvent } from './events';
 import LocalParticipant from './participant/LocalParticipant';
 import type Participant from './participant/Participant';
 import type { ConnectionQuality } from './participant/Participant';
 import RemoteParticipant from './participant/RemoteParticipant';
-import RTCEngine from './RTCEngine';
 import LocalAudioTrack from './track/LocalAudioTrack';
 import LocalTrackPublication from './track/LocalTrackPublication';
 import LocalVideoTrack from './track/LocalVideoTrack';
@@ -53,18 +54,17 @@ import { Track } from './track/Track';
 import type { TrackPublication } from './track/TrackPublication';
 import type { AdaptiveStreamSettings } from './track/types';
 import { getNewAudioContext } from './track/utils';
-import type { SimulationOptions } from './types';
+import type { SimulationOptions, SimulationScenario } from './types';
 import {
-  createDummyVideoStreamTrack,
   Future,
+  Mutex,
+  createDummyVideoStreamTrack,
   getEmptyAudioStreamTrack,
   isCloud,
   isWeb,
-  Mutex,
   supportsSetSinkId,
   unpackStreamId,
 } from './utils';
-import { RegionUrlProvider } from './RegionUrlProvider';
 
 export enum ConnectionState {
   Disconnected = 'disconnected',
@@ -99,23 +99,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   /** @internal */
   engine!: RTCEngine;
 
-  // available after connected
-  /** server assigned unique room id */
-  sid: string = '';
-
-  /** user assigned name, derived from JWT token */
-  name: string = '';
-
   /** the current participant */
   localParticipant: LocalParticipant;
 
-  /** room metadata */
-  metadata: string | undefined = undefined;
-
   /** options of room */
   options: InternalRoomOptions;
 
-  private _isRecording: boolean = false;
+  private roomInfo?: RoomModel;
 
   private identityToSid: Map<string, string>;
 
@@ -134,6 +124,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private disconnectLock: Mutex;
 
+  private cachedParticipantSids: Array<string>;
+
   /**
    * Creates a new Room, the primary construct for a LiveKit session.
    * @param options
@@ -142,6 +134,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     super();
     this.setMaxListeners(100);
     this.participants = new Map();
+    this.cachedParticipantSids = [];
     this.identityToSid = new Map();
     this.options = { ...roomOptionDefaults, ...options };
 
@@ -165,6 +158,36 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.localParticipant = new LocalParticipant('', '', this.engine, this.options);
   }
 
+  /**
+   * if the current room has a participant with `recorder: true` in its JWT grant
+   **/
+  get isRecording(): boolean {
+    return this.roomInfo?.activeRecording ?? false;
+  }
+
+  /** server assigned unique room id */
+  get sid(): string {
+    return this.roomInfo?.sid ?? '';
+  }
+
+  /** user assigned name, derived from JWT token */
+  get name(): string {
+    return this.roomInfo?.name ?? '';
+  }
+
+  /** room metadata */
+  get metadata(): string | undefined {
+    return this.roomInfo?.metadata;
+  }
+
+  get numParticipants(): number {
+    return this.roomInfo?.numParticipants ?? 0;
+  }
+
+  get numPublishers(): number {
+    return this.roomInfo?.numPublishers ?? 0;
+  }
+
   private maybeCreateEngine() {
     if (this.engine) {
       return;
@@ -195,11 +218,19 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
           this.emit(RoomEvent.Reconnecting);
         }
+        this.cachedParticipantSids = Array.from(this.participants.keys());
       })
       .on(EngineEvent.Resumed, () => {
         this.setAndEmitConnectionState(ConnectionState.Connected);
         this.emit(RoomEvent.Reconnected);
         this.updateSubscriptions();
+
+        // once reconnected, figure out if any participants connected during reconnect and emit events for it
+        const diffParticipants = Array.from(this.participants.values()).filter(
+          (p) => !this.cachedParticipantSids.includes(p.sid),
+        );
+        diffParticipants.forEach((p) => this.emit(RoomEvent.ParticipantConnected, p));
+        this.cachedParticipantSids = [];
       })
       .on(EngineEvent.SignalResumed, () => {
         if (this.state === ConnectionState.Reconnecting) {
@@ -207,7 +238,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         }
       })
       .on(EngineEvent.Restarting, this.handleRestarting)
-      .on(EngineEvent.Restarted, this.handleRestarted)
+      .on(EngineEvent.SignalRestarted, this.handleSignalRestarted)
       .on(EngineEvent.DCBufferStatusChanged, (status, kind) => {
         this.emit(RoomEvent.DCBufferStatusChanged, status, kind);
       });
@@ -368,31 +399,11 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.localParticipant.sid = pi.sid;
     this.localParticipant.identity = pi.identity;
 
-    this.localParticipant.updateInfo(pi);
-    // forward metadata changed for the local participant
-    this.setupLocalParticipantEvents();
-
     // populate remote participants, these should not trigger new events
-    joinResponse.otherParticipants.forEach((info) => {
-      if (
-        info.sid !== this.localParticipant.sid &&
-        info.identity !== this.localParticipant.identity
-      ) {
-        this.getOrCreateParticipant(info.sid, info);
-      } else {
-        log.warn('received info to create local participant as remote participant', {
-          info,
-          localParticipant: this.localParticipant,
-        });
-      }
-    });
+    this.handleParticipantUpdates([pi, ...joinResponse.otherParticipants]);
 
-    this.name = joinResponse.room!.name;
-    this.sid = joinResponse.room!.sid;
-    this.metadata = joinResponse.room!.metadata;
-    if (this._isRecording !== joinResponse.room!.activeRecording) {
-      this._isRecording = joinResponse.room!.activeRecording;
-      this.emit(RoomEvent.RecordingStatusChanged, joinResponse.room!.activeRecording);
+    if (joinResponse.room) {
+      this.handleRoomUpdate(joinResponse.room);
     }
   };
 
@@ -433,6 +444,8 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       );
 
       this.applyJoinResponse(joinResponse);
+      // forward metadata changed for the local participant
+      this.setupLocalParticipantEvents();
       this.emit(RoomEvent.SignalConnected);
     } catch (err) {
       this.recreateEngine();
@@ -534,17 +547,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.connectFuture = undefined;
   }
 
-  /**
-   * if the current room has a participant with `recorder: true` in its JWT grant
-   **/
-  get isRecording() {
-    return this._isRecording;
-  }
-
   /**
    * @internal for testing
    */
-  async simulateScenario(scenario: string) {
+  async simulateScenario(scenario: SimulationScenario) {
     let postAction = () => {};
     let req: SimulateScenario | undefined;
     switch (scenario) {
@@ -593,6 +599,13 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
           this.engine.client.onClose('simulate resume-reconnect');
         }
         break;
+      case 'full-reconnect':
+        this.engine.fullReconnectOnNext = true;
+        await this.engine.client.close();
+        if (this.engine.client.onClose) {
+          this.engine.client.onClose('simulate full-reconnect');
+        }
+        break;
       case 'force-tcp':
       case 'force-tls':
         req = SimulateScenario.fromPartial({
@@ -734,6 +747,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   private setupLocalParticipantEvents() {
     this.localParticipant
       .on(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+      .on(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged)
       .on(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
       .on(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
       .on(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
@@ -825,20 +839,15 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   };
 
-  private handleRestarted = async (joinResponse: JoinResponse) => {
-    log.debug(`reconnected to server`, {
+  private handleSignalRestarted = async (joinResponse: JoinResponse) => {
+    log.debug(`signal reconnected to server`, {
       region: joinResponse.serverRegion,
     });
 
-    try {
-      // rehydrate participants
-      if (joinResponse.participant) {
-        // with a restart, the sid will have changed, we'll map our understanding to it
-        this.localParticipant.sid = joinResponse.participant.sid;
-        this.handleParticipantUpdates([joinResponse.participant]);
-      }
-      this.handleParticipantUpdates(joinResponse.otherParticipants);
+    this.cachedParticipantSids = [];
+    this.applyJoinResponse(joinResponse);
 
+    try {
       // unpublish & republish tracks
       const localPubs: LocalTrackPublication[] = [];
       this.localParticipant.tracks.forEach((pub) => {
@@ -872,10 +881,24 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       );
     } catch (error) {
       log.error('error trying to re-publish tracks after reconnection', { error });
-    } finally {
-      this.setAndEmitConnectionState(ConnectionState.Connected);
-      this.emit(RoomEvent.Reconnected);
     }
+
+    try {
+      await this.engine.waitForRestarted();
+      log.debug(`fully reconnected to server`, {
+        region: joinResponse.serverRegion,
+      });
+    } catch {
+      // reconnection failed, handleDisconnect is being invoked already, just return here
+      return;
+    }
+    this.setAndEmitConnectionState(ConnectionState.Connected);
+    this.emit(RoomEvent.Reconnected);
+
+    // emit participant connected events after connection has been re-established
+    this.participants.forEach((participant) => {
+      this.emit(RoomEvent.ParticipantConnected, participant);
+    });
   };
 
   private handleDisconnect(shouldStopTracks = true, reason?: DisconnectReason) {
@@ -901,6 +924,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
     this.localParticipant
       .off(ParticipantEvent.ParticipantMetadataChanged, this.onLocalParticipantMetadataChanged)
+      .off(ParticipantEvent.ParticipantNameChanged, this.onLocalParticipantNameChanged)
       .off(ParticipantEvent.TrackMuted, this.onLocalTrackMuted)
       .off(ParticipantEvent.TrackUnmuted, this.onLocalTrackUnmuted)
       .off(ParticipantEvent.LocalTrackPublished, this.onLocalTrackPublished)
@@ -1106,14 +1130,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.MediaDevicesChanged);
   };
 
-  private handleRoomUpdate = (r: RoomModel) => {
-    if (this._isRecording !== r.activeRecording) {
-      this._isRecording = r.activeRecording;
-      this.emit(RoomEvent.RecordingStatusChanged, r.activeRecording);
+  private handleRoomUpdate = (room: RoomModel) => {
+    const oldRoom = this.roomInfo;
+    this.roomInfo = room;
+    if (oldRoom && oldRoom.metadata !== room.metadata) {
+      this.emitWhenConnected(RoomEvent.RoomMetadataChanged, room.metadata);
     }
-    if (this.metadata !== r.metadata) {
-      this.metadata = r.metadata;
-      this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
+    if (oldRoom?.activeRecording !== room.activeRecording) {
+      this.emitWhenConnected(RoomEvent.RecordingStatusChanged, room.activeRecording);
     }
   };
 
@@ -1222,6 +1246,9 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
         this.emitWhenConnected(RoomEvent.ParticipantMetadataChanged, metadata, participant);
       })
+      .on(ParticipantEvent.ParticipantNameChanged, (name) => {
+        this.emitWhenConnected(RoomEvent.ParticipantNameChanged, name, participant);
+      })
       .on(ParticipantEvent.ConnectionQualityChanged, (quality: ConnectionQuality) => {
         this.emitWhenConnected(RoomEvent.ConnectionQualityChanged, quality, participant);
       })
@@ -1338,6 +1365,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.emit(RoomEvent.ParticipantMetadataChanged, metadata, this.localParticipant);
   };
 
+  private onLocalParticipantNameChanged = (name: string) => {
+    this.emit(RoomEvent.ParticipantNameChanged, name, this.localParticipant);
+  };
+
   private onLocalTrackMuted = (pub: TrackPublication) => {
     this.emit(RoomEvent.TrackMuted, pub, this.localParticipant);
   };
@@ -1392,7 +1423,19 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       ...options.participants,
     };
     this.handleDisconnect();
-    this.name = 'simulated-room';
+    this.roomInfo = {
+      sid: 'RM_SIMULATED',
+      name: 'simulated-room',
+      emptyTimeout: 0,
+      maxParticipants: 0,
+      creationTime: new Date().getTime(),
+      metadata: '',
+      numParticipants: 1,
+      numPublishers: 1,
+      turnPassword: '',
+      enabledCodecs: [],
+      activeRecording: false,
+    };
 
     this.localParticipant.updateInfo(
       ParticipantInfo.fromPartial({
@@ -1537,6 +1580,7 @@ export type RoomEventCallbacks = {
     metadata: string | undefined,
     participant: RemoteParticipant | LocalParticipant,
   ) => void;
+  participantNameChanged: (name: string, participant: RemoteParticipant | LocalParticipant) => void;
   participantPermissionsChanged: (
     prevPermissions: ParticipantPermission | undefined,
     participant: RemoteParticipant | LocalParticipant,

package/src/room/events.ts

@@ -168,6 +168,14 @@ export enum RoomEvent {
    */
   ParticipantMetadataChanged = 'participantMetadataChanged',
 
+  /**
+   * Participant's display name changed
+   *
+   * args: (name: string, [[Participant]])
+   *
+   */
+  ParticipantNameChanged = 'participantNameChanged',
+
   /**
    * Room metadata is a simple way for app-specific state to be pushed to
    * all users.
@@ -359,6 +367,14 @@ export enum ParticipantEvent {
    */
   ParticipantMetadataChanged = 'participantMetadataChanged',
 
+  /**
+   * Participant's display name changed
+   *
+   * args: (name: string, [[Participant]])
+   *
+   */
+  ParticipantNameChanged = 'participantNameChanged',
+
   /**
    * Data received from this participant as sender.
    * Data packets provides the ability to use LiveKit to send/receive arbitrary payloads.
@@ -433,6 +449,7 @@ export enum EngineEvent {
   Restarting = 'restarting',
   Restarted = 'restarted',
   SignalResumed = 'signalResumed',
+  SignalRestarted = 'signalRestarted',
   Closing = 'closing',
   MediaTrackAdded = 'mediaTrackAdded',
   ActiveSpeakersUpdate = 'activeSpeakersUpdate',

package/src/room/participant/LocalParticipant.ts

@@ -10,35 +10,36 @@ import {
   TrackPublishedResponse,
   TrackUnpublishedResponse,
 } from '../../proto/livekit_rtc';
+import type RTCEngine from '../RTCEngine';
 import { DeviceUnsupportedError, TrackInvalidError, UnexpectedConnectionState } from '../errors';
 import { EngineEvent, ParticipantEvent, TrackEvent } from '../events';
-import type RTCEngine from '../RTCEngine';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
 import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTrack';
+import { Track } from '../track/Track';
 import {
   AudioCaptureOptions,
   BackupVideoCodec,
   CreateLocalTracksOptions,
-  isBackupCodec,
   ScreenShareCaptureOptions,
   ScreenSharePresets,
   TrackPublishOptions,
   VideoCaptureOptions,
+  isBackupCodec,
+  isCodecEqual,
 } from '../track/options';
-import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
 import type { DataPublishOptions } from '../types';
-import { Future, isFireFox, isSafari, isWeb, supportsAV1 } from '../utils';
+import { Future, isFireFox, isSVCCodec, isSafari, isWeb, supportsAV1, supportsVP9 } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
+import RemoteParticipant from './RemoteParticipant';
 import {
   computeTrackBackupEncodings,
   computeVideoEncodings,
   mediaTrackToLocalTrack,
 } from './publishUtils';
-import RemoteParticipant from './RemoteParticipant';
 
 export default class LocalParticipant extends Participant {
   audioTracks: Map<string, LocalTrackPublication>;
@@ -148,6 +149,26 @@ export default class LocalParticipant extends Participant {
     this.reconnectFuture = undefined;
   };
 
+  /**
+   * Sets and updates the metadata of the local participant.
+   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * @param metadata
+   */
+  setMetadata(metadata: string): void {
+    super.setMetadata(metadata);
+    this.engine.client.sendUpdateLocalMetadata(metadata, this.name ?? '');
+  }
+
+  /**
+   * Sets and updates the name of the local participant.
+   * Note: this requires `CanUpdateOwnMetadata` permission encoded in the token.
+   * @param metadata
+   */
+  setName(name: string): void {
+    super.setName(name);
+    this.engine.client.sendUpdateLocalMetadata(this.metadata ?? '', name);
+  }
+
   /**
    * Enable or disable a participant's camera track.
    *
@@ -550,10 +571,13 @@ export default class LocalParticipant extends Participant {
       opts.simulcast = false;
     }
 
-    // require full AV1 SVC support prior to using it
+    // require full AV1/VP9 SVC support prior to using it
     if (opts.videoCodec === 'av1' && !supportsAV1()) {
       opts.videoCodec = undefined;
     }
+    if (opts.videoCodec === 'vp9' && !supportsVP9()) {
+      opts.videoCodec = undefined;
+    }
 
     // handle track actions
     track.on(TrackEvent.Muted, this.onTrackMuted);
@@ -594,7 +618,7 @@ export default class LocalParticipant extends Participant {
       req.height = dims.height;
       // for svc codecs, disable simulcast and use vp8 for backup codec
       if (track instanceof LocalVideoTrack) {
-        if (opts?.videoCodec === 'av1') {
+        if (isSVCCodec(opts.videoCodec)) {
           // set scalabilityMode to 'L3T3' by default
           opts.scalabilityMode = opts.scalabilityMode ?? 'L3T3';
         }
@@ -640,6 +664,33 @@ export default class LocalParticipant extends Participant {
     }
 
     const ti = await this.engine.addTrack(req);
+    let primaryCodecSupported = false;
+    let backupCodecSupported = false;
+    ti.codecs.forEach((c) => {
+      if (isCodecEqual(c.mimeType, opts.videoCodec)) {
+        primaryCodecSupported = true;
+      } else if (opts.backupCodec && isCodecEqual(c.mimeType, opts.backupCodec.codec)) {
+        backupCodecSupported = true;
+      }
+    });
+
+    if (req.simulcastCodecs.length > 0) {
+      if (!primaryCodecSupported && !backupCodecSupported) {
+        throw Error('cannot publish track, codec not supported by server');
+      }
+
+      if (!primaryCodecSupported && opts.backupCodec) {
+        const backupCodec = opts.backupCodec;
+        opts = { ...opts };
+        log.debug(
+          `primary codec ${opts.videoCodec} not supported, fallback to ${backupCodec.codec}`,
+        );
+        opts.videoCodec = backupCodec.codec;
+        opts.videoEncoding = backupCodec.encoding;
+        encodings = simEncodings;
+      }
+    }
+
     const publication = new LocalTrackPublication(track.kind, ti, track);
     // save options for when it needs to be republished again
     publication.options = opts;
@@ -653,7 +704,7 @@ export default class LocalParticipant extends Participant {
     // store RTPSender
     track.sender = await this.engine.createSender(track, opts, encodings);
 
-    if (track.codec === 'av1' && encodings && encodings[0]?.maxBitrate) {
+    if (track.codec && isSVCCodec(track.codec) && encodings && encodings[0]?.maxBitrate) {
       this.engine.publisher.setTrackCodecBitrate(
         req.cid,
         track.codec,
@@ -961,13 +1012,15 @@ export default class LocalParticipant extends Participant {
   }
 
   /** @internal */
-  updateInfo(info: ParticipantInfo) {
+  updateInfo(info: ParticipantInfo): boolean {
     if (info.sid !== this.sid) {
       // drop updates that specify a wrong sid.
       // the sid for local participant is only explicitly set on join and full reconnect
-      return;
+      return false;
+    }
+    if (!super.updateInfo(info)) {
+      return false;
     }
-    super.updateInfo(info);
 
     // reconcile track mute status.
     // if server's track mute status doesn't match actual, we'll have to update
@@ -986,6 +1039,7 @@ export default class LocalParticipant extends Participant {
         }
       }
     });
+    return true;
   }
 
   private updateTrackSubscriptionPermissions = () => {