livekit-client 1.1.1 → 1.1.4

package/src/room/Room.ts

@@ -108,14 +108,6 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     this.identityToSid = new Map();
     this.options = options || {};
 
-    switch (this.options?.publishDefaults?.videoCodec) {
-      case 'av1':
-      case 'vp9':
-        this.options.publishDefaults.simulcast = undefined;
-        break;
-      default:
-    }
-
     this.options.audioCaptureDefaults = {
       ...audioDefaults,
       ...options?.audioCaptureDefaults,
@@ -178,6 +170,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       })
       .on(EngineEvent.Restarting, this.handleRestarting)
       .on(EngineEvent.Restarted, this.handleRestarted);
+
+    if (this.localParticipant) {
+      this.localParticipant.engine = this.engine;
+    }
   }
 
   /**
@@ -295,7 +291,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       this.metadata = joinResponse.room!.metadata;
       this.emit(RoomEvent.SignalConnected);
     } catch (err) {
-      this.engine.close();
+      this.recreateEngine();
       this.setAndEmitConnectionState(ConnectionState.Disconnected);
       throw err;
     }
@@ -304,14 +300,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return new Promise<Room>((resolve, reject) => {
       const connectTimeout = setTimeout(() => {
         // timeout
-        this.engine.close();
+        this.recreateEngine();
         this.setAndEmitConnectionState(ConnectionState.Disconnected);
         reject(new ConnectionError('could not connect after timeout'));
       }, maxICEConnectTimeout);
       const abortHandler = () => {
         log.warn('closing engine');
         clearTimeout(connectTimeout);
-        this.engine.close();
+        this.recreateEngine();
         this.setAndEmitConnectionState(ConnectionState.Disconnected);
         reject(new ConnectionError('room connection has been cancelled'));
       };
@@ -503,11 +499,37 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     }
   }
 
+  private recreateEngine() {
+    this.engine.close();
+    /* @ts-ignore */
+    this.engine = undefined;
+
+    // clear out existing remote participants, since they may have attached
+    // the old engine
+    this.participants.clear();
+
+    this.createEngine();
+  }
+
   private onTrackAdded(
     mediaTrack: MediaStreamTrack,
     stream: MediaStream,
     receiver?: RTCRtpReceiver,
   ) {
+    // don't fire onSubscribed when connecting
+    // WebRTC fires onTrack as soon as setRemoteDescription is called on the offer
+    // at that time, ICE connectivity has not been established so the track is not
+    // technically subscribed.
+    // We'll defer these events until when the room is connected or eventually disconnected.
+    if (this.state === ConnectionState.Connecting || this.state === ConnectionState.Reconnecting) {
+      setTimeout(() => {
+        this.onTrackAdded(mediaTrack, stream, receiver);
+      }, 50);
+      return;
+    }
+    if (this.state === ConnectionState.Disconnected) {
+      log.warn('skipping incoming track after Room disconnected');
+    }
     const parts = unpackStreamId(stream.id);
     const participantId = parts[0];
     let trackId = parts[1];
@@ -532,14 +554,14 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
   }
 
   private handleRestarting = () => {
-    if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
-      this.emit(RoomEvent.Reconnecting);
-    }
-
     // also unwind existing participants & existing subscriptions
     for (const p of this.participants.values()) {
       this.handleParticipantDisconnected(p.sid, p);
     }
+
+    if (this.setAndEmitConnectionState(ConnectionState.Reconnecting)) {
+      this.emit(RoomEvent.Reconnecting);
+    }
   };
 
   private handleRestarted = async (joinResponse: JoinResponse) => {
@@ -570,7 +592,10 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         const track = pub.track!;
         this.localParticipant.unpublishTrack(track, false);
         if (!track.isMuted) {
-          if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
+          if (
+            (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) &&
+            !track.isUserProvided
+          ) {
             // we need to restart the track before publishing, often a full reconnect
             // is necessary because computer had gone to sleep.
             log.debug('restarting existing track', {
@@ -644,7 +669,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.handleParticipantDisconnected(info.sid, remoteParticipant);
       } else if (isNewParticipant) {
         // fire connected event
-        this.emit(RoomEvent.ParticipantConnected, remoteParticipant);
+        this.emitWhenConnected(RoomEvent.ParticipantConnected, remoteParticipant);
       } else {
         // just update, no events
         remoteParticipant.updateInfo(info);
@@ -663,7 +688,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     participant.tracks.forEach((publication) => {
       participant.unpublishTrack(publication.trackSid, true);
     });
-    this.emit(RoomEvent.ParticipantDisconnected, participant);
+    this.emitWhenConnected(RoomEvent.ParticipantDisconnected, participant);
   }
 
   // updates are sent only when there's a change to speaker ordering
@@ -698,7 +723,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     });
 
     this.activeSpeakers = activeSpeakers;
-    this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
+    this.emitWhenConnected(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
   };
 
   // process list of changed speakers
@@ -727,7 +752,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     const activeSpeakers = Array.from(lastSpeakers.values());
     activeSpeakers.sort((a, b) => b.audioLevel - a.audioLevel);
     this.activeSpeakers = activeSpeakers;
-    this.emit(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
+    this.emitWhenConnected(RoomEvent.ActiveSpeakersChanged, activeSpeakers);
   };
 
   private handleStreamStateUpdate = (streamStateUpdate: StreamStateUpdate) => {
@@ -742,7 +767,12 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       }
       pub.track.streamState = Track.streamStateFromProto(streamState.state);
       participant.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState);
-      this.emit(ParticipantEvent.TrackStreamStateChanged, pub, pub.track.streamState, participant);
+      this.emitWhenConnected(
+        ParticipantEvent.TrackStreamStateChanged,
+        pub,
+        pub.track.streamState,
+        participant,
+      );
     });
   };
 
@@ -762,7 +792,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
       pub,
       pub.subscriptionStatus,
     );
-    this.emit(
+    this.emitWhenConnected(
       ParticipantEvent.TrackSubscriptionPermissionChanged,
       pub,
       pub.subscriptionStatus,
@@ -803,7 +833,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
 
   private handleRoomUpdate = (r: RoomModel) => {
     this.metadata = r.metadata;
-    this.emit(RoomEvent.RoomMetadataChanged, r.metadata);
+    this.emitWhenConnected(RoomEvent.RoomMetadataChanged, r.metadata);
   };
 
   private handleConnectionQualityUpdate = (update: ConnectionQualityUpdate) => {
@@ -858,7 +888,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     // and remote participant joined the room
     participant
       .on(ParticipantEvent.TrackPublished, (trackPublication: RemoteTrackPublication) => {
-        this.emit(RoomEvent.TrackPublished, trackPublication, participant);
+        this.emitWhenConnected(RoomEvent.TrackPublished, trackPublication, participant);
       })
       .on(
         ParticipantEvent.TrackSubscribed,
@@ -872,7 +902,7 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         },
       )
       .on(ParticipantEvent.TrackUnpublished, (publication: RemoteTrackPublication) => {
-        this.emit(RoomEvent.TrackUnpublished, publication, participant);
+        this.emitWhenConnected(RoomEvent.TrackUnpublished, publication, participant);
       })
       .on(
         ParticipantEvent.TrackUnsubscribed,
@@ -884,23 +914,32 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
         this.emit(RoomEvent.TrackSubscriptionFailed, sid, participant);
       })
       .on(ParticipantEvent.TrackMuted, (pub: TrackPublication) => {
-        this.emit(RoomEvent.TrackMuted, pub, participant);
+        this.emitWhenConnected(RoomEvent.TrackMuted, pub, participant);
       })
       .on(ParticipantEvent.TrackUnmuted, (pub: TrackPublication) => {
-        this.emit(RoomEvent.TrackUnmuted, pub, participant);
+        this.emitWhenConnected(RoomEvent.TrackUnmuted, pub, participant);
       })
       .on(ParticipantEvent.ParticipantMetadataChanged, (metadata: string | undefined) => {
-        this.emit(RoomEvent.ParticipantMetadataChanged, metadata, participant);
+        this.emitWhenConnected(RoomEvent.ParticipantMetadataChanged, metadata, participant);
       })
       .on(ParticipantEvent.ConnectionQualityChanged, (quality: ConnectionQuality) => {
-        this.emit(RoomEvent.ConnectionQualityChanged, quality, participant);
+        this.emitWhenConnected(RoomEvent.ConnectionQualityChanged, quality, participant);
       })
       .on(
         ParticipantEvent.ParticipantPermissionsChanged,
         (prevPermissions: ParticipantPermission) => {
-          this.emit(RoomEvent.ParticipantPermissionsChanged, prevPermissions, participant);
+          this.emitWhenConnected(
+            RoomEvent.ParticipantPermissionsChanged,
+            prevPermissions,
+            participant,
+          );
         },
       );
+
+    // update info at the end after callbacks have been set up
+    if (info) {
+      participant.updateInfo(info);
+    }
     return participant;
   }
 
@@ -967,6 +1006,16 @@ class Room extends (EventEmitter as new () => TypedEmitter<RoomEventCallbacks>)
     return true;
   }
 
+  private emitWhenConnected<E extends keyof RoomEventCallbacks>(
+    event: E,
+    ...args: Parameters<RoomEventCallbacks[E]>
+  ): boolean {
+    if (this.state === ConnectionState.Connected) {
+      return this.emit(event, ...args);
+    }
+    return false;
+  }
+
   // /** @internal */
   emit<E extends keyof RoomEventCallbacks>(
     event: E,

package/src/room/participant/LocalParticipant.ts

@@ -15,10 +15,7 @@ import RTCEngine from '../RTCEngine';
 import LocalAudioTrack from '../track/LocalAudioTrack';
 import LocalTrack from '../track/LocalTrack';
 import LocalTrackPublication from '../track/LocalTrackPublication';
-import LocalVideoTrack, {
-  SimulcastTrackInfo,
-  videoLayersFromEncodings,
-} from '../track/LocalVideoTrack';
+import LocalVideoTrack, { videoLayersFromEncodings } from '../track/LocalVideoTrack';
 import {
   AudioCaptureOptions,
   CreateLocalTracksOptions,
@@ -36,7 +33,7 @@ import { ParticipantTrackPermission, trackPermissionToProto } from './Participan
 import { computeVideoEncodings, mediaTrackToLocalTrack } from './publishUtils';
 import RemoteParticipant from './RemoteParticipant';
 
-const compatibleCodecForSVC = 'vp8';
+const compatibleCodec = 'vp8';
 export default class LocalParticipant extends Participant {
   audioTracks: Map<string, LocalTrackPublication>;
 
@@ -45,14 +42,15 @@ export default class LocalParticipant extends Participant {
   /** map of track sid => all published tracks */
   tracks: Map<string, LocalTrackPublication>;
 
+  /** @internal */
+  engine: RTCEngine;
+
   private pendingPublishing = new Set<Track.Source>();
 
   private cameraError: Error | undefined;
 
   private microphoneError: Error | undefined;
 
-  private engine: RTCEngine;
-
   private participantTrackPermissions: Array<ParticipantTrackPermission> = [];
 
   private allParticipantsAllowedToSubscribe: boolean = true;
@@ -369,11 +367,11 @@ export default class LocalParticipant extends Participant {
     if (tracks.length === 0) {
       throw new TrackInvalidError('no video track found');
     }
-    const screenVideo = new LocalVideoTrack(tracks[0]);
+    const screenVideo = new LocalVideoTrack(tracks[0], undefined, false);
     screenVideo.source = Track.Source.ScreenShare;
     const localTracks: Array<LocalTrack> = [screenVideo];
     if (stream.getAudioTracks().length > 0) {
-      const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0]);
+      const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0], undefined, false);
       screenAudio.source = Track.Source.ScreenShareAudio;
       localTracks.push(screenAudio);
     }
@@ -398,10 +396,10 @@ export default class LocalParticipant extends Participant {
     if (track instanceof MediaStreamTrack) {
       switch (track.kind) {
         case 'audio':
-          track = new LocalAudioTrack(track);
+          track = new LocalAudioTrack(track, undefined, true);
           break;
         case 'video':
-          track = new LocalVideoTrack(track);
+          track = new LocalVideoTrack(track, undefined, true);
           break;
         default:
           throw new TrackInvalidError(`unsupported MediaStreamTrack kind ${track.kind}`);
@@ -455,7 +453,6 @@ export default class LocalParticipant extends Participant {
     // compute encodings and layers for video
     let encodings: RTCRtpEncodingParameters[] | undefined;
     let simEncodings: RTCRtpEncodingParameters[] | undefined;
-    let simulcastTracks: SimulcastTrackInfo[] | undefined;
     if (track.kind === Track.Kind.Video) {
       // TODO: support react native, which doesn't expose getSettings
       const settings = track.mediaStreamTrack.getSettings();
@@ -465,37 +462,38 @@ export default class LocalParticipant extends Participant {
       req.width = width ?? 0;
       req.height = height ?? 0;
       // for svc codecs, disable simulcast and use vp8 for backup codec
-      if (
-        track instanceof LocalVideoTrack &&
-        (opts?.videoCodec === 'vp9' || opts?.videoCodec === 'av1')
-      ) {
-        // set scalabilityMode to 'L3T3' by default
-        opts.scalabilityMode = opts.scalabilityMode ?? 'L3T3';
-
-        // add backup codec track
-        const simOpts = { ...opts };
-        simOpts.simulcast = true;
-        simOpts.scalabilityMode = undefined;
-        simEncodings = computeVideoEncodings(
-          track.source === Track.Source.ScreenShare,
-          width,
-          height,
-          simOpts,
-        );
-        const simulcastTrack = track.addSimulcastTrack(compatibleCodecForSVC, simEncodings);
-        simulcastTracks = [simulcastTrack];
-        req.simulcastCodecs = [
-          {
-            codec: opts.videoCodec,
-            cid: track.mediaStreamTrack.id,
-            enableSimulcastLayers: true,
-          },
-          {
-            codec: simulcastTrack.codec,
-            cid: simulcastTrack.mediaStreamTrack.id,
-            enableSimulcastLayers: true,
-          },
-        ];
+      if (track instanceof LocalVideoTrack) {
+        if (opts?.videoCodec === 'vp9' || opts?.videoCodec === 'av1') {
+          // set scalabilityMode to 'L3T3' by default
+          opts.scalabilityMode = opts.scalabilityMode ?? 'L3T3';
+
+          // add backup codec track
+          const simOpts = { ...opts };
+          simOpts.simulcast = true;
+          simOpts.scalabilityMode = undefined;
+          simEncodings = computeVideoEncodings(
+            track.source === Track.Source.ScreenShare,
+            width,
+            height,
+            simOpts,
+          );
+        }
+
+        // set vp8 codec as backup for any other codecs
+        if (opts.videoCodec && opts.videoCodec !== 'vp8') {
+          req.simulcastCodecs = [
+            {
+              codec: opts.videoCodec,
+              cid: track.mediaStreamTrack.id,
+              enableSimulcastLayers: true,
+            },
+            {
+              codec: compatibleCodec,
+              cid: '',
+              enableSimulcastLayers: true,
+            },
+          ];
+        }
       }
 
       encodings = computeVideoEncodings(
@@ -541,22 +539,6 @@ export default class LocalParticipant extends Participant {
       track.codec = opts.videoCodec;
     }
 
-    const localTrack = track as LocalVideoTrack;
-    if (simulcastTracks) {
-      for await (const simulcastTrack of simulcastTracks) {
-        const simTransceiverInit: RTCRtpTransceiverInit = { direction: 'sendonly' };
-        if (simulcastTrack.encodings) {
-          simTransceiverInit.sendEncodings = simulcastTrack.encodings;
-        }
-        const simTransceiver = await this.engine.publisher!.pc.addTransceiver(
-          simulcastTrack.mediaStreamTrack,
-          simTransceiverInit,
-        );
-        this.setPreferredCodec(simTransceiver, localTrack.kind, simulcastTrack.codec);
-        localTrack.setSimulcastTrackSender(simulcastTrack.codec, simTransceiver.sender);
-      }
-    }
-
     this.engine.negotiate();
 
     // store RTPSender
@@ -574,6 +556,91 @@ export default class LocalParticipant extends Participant {
     return publication;
   }
 
+  /** @internal
+   * publish additional codec to existing track
+   */
+  async publishAdditionalCodecForTrack(
+    track: LocalTrack | MediaStreamTrack,
+    videoCodec: VideoCodec,
+    options?: TrackPublishOptions,
+  ) {
+    const opts: TrackPublishOptions = {
+      ...this.roomOptions?.publishDefaults,
+      ...options,
+    };
+    // clear scalabilityMode setting for backup codec
+    opts.scalabilityMode = undefined;
+    opts.videoCodec = videoCodec;
+    // is it not published? if so skip
+    let existingPublication: LocalTrackPublication | undefined;
+    this.tracks.forEach((publication) => {
+      if (!publication.track) {
+        return;
+      }
+      if (publication.track === track) {
+        existingPublication = <LocalTrackPublication>publication;
+      }
+    });
+    if (!existingPublication) {
+      throw new TrackInvalidError('track is not published');
+    }
+
+    if (!(track instanceof LocalVideoTrack)) {
+      throw new TrackInvalidError('track is not a video track');
+    }
+
+    const settings = track.mediaStreamTrack.getSettings();
+    const width = settings.width ?? track.dimensions?.width;
+    const height = settings.height ?? track.dimensions?.height;
+
+    const encodings = computeVideoEncodings(
+      track.source === Track.Source.ScreenShare,
+      width,
+      height,
+      opts,
+    );
+    const simulcastTrack = track.addSimulcastTrack(opts.videoCodec, encodings);
+    const req = AddTrackRequest.fromPartial({
+      cid: simulcastTrack.mediaStreamTrack.id,
+      type: Track.kindToProto(track.kind),
+      muted: track.isMuted,
+      source: Track.sourceToProto(track.source),
+      sid: track.sid,
+      simulcastCodecs: [
+        {
+          codec: opts.videoCodec,
+          cid: simulcastTrack.mediaStreamTrack.id,
+          enableSimulcastLayers: opts.simulcast,
+        },
+      ],
+    });
+    req.layers = videoLayersFromEncodings(req.width, req.height, encodings);
+
+    if (!this.engine || this.engine.isClosed) {
+      throw new UnexpectedConnectionState('cannot publish track when not connected');
+    }
+
+    const ti = await this.engine.addTrack(req);
+
+    if (!this.engine.publisher) {
+      throw new UnexpectedConnectionState('publisher is closed');
+    }
+    const transceiverInit: RTCRtpTransceiverInit = { direction: 'sendonly' };
+    if (encodings) {
+      transceiverInit.sendEncodings = encodings;
+    }
+    // addTransceiver for react-native is async. web is synchronous, but await won't effect it.
+    const transceiver = await this.engine.publisher.pc.addTransceiver(
+      simulcastTrack.mediaStreamTrack,
+      transceiverInit,
+    );
+    this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
+    track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+
+    this.engine.negotiate();
+    log.debug(`published ${opts.videoCodec} for track ${track.sid}`, { encodings, trackInfo: ti });
+  }
+
   unpublishTrack(
     track: LocalTrack | MediaStreamTrack,
     stopOnUnpublish?: boolean,
@@ -761,7 +828,7 @@ export default class LocalParticipant extends Participant {
     this.onTrackMuted(track, track.isMuted);
   };
 
-  private handleSubscribedQualityUpdate = (update: SubscribedQualityUpdate) => {
+  private handleSubscribedQualityUpdate = async (update: SubscribedQualityUpdate) => {
     if (!this.roomOptions?.dynacast) {
       return;
     }
@@ -774,7 +841,14 @@ export default class LocalParticipant extends Participant {
       return;
     }
     if (update.subscribedCodecs.length > 0) {
-      pub.videoTrack?.setPublishingCodecs(update.subscribedCodecs);
+      if (!pub.videoTrack) {
+        return;
+      }
+      const newCodecs = await pub.videoTrack.setPublishingCodecs(update.subscribedCodecs);
+      for await (const codec of newCodecs) {
+        log.debug(`publish ${codec} for ${pub.videoTrack.sid}`);
+        await this.publishAdditionalCodecForTrack(pub.videoTrack, codec, pub.options);
+      }
     } else if (update.subscribedQualities.length > 0) {
       pub.videoTrack?.setPublishingLayers(update.subscribedQualities);
     }

package/src/room/participant/RemoteParticipant.ts

@@ -23,9 +23,7 @@ export default class RemoteParticipant extends Participant {
 
   /** @internal */
   static fromParticipantInfo(signalClient: SignalClient, pi: ParticipantInfo): RemoteParticipant {
-    const rp = new RemoteParticipant(signalClient, pi.sid, pi.identity);
-    rp.updateInfo(pi);
-    return rp;
+    return new RemoteParticipant(signalClient, pi.sid, pi.identity);
   }
 
   /** @internal */
@@ -182,8 +180,6 @@ export default class RemoteParticipant extends Participant {
 
   /** @internal */
   updateInfo(info: ParticipantInfo) {
-    const alreadyHasMetadata = this.hasMetadata;
-
     super.updateInfo(info);
 
     // we are getting a list of all available tracks, reconcile in here
@@ -212,12 +208,10 @@ export default class RemoteParticipant extends Participant {
       validTracks.set(ti.sid, publication);
     });
 
-    // send new tracks
-    if (alreadyHasMetadata) {
-      newTracks.forEach((publication) => {
-        this.emit(ParticipantEvent.TrackPublished, publication);
-      });
-    }
+    // always emit events for new publications, Room will not forward them unless it's ready
+    newTracks.forEach((publication) => {
+      this.emit(ParticipantEvent.TrackPublished, publication);
+    });
 
     // detect removed tracks
     this.tracks.forEach((publication) => {

package/src/room/participant/publishUtils.ts

@@ -18,9 +18,9 @@ export function mediaTrackToLocalTrack(
 ): LocalVideoTrack | LocalAudioTrack {
   switch (mediaStreamTrack.kind) {
     case 'audio':
-      return new LocalAudioTrack(mediaStreamTrack, constraints);
+      return new LocalAudioTrack(mediaStreamTrack, constraints, false);
     case 'video':
-      return new LocalVideoTrack(mediaStreamTrack, constraints);
+      return new LocalVideoTrack(mediaStreamTrack, constraints, false);
     default:
       throw new TrackInvalidError(`unsupported track type: ${mediaStreamTrack.kind}`);
   }

package/src/room/track/LocalAudioTrack.ts

@@ -15,8 +15,12 @@ export default class LocalAudioTrack extends LocalTrack {
 
   private prevStats?: AudioSenderStats;
 
-  constructor(mediaTrack: MediaStreamTrack, constraints?: MediaTrackConstraints) {
-    super(mediaTrack, Track.Kind.Audio, constraints);
+  constructor(
+    mediaTrack: MediaStreamTrack,
+    constraints?: MediaTrackConstraints,
+    userProvidedTrack = true,
+  ) {
+    super(mediaTrack, Track.Kind.Audio, constraints, userProvidedTrack);
     this.checkForSilence();
   }
 
@@ -42,7 +46,7 @@ export default class LocalAudioTrack extends LocalTrack {
   }
 
   async unmute(): Promise<LocalAudioTrack> {
-    if (this.source === Track.Source.Microphone && this.stopOnMute) {
+    if (this.source === Track.Source.Microphone && this.stopOnMute && !this.isUserProvided) {
       log.debug('reacquiring mic track');
       await this.restartTrack();
     }

package/src/room/track/LocalTrack.ts

@@ -19,16 +19,20 @@ export default class LocalTrack extends Track {
 
   protected reacquireTrack: boolean;
 
+  protected providedByUser: boolean;
+
   protected constructor(
     mediaTrack: MediaStreamTrack,
     kind: Track.Kind,
     constraints?: MediaTrackConstraints,
+    userProvidedTrack = false,
   ) {
     super(mediaTrack, kind);
     this._mediaStreamTrack.addEventListener('ended', this.handleEnded);
     this.constraints = constraints ?? mediaTrack.getConstraints();
     this.reacquireTrack = false;
     this.wasMuted = false;
+    this.providedByUser = userProvidedTrack;
   }
 
   get id(): string {
@@ -56,6 +60,10 @@ export default class LocalTrack extends Track {
     return this._isUpstreamPaused;
   }
 
+  get isUserProvided() {
+    return this.providedByUser;
+  }
+
   /**
    * @returns DeviceID of the device that is currently being used for this track
    */
@@ -80,7 +88,7 @@ export default class LocalTrack extends Track {
     return this;
   }
 
-  async replaceTrack(track: MediaStreamTrack): Promise<LocalTrack> {
+  async replaceTrack(track: MediaStreamTrack, userProvidedTrack = true): Promise<LocalTrack> {
     if (!this.sender) {
       throw new TrackInvalidError('unable to replace an unpublished track');
     }
@@ -108,6 +116,7 @@ export default class LocalTrack extends Track {
     });
 
     this.mediaStream = new MediaStream([track]);
+    this.providedByUser = userProvidedTrack;
     return this;
   }
 
@@ -184,7 +193,7 @@ export default class LocalTrack extends Track {
     if (!isMobile()) return;
     log.debug(`visibility changed, is in Background: ${this.isInBackground}`);
 
-    if (!this.isInBackground && this.needsReAcquisition) {
+    if (!this.isInBackground && this.needsReAcquisition && !this.isUserProvided) {
       log.debug(`track needs to be reaquired, restarting ${this.source}`);
       await this.restart();
       this.reacquireTrack = false;