@100mslive/hms-video-store 0.2.48 → 0.2.51

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.48",
+  "version": "0.2.51",
   "license": "MIT",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
@@ -55,11 +55,11 @@
     "zustand": "3.5.7"
   },
   "peerDependencies": {
-    "@100mslive/hms-video": "0.0.193",
+    "@100mslive/hms-video": "0.0.199",
     "events": "^3.3.0"
   },
   "devDependencies": {
-    "@100mslive/hms-video": "0.0.193",
+    "@100mslive/hms-video": "0.0.199",
     "@size-limit/file": "^5.0.3",
     "events": "^3.3.0",
     "husky": "^6.0.0",

package/src/core/hmsSDKStore/HMSPlaylist.ts

@@ -1,6 +1,8 @@
 import { HMSPlaylistItem, HMSPlaylistType, IHMSPlaylistActions } from '../schema';
 import { HMSPlaylistManager } from './sdkTypes';
 import { HMSLogger } from '../../common/ui-logger';
+import { IHMSStore } from '../IHMSStore';
+import { selectVideoPlaylist, selectAudioPlaylist } from '../selectors';
 
 export class HMSPlaylist implements IHMSPlaylistActions {
   private type: HMSPlaylistType;
@@ -8,24 +10,28 @@ export class HMSPlaylist implements IHMSPlaylistActions {
     private playlistManager: HMSPlaylistManager,
     type: HMSPlaylistType,
     private syncPlaylistState: (action: string) => void,
+    private store: IHMSStore,
   ) {
     this.type = type;
   }
 
   async play(id: string): Promise<void> {
     if (!id) {
-      HMSLogger.w('Please pass id and type to pause');
+      HMSLogger.w('Please pass id to play');
       return;
     }
     await this.playlistManager.setEnabled(true, { id, type: this.type });
   }
 
-  async pause(id: string): Promise<void> {
-    if (!id) {
-      HMSLogger.w('Please pass id and type to pause');
+  async pause(): Promise<void> {
+    const selector =
+      this.type === HMSPlaylistType.audio ? selectAudioPlaylist : selectVideoPlaylist;
+    const selection = this.store.getState(selector.selection);
+    if (!selection.id) {
+      HMSLogger.w('No item is currently playing to pause');
       return;
     }
-    await this.playlistManager.setEnabled(false, { id, type: this.type });
+    await this.playlistManager.setEnabled(false, { id: selection.id, type: this.type });
   }
 
   async playNext(): Promise<void> {

package/src/core/hmsSDKStore/HMSSDKActions.ts

@@ -5,63 +5,64 @@ import {
   HMSMessageInput,
   HMSPeer,
   HMSPeerID,
+  HMSPlaylistType,
   HMSRoomState,
   HMSStore,
   HMSTrack,
   HMSTrackID,
   HMSTrackSource,
+  IHMSPlaylistActions,
 } from '../schema';
 import { IHMSActions } from '../IHMSActions';
 import * as sdkTypes from './sdkTypes';
 import { SDKToHMS } from './adapter';
 import {
+  HMSRoleChangeRequest,
+  selectHMSMessagesCount,
   selectIsLocalScreenShared,
+  selectIsLocalVideoDisplayEnabled,
   selectIsLocalVideoEnabled,
   selectLocalAudioTrackID,
-  selectLocalVideoTrackID,
-  selectHMSMessagesCount,
-  selectIsLocalVideoDisplayEnabled,
   selectLocalPeer,
+  selectLocalTrackIDs,
+  selectLocalVideoTrackID,
   selectPeerByID,
-  HMSRoleChangeRequest,
-  selectTrackByID,
-  selectRoomStarted,
   selectPermissions,
   selectRolesMap,
-  selectLocalTrackIDs,
+  selectRoomStarted,
   selectRoomState,
+  selectTrackByID,
 } from '../selectors';
 import { HMSLogger } from '../../common/ui-logger';
 import {
-  HMSSdk,
-  HMSVideoPlugin,
   HMSAudioPlugin,
-  HMSTrack as SDKHMSTrack,
-  HMSLocalTrack as SDKHMSLocalTrack,
-  HMSRemoteVideoTrack as SDKHMSRemoteVideoTrack,
+  HMSAudioTrack as SDKHMSAudioTrack,
+  HMSChangeTrackStateRequest as SDKHMSChangeTrackStateRequest,
+  HMSException as SDKHMSException,
+  HMSLeaveRoomRequest as SDKHMSLeaveRoomRequest,
   HMSLocalAudioTrack as SDKHMSLocalAudioTrack,
+  HMSLocalTrack as SDKHMSLocalTrack,
   HMSLocalVideoTrack as SDKHMSLocalVideoTrack,
+  HMSLogLevel,
   HMSRemoteTrack as SDKHMSRemoteTrack,
-  HMSAudioTrack as SDKHMSAudioTrack,
-  HMSVideoTrack as SDKHMSVideoTrack,
-  HMSException as SDKHMSException,
+  HMSRemoteVideoTrack as SDKHMSRemoteVideoTrack,
   HMSRoleChangeRequest as SDKHMSRoleChangeRequest,
-  HMSChangeTrackStateRequest as SDKHMSChangeTrackStateRequest,
+  HMSSdk,
   HMSSimulcastLayer,
-  HMSLeaveRoomRequest as SDKHMSLeaveRoomRequest,
-  HMSLogLevel,
+  HMSTrack as SDKHMSTrack,
+  HMSVideoPlugin,
+  HMSVideoTrack as SDKHMSVideoTrack,
 } from '@100mslive/hms-video';
 import { IHMSStore } from '../IHMSStore';
 
 import {
+  areArraysEqual,
   mergeNewPeersInDraft,
   mergeNewTracksInDraft,
-  areArraysEqual,
 } from './sdkUtils/storeMergeUtils';
 import { HMSNotifications } from './HMSNotifications';
 import { NamedSetState } from './internalTypes';
 import { isRemoteTrack } from './sdkUtils/sdkUtils';
-import { HMSPlaylistType, IHMSPlaylistActions } from '../schema';
 import { HMSPlaylist } from './HMSPlaylist';
 
 /**
@@ -123,7 +124,7 @@ export class HMSSDKActions implements IHMSActions {
     if (track) {
       if (track instanceof SDKHMSRemoteVideoTrack) {
         track.preferLayer(layer);
-        this.syncRoomState('setPreferredLayer');
+        this.updateVideoLayer(trackId, 'setPreferredLayer');
       } else {
         HMSLogger.w(`track ${trackId} is not an video track`);
       }
@@ -348,6 +349,7 @@ export class HMSSDKActions implements IHMSActions {
     const sdkTrack = this.hmsSDKTracks[trackID];
     if (sdkTrack && sdkTrack.type === 'video') {
       await (sdkTrack as SDKHMSVideoTrack).removeSink(videoElement);
+      this.updateVideoLayer(trackID, 'detachVideo');
     } else {
       this.logPossibleInconsistency('no video track found to remove sink');
     }
@@ -559,16 +561,7 @@ export class HMSSDKActions implements IHMSActions {
     const sdkTrack = this.hmsSDKTracks[trackID];
     if (sdkTrack && sdkTrack.type === 'video') {
       await (sdkTrack as SDKHMSVideoTrack).addSink(videoElement);
-      // Update layer as it is updated in addSink
-      if (
-        sdkTrack instanceof SDKHMSRemoteVideoTrack &&
-        sdkTrack.getSimulcastDefinitions().length > 0
-      ) {
-        this.setState(draft => {
-          const layer = sdkTrack.getSimulcastLayer();
-          draft.tracks[trackID].layer = layer;
-        }, 'updateLayerOnAttach');
-      }
+      this.updateVideoLayer(trackID, 'attachVideo');
     } else {
       this.logPossibleInconsistency('no video track found to add sink');
     }
@@ -617,6 +610,9 @@ export class HMSSDKActions implements IHMSActions {
       }
     }
 
+    const recording = this.sdk.getRecordingState();
+    const rtmp = this.sdk.getRTMPState();
+
     // then merge them carefully with our store so if something hasn't changed
     // the reference shouldn't change. Note that the draftStore is an immer draft
     // object.
@@ -631,6 +627,7 @@ export class HMSSDKActions implements IHMSActions {
       this.hmsSDKTracks = newHmsSDkTracks;
       Object.assign(draftStore.roles, SDKToHMS.convertRoles(this.sdk.getRoles()));
       Object.assign(draftStore.playlist, SDKToHMS.convertPlaylist(this.sdk.getPlaylistManager()));
+      Object.assign(draftStore.room, SDKToHMS.convertRecordingRTMPState(recording, rtmp));
     }, action);
   }
 
@@ -647,11 +644,13 @@ export class HMSSDKActions implements IHMSActions {
       this.sdk.getPlaylistManager(),
       HMSPlaylistType.audio,
       this.syncPlaylistState.bind(this),
+      this.store,
     );
     this.videoPlaylist = new HMSPlaylist(
       this.sdk.getPlaylistManager(),
       HMSPlaylistType.video,
       this.syncRoomState.bind(this),
+      this.store,
     );
     this.syncRoomState('joinSync');
     this.setState(store => {
@@ -828,6 +827,19 @@ export class HMSSDKActions implements IHMSActions {
     HMSLogger.e('received error from sdk', error);
   }
 
+  /**
+   * the layer gets updated on addsink/removesink/preferlayer calls, for simulcast there
+   * can be multiple layers, while for non simulcast there will be None and High.
+   */
+  private updateVideoLayer(trackID: string, action: string) {
+    const sdkTrack = this.hmsSDKTracks[trackID];
+    if (sdkTrack && sdkTrack instanceof SDKHMSRemoteVideoTrack) {
+      this.setState(draft => {
+        draft.tracks[trackID].layer = sdkTrack.getSimulcastLayer();
+      }, action);
+    }
+  }
+
   private handleTrackRemove(sdkTrack: SDKHMSTrack, sdkPeer: sdkTypes.HMSPeer) {
     this.setState(draftStore => {
       const hmsPeer = draftStore.peers[sdkPeer.peerId];

package/src/core/hmsSDKStore/adapter.ts

@@ -188,4 +188,19 @@ export class SDKToHMS {
       currentTime: playlistManager.getCurrentTime(type),
     };
   }
+
+  static convertRecordingRTMPState(
+    recording: sdkTypes.HMSRecording | undefined,
+    rtmp: sdkTypes.HMSRTMP | undefined,
+  ) {
+    return {
+      recording: {
+        browser: {
+          running: !!recording?.browser.running,
+        },
+        server: { running: !!recording?.server?.running },
+      },
+      rtmp: { running: !!rtmp?.running },
+    };
+  }
 }

package/src/core/hmsSDKStore/sdkTypes.ts

@@ -22,6 +22,8 @@ import {
   HMSPlaylistManager,
   HMSPlaylistProgressEvent,
   RTMPRecordingConfig,
+  HMSRecording,
+  HMSRTMP,
 } from '@100mslive/hms-video';
 
 export {
@@ -48,4 +50,6 @@ export {
   HMSPlaylistManager,
   HMSPlaylistProgressEvent,
   RTMPRecordingConfig,
+  HMSRecording,
+  HMSRTMP,
 };

package/src/core/schema/playlist.ts

@@ -40,40 +40,39 @@ export interface HMSPlaylist<T> {
 
 export interface IHMSPlaylistActions {
   /**
-   * Play audio/video passing url and type
+   * Pass the id of the item to be played
    * @param {string} id - id of playlist item
    */
   play(id: string): Promise<void>;
   /**
-   * Pause audio/video passing url and type
-   * @param {string} id - id of playlist item
+   * Pauses current playing item
    */
-  pause(id: string): Promise<void>;
+  pause(): Promise<void>;
   /**
-   * PlayNext audio/video passing type
+   * PlayNext
    */
   playNext(): Promise<void>;
   /**
-   * PlayPrevious audio/video passing type
+   * PlayPrevious
    */
   playPrevious(): Promise<void>;
   /**
-   * seek audio/video passing seekValue and type - this is relative to current position
+   * seek passing seekValue - this is relative to current position
    * @param {number} seekValue - number in seconds to move forwards(pass negative values to move backwards)
    */
   seek(seekValue: number): void;
   /**
-   * seek audio/video passing seekValue and type - seekValue will be absolute
+   * seek passing seekValue  - seekValue will be absolute
    * @param {number} seekValue - value in seconds of absolute position in the playlist item duration
    */
   seekTo(seekValue: number): void;
   /**
-   * set audio/video volume passing volume and type
+   * set volume passing volume
    * @param {number} volume - number between 0-100
    */
   setVolume(volume: number): void;
   /**
-   * pass list and type to set audio/video playlist
+   * pass list to set playlist
    * @param {HMSPlaylistItem[]} - list of playlist items
    */
   setList<T>(list: HMSPlaylistItem<T>[]): void;

package/src/core/schema/room.ts

@@ -19,4 +19,15 @@ export interface HMSRoom {
   shareableLink: string;
   hasWaitingRoom: boolean;
   roomState: HMSRoomState;
+  recording: {
+    browser: {
+      running: boolean;
+    };
+    server: {
+      running: boolean;
+    };
+  };
+  rtmp: {
+    running: boolean;
+  };
 }

package/src/core/schema/schema.ts

@@ -42,6 +42,17 @@ export const createDefaultStoreState = (): HMSStore => {
       shareableLink: '',
       hasWaitingRoom: false,
       roomState: HMSRoomState.Disconnected,
+      recording: {
+        browser: {
+          running: false,
+        },
+        server: {
+          running: false,
+        },
+      },
+      rtmp: {
+        running: false,
+      },
     },
     peers: {},
     tracks: {},

package/src/core/selectors/selectors.ts

@@ -379,3 +379,6 @@ export const selectIsAllowedToSubscribe = createSelector([selectLocalPeerRole],
  * Select the permissions which determine what actions the local peer can do.
  */
 export const selectPermissions = createSelector(selectLocalPeerRole, role => role?.permissions);
+
+export const selectRecordingState = createSelector(selectRoom, room => room.recording);
+export const selectRTMPState = createSelector(selectRoom, room => room.rtmp);

package/src/test/fakeStore.ts

@@ -60,6 +60,17 @@ export const makeFakeStore = (): HMSStore => {
       shareableLink: '',
       hasWaitingRoom: false,
       roomState: HMSRoomState.Disconnected,
+      recording: {
+        browser: {
+          running: false,
+        },
+        server: {
+          running: false,
+        },
+      },
+      rtmp: {
+        running: false,
+      },
     },
     peers: {
       '1': {