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

package/src/classes/HMSNativeEventEmitter.ts

@@ -0,0 +1,109 @@
+import { EventSubscription, NativeEventEmitter } from 'react-native';
+import { logger } from './HMSLogger';
+
+export type HMSEventSubscription = {
+  remove(): void;
+};
+
+export class HMSNativeEventEmitter {
+  private _nativeEventEmitter: NativeEventEmitter;
+  private _nativeModule: any;
+
+  constructor(nativeModule: any) {
+    this._nativeModule = nativeModule;
+    this._nativeEventEmitter = new NativeEventEmitter(nativeModule);
+  }
+
+  listenerCount(eventType: string): number {
+    // For RN version < v0.64, listenerCount method is not available
+    // @ts-ignore - typescript is giving error because we are running it with RN types version >= 0.64
+    if (typeof this._nativeEventEmitter.listeners === 'function') {
+      // @ts-ignore - typescript is giving error because we are running it with RN types version >= 0.64
+      const count = this._nativeEventEmitter.listeners(eventType).length;
+
+      logger?.verbose('#Function HMSNativeEventEmitter.listenerCount', {
+        eventType,
+        count,
+      });
+      return count;
+    }
+
+    // For RN version >= v0.64
+    const count = this._nativeEventEmitter.listenerCount(eventType);
+
+    logger?.verbose('#Function HMSNativeEventEmitter.listenerCount', {
+      eventType,
+      count,
+    });
+    return count;
+  }
+
+  addListener(
+    id: string,
+    eventType: string,
+    listener: (...args: any[]) => any
+  ): HMSEventSubscription {
+    logger?.verbose('#Function HMSNativeEventEmitter.addListener', {
+      id,
+      eventType,
+      listener,
+    });
+
+    // enable `eventType` on `HMSSDK`, if no listeners were added before
+    // if some listeners were added before, then `eventType` on `HMSSDK` should already be enabled
+    if (this.listenerCount(eventType) <= 0) {
+      this.enableHMSEventType(id, eventType);
+    }
+
+    let subscription: EventSubscription | null =
+      this._nativeEventEmitter.addListener(eventType, listener);
+
+    return {
+      remove: () => {
+        if (
+          subscription &&
+          Object.getOwnPropertyNames(subscription).includes('remove') &&
+          typeof subscription.remove === 'function'
+        ) {
+          subscription.remove();
+          subscription = null;
+        } else {
+          this._nativeEventEmitter.removeListener(eventType, listener);
+        }
+
+        // disable `eventType` on `HMSSDK`, if all listeners has been removed
+        if (this.listenerCount(eventType) <= 0) {
+          this.disableHMSEventType(id, eventType);
+        }
+      },
+    };
+  }
+
+  removeAllListeners(id: string, eventType: string) {
+    logger?.verbose('#Function HMSNativeEventEmitter.removeAllListeners', {
+      id,
+      eventType,
+    });
+
+    // disable `eventType` on `HMSSDK`
+    this.disableHMSEventType(id, eventType);
+
+    return this._nativeEventEmitter.removeAllListeners(eventType);
+  }
+
+  private enableHMSEventType(id: string, eventType: string) {
+    logger?.verbose('#Function HMSNativeEventEmitter.enableHMSEventType', {
+      id,
+      eventType,
+    });
+    this._nativeModule.enableEvent({ id, eventType });
+  }
+
+  private disableHMSEventType(id: string, eventType: string) {
+    logger?.verbose('#Function HMSNativeEventEmitter.disableHMSEventType', {
+      id,
+      eventType,
+    });
+    this._nativeModule.disableEvent({ id, eventType });
+  }
+}

package/src/classes/HMSPeer.ts

@@ -3,43 +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/HMSPublishSettings.ts

@@ -1,31 +1,21 @@
 import type { HMSAudioSettings } from './HMSAudioSettings';
-import type { HMSSimulcastSettings } from './HMSSimulcastSettings';
 import type { HMSVideoSettings } from './HMSVideoSettings';
 
 export class HMSPublishSettings {
-  audio: HMSAudioSettings;
-  video: HMSVideoSettings;
-  screen: HMSVideoSettings;
-  audioSimulcast?: HMSSimulcastSettings;
-  videoSimulcast?: HMSSimulcastSettings;
-  screenSimulcast?: HMSSimulcastSettings;
-  allowed?: [string];
+  audio?: HMSAudioSettings;
+  video?: HMSVideoSettings;
+  screen?: HMSVideoSettings;
+  allowed?: string[];
 
   constructor(params: {
-    audio: HMSAudioSettings;
-    video: HMSVideoSettings;
-    screen: HMSVideoSettings;
-    audioSimulcast?: HMSSimulcastSettings;
-    videoSimulcast?: HMSSimulcastSettings;
-    screenSimulcast?: HMSSimulcastSettings;
-    allowed?: [string];
+    audio?: HMSAudioSettings;
+    video?: HMSVideoSettings;
+    screen?: HMSVideoSettings;
+    allowed?: string[];
   }) {
     this.audio = params.audio;
     this.video = params.video;
     this.screen = params.screen;
-    this.audioSimulcast = params.audioSimulcast;
-    this.videoSimulcast = params.videoSimulcast;
-    this.screenSimulcast = params.screenSimulcast;
     this.allowed = params.allowed;
   }
 }

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/HMSRole.ts

@@ -8,9 +8,6 @@ export class HMSRole {
   subscribeSettings?: HMSSubscribeSettings;
   permissions?: HMSPermissions;
   priority?: number;
-  generalPermissions?: any;
-  internalPlugins?: any;
-  externalPlugins?: any;
 
   constructor(params?: {
     name?: string;
@@ -18,9 +15,6 @@ export class HMSRole {
     permissions?: HMSPermissions;
     publishSettings?: HMSPublishSettings;
     subscribeSettings?: HMSSubscribeSettings;
-    generalPermissions?: any;
-    internalPlugins?: any;
-    externalPlugins?: any;
   }) {
     if (params) {
       this.name = params.name;
@@ -28,9 +22,6 @@ export class HMSRole {
       this.permissions = params.permissions;
       this.publishSettings = params.publishSettings;
       this.subscribeSettings = params.subscribeSettings;
-      this.generalPermissions = params.generalPermissions;
-      this.internalPlugins = params.internalPlugins;
-      this.externalPlugins = params.externalPlugins;
     }
   }
 }

package/src/classes/HMSRoleChangeRequest.ts

@@ -2,11 +2,13 @@ import type { HMSRole } from './HMSRole';
 import type { HMSPeer } from './HMSPeer';
 
 export class HMSRoleChangeRequest {
-  requestedBy: HMSPeer;
+  requestedBy?: HMSPeer;
   suggestedRole: HMSRole;
 
-  constructor(params: { requestedBy: HMSPeer; suggestedRole: HMSRole }) {
-    this.requestedBy = params.requestedBy;
+  constructor(params: { requestedBy?: HMSPeer; suggestedRole: HMSRole }) {
+    if (params.requestedBy) {
+      this.requestedBy = params.requestedBy;
+    }
     this.suggestedRole = params.suggestedRole;
   }
 }