@stream-io/video-client 0.0.7 → 0.0.9

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+### [0.0.9](https://github.com/GetStream/stream-video-js/compare/client0.0.8...client0.0.9) (2023-06-12)
+
+
+### Bug Fixes
+
+* prevent misleading "stop publish" log messages upon call instantiation ([#629](https://github.com/GetStream/stream-video-js/issues/629)) ([af40939](https://github.com/GetStream/stream-video-js/commit/af4093966c408d37fbf59c4c8fafd22756aa8888))
+
+### [0.0.8](https://github.com/GetStream/stream-video-js/compare/client0.0.7...client0.0.8) (2023-06-09)
+
+
+### Features
+
+* **react-native:** support reconnection flow ([#458](https://github.com/GetStream/stream-video-js/issues/458)) ([89f2dda](https://github.com/GetStream/stream-video-js/commit/89f2ddafd1397d91f8ddea5a3c69dd62ae027313))
+
 ### [0.0.7](https://github.com/GetStream/stream-video-js/compare/client0.0.6...client0.0.7) (2023-06-08)
 
 

package/dist/index.browser.es.js

@@ -5692,6 +5692,19 @@ class Publisher {
                 return this.notifyTrackMuteStateChanged(undefined, transceiver.sender.track, trackType, true);
             }
         });
+        /**
+         * Returns true if the given track type is currently being published to the SFU.
+         *
+         * @param trackType the track type to check.
+         */
+        this.isPublishing = (trackType) => {
+            const transceiverForTrackType = this.transceiverRegistry[trackType];
+            if (transceiverForTrackType && transceiverForTrackType.sender) {
+                const sender = transceiverForTrackType.sender;
+                return !!sender.track && sender.track.readyState === 'live';
+            }
+            return false;
+        };
         this.notifyTrackMuteStateChanged = (mediaStream, track, trackType, isMuted) => __awaiter(this, void 0, void 0, function* () {
             yield this.sfuClient.updateMuteState(trackType, isMuted);
             const audioOrVideoOrScreenShareStream = trackTypeToParticipantStreamKey(trackType);
@@ -5969,13 +5982,13 @@ const createWebSocketSignalChannel = (opts) => {
     const ws = new WebSocket(endpoint);
     ws.binaryType = 'arraybuffer'; // do we need this?
     ws.addEventListener('error', (e) => {
-        console.error('Error', e);
+        console.log('Signaling WS channel error', e);
     });
     ws.addEventListener('close', (e) => {
-        console.warn('Signalling channel is closed', e);
+        console.log('Signaling WS channel is closed', e);
     });
     ws.addEventListener('open', (e) => {
-        console.log('Signalling channel is open', e);
+        console.log('Signaling WS channel is open', e);
     });
     if (onMessage) {
         ws.addEventListener('message', (e) => {
@@ -8318,6 +8331,13 @@ const getSdkInfo = () => {
  * An object representation of a `Call`.
  */
 class Call {
+    /**
+     * A promise that exposes the reconnection logic
+     * The use-case is for the react-native platform where online/offline events are not available in the window
+     */
+    get rejoin() {
+        return this.rejoinPromise;
+    }
     /**
      * Constructs a new `Call` instance.
      *
@@ -8363,6 +8383,7 @@ class Call {
             if (callingState === CallingState.LEFT) {
                 throw new Error('Cannot leave call that has already been left.');
             }
+            this.rejoinPromise = undefined;
             if (this.ringing) {
                 // I'm the one who started the call, so I should cancel it.
                 const hasOtherParticipants = this.state.remoteParticipants.length > 0;
@@ -8555,7 +8576,7 @@ class Call {
                 yield sleep(retryInterval(this.reconnectAttempts));
                 yield this.join(data);
                 console.log(`Rejoin: ${this.reconnectAttempts} successful!`);
-                if (localParticipant) {
+                if (localParticipant && !isReactNative()) {
                     const { audioStream, videoStream, screenShareStream: screenShare, } = localParticipant;
                     // restore previous publishing state
                     if (audioStream)
@@ -8567,6 +8588,7 @@ class Call {
                 }
                 console.log(`Rejoin: state restored ${this.reconnectAttempts}`);
             });
+            this.rejoinPromise = rejoin;
             // reconnect if the connection was closed unexpectedly. example:
             // - SFU crash or restart
             // - network change
@@ -8579,6 +8601,9 @@ class Call {
                     // e.g., the user has been blocked by an admin or moderator
                     if (e.code === KnownCodes.WS_POLICY_VIOLATION)
                         return;
+                    // do nothing for react-native as its handled by SDK
+                    if (isReactNative())
+                        return;
                     if (this.reconnectAttempts < this.maxReconnectAttempts) {
                         rejoin().catch(() => {
                             console.log(`Rejoin failed for ${this.reconnectAttempts} times. Giving up.`);
@@ -9279,20 +9304,22 @@ class Call {
         createSubscription(this.state.ownCapabilities$, (ownCapabilities) => {
             // update the permission context.
             this.permissionsContext.setPermissions(ownCapabilities);
+            if (!this.publisher)
+                return;
             // check if the user still has publishing permissions and stop publishing if not.
             const permissionToTrackType = {
                 [OwnCapability.SEND_AUDIO]: TrackType.AUDIO,
                 [OwnCapability.SEND_VIDEO]: TrackType.VIDEO,
                 [OwnCapability.SCREENSHARE]: TrackType.SCREEN_SHARE,
             };
-            Object.entries(permissionToTrackType).forEach(([permission, type]) => {
+            for (const [permission, trackType] of Object.entries(permissionToTrackType)) {
                 const hasPermission = this.permissionsContext.hasPermission(permission);
-                if (!hasPermission) {
-                    this.stopPublish(type).catch((err) => {
-                        console.error('Error stopping publish', type, err);
+                if (!hasPermission && this.publisher.isPublishing(trackType)) {
+                    this.stopPublish(trackType).catch((err) => {
+                        console.error('Error stopping publish', trackType, err);
                     });
                 }
-            });
+            }
         }), 
         // handles the case when the user is blocked by the call owner.
         createSubscription(this.state.metadata$, (metadata) => __awaiter(this, void 0, void 0, function* () {
@@ -10993,7 +11020,7 @@ class StreamClient {
     }
     getUserAgent() {
         return (this.userAgent ||
-            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.6"}`);
+            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.8"}`);
     }
     setUserAgent(userAgent) {
         this.userAgent = userAgent;