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

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'
+    );
   }
 }

package/src/classes/HMSRoomCache.ts

@@ -0,0 +1,157 @@
+import { NativeModules } from 'react-native';
+import type { HMSRoom } from './HMSRoom';
+import { HMSEncoder } from './HMSEncoder';
+import { HMSRoomUpdate } from './HMSRoomUpdate';
+
+const { HMSManager } = NativeModules;
+
+export let hmsRoomCache: HMSRoomCache | undefined;
+
+export const getHmsRoomCache = () => hmsRoomCache;
+
+export const setHmsRoomCache = (_hmsRoomCache: HMSRoomCache) => {
+  hmsRoomCache = _hmsRoomCache;
+};
+
+export const clearHmsRoomCache = () => {
+  if (hmsRoomCache) {
+    hmsRoomCache.cleanup();
+  }
+  hmsRoomCache = undefined;
+};
+
+export type HMSRoomCacheProps = Partial<Omit<HMSRoom, 'id'>>;
+
+export class HMSRoomCache {
+  private _data = new Map<
+    keyof HMSRoomCacheProps,
+    HMSRoomCacheProps[keyof HMSRoomCacheProps]
+  >();
+  private id: string;
+
+  constructor(id: string) {
+    this.id = id;
+  }
+
+  getProperty<T extends keyof Required<HMSRoomCacheProps>>(
+    property: T
+  ): Required<HMSRoomCacheProps>[T] {
+    const value: any = this._data.get(property);
+
+    if (value) {
+      return value;
+    }
+
+    const encodedValue = getHMSRoomPropertyFromNative(this.id, property);
+
+    this._data.set(property, encodedValue);
+
+    return encodedValue;
+  }
+
+  updateRoomCache(
+    data: Record<keyof HMSRoomCacheProps, any>,
+    updateType?: HMSRoomUpdate
+  ) {
+    switch (updateType) {
+      case HMSRoomUpdate.ROOM_MUTED:
+      case HMSRoomUpdate.ROOM_UNMUTED: {
+        break;
+      }
+      case HMSRoomUpdate.SERVER_RECORDING_STATE_UPDATED: {
+        this._data.set(
+          'serverRecordingState',
+          HMSEncoder.encodeServerRecordingState(data.serverRecordingState)
+        );
+        break;
+      }
+      case HMSRoomUpdate.RTMP_STREAMING_STATE_UPDATED: {
+        this._data.set(
+          'rtmpHMSRtmpStreamingState',
+          HMSEncoder.encodeRTMPStreamingState(data.rtmpHMSRtmpStreamingState)
+        );
+        break;
+      }
+      case HMSRoomUpdate.BROWSER_RECORDING_STATE_UPDATED: {
+        this._data.set(
+          'browserRecordingState',
+          HMSEncoder.encodeBrowserRecordingState(data.browserRecordingState)
+        );
+        break;
+      }
+      case HMSRoomUpdate.HLS_STREAMING_STATE_UPDATED: {
+        this._data.set(
+          'hlsStreamingState',
+          HMSEncoder.encodeHLSStreamingState(data.hlsStreamingState)
+        );
+        break;
+      }
+      case HMSRoomUpdate.HLS_RECORDING_STATE_UPDATED: {
+        this._data.set(
+          'hlsRecordingState',
+          HMSEncoder.encodeHLSRecordingState(data.hlsRecordingState)
+        );
+        break;
+      }
+      default: {
+        for (const key in data) {
+          const property = key as keyof HMSRoomCacheProps;
+
+          if (Object.prototype.hasOwnProperty.call(data, property)) {
+            const value = encodeHMSRoomProperty(this.id, property, data);
+            this._data.set(property, value);
+          }
+        }
+        break;
+      }
+    }
+  }
+
+  cleanup() {
+    this._data.clear();
+  }
+}
+
+export function getHMSRoomPropertyFromNative<T extends keyof HMSRoomCacheProps>(
+  id: string,
+  property: T
+): Required<HMSRoomCacheProps>[T] {
+  const data: any = HMSManager.getRoomProperty({
+    id,
+    property,
+  });
+
+  if (!data) return data;
+
+  const value = encodeHMSRoomProperty(id, property, data);
+
+  return value;
+}
+
+function encodeHMSRoomProperty<T extends keyof HMSRoomCacheProps>(
+  id: string,
+  property: T,
+  data: Record<string, any>
+): Required<HMSRoomCacheProps>[T] {
+  let value;
+
+  if (property === 'peers') {
+    value = HMSEncoder.encodeHmsPeers(data.peers);
+  } else if (property === 'browserRecordingState') {
+    value = HMSEncoder.encodeBrowserRecordingState(data.browserRecordingState);
+  } else if (property === 'rtmpHMSRtmpStreamingState') {
+    value = HMSEncoder.encodeRTMPStreamingState(data.rtmpHMSRtmpStreamingState);
+  } else if (property === 'serverRecordingState') {
+    value = HMSEncoder.encodeServerRecordingState(data.serverRecordingState);
+  } else if (property === 'hlsStreamingState') {
+    value = HMSEncoder.encodeHLSStreamingState(data.hlsStreamingState);
+  } else if (property === 'hlsRecordingState') {
+    value = HMSEncoder.encodeHLSRecordingState(data.hlsRecordingState);
+  } else if (property === 'localPeer') {
+    value = HMSEncoder.encodeHmsLocalPeer(data.localPeer, id);
+  } else {
+    value = data[property];
+  }
+
+  return value;
+}