@100mslive/react-native-hms 0.7.3 → 0.8.2

package/src/classes/HMSEncoder.ts

@@ -14,29 +14,33 @@ import { HMSLocalAudioTrack } from './HMSLocalAudioTrack';
 import { HMSRole } from './HMSRole';
 import { HMSRoleChangeRequest } from './HMSRoleChangeRequest';
 import { HMSChangeTrackStateRequest } from './HMSChangeTrackStateRequest';
+import { HMSVideoResolution } from './HMSVideoResolution';
 
 export class HMSEncoder {
-  static encodeHmsRoom(room: any) {
+  static encodeHmsRoom(room: HMSRoom, id: string) {
     const encodedObj = {
       id: room?.id,
       metaData: room?.metaData,
       name: room?.name,
-      peers: HMSEncoder.encodeHmsPeers(room?.peers),
+      peers: HMSEncoder.encodeHmsPeers(room?.peers, id),
+      browserRecordingState: room?.browserRecordingState,
+      rtmpHMSRtmpStreamingState: room?.rtmpHMSRtmpStreamingState,
+      serverRecordingState: room?.serverRecordingState,
     };
 
     return new HMSRoom(encodedObj);
   }
 
-  static encodeHmsPeers(peers: any) {
+  static encodeHmsPeers(peers: any, id: string) {
     const encodedPeers: HMSPeer[] = [];
     peers?.map((peer: any) => {
-      encodedPeers.push(HMSEncoder.encodeHmsPeer(peer));
+      encodedPeers.push(HMSEncoder.encodeHmsPeer(peer, id));
     });
 
     return encodedPeers;
   }
 
-  static encodeHmsPeer(peer: any) {
+  static encodeHmsPeer(peer: any, id: string) {
     const encodedObj = {
       peerID: peer?.peerID,
       name: peer?.name,
@@ -44,71 +48,83 @@ export class HMSEncoder {
       role: HMSEncoder.encodeHmsRole(peer?.role),
       customerUserID: peer?.customerUserID,
       customerDescription: peer?.customerDescription,
-      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack),
-      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack),
+      metadata: peer?.metadata,
+      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id),
+      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
-        peer?.auxiliaryTracks
+        peer?.auxiliaryTracks,
+        id
       ),
     };
 
     return new HMSPeer(encodedObj);
   }
 
-  static encodeHmsAudioTrack(track: any) {
+  static encodeHmsAudioTrack(track: any, id: string) {
     const encodedObj = {
       trackId: track?.trackId,
       source: track?.source,
       trackDescription: track?.trackDescription,
       isMute: track?.isMute,
+      id: id,
+      type: track?.type,
     };
 
     return new HMSAudioTrack(encodedObj);
   }
 
-  static encodeHmsVideoTrack(track: any) {
+  static encodeHmsVideoTrack(track: any, id: string) {
     const encodedObj = {
+      id: id,
       trackId: track?.trackId,
       source: track?.source,
       trackDescription: track?.trackDescription,
       isMute: track?.isMute,
+      isDegraded: track?.isDegraded,
+      type: track?.type,
     };
 
     return new HMSVideoTrack(encodedObj);
   }
 
-  static encodeHmsAuxiliaryTracks(tracks: any) {
+  static encodeHmsAuxiliaryTracks(tracks: any, id: string) {
     const auxiliaryTracks: HMSTrack[] = [];
     tracks?.map((track: any) => {
-      auxiliaryTracks.push(HMSEncoder.encodeHmsTrack(track));
+      auxiliaryTracks.push(HMSEncoder.encodeHmsTrack(track, id));
     });
     return auxiliaryTracks;
   }
 
-  static encodeHmsTrack(track: any) {
+  static encodeHmsTrack(track: any, id: string) {
     const encodedObj = {
       trackId: track?.trackId,
       source: track?.source,
       trackDescription: track?.trackDescription,
       isMute: track?.isMute,
+      id: id,
+      type: track?.type,
     };
 
     return new HMSTrack(encodedObj);
   }
 
-  static encodeHmsLocalPeer(peer: any) {
+  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),
-      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack),
-      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack),
+      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
+      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
-        peer.auxiliaryTracks
+        peer.auxiliaryTracks,
+        id
       ),
       localAudioTrackData: {
+        id: id,
         trackId: peer?.localAudioTrackData?.trackId,
         source: peer?.localAudioTrackData?.source,
         trackDescription: peer?.localAudioTrackData?.trackDescription,
@@ -116,8 +132,10 @@ export class HMSEncoder {
         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,
@@ -125,6 +143,7 @@ export class HMSEncoder {
         settings: HMSEncoder.encodeHmsVideoTrackSettings(
           peer?.localVideoTrackData?.settings
         ),
+        type: peer?.localVideoTrackData?.type,
       },
     };
 
@@ -135,6 +154,7 @@ export class HMSEncoder {
     const encodedObj = {
       maxBitrate: settings?.maxBitrate,
       trackDescription: settings?.trackDescription,
+      codec: settings?.codec,
     };
 
     return new HMSAudioTrackSettings(encodedObj);
@@ -143,7 +163,7 @@ export class HMSEncoder {
   static encodeHmsVideoTrackSettings(settings: any) {
     const encodedObj = {
       codec: settings?.codec,
-      resolution: settings?.resolution,
+      resolution: HMSEncoder.encodeHmsVideoResolution(settings?.resolution),
       maxBitrate: settings?.maxBitrate,
       maxFrameRate: settings?.maxFrameRate,
       cameraFacing: settings?.cameraFacing,
@@ -153,11 +173,20 @@ export class HMSEncoder {
     return new HMSVideoTrackSettings(encodedObj);
   }
 
-  static encodeHmsRemotePeers(peers: any) {
+  static encodeHmsVideoResolution(resolution: any) {
+    const encodedObj = {
+      height: resolution?.height,
+      width: resolution?.width,
+    };
+
+    return new HMSVideoResolution(encodedObj);
+  }
+
+  static encodeHmsRemotePeers(peers: any, id: string) {
     const hmsPeers: any[] = [];
 
     peers.map((peer: any) => {
-      const encodedPeer = HMSEncoder.encodeHmsRemotePeer(peer);
+      const encodedPeer = HMSEncoder.encodeHmsRemotePeer(peer, id);
 
       hmsPeers.push(encodedPeer);
     });
@@ -165,20 +194,23 @@ export class HMSEncoder {
     return hmsPeers;
   }
 
-  static encodeHmsRemotePeer(peer: any) {
+  static encodeHmsRemotePeer(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),
-      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack),
-      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack),
+      audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
+      videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
-        peer.auxiliaryTracks
+        peer.auxiliaryTracks,
+        id
       ),
       remoteAudioTrackData: {
+        id: id,
         trackId: peer?.remoteAudioTrackData?.trackId,
         source: peer?.remoteAudioTrackData?.source,
         trackDescription: peer?.remoteAudioTrackData?.trackDescription,
@@ -186,6 +218,7 @@ export class HMSEncoder {
         playbackAllowed: peer?.remoteAudioTrackData?.playbackAllowed,
       },
       remoteVideoTrackData: {
+        id: id,
         trackId: peer?.remoteVideoTrackData?.trackId,
         source: peer?.remoteVideoTrackData?.source,
         trackDescription: peer?.remoteVideoTrackData?.trackDescription,
@@ -227,18 +260,21 @@ export class HMSEncoder {
     return hmsRole;
   }
 
-  static encodeHmsRoleChangeRequest(data: any) {
+  static encodeHmsRoleChangeRequest(data: any, id: string) {
     const encodedRoleChangeRequest = {
-      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy),
+      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
       suggestedRole: HMSEncoder.encodeHmsRole(data.suggestedRole),
     };
 
     return new HMSRoleChangeRequest(encodedRoleChangeRequest);
   }
 
-  static encodeHmsChangeTrackStateRequest(data: HMSChangeTrackStateRequest) {
+  static encodeHmsChangeTrackStateRequest(
+    data: HMSChangeTrackStateRequest,
+    id: string
+  ) {
     const encodedChangeTrackStateRequest = {
-      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy),
+      requestedBy: HMSEncoder.encodeHmsPeer(data.requestedBy, id),
       trackType: data.trackType,
     };
 

package/src/classes/HMSException.ts

@@ -0,0 +1,33 @@
+export class HMSException {
+  public error: {
+    code: number;
+    description: string;
+    localizedDescription: string;
+    message: string;
+    name: string;
+    action: string;
+  };
+  public event: string;
+
+  constructor(params: {
+    error: {
+      code: number;
+      description: string;
+      localizedDescription: string;
+      message: string;
+      name: string;
+      action: string;
+    };
+    event: string;
+  }) {
+    this.error = {
+      code: params.error.code,
+      description: params.error.description,
+      localizedDescription: params.error.localizedDescription,
+      message: params.error.message,
+      name: params.error.name,
+      action: params.error.action,
+    };
+    this.event = params.event;
+  }
+}

package/src/classes/HMSHelper.ts

@@ -5,8 +5,8 @@ export class HMSHelper {
     let names: string[] = [];
 
     roles?.map((item: HMSRole) => {
-      if (item.name) {
-        names.push(item.name);
+      if (item?.name) {
+        names.push(item?.name);
       }
     });
 

package/src/classes/HMSLocalAudioTrack.ts

@@ -1,6 +1,8 @@
-import { NativeModules } from 'react-native';
+import { NativeModules, Platform } from 'react-native';
 import { HMSAudioTrack } from './HMSAudioTrack';
+import { HMSSDK } from './HMSSDK';
 import type { HMSAudioTrackSettings } from './HMSAudioTrackSettings';
+import type { HMSTrackType } from './HMSTrackType';
 
 const {
   /**
@@ -11,6 +13,7 @@ const {
 
 export class HMSLocalAudioTrack extends HMSAudioTrack {
   settings?: HMSAudioTrackSettings;
+  id: string;
 
   /**
    * Switches Audio of current user on/off depending upon the value of isMute
@@ -19,17 +22,47 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
    * @memberof HMSLocalAudioTrack
    */
   setMute(isMute: boolean) {
-    HmsManager.setLocalMute(isMute);
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function setMute', {
+      trackId: this.trackId,
+      id: this.id,
+      source: this.source,
+      type: this.type,
+      isMute,
+    });
+    HmsManager.setLocalMute({ isMute, id: this.id });
   }
 
+  getVolume = async () => {
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function getVolume', {
+      trackId: this.trackId,
+      id: this.id,
+      source: this.source,
+      type: this.type,
+    });
+    if (Platform.OS === 'ios') {
+      return 'This API not available for IOS';
+    }
+    const volume = await HmsManager.getVolume({
+      trackId: this.trackId,
+      id: this.id,
+    });
+
+    return volume;
+  };
+
   constructor(params: {
+    id: string;
     trackId: string;
     source?: number | string;
     trackDescription?: string;
     isMute?: boolean;
     settings?: HMSAudioTrackSettings;
+    type?: HMSTrackType;
   }) {
     super(params);
+    this.id = params.id;
     this.settings = params.settings;
   }
 }

package/src/classes/HMSLocalPeer.ts

@@ -7,6 +7,7 @@ import type { HMSAudioTrackSettings } from './HMSAudioTrackSettings';
 import { HMSLocalAudioTrack } from './HMSLocalAudioTrack';
 import { HMSLocalVideoTrack } from './HMSLocalVideoTrack';
 import type { HMSRole } from './HMSRole';
+import type { HMSTrackType } from './HMSTrackType';
 
 export class HMSLocalPeer extends HMSPeer {
   private localAudio?: HMSLocalAudioTrack;
@@ -25,23 +26,28 @@ export class HMSLocalPeer extends HMSPeer {
     isLocal?: boolean;
     customerUserID?: string;
     customerDescription?: string;
+    metadata?: string;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
     role?: HMSRole;
     auxiliaryTracks?: HMSTrack[];
     localAudioTrackData?: {
+      id: string;
       trackId: string;
       source?: number | string;
       trackDescription?: string;
       isMute?: boolean;
       settings?: HMSAudioTrackSettings;
+      type: HMSTrackType;
     };
     localVideoTrackData?: {
+      id: string;
       trackId: string;
       source?: number | string;
       trackDescription?: string;
       isMute?: boolean;
       settings?: HMSVideoTrackSettings;
+      type: HMSTrackType;
     };
   }) {
     super(params);

package/src/classes/HMSLocalVideoTrack.ts

@@ -1,6 +1,8 @@
 import { NativeModules } from 'react-native';
 import { HMSVideoTrack } from './HMSVideoTrack';
+import { HMSSDK } from './HMSSDK';
 import type { HMSVideoTrackSettings } from './HMSVideoTrackSettings';
+import type { HMSTrackType } from './HMSTrackType';
 
 const {
   /**
@@ -13,6 +15,7 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
   settings?: HMSVideoTrackSettings;
   startCapturing?: Function;
   stopCapturing?: Function;
+  id: string;
 
   /**
    * switches camera between front/back
@@ -20,7 +23,14 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
    * @memberof HMSSDK
    */
   switchCamera = () => {
-    HmsManager.switchCamera();
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function switchCamera', {
+      trackId: this.trackId,
+      source: this.source,
+      type: this.type,
+      id: this.id,
+    });
+    HmsManager.switchCamera({ id: this.id });
   };
 
   /**
@@ -30,17 +40,27 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
    * @memberof HMSLocalVideoTrack
    */
   setMute(isMute: boolean) {
-    HmsManager.setLocalVideoMute(isMute);
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function setMute', {
+      trackId: this.trackId,
+      source: this.source,
+      type: this.type,
+      id: this.id,
+    });
+    HmsManager.setLocalVideoMute({ isMute, id: this.id });
   }
 
   constructor(params: {
+    id: string;
     trackId: string;
     source?: number | string;
     trackDescription?: string;
     isMute?: boolean;
     settings?: HMSVideoTrackSettings;
+    type?: HMSTrackType;
   }) {
     super(params);
     this.settings = params.settings;
+    this.id = params.id;
   }
 }

package/src/classes/HMSLogger.ts

@@ -1,11 +1,17 @@
 import { HMSLogLevel } from './HMSLogLevel';
 
 export class HMSLogger {
-  private _verbose: Boolean = false;
-  private _warning: Boolean = false;
-  private _error: Boolean = false;
+  private _verbose: boolean = false;
+  private _warning: boolean = false;
+  private _error: boolean = false;
+  private logs: {
+    type: 'verbose' | 'warn' | 'error';
+    message: string;
+    data: any;
+    id: string;
+  }[] = [];
 
-  constructor(params?: { verbose: Boolean; warning: Boolean; error: Boolean }) {
+  constructor(params?: { verbose: boolean; warning: boolean; error: boolean }) {
     if (params) {
       this._verbose = params.verbose;
       this._warning = params.warning;
@@ -14,24 +20,31 @@ export class HMSLogger {
   }
 
   verbose(message: string, data: any) {
-    if (this._verbose === true) {
+    if (this._verbose) {
       console.log(message, data);
     }
+    this.logs.push({ type: 'verbose', message, data, id: data?.id });
   }
 
   warn(message: string, data: any) {
     if (this._warning) {
       console.warn(message, data);
     }
+    this.logs.push({ type: 'warn', message, data, id: data?.id });
   }
 
   error(message: string, data: any) {
     if (this._error) {
       console.error(message, data);
     }
+    this.logs.push({ type: 'error', message, data, id: data?.id });
   }
 
-  updateLogLevel(level: HMSLogLevel, value: Boolean) {
+  getLogs() {
+    return this.logs;
+  }
+
+  updateLogLevel(level: HMSLogLevel, value: boolean) {
     switch (level) {
       case HMSLogLevel.VERBOSE: {
         this._verbose = value;

package/src/classes/HMSPeer.ts

@@ -9,6 +9,7 @@ export class HMSPeer {
   isLocal?: boolean;
   customerUserID?: string;
   customerDescription?: string;
+  metadata?: string;
   role?: HMSRole;
 
   audioTrack?: HMSAudioTrack;
@@ -22,6 +23,7 @@ export class HMSPeer {
     isLocal?: boolean;
     customerUserID?: string;
     customerDescription?: string;
+    metadata?: string;
     role?: HMSRole;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
@@ -36,5 +38,6 @@ export class HMSPeer {
     this.videoTrack = params.videoTrack;
     this.auxiliaryTracks = params.auxiliaryTracks;
     this.role = params.role;
+    this.metadata = params.metadata;
   }
 }

package/src/classes/HMSPeerUpdate.ts

@@ -3,6 +3,7 @@ export enum HMSPeerUpdate {
   PEER_LEFT = 'PEER_LEFT',
   AUDIO_TOGGLED = 'AUDIO_TOGGLED',
   VIDEO_TOGGLED = 'VIDEO_TOGGLED',
+  METADATA_CHANGED = 'METADATA_CHANGED',
   BECAME_DOMINANT_SPEAKER = 'BECAME_DOMINANT_SPEAKER',
   NO_DOMINANT_SPEAKER = 'NO_DOMINANT_SPEAKER',
   RESIGNED_DOMINANT_SPEAKER = 'RESIGNED_DOMINANT_SPEAKER',

package/src/classes/HMSPermissions.ts

@@ -4,6 +4,8 @@ export class HMSPermissions {
   unmute?: boolean;
   mute?: boolean;
   changeRole?: boolean;
+  recording?: boolean;
+  rtmp?: boolean;
 
   constructor(params?: {
     endRoom?: boolean;
@@ -11,6 +13,8 @@ export class HMSPermissions {
     unmute?: boolean;
     mute?: boolean;
     changeRole?: boolean;
+    recording?: boolean;
+    rtmp?: boolean;
   }) {
     if (params) {
       this.endRoom = params.endRoom;
@@ -18,6 +22,8 @@ export class HMSPermissions {
       this.unmute = params.unmute;
       this.mute = params.mute;
       this.changeRole = params.changeRole;
+      this.recording = params.recording;
+      this.rtmp = params.rtmp;
     }
   }
 }

package/src/classes/HMSRTMPConfig.ts

@@ -0,0 +1,15 @@
+export class HMSRTMPConfig {
+  meetingURL: string;
+  rtmpURLs?: Array<string>;
+  record: boolean;
+
+  constructor(params: {
+    meetingURL: string;
+    rtmpURLs?: Array<string>;
+    record: boolean;
+  }) {
+    this.meetingURL = params.meetingURL;
+    this.rtmpURLs = params.rtmpURLs;
+    this.record = params.record;
+  }
+}

package/src/classes/HMSRemoteAudioTrack.ts

@@ -1,4 +1,6 @@
 import { NativeModules } from 'react-native';
+import { HMSSDK } from './HMSSDK';
+import type { HMSTrackType } from './HMSTrackType';
 import { HMSAudioTrack } from './HMSAudioTrack';
 
 const {
@@ -16,12 +18,34 @@ export class HMSRemoteAudioTrack extends HMSAudioTrack {
    * @memberof HMSRemoteAudioTrack
    */
   setPlaybackAllowed(playbackAllowed: boolean) {
-    HmsManager.setPlaybackAllowed({ trackId: this.trackId, playbackAllowed });
+    const logger = HMSSDK.getLogger();
+    logger?.verbose('#Function setPlaybackAllowed', {
+      trackId: this.trackId,
+      id: this.id,
+      source: this.source,
+      type: this.type,
+      playbackAllowed,
+    });
+    HmsManager.setPlaybackAllowed({
+      id: this.id,
+      trackId: this.trackId,
+      playbackAllowed,
+    });
   }
 
   isPlaybackAllowed = async () => {
     try {
-      const val = await HmsManager.isPlaybackAllowed({ trackId: this.trackId });
+      const logger = HMSSDK.getLogger();
+      logger?.verbose('#Function isPlaybackAllowed', {
+        trackId: this.trackId,
+        id: this.id,
+        source: this.source,
+        type: this.type,
+      });
+      const val = await HmsManager.isPlaybackAllowed({
+        id: this.id,
+        trackId: this.trackId,
+      });
       return val;
     } catch (e) {
       return true;
@@ -33,6 +57,9 @@ export class HMSRemoteAudioTrack extends HMSAudioTrack {
     source?: number | string;
     isMute?: boolean;
     trackDescription?: string;
+    playbackAllowed?: boolean;
+    id: string;
+    type?: HMSTrackType;
   }) {
     super(params);
   }

package/src/classes/HMSRemotePeer.ts

@@ -24,6 +24,7 @@ export class HMSRemotePeer extends HMSPeer {
     isLocal?: boolean;
     customerUserID?: string;
     customerDescription?: string;
+    metadata?: string;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
     role?: HMSRole;
@@ -34,6 +35,7 @@ export class HMSRemotePeer extends HMSPeer {
       isMute?: boolean;
       trackDescription?: string;
       playbackAllowed?: boolean;
+      id: string;
     };
     remoteVideoTrackData?: {
       trackId: string;
@@ -42,6 +44,7 @@ export class HMSRemotePeer extends HMSPeer {
       isMute?: boolean;
       layer?: any;
       playbackAllowed?: boolean;
+      id: string;
     };
   }) {
     super(params);