@stream-io/video-client 0.0.7 → 0.0.9

package/dist/src/Call.d.ts

@@ -30,6 +30,12 @@ export declare class Call {
      * The state of this call.
      */
     readonly state: CallState;
+    private rejoinPromise;
+    /**
+     * 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(): (() => Promise<void>) | undefined;
     /**
      * Flag indicating whether this call is "watched" and receives
      * updates from the backend.

package/dist/src/rtc/publisher.d.ts

@@ -41,6 +41,12 @@ export declare class Publisher {
      * @param trackType the track type to unpublish.
      */
     unpublishStream: (trackType: TrackType) => Promise<void>;
+    /**
+     * Returns true if the given track type is currently being published to the SFU.
+     *
+     * @param trackType the track type to check.
+     */
+    isPublishing: (trackType: TrackType) => boolean;
     private notifyTrackMuteStateChanged;
     /**
      * Stops publishing all tracks and stop all tracks.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/video-client",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "packageManager": "yarn@3.2.4",
   "main": "dist/index.cjs.js",
   "module": "dist/index.es.js",

package/src/Call.ts

@@ -135,6 +135,16 @@ export class Call {
    */
   readonly state = new CallState();
 
+  private rejoinPromise: (() => Promise<void>) | undefined;
+
+  /**
+   * 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(): (() => Promise<void>) | undefined {
+    return this.rejoinPromise;
+  }
+
   /**
    * Flag indicating whether this call is "watched" and receives
    * updates from the backend.
@@ -254,22 +264,26 @@ export class Call {
         // 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 as OwnCapability,
           );
-          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.
@@ -370,6 +384,7 @@ export 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.
@@ -642,7 +657,7 @@ export class Call {
       await sleep(retryInterval(this.reconnectAttempts));
       await this.join(data);
       console.log(`Rejoin: ${this.reconnectAttempts} successful!`);
-      if (localParticipant) {
+      if (localParticipant && !isReactNative()) {
         const {
           audioStream,
           videoStream,
@@ -657,6 +672,8 @@ export 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
@@ -667,6 +684,8 @@ export class Call {
         // do nothing if the connection was closed because of a policy violation
         // 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(

package/src/rtc/publisher.ts

@@ -214,6 +214,20 @@ export class Publisher {
     }
   };
 
+  /**
+   * Returns true if the given track type is currently being published to the SFU.
+   *
+   * @param trackType the track type to check.
+   */
+  isPublishing = (trackType: TrackType): boolean => {
+    const transceiverForTrackType = this.transceiverRegistry[trackType];
+    if (transceiverForTrackType && transceiverForTrackType.sender) {
+      const sender = transceiverForTrackType.sender;
+      return !!sender.track && sender.track.readyState === 'live';
+    }
+    return false;
+  };
+
   private notifyTrackMuteStateChanged = async (
     mediaStream: MediaStream | undefined,
     track: MediaStreamTrack,

package/src/rtc/signal.ts

@@ -9,15 +9,15 @@ export const createWebSocketSignalChannel = (opts: {
   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) {