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

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

package/src/classes/HMSRtmpStreamingState.ts

@@ -3,14 +3,14 @@ import type { HMSException } from './HMSException';
 export class HMSRtmpStreamingState {
   running: boolean;
   error?: HMSException;
-  startedAt: Date;
-  stoppedAt: Date;
+  startedAt?: Date;
+  stoppedAt?: Date;
 
   constructor(params: {
     running: boolean;
     error?: HMSException;
-    startedAt: Date;
-    stoppedAt: Date;
+    startedAt?: Date;
+    stoppedAt?: Date;
   }) {
     this.running = params.running;
     this.error = params.error;