livekit-client 1.1.9 → 1.2.2

package/src/room/participant/LocalParticipant.ts

@@ -32,7 +32,7 @@ import {
 } from '../track/options';
 import { Track } from '../track/Track';
 import { constraintsForOptions, mergeDefaultOptions } from '../track/utils';
-import { isFireFox } from '../utils';
+import { isFireFox, isWeb } from '../utils';
 import Participant from './Participant';
 import { ParticipantTrackPermission, trackPermissionToProto } from './ParticipantTrackPermission';
 import { computeVideoEncodings, mediaTrackToLocalTrack } from './publishUtils';
@@ -125,8 +125,9 @@ export default class LocalParticipant extends Participant {
   setCameraEnabled(
     enabled: boolean,
     options?: VideoCaptureOptions,
+    publishOptions?: TrackPublishOptions,
   ): Promise<LocalTrackPublication | undefined> {
-    return this.setTrackEnabled(Track.Source.Camera, enabled, options);
+    return this.setTrackEnabled(Track.Source.Camera, enabled, options, publishOptions);
   }
 
   /**
@@ -138,8 +139,9 @@ export default class LocalParticipant extends Participant {
   setMicrophoneEnabled(
     enabled: boolean,
     options?: AudioCaptureOptions,
+    publishOptions?: TrackPublishOptions,
   ): Promise<LocalTrackPublication | undefined> {
-    return this.setTrackEnabled(Track.Source.Microphone, enabled, options);
+    return this.setTrackEnabled(Track.Source.Microphone, enabled, options, publishOptions);
   }
 
   /**
@@ -149,8 +151,9 @@ export default class LocalParticipant extends Participant {
   setScreenShareEnabled(
     enabled: boolean,
     options?: ScreenShareCaptureOptions,
+    publishOptions?: TrackPublishOptions,
   ): Promise<LocalTrackPublication | undefined> {
-    return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options);
+    return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options, publishOptions);
   }
 
   /** @internal */
@@ -172,21 +175,25 @@ export default class LocalParticipant extends Participant {
     source: Extract<Track.Source, Track.Source.Camera>,
     enabled: boolean,
     options?: VideoCaptureOptions,
+    publishOptions?: TrackPublishOptions,
   ): Promise<LocalTrackPublication | undefined>;
   private async setTrackEnabled(
     source: Extract<Track.Source, Track.Source.Microphone>,
     enabled: boolean,
     options?: AudioCaptureOptions,
+    publishOptions?: TrackPublishOptions,
   ): Promise<LocalTrackPublication | undefined>;
   private async setTrackEnabled(
     source: Extract<Track.Source, Track.Source.ScreenShare>,
     enabled: boolean,
     options?: ScreenShareCaptureOptions,
+    publishOptions?: TrackPublishOptions,
   ): Promise<LocalTrackPublication | undefined>;
   private async setTrackEnabled(
     source: Track.Source,
     enabled: true,
     options?: VideoCaptureOptions | AudioCaptureOptions | ScreenShareCaptureOptions,
+    publishOptions?: TrackPublishOptions,
   ) {
     log.debug('setTrackEnabled', { source, enabled });
     let track = this.getTrack(source);
@@ -224,7 +231,7 @@ export default class LocalParticipant extends Participant {
           }
           const publishPromises: Array<Promise<LocalTrackPublication>> = [];
           for (const localTrack of localTracks) {
-            publishPromises.push(this.publishTrack(localTrack));
+            publishPromises.push(this.publishTrack(localTrack, publishOptions));
           }
           const publishedTracks = await Promise.all(publishPromises);
           // for screen share publications including audio, this will only return the screen share publication, not the screen share audio one
@@ -544,6 +551,14 @@ export default class LocalParticipant extends Participant {
       track.codec = opts.videoCodec;
     }
 
+    if (track.codec === 'av1' && encodings && encodings[0]?.maxBitrate) {
+      this.engine.publisher.setTrackCodecBitrate(
+        req.cid,
+        track.codec,
+        encodings[0].maxBitrate / 1000,
+      );
+    }
+
     this.engine.negotiate();
 
     // store RTPSender
@@ -642,6 +657,13 @@ export default class LocalParticipant extends Participant {
     this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
     track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
 
+    if (videoCodec === 'av1' && encodings[0]?.maxBitrate) {
+      this.engine.publisher.setTrackCodecBitrate(
+        req.cid,
+        videoCodec,
+        encodings[0].maxBitrate / 1000,
+      );
+    }
     this.engine.negotiate();
     log.debug(`published ${opts.videoCodec} for track ${track.sid}`, { encodings, trackInfo: ti });
   }
@@ -894,11 +916,49 @@ export default class LocalParticipant extends Participant {
     this.unpublishTrack(track.track!);
   };
 
-  private handleTrackEnded = (track: LocalTrack) => {
-    log.debug('unpublishing local track due to TrackEnded', {
-      track: track.sid,
-    });
-    this.unpublishTrack(track);
+  private handleTrackEnded = async (track: LocalTrack) => {
+    if (
+      track.source === Track.Source.ScreenShare ||
+      track.source === Track.Source.ScreenShareAudio
+    ) {
+      log.debug('unpublishing local track due to TrackEnded', {
+        track: track.sid,
+      });
+      this.unpublishTrack(track);
+    } else if (track.isUserProvided) {
+      await track.pauseUpstream();
+    } else if (track instanceof LocalAudioTrack || track instanceof LocalVideoTrack) {
+      try {
+        if (isWeb()) {
+          try {
+            const currentPermissions = await navigator?.permissions.query({
+              // the permission query for camera and microphone currently not supported in Safari and Firefox
+              // @ts-ignore
+              name: track.source === Track.Source.Camera ? 'camera' : 'microphone',
+            });
+            if (currentPermissions && currentPermissions.state === 'denied') {
+              log.warn(`user has revoked access to ${track.source}`);
+
+              // detect granted change after permissions were denied to try and resume then
+              currentPermissions.onchange = () => {
+                if (currentPermissions.state !== 'denied') {
+                  track.restartTrack();
+                  currentPermissions.onchange = null;
+                }
+              };
+              throw new Error('GetUserMedia Permission denied');
+            }
+          } catch (e: any) {
+            // permissions query fails for firefox, we continue and try to restart the track
+          }
+        }
+        log.debug('track ended, attempting to use a different device');
+        await track.restartTrack();
+      } catch (e) {
+        log.warn(`could not restart track, pausing upstream instead`);
+        await track.pauseUpstream();
+      }
+    }
   };
 
   private getPublicationForTrack(

package/src/room/participant/RemoteParticipant.ts

@@ -7,6 +7,7 @@ import RemoteAudioTrack from '../track/RemoteAudioTrack';
 import RemoteTrackPublication from '../track/RemoteTrackPublication';
 import RemoteVideoTrack from '../track/RemoteVideoTrack';
 import { Track } from '../track/Track';
+import { TrackPublication } from '../track/TrackPublication';
 import { AdaptiveStreamSettings, RemoteTrack } from '../track/types';
 import Participant, { ParticipantEventCallbacks } from './Participant';
 
@@ -49,8 +50,17 @@ export default class RemoteParticipant extends Participant {
       });
       this.signalClient.sendUpdateSubscription(sub);
     });
-    publication.on(TrackEvent.Ended, (track: RemoteTrack) => {
-      this.emit(ParticipantEvent.TrackUnsubscribed, track, publication);
+    publication.on(
+      TrackEvent.SubscriptionPermissionChanged,
+      (status: TrackPublication.SubscriptionStatus) => {
+        this.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, publication, status);
+      },
+    );
+    publication.on(TrackEvent.Subscribed, (track: RemoteTrack) => {
+      this.emit(ParticipantEvent.TrackSubscribed, track, publication);
+    });
+    publication.on(TrackEvent.Unsubscribed, (previousTrack: RemoteTrack) => {
+      this.emit(ParticipantEvent.TrackUnsubscribed, previousTrack, publication);
     });
   }
 
@@ -156,8 +166,6 @@ export default class RemoteParticipant extends Participant {
     track.start();
 
     publication.setTrack(track);
-    // subscription means participant has permissions to subscribe
-    publication._allowed = true;
     // set participant volume on new microphone tracks
     if (
       this.volume !== undefined &&
@@ -166,7 +174,6 @@ export default class RemoteParticipant extends Participant {
     ) {
       track.setVolume(this.volume);
     }
-    this.emit(ParticipantEvent.TrackSubscribed, track, publication);
 
     return publication;
   }
@@ -251,13 +258,8 @@ export default class RemoteParticipant extends Participant {
     // also send unsubscribe, if track is actively subscribed
     const { track } = publication;
     if (track) {
-      const { isSubscribed } = publication;
       track.stop();
       publication.setTrack(undefined);
-      // always send unsubscribed, since apps may rely on this
-      if (isSubscribed) {
-        this.emit(ParticipantEvent.TrackUnsubscribed, track, publication);
-      }
     }
     if (sendUnpublish) {
       this.emit(ParticipantEvent.TrackUnpublished, publication);

package/src/room/participant/publishUtils.ts

@@ -106,7 +106,7 @@ export function computeVideoEncodings(
           encodings.push({
             rid: videoRids[2 - i],
             scaleResolutionDownBy: 2 ** i,
-            maxBitrate: videoEncoding ? videoEncoding.maxBitrate / 2 ** i : 0,
+            maxBitrate: videoEncoding ? videoEncoding.maxBitrate / 3 ** i : 0,
             /* @ts-ignore */
             maxFramerate: original.encoding.maxFramerate,
             /* @ts-ignore */

package/src/room/track/LocalTrack.ts

@@ -117,6 +117,8 @@ export default class LocalTrack extends Track {
     }
     this._mediaStreamTrack = track;
 
+    await this.resumeUpstream();
+
     this.attachedElements.forEach((el) => {
       attachToElement(track, el);
     });
@@ -166,6 +168,8 @@ export default class LocalTrack extends Track {
 
     this._mediaStreamTrack = newTrack;
 
+    await this.resumeUpstream();
+
     this.attachedElements.forEach((el) => {
       attachToElement(newTrack, el);
     });

package/src/room/track/RemoteTrackPublication.ts

@@ -11,7 +11,7 @@ export default class RemoteTrackPublication extends TrackPublication {
   track?: RemoteTrack;
 
   /** @internal */
-  _allowed = true;
+  protected allowed = true;
 
   // keeps track of client's desire to subscribe to a track
   protected subscribed?: boolean;
@@ -28,6 +28,9 @@ export default class RemoteTrackPublication extends TrackPublication {
    */
   setSubscribed(subscribed: boolean) {
     this.subscribed = subscribed;
+    // reset allowed status when desired subscription state changes
+    // server will notify client via signal message if it's not allowed
+    this.allowed = true;
 
     const sub: UpdateSubscription = {
       trackSids: [this.trackSid],
@@ -46,11 +49,11 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   get subscriptionStatus(): TrackPublication.SubscriptionStatus {
     if (this.subscribed === false || !super.isSubscribed) {
+      if (!this.allowed) {
+        return TrackPublication.SubscriptionStatus.NotAllowed;
+      }
       return TrackPublication.SubscriptionStatus.Unsubscribed;
     }
-    if (!this._allowed) {
-      return TrackPublication.SubscriptionStatus.NotAllowed;
-    }
     return TrackPublication.SubscriptionStatus.Subscribed;
   }
 
@@ -61,9 +64,6 @@ export default class RemoteTrackPublication extends TrackPublication {
     if (this.subscribed === false) {
       return false;
     }
-    if (!this._allowed) {
-      return false;
-    }
     return super.isSubscribed;
   }
 
@@ -127,11 +127,13 @@ export default class RemoteTrackPublication extends TrackPublication {
 
   /** @internal */
   setTrack(track?: Track) {
-    if (this.track) {
+    const prevStatus = this.subscriptionStatus;
+    const prevTrack = this.track;
+    if (prevTrack) {
       // unregister listener
-      this.track.off(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
-      this.track.off(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
-      this.track.off(TrackEvent.Ended, this.handleEnded);
+      prevTrack.off(TrackEvent.VideoDimensionsChanged, this.handleVideoDimensionsChange);
+      prevTrack.off(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
+      prevTrack.off(TrackEvent.Ended, this.handleEnded);
     }
     super.setTrack(track);
     if (track) {
@@ -140,6 +142,22 @@ export default class RemoteTrackPublication extends TrackPublication {
       track.on(TrackEvent.VisibilityChanged, this.handleVisibilityChange);
       track.on(TrackEvent.Ended, this.handleEnded);
     }
+    this.emitSubscriptionUpdateIfChanged(prevStatus);
+    if (!!track !== !!prevTrack) {
+      // when undefined status changes, there's a subscription changed event
+      if (track) {
+        this.emit(TrackEvent.Subscribed, track);
+      } else {
+        this.emit(TrackEvent.Unsubscribed, prevTrack);
+      }
+    }
+  }
+
+  /** @internal */
+  setAllowed(allowed: boolean) {
+    const prevStatus = this.subscriptionStatus;
+    this.allowed = allowed;
+    this.emitSubscriptionUpdateIfChanged(prevStatus);
   }
 
   /** @internal */
@@ -149,6 +167,14 @@ export default class RemoteTrackPublication extends TrackPublication {
     this.track?.setMuted(info.muted);
   }
 
+  private emitSubscriptionUpdateIfChanged(previousStatus: TrackPublication.SubscriptionStatus) {
+    const currentStatus = this.subscriptionStatus;
+    if (previousStatus === currentStatus) {
+      return;
+    }
+    this.emit(TrackEvent.SubscriptionPermissionChanged, currentStatus, previousStatus);
+  }
+
   private isManualOperationAllowed(): boolean {
     if (this.isAdaptiveStream) {
       log.warn('adaptive stream is enabled, cannot change track settings', {