@100mslive/hms-video-store 0.2.66 → 0.2.70

package/package.json

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

package/src/common/ui-logger.ts

@@ -25,6 +25,19 @@ export class HMSLogger {
     this.log(HMSLogLevel.ERROR, ...data);
   }
 
+  static time(mark: string) {
+    this.log(HMSLogLevel.TIME, '[HMSPerformanceTiming]', mark);
+  }
+
+  static timeEnd(mark: string) {
+    this.log(HMSLogLevel.TIMEEND, '[HMSPerformanceTiming]', mark, mark);
+  }
+
+  static cleanUp() {
+    performance.clearMarks();
+    performance.clearMeasures();
+  }
+
   /* eslint-disable */
   private static log(level: HMSLogLevel, ...data: any[]) {
     if (this.level.valueOf() > level.valueOf()) {
@@ -52,6 +65,24 @@ export class HMSLogger {
         console.error(HMS_STORE_TAG, ...data);
         break;
       }
+      case HMSLogLevel.TIME: {
+        performance.mark(data[1]);
+        break;
+      }
+      case HMSLogLevel.TIMEEND: {
+        const tag = data[0];
+        const mark = data[1];
+        try {
+          const entry = performance.measure(mark, mark);
+          //@ts-ignore
+          this.log(HMSLogLevel.DEBUG, tag, mark, entry?.duration);
+          performance.clearMarks(mark);
+          performance.clearMeasures(mark);
+        } catch (error) {
+          this.log(HMSLogLevel.DEBUG, tag, mark, error);
+        }
+        break;
+      }
     }
   }
 }

package/src/core/IHMSActions.ts

@@ -14,7 +14,7 @@ import {
   HMSTrackID,
   HMSTrackSource,
   IHMSPlaylistActions,
-  HMSChangeMultiTrackStateRequest,
+  HMSChangeMultiTrackStateParams,
 } from './schema';
 import { HMSRoleChangeRequest } from './selectors';
 import { RTMPRecordingConfig } from './hmsSDKStore/sdkTypes';
@@ -238,9 +238,9 @@ export interface IHMSActions {
 
   /**
    * Use this to mute/unmute multipe tracks by source, role or type
-   * @param {HMSChangeMultiTrackStateRequest} params
+   * @param {HMSChangeMultiTrackStateParams} params
    */
-  setRemoteTracksEnabled(params: HMSChangeMultiTrackStateRequest): Promise<void>;
+  setRemoteTracksEnabled(params: HMSChangeMultiTrackStateParams): Promise<void>;
 
   /**
    * Method to be called with some UI interaction after autoplay error is received

package/src/core/hmsSDKStore/HMSNotifications.ts

@@ -12,6 +12,7 @@ import {
   HMSException,
   HMSMessage,
   HMSTrack,
+  HMSTrackID,
   HMSChangeTrackStateRequest,
   HMSChangeMultiTrackStateRequest,
   HMSLeaveRoomRequest,
@@ -56,6 +57,15 @@ export class HMSNotifications implements IHMSNotifications {
     this.emitEvent(notification);
   }
 
+  sendPeerList(peers: HMSPeer[]) {
+    const notification = this.createNotification(
+      HMSNotificationTypes.PEER_LIST,
+      peers,
+      HMSNotificationSeverity.INFO,
+    );
+    this.emitEvent(notification);
+  }
+
   sendPeerUpdate(type: sdkTypes.HMSPeerUpdate, peer: HMSPeer | null) {
     const hmsPeer = this.store.getState(selectPeerByID(peer?.id)) || peer;
     const notificationType = PEER_NOTIFICATION_TYPES[type];
@@ -69,7 +79,7 @@ export class HMSNotifications implements IHMSNotifications {
     }
   }
 
-  sendTrackUpdate(type: sdkTypes.HMSTrackUpdate, trackID: string) {
+  sendTrackUpdate(type: sdkTypes.HMSTrackUpdate, trackID: HMSTrackID) {
     const hmsTrack = this.store.getState(selectTrackByID(trackID));
     const notificationType = TRACK_NOTIFICATION_TYPES[type];
     if (notificationType) {
@@ -144,6 +154,7 @@ export class HMSNotifications implements IHMSNotifications {
     type: string,
     data?:
       | HMSPeer
+      | HMSPeer[]
       | HMSTrack
       | HMSMessage
       | HMSException

package/src/core/hmsSDKStore/HMSSDKActions.ts

@@ -487,6 +487,7 @@ export class HMSSDKActions implements IHMSActions {
     }, reason);
     this.isRoomJoinCalled = false;
     this.hmsSDKTracks = {};
+    HMSLogger.cleanUp();
   }
 
   private sdkJoinWithListeners(config: sdkTypes.HMSConfig) {
@@ -610,7 +611,7 @@ export class HMSSDKActions implements IHMSActions {
    * @protected
    */
   protected syncRoomState(action?: string) {
-    console.time('syncRoomState');
+    HMSLogger.time(`store-sync-${action}`);
     const newHmsPeers: Record<HMSPeerID, Partial<HMSPeer>> = {};
     const newHmsPeerIDs: HMSPeerID[] = []; // to add in room.peers
     const newHmsTracks: Record<HMSTrackID, Partial<HMSTrack>> = {};
@@ -652,7 +653,7 @@ export class HMSSDKActions implements IHMSActions {
       const draftPeers = draftStore.peers;
       const draftTracks = draftStore.tracks;
       // the order of below statements are important as merge functions are mutating
-      mergeNewPeersInDraft(draftPeers, newHmsPeers, newHmsTracks, newHmsSDkTracks);
+      mergeNewPeersInDraft(draftPeers, newHmsPeers);
       mergeNewTracksInDraft(draftTracks, newHmsTracks);
       Object.assign(draftStore.settings, newMediaSettings);
       this.hmsSDKTracks = newHmsSDkTracks;
@@ -660,7 +661,7 @@ export class HMSSDKActions implements IHMSActions {
       Object.assign(draftStore.playlist, SDKToHMS.convertPlaylist(this.sdk.getPlaylistManager()));
       Object.assign(draftStore.room, SDKToHMS.convertRecordingRTMPState(recording, rtmp));
     }, action);
-    console.timeEnd('syncRoomState');
+    HMSLogger.timeEnd(`store-sync-${action}`);
   }
 
   protected onPreview(sdkRoom: sdkTypes.HMSRoom) {
@@ -711,19 +712,26 @@ export class HMSSDKActions implements IHMSActions {
     sdkPeer: sdkTypes.HMSPeer | sdkTypes.HMSPeer[],
   ) {
     if (
-      type === sdkTypes.HMSPeerUpdate.BECAME_DOMINANT_SPEAKER ||
-      type === sdkTypes.HMSPeerUpdate.RESIGNED_DOMINANT_SPEAKER
+      [
+        sdkTypes.HMSPeerUpdate.BECAME_DOMINANT_SPEAKER,
+        sdkTypes.HMSPeerUpdate.RESIGNED_DOMINANT_SPEAKER,
+      ].includes(type)
     ) {
       return; // ignore, high frequency update so no point of syncing peers
-    } else if (Array.isArray(sdkPeer)) {
+    }
+    if (Array.isArray(sdkPeer)) {
       this.syncRoomState('peersJoined');
+      const hmsPeers = [];
       for (let peer of sdkPeer) {
         const hmsPeer = this.store.getState(selectPeerByID(peer.peerId));
-        this.hmsNotifications.sendPeerUpdate(type, hmsPeer);
+        if (hmsPeer) {
+          hmsPeers.push(hmsPeer);
+        }
       }
-    } else {
-      this.peerUpdateInternal(type, sdkPeer);
+      this.hmsNotifications.sendPeerList(hmsPeers);
+      return;
     }
+    this.sendPeerUpdateNotification(type, sdkPeer);
   }
 
   protected onTrackUpdate(
@@ -739,7 +747,7 @@ export class HMSSDKActions implements IHMSActions {
     } else {
       const actionName =
         type === sdkTypes.HMSTrackUpdate.TRACK_ADDED ? 'trackAdded' : 'trackUpdate';
-      this.syncRemoteTrackState(actionName, track, peer);
+      this.syncRoomState(actionName);
       this.hmsNotifications.sendTrackUpdate(type, track.trackId);
     }
   }
@@ -906,22 +914,23 @@ export class HMSSDKActions implements IHMSActions {
     this.setState(draftStore => {
       const hmsPeer = draftStore.peers[sdkPeer.peerId];
       const draftTracks = draftStore.tracks;
+      const trackId = sdkTrack.trackId;
       // find and remove the exact track from hmsPeer
-      if (this.isSameStoreSDKTrack(sdkTrack.trackId, hmsPeer?.audioTrack)) {
+      if (this.isSameStoreSDKTrack(trackId, hmsPeer?.audioTrack)) {
         delete hmsPeer?.audioTrack;
-      } else if (this.isSameStoreSDKTrack(sdkTrack.trackId, hmsPeer?.videoTrack)) {
+      } else if (this.isSameStoreSDKTrack(trackId, hmsPeer?.videoTrack)) {
         delete hmsPeer?.videoTrack;
       } else {
-        const auxiliaryIndex = hmsPeer?.auxiliaryTracks.indexOf(sdkTrack.trackId);
+        const auxiliaryIndex = hmsPeer?.auxiliaryTracks.indexOf(trackId);
         if (
           auxiliaryIndex > -1 &&
-          this.isSameStoreSDKTrack(sdkTrack.trackId, hmsPeer?.auxiliaryTracks[auxiliaryIndex])
+          this.isSameStoreSDKTrack(trackId, hmsPeer?.auxiliaryTracks[auxiliaryIndex])
         ) {
           hmsPeer?.auxiliaryTracks.splice(auxiliaryIndex, 1);
         }
       }
-      delete draftTracks[sdkTrack.trackId];
-      delete this.hmsSDKTracks[sdkTrack.trackId];
+      delete draftTracks[trackId];
+      delete this.hmsSDKTracks[trackId];
     }, 'trackRemoved');
   }
 
@@ -1113,43 +1122,10 @@ export class HMSSDKActions implements IHMSActions {
     }, action);
   };
 
-  /**
-   * Handle store update on remote track changes
-   * @param {string} action - 'trackAdded' | 'trackUpdate'
-   * @param {SDKHMSTrack} track - track added/updated
-   * @param {sdkTypes.HMSPeer}peer - peer on which track is added/updated
-   */
-  private syncRemoteTrackState = (
-    action: 'trackAdded' | 'trackUpdate',
-    track: SDKHMSTrack,
-    peer: sdkTypes.HMSPeer,
+  private sendPeerUpdateNotification = (
+    type: sdkTypes.HMSPeerUpdate,
+    sdkPeer: sdkTypes.HMSPeer,
   ) => {
-    this.setState(draftStore => {
-      let draftPeer = draftStore.peers[peer.peerId];
-      /**
-       * in preview -> leave -> join flow or join -> leave -> join flow,
-       * since peer will be cleared by leave, set peer again in the store
-       **/
-      if (!draftPeer) {
-        const hmsPeer = SDKToHMS.convertPeer(peer) as HMSPeer;
-        draftStore.peers[peer.peerId] = hmsPeer;
-        draftPeer = hmsPeer;
-      }
-      const hmsTrack = SDKToHMS.convertTrack(track, peer.peerId);
-      if (action === 'trackAdded') {
-        draftStore.tracks[hmsTrack.id] = hmsTrack;
-        this.updateTracksInPeer(peer, draftPeer, hmsTrack);
-      } else if (draftStore.tracks[hmsTrack.id]) {
-        Object.assign(draftStore.tracks[hmsTrack.id], hmsTrack);
-      } else {
-        this.logPossibleInconsistency(`track ${hmsTrack.id} not present, unable to update track`);
-      }
-      this.hmsSDKTracks[track.trackId] = track;
-    }, action);
-  };
-
-  private peerUpdateInternal(type: sdkTypes.HMSPeerUpdate, sdkPeer: sdkTypes.HMSPeer) {
-    // store peer in case it doesn't exist later(will happen if event is peer leave)
     let peer = this.store.getState(selectPeerByID(sdkPeer.peerId));
     let actionName = 'peerUpdate';
     if (type === sdkTypes.HMSPeerUpdate.PEER_JOINED) {
@@ -1157,41 +1133,13 @@ export class HMSSDKActions implements IHMSActions {
     } else if (type === sdkTypes.HMSPeerUpdate.PEER_LEFT) {
       actionName = 'peerLeft';
     }
-    this.setState(draftStore => {
-      if (actionName === 'peerLeft') {
-        const index = draftStore.room.peers.indexOf(sdkPeer.peerId);
-        if (index > -1) {
-          draftStore.room.peers.splice(index, 1);
-        }
-        delete draftStore.peers[sdkPeer.peerId];
-        delete this.hmsSDKPeers[sdkPeer.peerId];
-      } else {
-        const hmsPeer = SDKToHMS.convertPeer(sdkPeer);
-        if (draftStore.peers[hmsPeer.id]) {
-          Object.assign(draftStore.peers[hmsPeer.id], hmsPeer);
-        } else {
-          draftStore.peers[hmsPeer.id] = hmsPeer as HMSPeer;
-          draftStore.room.peers.push(hmsPeer.id);
-        }
-        this.hmsSDKPeers[sdkPeer.peerId] = sdkPeer;
-      }
-    }, actionName);
+    this.syncRoomState(actionName);
     // if peer wasn't available before sync(will happen if event is peer join)
     if (!peer) {
       peer = this.store.getState(selectPeerByID(sdkPeer.peerId));
     }
     this.hmsNotifications.sendPeerUpdate(type, peer);
-  }
-
-  private updateTracksInPeer(peer: sdkTypes.HMSPeer, draftPeer: HMSPeer, hmsTrack: HMSTrack) {
-    if (peer.audioTrack?.trackId === hmsTrack.id) {
-      draftPeer.audioTrack = hmsTrack.id;
-    } else if (peer.videoTrack?.trackId === hmsTrack.id) {
-      draftPeer.videoTrack = hmsTrack.id;
-    } else if (!draftPeer.auxiliaryTracks.includes(hmsTrack.id)) {
-      draftPeer.auxiliaryTracks.push(hmsTrack.id);
-    }
-  }
+  };
 
   /**
    * setState is separate so any future changes to how state change can be done from one place.

package/src/core/hmsSDKStore/adapter.ts

@@ -33,7 +33,7 @@ export class SDKToHMS {
       isLocal: sdkPeer.isLocal,
       videoTrack: sdkPeer.videoTrack?.trackId,
       audioTrack: sdkPeer.audioTrack?.trackId,
-      auxiliaryTracks: sdkPeer.auxiliaryTracks.map(t => t.trackId),
+      auxiliaryTracks: sdkPeer.auxiliaryTracks.map(track => track.trackId),
       customerUserId: sdkPeer.customerUserId,
       customerDescription: sdkPeer.customerDescription,
     };

package/src/core/hmsSDKStore/sdkUtils/storeMergeUtils.ts

@@ -1,5 +1,4 @@
 import { HMSPeer, HMSPeerID, HMSTrack, HMSTrackID } from '../../schema';
-import { HMSTrack as SDKHMSTrack } from '@100mslive/hms-video';
 
 /**
  * updates draftPeers with newPeers ensuring minimal reference changes
@@ -14,8 +13,6 @@ import { HMSTrack as SDKHMSTrack } from '@100mslive/hms-video';
 export const mergeNewPeersInDraft = (
   draftPeers: Record<HMSPeerID, HMSPeer>,
   newPeers: Record<HMSPeerID, Partial<HMSPeer>>,
-  newHmsTracks: Record<HMSTrackID, Partial<HMSTrack>>,
-  newHmsSDkTracks: Record<HMSTrackID, SDKHMSTrack>,
 ) => {
   const peerIDs = union(Object.keys(draftPeers), Object.keys(newPeers));
   for (let peerID of peerIDs) {
@@ -25,7 +22,6 @@ export const mergeNewPeersInDraft = (
       if (areArraysEqual(oldPeer.auxiliaryTracks, newPeer.auxiliaryTracks)) {
         newPeer.auxiliaryTracks = oldPeer.auxiliaryTracks;
       }
-      handleLocalVideoReplaceTrack(oldPeer, newPeer, newHmsTracks, newHmsSDkTracks);
       Object.assign(oldPeer, newPeer);
     } else if (isEntityRemoved(oldPeer, newPeer)) {
       delete draftPeers[peerID];
@@ -100,29 +96,3 @@ const union = <T>(arr1: T[], arr2: T[]): T[] => {
   }
   return Array.from(set);
 };
-
-/**
- * on replace track, use prev video track id in peer object, this is because we
- * don't want the peer or peers object reference to change, the fact that the video
- * track is changed on mute/unmute because of replace track is abstracted
- */
-function handleLocalVideoReplaceTrack(
-  oldPeer: HMSPeer,
-  newPeer: Partial<HMSPeer>,
-  newHmsTracks: Record<HMSTrackID, Partial<HMSTrack>>,
-  newHmsSDkTracks: Record<HMSTrackID, SDKHMSTrack>,
-) {
-  if (
-    oldPeer.isLocal &&
-    oldPeer.videoTrack &&
-    newPeer.videoTrack &&
-    oldPeer.videoTrack !== newPeer.videoTrack
-  ) {
-    newHmsSDkTracks[oldPeer.videoTrack] = newHmsSDkTracks[newPeer.videoTrack];
-    delete newHmsSDkTracks[newPeer.videoTrack];
-    newHmsTracks[oldPeer.videoTrack] = newHmsTracks[newPeer.videoTrack];
-    newHmsTracks[oldPeer.videoTrack].id = oldPeer.videoTrack;
-    delete newHmsTracks[newPeer.videoTrack];
-    newPeer.videoTrack = oldPeer.videoTrack;
-  }
-}

package/src/core/schema/notification.ts

@@ -17,6 +17,7 @@ export enum HMSNotificationSeverity {
 export enum HMSNotificationTypes {
   PEER_JOINED = 'PEER_JOINED',
   PEER_LEFT = 'PEER_LEFT',
+  PEER_LIST = 'PEER_LIST',
   NEW_MESSAGE = 'NEW_MESSAGE',
   ERROR = 'ERROR',
   RECONNECTING = 'RECONNECTING',

package/src/test/unit/storeMergeUtils.test.ts

@@ -98,21 +98,21 @@ describe('peers merge is happening properly', () => {
   };
 
   test('no errors with empty peers', () => {
-    mergeNewPeersInDraft(draftPeers as peerMap, newPeers, {}, {});
+    mergeNewPeersInDraft(draftPeers as peerMap, newPeers);
     expectNoReferenceChange();
     expect(draftPeers).toEqual({});
   });
 
   test('peer is deleted from draft if gone', () => {
     draftPeers[fakePeer.id] = fakePeer;
-    mergeNewPeersInDraft(draftPeers as peerMap, newPeers, {}, {});
+    mergeNewPeersInDraft(draftPeers as peerMap, newPeers);
     expectNoReferenceChange();
     expect(draftPeers).toEqual({});
   });
 
   test('new peer is added to draft', () => {
     newPeers[fakePeer.id] = fakePeer;
-    mergeNewPeersInDraft(draftPeers as peerMap, newPeers, newTracks, newSDKTracks);
+    mergeNewPeersInDraft(draftPeers as peerMap, newPeers);
     expectNoReferenceChange();
     expect(draftPeers).toEqual(newPeers);
   });
@@ -125,7 +125,7 @@ describe('peers merge is happening properly', () => {
     };
     draftPeers[fakePeer.id] = fakePeer;
     newPeers[clonedPeer.id] = clonedPeer;
-    mergeNewPeersInDraft(draftPeers as peerMap, newPeers, newTracks, newSDKTracks);
+    mergeNewPeersInDraft(draftPeers as peerMap, newPeers);
     expectNoReferenceChange();
     expect(draftPeers[fakePeer.id]).toBe(fakePeer);
     expect(draftPeers[fakePeer.id].auxiliaryTracks).toBe(fakePeer.auxiliaryTracks);
@@ -139,7 +139,7 @@ describe('peers merge is happening properly', () => {
     fakePeer.roleName = 'random';
     draftPeers[fakePeer.id] = fakePeer;
     newPeers[clonedPeer.id] = clonedPeer;
-    mergeNewPeersInDraft(draftPeers as peerMap, newPeers, newTracks, newSDKTracks);
+    mergeNewPeersInDraft(draftPeers as peerMap, newPeers);
     expectNoReferenceChange();
     expect(fakePeer.roleName).toBe('random');
     expect(clonedPeer.roleName).toBeUndefined();
@@ -159,7 +159,7 @@ describe('peers merge is happening properly', () => {
     }
     newTracks[newVideo.id] = newVideo;
     newPeers[clonedPeer.id] = clonedPeer;
-    mergeNewPeersInDraft(draftPeers as peerMap, newPeers, newTracks, newSDKTracks);
+    mergeNewPeersInDraft(draftPeers as peerMap, newPeers);
     expect(draftPeers[fakePeer.id]).toBe(fakePeer);
     expect(draftPeers[fakePeer.id].videoTrack).toBe(fakePeer.videoTrack);
     // ensure the unchanged video track id can be used to get the new sdk track