livekit-client 1.1.9 → 1.2.0

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.0";
 
 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);
     });
@@ -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();
@@ -19422,23 +19495,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 +19582,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 +19654,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 +19688,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 +20064,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 +20082,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 +20090,7 @@ class Room extends events.exports.EventEmitter {
         _this.engine.close();
       }
 
-      _this.handleDisconnect(stopTracks);
+      _this.handleDisconnect(stopTracks, DisconnectReason.CLIENT_INITIATED);
       /* @ts-ignore */
 
 
@@ -20183,9 +20287,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 +20630,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 +20651,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 +20755,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) {