livekit-client 1.1.9 → 1.2.2

package/dist/livekit-client.esm.mjs

@@ -10189,6 +10189,8 @@ var TrackEvent;
   TrackEvent["Muted"] = "muted";
   TrackEvent["Unmuted"] = "unmuted";
   TrackEvent["Ended"] = "ended";
+  TrackEvent["Subscribed"] = "subscribed";
+  TrackEvent["Unsubscribed"] = "unsubscribed";
   /** @internal */
 
   TrackEvent["UpdateSettings"] = "updateSettings";
@@ -10231,6 +10233,12 @@ var TrackEvent;
    */
 
   TrackEvent["UpstreamResumed"] = "upstreamResumed";
+  /**
+   * @internal
+   * Fires on RemoteTrackPublication
+   */
+
+  TrackEvent["SubscriptionPermissionChanged"] = "subscriptionPermissionChanged";
 })(TrackEvent || (TrackEvent = {}));
 
 const monitorFrequency = 2000;
@@ -10257,7 +10265,7 @@ function computeBitrate(currentStats, prevStats) {
   return (bytesNow - bytesPrev) * 8 * 1000 / (currentStats.timestamp - prevStats.timestamp);
 }
 
-var version$1 = "1.1.9";
+var version$1 = "1.2.2";
 
 const version = version$1;
 const protocolVersion = 8;
@@ -11550,6 +11558,7 @@ class LocalTrack extends Track {
     }
 
     this._mediaStreamTrack = track;
+    await this.resumeUpstream();
     this.attachedElements.forEach(el => {
       attachToElement(track, el);
     });
@@ -11599,6 +11608,7 @@ class LocalTrack extends Track {
     }
 
     this._mediaStreamTrack = newTrack;
+    await this.resumeUpstream();
     this.attachedElements.forEach(el => {
       attachToElement(newTrack, el);
     });
@@ -13445,7 +13455,7 @@ function computeVideoEncodings(isScreenShare, width, height, options) {
           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,
@@ -13612,7 +13622,7 @@ class RemoteTrackPublication extends TrackPublication {
     super(...arguments);
     /** @internal */
 
-    this._allowed = true;
+    this.allowed = true;
     this.disabled = false;
     this.currentVideoQuality = VideoQuality.HIGH;
 
@@ -13644,7 +13654,10 @@ class RemoteTrackPublication extends TrackPublication {
 
 
   setSubscribed(subscribed) {
-    this.subscribed = subscribed;
+    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 = {
       trackSids: [this.trackSid],
       subscribe: this.subscribed,
@@ -13660,11 +13673,11 @@ class RemoteTrackPublication extends TrackPublication {
 
   get subscriptionStatus() {
     if (this.subscribed === false || !super.isSubscribed) {
-      return TrackPublication.SubscriptionStatus.Unsubscribed;
-    }
+      if (!this.allowed) {
+        return TrackPublication.SubscriptionStatus.NotAllowed;
+      }
 
-    if (!this._allowed) {
-      return TrackPublication.SubscriptionStatus.NotAllowed;
+      return TrackPublication.SubscriptionStatus.Unsubscribed;
     }
 
     return TrackPublication.SubscriptionStatus.Subscribed;
@@ -13679,10 +13692,6 @@ class RemoteTrackPublication extends TrackPublication {
       return false;
     }
 
-    if (!this._allowed) {
-      return false;
-    }
-
     return super.isSubscribed;
   }
 
@@ -13750,11 +13759,14 @@ class RemoteTrackPublication extends TrackPublication {
 
 
   setTrack(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);
@@ -13765,6 +13777,25 @@ 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) {
+    const prevStatus = this.subscriptionStatus;
+    this.allowed = allowed;
+    this.emitSubscriptionUpdateIfChanged(prevStatus);
   }
   /** @internal */
 
@@ -13777,6 +13808,16 @@ class RemoteTrackPublication extends TrackPublication {
     (_a = this.track) === null || _a === void 0 ? void 0 : _a.setMuted(info.muted);
   }
 
+  emitSubscriptionUpdateIfChanged(previousStatus) {
+    const currentStatus = this.subscriptionStatus;
+
+    if (previousStatus === currentStatus) {
+      return;
+    }
+
+    this.emit(TrackEvent.SubscriptionPermissionChanged, currentStatus, previousStatus);
+  }
+
   isManualOperationAllowed() {
     if (this.isAdaptiveStream) {
       livekitLogger.warn('adaptive stream is enabled, cannot change track settings', {
@@ -13851,8 +13892,14 @@ class RemoteParticipant extends Participant {
       });
       this.signalClient.sendUpdateSubscription(sub);
     });
-    publication.on(TrackEvent.Ended, track => {
-      this.emit(ParticipantEvent.TrackUnsubscribed, track, publication);
+    publication.on(TrackEvent.SubscriptionPermissionChanged, status => {
+      this.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, publication, status);
+    });
+    publication.on(TrackEvent.Subscribed, track => {
+      this.emit(ParticipantEvent.TrackSubscribed, track, publication);
+    });
+    publication.on(TrackEvent.Unsubscribed, previousTrack => {
+      this.emit(ParticipantEvent.TrackUnsubscribed, previousTrack, publication);
     });
   }
 
@@ -13953,15 +14000,12 @@ class RemoteParticipant extends Participant {
     track.isMuted = publication.isMuted;
     track.setMediaStream(mediaStream);
     track.start();
-    publication.setTrack(track); // subscription means participant has permissions to subscribe
-
-    publication._allowed = true; // set participant volume on new microphone tracks
+    publication.setTrack(track); // set participant volume on new microphone tracks
 
     if (this.volume !== undefined && track instanceof RemoteAudioTrack && track.source === Track.Source.Microphone) {
       track.setVolume(this.volume);
     }
 
-    this.emit(ParticipantEvent.TrackSubscribed, track, publication);
     return publication;
   }
   /** @internal */
@@ -14049,15 +14093,8 @@ class RemoteParticipant extends Participant {
     } = 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);
-      }
+      publication.setTrack(undefined);
     }
 
     if (sendUnpublish) {
@@ -14178,11 +14215,47 @@ class LocalParticipant extends Participant {
       this.unpublishTrack(track.track);
     };
 
-    this.handleTrackEnded = track => {
-      livekitLogger.debug('unpublishing local track due to TrackEnded', {
-        track: track.sid
-      });
-      this.unpublishTrack(track);
+    this.handleTrackEnded = async track => {
+      if (track.source === Track.Source.ScreenShare || track.source === Track.Source.ScreenShareAudio) {
+        livekitLogger.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 === null || navigator === void 0 ? void 0 : 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') {
+                livekitLogger.warn("user has revoked access to ".concat(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) {// permissions query fails for firefox, we continue and try to restart the track
+            }
+          }
+
+          livekitLogger.debug('track ended, attempting to use a different device');
+          await track.restartTrack();
+        } catch (e) {
+          livekitLogger.warn("could not restart track, pausing upstream instead");
+          await track.pauseUpstream();
+        }
+      }
     };
 
     this.audioTracks = new Map();
@@ -14241,8 +14314,8 @@ class LocalParticipant extends Participant {
    */
 
 
-  setCameraEnabled(enabled, options) {
-    return this.setTrackEnabled(Track.Source.Camera, enabled, options);
+  setCameraEnabled(enabled, options, publishOptions) {
+    return this.setTrackEnabled(Track.Source.Camera, enabled, options, publishOptions);
   }
   /**
    * Enable or disable a participant's microphone track.
@@ -14252,8 +14325,8 @@ class LocalParticipant extends Participant {
    */
 
 
-  setMicrophoneEnabled(enabled, options) {
-    return this.setTrackEnabled(Track.Source.Microphone, enabled, options);
+  setMicrophoneEnabled(enabled, options, publishOptions) {
+    return this.setTrackEnabled(Track.Source.Microphone, enabled, options, publishOptions);
   }
   /**
    * Start or stop sharing a participant's screen
@@ -14261,8 +14334,8 @@ class LocalParticipant extends Participant {
    */
 
 
-  setScreenShareEnabled(enabled, options) {
-    return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options);
+  setScreenShareEnabled(enabled, options, publishOptions) {
+    return this.setTrackEnabled(Track.Source.ScreenShare, enabled, options, publishOptions);
   }
   /** @internal */
 
@@ -14278,7 +14351,7 @@ class LocalParticipant extends Participant {
     return changed;
   }
 
-  async setTrackEnabled(source, enabled, options) {
+  async setTrackEnabled(source, enabled, options, publishOptions) {
     var _a, _b;
 
     livekitLogger.debug('setTrackEnabled', {
@@ -14328,7 +14401,7 @@ class LocalParticipant extends Participant {
           const publishPromises = [];
 
           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
@@ -14508,7 +14581,7 @@ class LocalParticipant extends Participant {
 
 
   async publishTrack(track, options) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f, _g, _h;
 
     const opts = _objectSpread2(_objectSpread2({}, (_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.publishDefaults), options); // convert raw media track into audio or video track
 
@@ -14652,6 +14725,10 @@ class LocalParticipant extends Participant {
       track.codec = opts.videoCodec;
     }
 
+    if (track.codec === 'av1' && encodings && ((_h = encodings[0]) === null || _h === void 0 ? void 0 : _h.maxBitrate)) {
+      this.engine.publisher.setTrackCodecBitrate(req.cid, track.codec, encodings[0].maxBitrate / 1000);
+    }
+
     this.engine.negotiate(); // store RTPSender
 
     track.sender = transceiver.sender;
@@ -14673,7 +14750,7 @@ class LocalParticipant extends Participant {
 
 
   async publishAdditionalCodecForTrack(track, videoCodec, options) {
-    var _a, _b, _c, _d, _e;
+    var _a, _b, _c, _d, _e, _f;
 
     const opts = _objectSpread2(_objectSpread2({}, (_a = this.roomOptions) === null || _a === void 0 ? void 0 : _a.publishDefaults), options); // clear scalabilityMode setting for backup codec
 
@@ -14741,6 +14818,11 @@ class LocalParticipant extends Participant {
     const transceiver = await this.engine.publisher.pc.addTransceiver(simulcastTrack.mediaStreamTrack, transceiverInit);
     this.setPreferredCodec(transceiver, track.kind, opts.videoCodec);
     track.setSimulcastTrackSender(opts.videoCodec, transceiver.sender);
+
+    if (videoCodec === 'av1' && ((_f = encodings[0]) === null || _f === void 0 ? void 0 : _f.maxBitrate)) {
+      this.engine.publisher.setTrackCodecBitrate(req.cid, videoCodec, encodings[0].maxBitrate / 1000);
+    }
+
     this.engine.negotiate();
     livekitLogger.debug("published ".concat(opts.videoCodec, " for track ").concat(track.sid), {
       encodings,
@@ -18974,7 +19056,8 @@ class PCTransport {
   constructor(config) {
     this.pendingCandidates = [];
     this.restartingIce = false;
-    this.renegotiate = false; // debounced negotiate interface
+    this.renegotiate = false;
+    this.trackBitrates = []; // debounced negotiate interface
 
     this.negotiate = r(() => {
       this.createAndSendOffer();
@@ -19038,11 +19121,38 @@ class PCTransport {
 
 
     livekitLogger.debug('starting to negotiate');
-    const offer = await this.pc.createOffer(options);
+    const offer = await this.pc.createOffer(options); // mung sdp for codec bitrate setting that can't apply by sendEncoding
+
+    this.trackBitrates.forEach(trackbr => {
+      var _a;
+
+      let sdp = (_a = offer.sdp) !== null && _a !== void 0 ? _a : '';
+      const sidIndex = sdp.search(new RegExp("msid.* ".concat(trackbr.sid)));
+
+      if (sidIndex < 0) {
+        return;
+      }
+
+      const mlineStart = sdp.substring(0, sidIndex).lastIndexOf('m=');
+      const mlineEnd = sdp.indexOf('m=', sidIndex);
+      const mediaSection = sdp.substring(mlineStart, mlineEnd);
+      const mungedMediaSection = mediaSection.replace(new RegExp("a=rtpmap:(\\d+) ".concat(trackbr.codec, "/\\d+"), 'i'), '$'.concat("&\r\na=fmtp:$1 x-google-max-bitrate=".concat(trackbr.maxbr)));
+      sdp = sdp.substring(0, mlineStart) + mungedMediaSection + sdp.substring(mlineEnd);
+      offer.sdp = sdp;
+    });
+    this.trackBitrates = [];
     await this.pc.setLocalDescription(offer);
     this.onOffer(offer);
   }
 
+  setTrackCodecBitrate(sid, codec, maxbr) {
+    this.trackBitrates.push({
+      sid,
+      codec,
+      maxbr
+    });
+  }
+
   close() {
     this.pc.close();
   }
@@ -19422,23 +19532,9 @@ class RTCEngine extends events.exports.EventEmitter {
         const track = ev.stream.getTracks()[0];
         this.emit(EngineEvent.MediaTrackAdded, track, ev.stream);
       };
-    } // data channels
-
-
-    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
-      // will drop older packets that arrive
-      ordered: true,
-      maxRetransmits: 0
-    });
-    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
-      ordered: true
-    }); // also handle messages over the pub channel, for backwards compatibility
-
-    this.lossyDC.onmessage = this.handleDataMessage;
-    this.reliableDC.onmessage = this.handleDataMessage; // handle datachannel errors
+    }
 
-    this.lossyDC.onerror = this.handleDataError;
-    this.reliableDC.onerror = this.handleDataError; // configure signaling client
+    this.createDataChannels(); // configure signaling client
 
     this.client.onAnswer = async sd => {
       if (!this.publisher) {
@@ -19523,6 +19619,39 @@ class RTCEngine extends events.exports.EventEmitter {
     };
   }
 
+  createDataChannels() {
+    if (!this.publisher) {
+      return;
+    } // clear old data channel callbacks if recreate
+
+
+    if (this.lossyDC) {
+      this.lossyDC.onmessage = null;
+      this.lossyDC.onerror = null;
+    }
+
+    if (this.reliableDC) {
+      this.reliableDC.onmessage = null;
+      this.reliableDC.onerror = null;
+    } // create data channels
+
+
+    this.lossyDC = this.publisher.pc.createDataChannel(lossyDataChannel, {
+      // will drop older packets that arrive
+      ordered: true,
+      maxRetransmits: 0
+    });
+    this.reliableDC = this.publisher.pc.createDataChannel(reliableDataChannel, {
+      ordered: true
+    }); // also handle messages over the pub channel, for backwards compatibility
+
+    this.lossyDC.onmessage = this.handleDataMessage;
+    this.reliableDC.onmessage = this.handleDataMessage; // handle datachannel errors
+
+    this.lossyDC.onerror = this.handleDataError;
+    this.reliableDC.onerror = this.handleDataError;
+  }
+
   async restartConnection() {
     var _a, _b;
 
@@ -19562,6 +19691,8 @@ class RTCEngine extends events.exports.EventEmitter {
   }
 
   async resumeConnection() {
+    var _a;
+
     if (!this.url || !this.token) {
       // permanent failure, don't attempt reconnection
       throw new UnexpectedConnectionState('could not reconnect, url or token not saved');
@@ -19594,7 +19725,13 @@ class RTCEngine extends events.exports.EventEmitter {
     }
 
     await this.waitForPCConnected();
-    this.client.setReconnected(); // resume success
+    this.client.setReconnected(); // recreate publish datachannel if it's id is null
+    // (for safari https://bugs.webkit.org/show_bug.cgi?id=184688)
+
+    if (((_a = this.reliableDC) === null || _a === void 0 ? void 0 : _a.readyState) === 'open' && this.reliableDC.id === null) {
+      this.createDataChannels();
+    } // resume success
+
 
     this.emit(EngineEvent.Resumed);
   }
@@ -19964,11 +20101,15 @@ class Room extends events.exports.EventEmitter {
      */
 
 
-    this.disconnect = function () {
+    this.disconnect = async function () {
       let stopTracks = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
 
       var _a, _b;
 
+      livekitLogger.info('disconnect from room', {
+        identity: _this.localParticipant.identity
+      });
+
       if (_this.state === ConnectionState.Connecting) {
         // try aborting pending connection attempt
         livekitLogger.warn('abort connection attempt');
@@ -19978,7 +20119,7 @@ class Room extends events.exports.EventEmitter {
 
 
       if ((_b = _this.engine) === null || _b === void 0 ? void 0 : _b.client.isConnected) {
-        _this.engine.client.sendLeave();
+        await _this.engine.client.sendLeave();
       } // close engine (also closes client)
 
 
@@ -19986,7 +20127,7 @@ class Room extends events.exports.EventEmitter {
         _this.engine.close();
       }
 
-      _this.handleDisconnect(stopTracks);
+      _this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
       /* @ts-ignore */
 
 
@@ -20183,9 +20324,7 @@ class Room extends events.exports.EventEmitter {
         return;
       }
 
-      pub._allowed = update.allowed;
-      participant.emit(ParticipantEvent.TrackSubscriptionPermissionChanged, pub, pub.subscriptionStatus);
-      this.emitWhenConnected(RoomEvent.TrackSubscriptionPermissionChanged, pub, pub.subscriptionStatus, participant);
+      pub.setAllowed(update.allowed);
     };
 
     this.handleDataPacket = (userPacket, kind) => {
@@ -20528,6 +20667,10 @@ class Room extends events.exports.EventEmitter {
 
     var _a;
 
+    if (this.state === ConnectionState.Disconnected) {
+      return;
+    }
+
     this.participants.forEach(p => {
       p.tracks.forEach(pub => {
         p.unpublishTrack(pub.trackSid);
@@ -20545,6 +20688,9 @@ class Room extends events.exports.EventEmitter {
         (_b = pub.track) === null || _b === void 0 ? void 0 : _b.stop();
       }
     });
+    this.localParticipant.tracks.clear();
+    this.localParticipant.videoTracks.clear();
+    this.localParticipant.audioTracks.clear();
     this.participants.clear();
     this.activeSpeakers = [];
 
@@ -20646,6 +20792,8 @@ class Room extends events.exports.EventEmitter {
       this.emitWhenConnected(RoomEvent.ConnectionQualityChanged, quality, participant);
     }).on(ParticipantEvent.ParticipantPermissionsChanged, prevPermissions => {
       this.emitWhenConnected(RoomEvent.ParticipantPermissionsChanged, prevPermissions, participant);
+    }).on(ParticipantEvent.TrackSubscriptionPermissionChanged, (pub, status) => {
+      this.emitWhenConnected(RoomEvent.TrackSubscriptionPermissionChanged, pub, status, participant);
     }); // update info at the end after callbacks have been set up
 
     if (info) {