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

package/src/classes/HMSEncoder.ts

@@ -1,3 +1,5 @@
+import { NativeModules } from 'react-native';
+
 import { HMSTrack } from './HMSTrack';
 import { HMSAudioTrack } from './HMSAudioTrack';
 import { HMSVideoTrack } from './HMSVideoTrack';
@@ -28,8 +30,22 @@ import { HMSServerRecordingState } from './HMSServerRecordingState';
 import { HMSMessage } from './HMSMessage';
 import { HMSMessageRecipient } from './HMSMessageRecipient';
 import { HMSException } from './HMSException';
+import { HMSConstants } from './HMSConstants';
+import { HMSPeerUpdateOrdinals } from './HMSPeerUpdate';
+
+const { HMSManager } = NativeModules;
+
+interface InitialData {
+  roles: Record<string, HMSRole>;
+}
 
 export class HMSEncoder {
+  private static data: InitialData = { roles: {} };
+
+  static clearData() {
+    this.data = { roles: {} };
+  }
+
   static encodeHmsRoom(room: HMSRoom, id: string) {
     const encodedObj = {
       id: room?.id,
@@ -37,7 +53,7 @@ export class HMSEncoder {
       metaData: room?.metaData,
       name: room?.name,
       peerCount: room?.peerCount,
-      peers: HMSEncoder.encodeHmsPeers(room?.peers, id),
+      peers: HMSEncoder.encodeHmsPeers(room?.peers),
       browserRecordingState: HMSEncoder.encodeBrowserRecordingState(
         room?.browserRecordingState
       ),
@@ -59,36 +75,28 @@ export class HMSEncoder {
     return new HMSRoom(encodedObj);
   }
 
-  static encodeHmsPeers(peers: any, id: string) {
+  static encodeHmsPeers(peers: any) {
     const encodedPeers: HMSPeer[] = [];
     peers?.map((peer: any) => {
-      encodedPeers.push(HMSEncoder.encodeHmsPeer(peer, id));
+      encodedPeers.push(HMSEncoder.encodeHmsPeer(peer));
     });
 
     return encodedPeers;
   }
 
-  static encodeHmsPeer(peer: any, id: string) {
+  static encodeHmsPeer(peer: any) {
     const encodedObj = {
       peerID: peer?.peerID,
-      name: peer?.name,
-      isLocal: peer?.isLocal,
-      customerUserID: peer?.customerUserID,
-      customerDescription: peer?.customerDescription,
-      metadata: peer?.metadata,
-      role: HMSEncoder.encodeHmsRole(peer?.role),
-      networkQuality: HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality),
-      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id),
-      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack, id),
-      auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
-        peer?.auxiliaryTracks,
-        id
-      ),
+      customerDescription: peer?.customerDescription || undefined,
     };
 
     return new HMSPeer(encodedObj);
   }
 
+  static encodeHmsPeerUpdate(hmsPeerUpdateOrdinal: string) {
+    return HMSPeerUpdateOrdinals.get(hmsPeerUpdateOrdinal);
+  }
+
   static encodeHmsAudioTrack(track: any, id: string) {
     const encodedObj = {
       trackId: track?.trackId,
@@ -139,42 +147,38 @@ export class HMSEncoder {
 
   static encodeHmsLocalPeer(peer: any, id: string) {
     const encodedObj = {
-      peerID: peer.peerID,
-      name: peer.name,
-      isLocal: peer.isLocal,
-      customerUserID: peer.customerUserID,
-      customerDescription: peer.customerDescription,
-      metadata: peer.metadata,
-      role: HMSEncoder.encodeHmsRole(peer?.role),
-      networkQuality: HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality),
-      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
-      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
-      auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
-        peer.auxiliaryTracks,
-        id
-      ),
-      localAudioTrackData: {
-        id: id,
-        trackId: peer?.localAudioTrackData?.trackId,
-        source: peer?.localAudioTrackData?.source,
-        trackDescription: peer?.localAudioTrackData?.trackDescription,
-        isMute: peer?.localAudioTrackData?.isMute,
-        settings: HMSEncoder.encodeHmsAudioTrackSettings(
-          peer?.localAudioTrackData?.settings
-        ),
-        type: peer?.localAudioTrackData?.type,
-      },
-      localVideoTrackData: {
-        id: id,
-        trackId: peer?.localVideoTrackData?.trackId,
-        source: peer?.localVideoTrackData?.source,
-        trackDescription: peer?.localVideoTrackData?.trackDescription,
-        isMute: peer?.localVideoTrackData?.isMute,
-        settings: HMSEncoder.encodeHmsVideoTrackSettings(
-          peer?.localVideoTrackData?.settings
-        ),
-        type: peer?.localVideoTrackData?.type,
-      },
+      peerID: peer?.peerID,
+      customerDescription: peer?.customerDescription || undefined,
+      localAudioTrackData: peer?.localAudioTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.localAudioTrackData?.trackId,
+            source: peer?.localAudioTrackData?.source,
+            trackDescription: peer?.localAudioTrackData?.trackDescription,
+            isMute: peer?.localAudioTrackData?.isMute,
+            settings: peer?.localAudioTrackData?.settings
+              ? HMSEncoder.encodeHmsAudioTrackSettings(
+                  peer?.localAudioTrackData?.settings
+                )
+              : undefined,
+            type: peer?.localAudioTrackData?.type,
+          }
+        : undefined,
+      localVideoTrackData: peer?.localVideoTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.localVideoTrackData?.trackId,
+            source: peer?.localVideoTrackData?.source,
+            trackDescription: peer?.localVideoTrackData?.trackDescription,
+            isMute: peer?.localVideoTrackData?.isMute,
+            settings: peer?.localVideoTrackData?.settings
+              ? HMSEncoder.encodeHmsVideoTrackSettings(
+                  peer?.localVideoTrackData?.settings
+                )
+              : undefined,
+            type: peer?.localVideoTrackData?.type,
+          }
+        : undefined,
     };
 
     return new HMSLocalPeer(encodedObj);
@@ -217,7 +221,9 @@ export class HMSEncoder {
       source: track?.source,
       trackDescription: track?.trackDescription,
       isMute: track?.isMute,
-      settings: HMSEncoder.encodeHmsAudioTrackSettings(track?.settings),
+      settings: track?.settings
+        ? HMSEncoder.encodeHmsAudioTrackSettings(track?.settings)
+        : undefined,
       type: track?.type,
     };
 
@@ -231,7 +237,9 @@ export class HMSEncoder {
       source: track?.source,
       trackDescription: track?.trackDescription,
       isMute: track?.isMute,
-      settings: HMSEncoder.encodeHmsVideoTrackSettings(track?.settings),
+      settings: track?.settings
+        ? HMSEncoder.encodeHmsVideoTrackSettings(track?.settings)
+        : undefined,
       type: track?.type,
     };
 
@@ -252,37 +260,29 @@ export class HMSEncoder {
 
   static encodeHmsRemotePeer(peer: any, id: string) {
     const encodedObj = {
-      peerID: peer.peerID,
-      name: peer.name,
-      isLocal: peer.isLocal,
-      customerUserID: peer.customerUserID,
+      peerID: peer?.peerID,
       customerDescription: peer.customerDescription,
-      metadata: peer.metadata,
-      role: HMSEncoder.encodeHmsRole(peer?.role),
-      networkQuality: HMSEncoder.encodeHMSNetworkQuality(peer?.networkQuality),
-      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
-      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
-      auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
-        peer.auxiliaryTracks,
-        id
-      ),
-      remoteAudioTrackData: {
-        id: id,
-        trackId: peer?.remoteAudioTrackData?.trackId,
-        source: peer?.remoteAudioTrackData?.source,
-        trackDescription: peer?.remoteAudioTrackData?.trackDescription,
-        isMute: peer?.remoteAudioTrackData?.isMute,
-        playbackAllowed: peer?.remoteAudioTrackData?.playbackAllowed,
-      },
-      remoteVideoTrackData: {
-        id: id,
-        trackId: peer?.remoteVideoTrackData?.trackId,
-        source: peer?.remoteVideoTrackData?.source,
-        trackDescription: peer?.remoteVideoTrackData?.trackDescription,
-        layer: peer?.remoteVideoTrackData?.layer,
-        isMute: peer?.remoteVideoTrackData?.isMute,
-        playbackAllowed: peer?.remoteVideoTrackData?.playbackAllowed,
-      },
+      remoteAudioTrackData: peer?.remoteAudioTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.remoteAudioTrackData?.trackId,
+            source: peer?.remoteAudioTrackData?.source,
+            trackDescription: peer?.remoteAudioTrackData?.trackDescription,
+            isMute: peer?.remoteAudioTrackData?.isMute,
+            playbackAllowed: peer?.remoteAudioTrackData?.playbackAllowed,
+          }
+        : undefined,
+      remoteVideoTrackData: peer?.remoteVideoTrackData?.trackId
+        ? {
+            id: id,
+            trackId: peer?.remoteVideoTrackData?.trackId,
+            source: peer?.remoteVideoTrackData?.source,
+            trackDescription: peer?.remoteVideoTrackData?.trackDescription,
+            layer: peer?.remoteVideoTrackData?.layer,
+            isMute: peer?.remoteVideoTrackData?.isMute,
+            playbackAllowed: peer?.remoteVideoTrackData?.playbackAllowed,
+          }
+        : undefined,
     };
 
     return new HMSRemotePeer(encodedObj);
@@ -332,26 +332,51 @@ export class HMSEncoder {
   }
 
   static encodeHmsRole(role: any) {
-    const hmsRole = new HMSRole(role);
+    if (!role) {
+      return new HMSRole(role);
+    }
+
+    const rolesCache = this.data.roles;
+
+    const cachedRole = rolesCache[role.name];
+
+    // create new HMSRole instance, if cached role does not exist OR `role.publishSettings?.allowed` does not exist
+    if (!cachedRole || !cachedRole.publishSettings?.allowed) {
+      // Creating HMSRole object with data
+      const hmsRole = new HMSRole(role);
+
+      // saving the created HMSRole object into cache
+      rolesCache[role.name] = hmsRole;
+
+      // If the created HMSRole object is complete,
+      // sending notification to Native Side to stop sending data for this role
+      if (hmsRole.publishSettings?.allowed) {
+        HMSManager.restrictData({
+          id: HMSConstants.DEFAULT_SDK_ID,
+          roleName: hmsRole.name,
+        });
+      }
+    }
 
-    return hmsRole;
+    return rolesCache[role.name];
   }
 
-  static encodeHmsRoleChangeRequest(data: any, id: string) {
+  static encodeHmsRoleChangeRequest(data: any) {
     const encodedRoleChangeRequest = {
-      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
+      requestedBy: data.requestedBy
+        ? HMSEncoder.encodeHmsPeer(data.requestedBy)
+        : undefined,
       suggestedRole: HMSEncoder.encodeHmsRole(data.suggestedRole),
     };
 
     return new HMSRoleChangeRequest(encodedRoleChangeRequest);
   }
 
-  static encodeHmsChangeTrackStateRequest(
-    data: HMSChangeTrackStateRequest,
-    id: string
-  ) {
+  static encodeHmsChangeTrackStateRequest(data: HMSChangeTrackStateRequest) {
     const encodedChangeTrackStateRequest = {
-      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
+      requestedBy: data?.requestedBy
+        ? HMSEncoder.encodeHmsPeer(data?.requestedBy)
+        : undefined,
       trackType: data.trackType,
       mute: data.mute,
     };
@@ -392,51 +417,64 @@ export class HMSEncoder {
   static encodeHmsSpeaker(data: any, id: string) {
     return new HMSSpeaker({
       level: data?.level,
-      peer: HMSEncoder.encodeHmsPeer(data?.peer, id),
+      peer: HMSEncoder.encodeHmsPeer(data?.peer),
       track: HMSEncoder.encodeHmsTrack(data?.track, id),
     });
   }
 
   static encodeBrowserRecordingState(data: any) {
     return new HMSBrowserRecordingState({
-      running: data?.running,
-      startedAt: new Date(parseInt(data?.startedAt)),
-      stoppedAt: new Date(parseInt(data?.stoppedAt)),
-      error: data?.error,
+      running: data?.running || false,
+      startedAt: HMSEncoder.encodeDate(data?.startedAt),
+      stoppedAt: HMSEncoder.encodeDate(data?.stoppedAt),
+      error: data?.error || undefined,
     });
   }
 
   static encodeServerRecordingState(data: any) {
     return new HMSServerRecordingState({
-      running: data?.running,
-      error: data?.error,
-      startedAt: new Date(parseInt(data?.startedAt)),
+      running: data?.running || false,
+      error: data?.error || undefined,
+      startedAt: HMSEncoder.encodeDate(data?.startedAt),
     });
   }
 
   static encodeRTMPStreamingState(data: any) {
     return new HMSRtmpStreamingState({
-      running: data?.running,
-      startedAt: new Date(parseInt(data?.startedAt)),
-      stoppedAt: new Date(parseInt(data?.stoppedAt)),
-      error: data?.error,
+      running: data?.running || false,
+      startedAt: HMSEncoder.encodeDate(data?.startedAt),
+      stoppedAt: HMSEncoder.encodeDate(data?.stoppedAt),
+      error: data?.error || undefined,
     });
   }
 
+  static encodeDate(dateData: any) {
+    if (!dateData) {
+      return undefined;
+    }
+    const dateNum = parseInt(dateData);
+    if (isNaN(dateNum)) {
+      return undefined;
+    }
+    return new Date(dateNum);
+  }
+
   static encodeHLSStreamingState(data: any) {
     return new HMSHLSStreamingState({
-      running: data?.running,
-      variants: this.encodeHLSVariants(data?.variants),
+      running: data?.running || false,
+      variants: Array.isArray(data?.variants)
+        ? this.encodeHLSVariants(data?.variants)
+        : undefined,
     });
   }
 
   static encodeHLSRecordingState(data: any) {
     if (data) {
       return new HMSHLSRecordingState({
-        running: data?.running,
-        startedAt: new Date(parseInt(data?.startedAt)),
-        singleFilePerLayer: data?.singleFilePerLayer,
-        videoOnDemand: data?.videoOnDemand,
+        running: data?.running || false,
+        startedAt: HMSEncoder.encodeDate(data?.startedAt),
+        singleFilePerLayer: data?.singleFilePerLayer || false,
+        videoOnDemand: data?.videoOnDemand || false,
       });
     } else {
       return undefined;
@@ -450,8 +488,8 @@ export class HMSEncoder {
       let variant = new HMSHLSVariant({
         hlsStreamUrl: item.hlsStreamUrl,
         meetingUrl: item.meetingUrl,
-        metadata: item?.metadata,
-        startedAt: new Date(parseInt(item?.startedAt)),
+        metadata: item?.metaData ? item?.metadata : undefined,
+        startedAt: HMSEncoder.encodeDate(item?.startedAt),
       });
       variants.push(variant);
     });
@@ -469,25 +507,29 @@ export class HMSEncoder {
     }
   }
 
-  static encodeHMSMessage(data: any, id: string) {
+  static encodeHMSMessage(data: any) {
     if (data) {
       return new HMSMessage({
         message: data?.message,
         type: data?.type,
         time: new Date(parseInt(data?.time)),
-        sender: this.encodeHmsPeer(data?.sender, id),
-        recipient: this.encodeHMSMessageRecipient(data?.recipient, id),
+        sender: this.encodeHmsPeer(data?.sender),
+        recipient: this.encodeHMSMessageRecipient(data?.recipient),
       });
     } else {
       return undefined;
     }
   }
 
-  static encodeHMSMessageRecipient(data: any, id: string) {
+  static encodeHMSMessageRecipient(data: any) {
     return new HMSMessageRecipient({
       recipientType: data?.recipientType,
-      recipientPeer: this.encodeHmsPeer(data?.recipientPeer, id),
-      recipientRoles: this.encodeHmsRoles(data?.recipientRoles),
+      recipientPeer: data?.recipientPeer
+        ? this.encodeHmsPeer(data.recipientPeer)
+        : undefined,
+      recipientRoles: Array.isArray(data?.recipientRoles)
+        ? this.encodeHmsRoles(data.recipientRoles)
+        : [],
     });
   }
 

package/src/classes/HMSHLSStreamingState.ts

@@ -2,9 +2,9 @@ import type { HMSHLSVariant } from './HMSHLSVariant';
 
 export class HMSHLSStreamingState {
   running: boolean;
-  variants: Array<HMSHLSVariant>;
+  variants?: Array<HMSHLSVariant>;
 
-  constructor(params: { running: boolean; variants: Array<HMSHLSVariant> }) {
+  constructor(params: { running: boolean; variants?: Array<HMSHLSVariant> }) {
     this.running = params.running;
     this.variants = params.variants;
   }

package/src/classes/HMSLocalPeer.ts

@@ -1,14 +1,9 @@
-import type { HMSAudioTrack } from './HMSAudioTrack';
 import { HMSPeer } from './HMSPeer';
-import type { HMSTrack } from './HMSTrack';
-import type { HMSVideoTrack } from './HMSVideoTrack';
 import type { HMSVideoTrackSettings } from './HMSVideoTrackSettings';
 import type { HMSAudioTrackSettings } from './HMSAudioTrackSettings';
 import { HMSLocalAudioTrack } from './HMSLocalAudioTrack';
 import { HMSLocalVideoTrack } from './HMSLocalVideoTrack';
-import type { HMSRole } from './HMSRole';
 import type { HMSTrackType } from './HMSTrackType';
-import type { HMSNetworkQuality } from './HMSNetworkQuality';
 
 export class HMSLocalPeer extends HMSPeer {
   private localAudio?: HMSLocalAudioTrack;
@@ -23,16 +18,7 @@ export class HMSLocalPeer extends HMSPeer {
 
   constructor(params: {
     peerID: string;
-    name: string;
-    isLocal?: boolean;
-    customerUserID?: string;
     customerDescription?: string;
-    metadata?: string;
-    audioTrack?: HMSAudioTrack;
-    videoTrack?: HMSVideoTrack;
-    networkQuality?: HMSNetworkQuality;
-    role?: HMSRole;
-    auxiliaryTracks?: HMSTrack[];
     localAudioTrackData?: {
       id: string;
       trackId: string;
@@ -53,7 +39,6 @@ export class HMSLocalPeer extends HMSPeer {
     };
   }) {
     super(params);
-    this.isLocal = true;
     if (params.localAudioTrackData) {
       this.localAudio = new HMSLocalAudioTrack(params.localAudioTrackData);
     }

package/src/classes/HMSLocalVideoTrack.ts

@@ -13,8 +13,6 @@ const {
 
 export class HMSLocalVideoTrack extends HMSVideoTrack {
   settings?: HMSVideoTrackSettings;
-  startCapturing?: Function;
-  stopCapturing?: Function;
   id: string;
 
   /**

package/src/classes/HMSLogger.ts

@@ -15,12 +15,6 @@ export class HMSLogger {
   private _verbose: boolean = false;
   private _warning: boolean = false;
   private _error: boolean = false;
-  private logs: {
-    type: 'verbose' | 'warn' | 'error';
-    message: string;
-    data: any;
-    id: string;
-  }[] = [];
   private onLog?: Function;
 
   constructor(params?: { verbose: boolean; warning: boolean; error: boolean }) {
@@ -33,38 +27,34 @@ export class HMSLogger {
 
   verbose(message: string, data: any) {
     if (this._verbose) {
-      console.log(message, data);
+      const timestamp = this.getTimestamp();
+      console.log(timestamp, message, data);
       if (this.onLog) {
-        this?.onLog({ message, data });
+        this?.onLog({ timestamp, message, data });
       }
-      this.logs.push({ type: 'verbose', message, data, id: data?.id });
     }
   }
 
   warn(message: string, data: any) {
     if (this._warning) {
-      console.warn(message, data);
+      const timestamp = this.getTimestamp();
+      console.warn(timestamp, message, data);
       if (this.onLog) {
-        this?.onLog({ message, data });
+        this?.onLog({ timestamp, message, data });
       }
-      this.logs.push({ type: 'warn', message, data, id: data?.id });
     }
   }
 
   error(message: string, data: any) {
     if (this._error) {
-      console.error(message, data);
+      const timestamp = this.getTimestamp();
+      console.error(timestamp, message, data);
       if (this.onLog) {
-        this?.onLog({ message, data });
+        this?.onLog({ timestamp, message, data });
       }
-      this.logs.push({ type: 'error', message, data, id: data?.id });
     }
   }
 
-  getLogs() {
-    return this.logs;
-  }
-
   setLogListener(callback: Function) {
     this.onLog = callback;
   }
@@ -88,4 +78,15 @@ export class HMSLogger {
       }
     }
   }
+
+  getTimestamp(): string {
+    const d = new Date();
+
+    const hh = d.getHours().toString().padStart(2, '0');
+    const mm = d.getMinutes().toString().padStart(2, '0');
+    const ss = d.getSeconds().toString().padStart(2, '0');
+    const millis = d.getMilliseconds().toString().padStart(3, '0');
+
+    return `${hh}:${mm}:${ss}:${millis}`;
+  }
 }

package/src/classes/HMSMessageRecipient.ts

@@ -3,9 +3,9 @@ import type { HMSPeer } from './HMSPeer';
 import type { HMSRole } from './HMSRole';
 
 export class HMSMessageRecipient {
-  public recipientType?: HMSMessageRecipientType;
+  public recipientType: HMSMessageRecipientType;
   public recipientPeer?: HMSPeer;
-  public recipientRoles?: HMSRole[];
+  public recipientRoles: HMSRole[];
 
   constructor(params: {
     recipientType: HMSMessageRecipientType;
@@ -14,6 +14,6 @@ export class HMSMessageRecipient {
   }) {
     this.recipientType = params.recipientType;
     this.recipientPeer = params.recipientPeer;
-    this.recipientRoles = params.recipientRoles;
+    this.recipientRoles = params.recipientRoles || [];
   }
 }