@100mslive/react-native-hms 1.2.0 → 1.4.0

package/src/classes/HMSPeer.ts

@@ -3,47 +3,146 @@ import type { HMSNetworkQuality } from './HMSNetworkQuality';
 import type { HMSRole } from './HMSRole';
 import type { HMSTrack } from './HMSTrack';
 import type { HMSVideoTrack } from './HMSVideoTrack';
+import { getHmsPeersCache, getPeerPropertyFromNative } from './HMSPeersCache';
+import { HMSConstants } from './HMSConstants';
 
 export class HMSPeer {
   peerID: string;
-  name: string;
-  isLocal?: boolean;
-  customerUserID?: string;
-
-  /*
+  /**
    * @deprecated customerDescription has been deprecated in favor of metadata
    */
   customerDescription?: string;
-  metadata?: string;
-  role?: HMSRole;
-  networkQuality?: HMSNetworkQuality;
-  audioTrack?: HMSAudioTrack;
-  videoTrack?: HMSVideoTrack;
-  auxiliaryTracks?: HMSTrack[];
-
-  constructor(params: {
-    peerID: string;
-    name: string;
-    isLocal?: boolean;
-    customerUserID?: string;
-    customerDescription?: string;
-    metadata?: string;
-    role?: HMSRole;
-    networkQuality?: HMSNetworkQuality;
-    audioTrack?: HMSAudioTrack;
-    videoTrack?: HMSVideoTrack;
-    auxiliaryTracks?: HMSTrack[];
-  }) {
+
+  constructor(params: { peerID: string; customerDescription?: string }) {
     this.peerID = params.peerID;
-    this.name = params.name;
-    this.isLocal = params.isLocal;
-    this.customerUserID = params.customerUserID;
     this.customerDescription = params.customerDescription;
-    this.audioTrack = params.audioTrack;
-    this.videoTrack = params.videoTrack;
-    this.auxiliaryTracks = params.auxiliaryTracks;
-    this.role = params.role;
-    this.networkQuality = params.networkQuality;
-    this.metadata = params.metadata;
+  }
+
+  get name(): string {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'name') || '';
+    }
+
+    return (
+      getPeerPropertyFromNative(
+        HMSConstants.DEFAULT_SDK_ID,
+        this.peerID,
+        'name'
+      ) || ''
+    );
+  }
+
+  get isLocal(): boolean | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'isLocal');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'isLocal'
+    );
+  }
+
+  get networkQuality(): HMSNetworkQuality | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'networkQuality');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'networkQuality'
+    );
+  }
+
+  get customerUserID(): string | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'customerUserID');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'customerUserID'
+    );
+  }
+
+  get metadata(): string | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'metadata');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'metadata'
+    );
+  }
+
+  get role(): HMSRole | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'role');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'role'
+    );
+  }
+
+  get audioTrack(): HMSAudioTrack | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'audioTrack');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'audioTrack'
+    );
+  }
+
+  get videoTrack(): HMSVideoTrack | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'videoTrack');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'videoTrack'
+    );
+  }
+
+  get auxiliaryTracks(): HMSTrack[] | undefined {
+    const hmsPeersCache = getHmsPeersCache();
+
+    if (hmsPeersCache) {
+      return hmsPeersCache.getProperty(this.peerID, 'auxiliaryTracks');
+    }
+
+    return getPeerPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      this.peerID,
+      'auxiliaryTracks'
+    );
   }
 }

package/src/classes/HMSPeerUpdate.ts

@@ -6,3 +6,12 @@ export enum HMSPeerUpdate {
   NAME_CHANGED = 'NAME_CHANGED',
   NETWORK_QUALITY_UPDATED = 'NETWORK_QUALITY_UPDATED',
 }
+
+export const HMSPeerUpdateOrdinals = new Map([
+  ['0', HMSPeerUpdate.PEER_JOINED],
+  ['1', HMSPeerUpdate.PEER_LEFT],
+  ['9', HMSPeerUpdate.ROLE_CHANGED],
+  ['10', HMSPeerUpdate.NAME_CHANGED],
+  ['11', HMSPeerUpdate.METADATA_CHANGED],
+  ['12', HMSPeerUpdate.NETWORK_QUALITY_UPDATED],
+]);

package/src/classes/HMSPeersCache.ts

@@ -0,0 +1,252 @@
+import { NativeModules } from 'react-native';
+import type { HMSPeer } from './HMSPeer';
+import { HMSEncoder } from './HMSEncoder';
+import { HMSPeerUpdate } from './HMSPeerUpdate';
+import { HMSTrackUpdate } from './HMSTrackUpdate';
+import type { HMSTrack } from './HMSTrack';
+import { HMSTrackType } from './HMSTrackType';
+import { HMSTrackSource } from './HMSTrackSource';
+
+const { HMSManager } = NativeModules;
+
+export let hmsPeersCache: HMSPeersCache | undefined;
+
+export const getHmsPeersCache = () => {
+  return hmsPeersCache;
+};
+
+export const setHmsPeersCache = (_hmsPeersCache: HMSPeersCache) => {
+  hmsPeersCache = _hmsPeersCache;
+};
+
+export const clearHmsPeersCache = () => {
+  if (hmsPeersCache) {
+    hmsPeersCache.cleanup();
+  }
+  hmsPeersCache = undefined;
+};
+
+export type HMSPeerCacheProps = Partial<
+  Omit<HMSPeer, 'peerID' | 'customerDescription'>
+>;
+
+export class HMSPeersCache {
+  private _data = new Map<string, HMSPeerCacheProps>();
+  private id: string;
+
+  constructor(id: string) {
+    this.id = id;
+  }
+
+  getProperty<T extends keyof HMSPeerCacheProps>(
+    peerId: string,
+    property: T
+  ): HMSPeerCacheProps[T] | undefined {
+    const peerObj = this._data.get(peerId);
+
+    if (peerObj && property in peerObj) {
+      return peerObj[property];
+    }
+
+    const encodedValue = getPeerPropertyFromNative(this.id, peerId, property);
+
+    if (!peerObj) {
+      this._data.set(peerId, { [property]: encodedValue });
+    } else {
+      peerObj[property] = encodedValue;
+    }
+
+    return encodedValue;
+  }
+
+  updatePeerCache(
+    peerId: string,
+    data: Partial<Record<keyof HMSPeerCacheProps | 'track', any>>,
+    updateType?: HMSPeerUpdate | HMSTrackUpdate
+  ) {
+    const peerObj = this._data.get(peerId);
+
+    if (updateType === HMSPeerUpdate.PEER_LEFT) {
+      this._data.delete(peerId);
+      return;
+    }
+
+    let updatedObj = { ...peerObj };
+
+    switch (updateType) {
+      case HMSTrackUpdate.TRACK_ADDED: {
+        const track = data.track as HMSTrack;
+
+        if (track.source === HMSTrackSource.REGULAR) {
+          if (track.type === HMSTrackType.VIDEO) {
+            updatedObj.videoTrack = { ...track, isDegraded: false };
+          } else if (track.type === HMSTrackType.AUDIO) {
+            updatedObj.audioTrack = track;
+          }
+        } else {
+          if (Array.isArray(updatedObj.auxiliaryTracks)) {
+            updatedObj.auxiliaryTracks.push(track);
+          } else {
+            updatedObj.auxiliaryTracks = [track];
+          }
+        }
+        break;
+      }
+      case HMSTrackUpdate.TRACK_REMOVED: {
+        const track = data.track as HMSTrack;
+
+        if (track.source === HMSTrackSource.REGULAR) {
+          if (track.type === HMSTrackType.VIDEO) {
+            updatedObj.videoTrack = undefined;
+          } else if (track.type === HMSTrackType.AUDIO) {
+            updatedObj.audioTrack = undefined;
+          }
+        } else if (Array.isArray(updatedObj.auxiliaryTracks)) {
+          updatedObj = {
+            ...updatedObj,
+            auxiliaryTracks: updatedObj.auxiliaryTracks.filter(
+              (auxiliaryTrack) => auxiliaryTrack.trackId !== track.trackId
+            ),
+          };
+        }
+        break;
+      }
+      case HMSTrackUpdate.TRACK_MUTED:
+      case HMSTrackUpdate.TRACK_UNMUTED: {
+        const track = data.track as HMSTrack;
+
+        if (track.source === HMSTrackSource.REGULAR) {
+          if (track.type === HMSTrackType.VIDEO) {
+            updatedObj.videoTrack = {
+              ...track,
+              isDegraded: updatedObj.videoTrack?.isDegraded || false,
+            };
+          } else if (track.type === HMSTrackType.AUDIO) {
+            updatedObj.audioTrack = track;
+          }
+        } else {
+          if (Array.isArray(updatedObj.auxiliaryTracks)) {
+            updatedObj = {
+              ...updatedObj,
+              auxiliaryTracks: updatedObj.auxiliaryTracks.map(
+                (auxiliaryTrack) =>
+                  auxiliaryTrack.trackId === track.trackId
+                    ? track
+                    : auxiliaryTrack
+              ),
+            };
+          } else {
+            updatedObj.auxiliaryTracks = [track];
+          }
+        }
+        break;
+      }
+      case HMSTrackUpdate.TRACK_DEGRADED:
+      case HMSTrackUpdate.TRACK_RESTORED: {
+        const track = data.track as HMSTrack;
+
+        if (track.source === HMSTrackSource.REGULAR) {
+          if (track.type === HMSTrackType.VIDEO) {
+            updatedObj.videoTrack = {
+              ...track,
+              isDegraded: updateType === HMSTrackUpdate.TRACK_DEGRADED,
+            };
+          } else if (track.type === HMSTrackType.AUDIO) {
+            updatedObj.audioTrack = track;
+          }
+        } else {
+          if (Array.isArray(updatedObj.auxiliaryTracks)) {
+            updatedObj = {
+              ...updatedObj,
+              auxiliaryTracks: updatedObj.auxiliaryTracks.map(
+                (auxiliaryTrack) => {
+                  if (auxiliaryTrack.trackId === track.trackId) {
+                    return {
+                      ...auxiliaryTrack,
+                      isDegraded: updateType === HMSTrackUpdate.TRACK_DEGRADED,
+                    };
+                  }
+
+                  return auxiliaryTrack;
+                }
+              ),
+            };
+          } else {
+            updatedObj.auxiliaryTracks = [track];
+          }
+        }
+        break;
+      }
+      case HMSPeerUpdate.ROLE_CHANGED: {
+        updatedObj.role = HMSEncoder.encodeHmsRole(data.role);
+        break;
+      }
+      case HMSPeerUpdate.NETWORK_QUALITY_UPDATED: {
+        updatedObj.networkQuality = HMSEncoder.encodeHMSNetworkQuality(
+          data.networkQuality
+        );
+        break;
+      }
+      case HMSPeerUpdate.METADATA_CHANGED:
+      case HMSPeerUpdate.NAME_CHANGED:
+      case HMSPeerUpdate.PEER_JOINED:
+      case HMSPeerUpdate.ROLE_CHANGED: {
+        updatedObj = { ...updatedObj, ...data };
+        break;
+      }
+      default: {
+        updatedObj = { ...updatedObj, ...data };
+        break;
+      }
+    }
+
+    if (Object.keys(updatedObj).length > 0) {
+      this._data.set(peerId, updatedObj);
+    }
+  }
+
+  cleanup() {
+    this._data.clear();
+  }
+}
+
+export function getPeerPropertyFromNative<T extends keyof HMSPeerCacheProps>(
+  id: string,
+  peerId: string,
+  property: T
+): HMSPeerCacheProps[T] {
+  const data: any = HMSManager.getPeerProperty({
+    id,
+    peerId,
+    property,
+  });
+
+  let value;
+
+  if (property === 'role') {
+    value = data ? HMSEncoder.encodeHmsRole(data.role) : undefined;
+  } else if (property === 'networkQuality') {
+    value = data
+      ? HMSEncoder.encodeHMSNetworkQuality(data.networkQuality)
+      : undefined;
+  } else if (property === 'audioTrack') {
+    value = data
+      ? HMSEncoder.encodeHmsAudioTrack(data.audioTrack, id)
+      : undefined;
+  } else if (property === 'videoTrack') {
+    value = data
+      ? HMSEncoder.encodeHmsVideoTrack(data.videoTrack, id)
+      : undefined;
+  } else if (property === 'auxiliaryTracks') {
+    value =
+      data && Array.isArray(data.auxiliaryTracks)
+        ? HMSEncoder.encodeHmsAuxiliaryTracks(data.auxiliaryTracks, id)
+        : undefined;
+  } else if (property === 'name') {
+    value = data?.[property] || '';
+  } else {
+    value = data ? data[property] : undefined;
+  }
+
+  return value;
+}

package/src/classes/HMSRemotePeer.ts

@@ -1,11 +1,6 @@
-import type { HMSAudioTrack } from './HMSAudioTrack';
-import type { HMSNetworkQuality } from './HMSNetworkQuality';
 import { HMSPeer } from './HMSPeer';
 import { HMSRemoteAudioTrack } from './HMSRemoteAudioTrack';
 import { HMSRemoteVideoTrack } from './HMSRemoteVideoTrack';
-import type { HMSRole } from './HMSRole';
-import type { HMSTrack } from './HMSTrack';
-import type { HMSVideoTrack } from './HMSVideoTrack';
 
 export class HMSRemotePeer extends HMSPeer {
   private remoteAudio?: HMSRemoteAudioTrack;
@@ -21,16 +16,7 @@ export class HMSRemotePeer extends HMSPeer {
 
   constructor(params: {
     peerID: string;
-    name: string;
-    isLocal?: boolean;
-    customerUserID?: string;
     customerDescription?: string;
-    metadata?: string;
-    audioTrack?: HMSAudioTrack;
-    videoTrack?: HMSVideoTrack;
-    role?: HMSRole;
-    networkQuality?: HMSNetworkQuality;
-    auxiliaryTracks?: HMSTrack[];
     remoteAudioTrackData?: {
       trackId: string;
       source?: number | string;
@@ -50,8 +36,6 @@ export class HMSRemotePeer extends HMSPeer {
     };
   }) {
     super(params);
-    this.isLocal = false;
-
     if (params.remoteAudioTrackData) {
       this.remoteAudio = new HMSRemoteAudioTrack(params.remoteAudioTrackData);
     }

package/src/classes/HMSRoom.ts

@@ -5,46 +5,150 @@ import type { HMSBrowserRecordingState } from './HMSBrowserRecordingState';
 import type { HMSHLSStreamingState } from './HMSHLSStreamingState';
 import type { HMSHLSRecordingState } from './HMSHLSRecordingState';
 import type { HMSLocalPeer } from './HMSLocalPeer';
+import { getHmsRoomCache, getHMSRoomPropertyFromNative } from './HMSRoomCache';
+import { HMSConstants } from './HMSConstants';
 
 export class HMSRoom {
   id: string;
-  sessionId: string;
-  name: string;
-  metaData?: string;
-  peers: HMSPeer[];
-  browserRecordingState: HMSBrowserRecordingState;
-  rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
-  serverRecordingState: HMSServerRecordingState;
-  hlsStreamingState: HMSHLSStreamingState;
-  hlsRecordingState?: HMSHLSRecordingState;
-  peerCount: number;
-  localPeer: HMSLocalPeer;
-
-  constructor(params: {
-    id: string;
-    sessionId: string;
-    name: string;
-    metaData?: string;
-    peers: HMSPeer[];
-    browserRecordingState: HMSBrowserRecordingState;
-    rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
-    serverRecordingState: HMSServerRecordingState;
-    hlsStreamingState: HMSHLSStreamingState;
-    hlsRecordingState?: HMSHLSRecordingState;
-    peerCount: number;
-    localPeer: HMSLocalPeer;
-  }) {
+
+  constructor(params: { id: string }) {
     this.id = params.id;
-    this.sessionId = params.sessionId;
-    this.name = params.name;
-    this.metaData = params.metaData;
-    this.peers = params.peers;
-    this.browserRecordingState = params.browserRecordingState;
-    this.rtmpHMSRtmpStreamingState = params.rtmpHMSRtmpStreamingState;
-    this.serverRecordingState = params.serverRecordingState;
-    this.hlsStreamingState = params.hlsStreamingState;
-    this.hlsRecordingState = params.hlsRecordingState;
-    this.peerCount = params.peerCount;
-    this.localPeer = params.localPeer;
+  }
+
+  get sessionId(): string {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('sessionId');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'sessionId'
+    );
+  }
+
+  get name(): string {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('name');
+    }
+
+    return getHMSRoomPropertyFromNative(HMSConstants.DEFAULT_SDK_ID, 'name');
+  }
+
+  get metaData(): string | undefined {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('metaData');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'metaData'
+    );
+  }
+
+  get peers(): HMSPeer[] {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('peers');
+    }
+
+    return getHMSRoomPropertyFromNative(HMSConstants.DEFAULT_SDK_ID, 'peers');
+  }
+
+  get browserRecordingState(): HMSBrowserRecordingState {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('browserRecordingState');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'browserRecordingState'
+    );
+  }
+
+  get rtmpHMSRtmpStreamingState(): HMSRtmpStreamingState {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('rtmpHMSRtmpStreamingState');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'rtmpHMSRtmpStreamingState'
+    );
+  }
+
+  get serverRecordingState(): HMSServerRecordingState {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('serverRecordingState');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'serverRecordingState'
+    );
+  }
+
+  get hlsStreamingState(): HMSHLSStreamingState {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('hlsStreamingState');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'hlsStreamingState'
+    );
+  }
+
+  get hlsRecordingState(): HMSHLSRecordingState | undefined {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('hlsRecordingState');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'hlsRecordingState'
+    );
+  }
+
+  get peerCount(): number {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('peerCount');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'peerCount'
+    );
+  }
+
+  get localPeer(): HMSLocalPeer {
+    const hmsRoomCache = getHmsRoomCache();
+
+    if (hmsRoomCache) {
+      return hmsRoomCache.getProperty('localPeer');
+    }
+
+    return getHMSRoomPropertyFromNative(
+      HMSConstants.DEFAULT_SDK_ID,
+      'localPeer'
+    );
   }
 }