livekit-client 1.1.2 → 1.1.5

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;

package/src/room/track/LocalVideoTrack.ts

@@ -41,8 +41,12 @@ export default class LocalVideoTrack extends LocalTrack {
 
   private subscribedCodecs?: SubscribedCodec[];
 
-  constructor(mediaTrack: MediaStreamTrack, constraints?: MediaTrackConstraints) {
-    super(mediaTrack, Track.Kind.Video, constraints);
+  constructor(
+    mediaTrack: MediaStreamTrack,
+    constraints?: MediaTrackConstraints,
+    userProvidedTrack = true,
+  ) {
+    super(mediaTrack, Track.Kind.Video, constraints, userProvidedTrack);
   }
 
   get isSimulcast(): boolean {
@@ -92,7 +96,7 @@ export default class LocalVideoTrack extends LocalTrack {
   }
 
   async unmute(): Promise<LocalVideoTrack> {
-    if (this.source === Track.Source.Camera) {
+    if (this.source === Track.Source.Camera && !this.isUserProvided) {
       log.debug('reacquiring camera track');
       await this.restartTrack();
     }

package/src/room/track/RemoteVideoTrack.ts

@@ -110,6 +110,8 @@ export default class RemoteVideoTrack extends RemoteTrack {
       // the tab comes into focus for the first time.
       this.debouncedHandleResize();
       this.updateVisibility();
+    } else {
+      log.warn('visibility resize observer not triggered');
     }
   }
 
@@ -294,9 +296,9 @@ class HTMLElementInfo implements ElementInfo {
 
   handleVisibilityChanged?: () => void;
 
-  constructor(element: HTMLMediaElement, visible: boolean = false) {
+  constructor(element: HTMLMediaElement, visible?: boolean) {
     this.element = element;
-    this.visible = visible;
+    this.visible = visible ?? isElementInViewport(element);
     this.visibilityChangedAt = 0;
   }
 
@@ -332,3 +334,29 @@ class HTMLElementInfo implements ElementInfo {
     getResizeObserver()?.unobserve(this.element);
   }
 }
+
+// does not account for occlusion by other elements
+function isElementInViewport(el: HTMLElement) {
+  let top = el.offsetTop;
+  let left = el.offsetLeft;
+  const width = el.offsetWidth;
+  const height = el.offsetHeight;
+  const { hidden } = el;
+  const { opacity, display } = getComputedStyle(el);
+
+  while (el.offsetParent) {
+    el = el.offsetParent as HTMLElement;
+    top += el.offsetTop;
+    left += el.offsetLeft;
+  }
+
+  return (
+    top < window.pageYOffset + window.innerHeight &&
+    left < window.pageXOffset + window.innerWidth &&
+    top + height > window.pageYOffset &&
+    left + width > window.pageXOffset &&
+    !hidden &&
+    (opacity !== '' ? parseFloat(opacity) > 0 : true) &&
+    display !== 'none'
+  );
+}

package/src/room/track/create.ts

@@ -110,11 +110,11 @@ export async function createLocalScreenTracks(
   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);
   }

package/src/room/utils.ts

@@ -114,3 +114,18 @@ export function getEmptyAudioStreamTrack() {
   }
   return emptyAudioStreamTrack;
 }
+
+export class Future<T> {
+  promise: Promise<T>;
+
+  resolve!: (arg: T) => void;
+
+  reject!: (e: any) => void;
+
+  constructor() {
+    this.promise = new Promise<T>((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+}