@100mslive/react-native-hms 0.7.2 → 0.8.1

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,
@@ -118,6 +134,7 @@ export class HMSEncoder {
         ),
       },
       localVideoTrackData: {
+        id: id,
         trackId: peer?.localVideoTrackData?.trackId,
         source: peer?.localVideoTrackData?.source,
         trackDescription: peer?.localVideoTrackData?.trackDescription,
@@ -135,6 +152,7 @@ export class HMSEncoder {
     const encodedObj = {
       maxBitrate: settings?.maxBitrate,
       trackDescription: settings?.trackDescription,
+      codec: settings?.codec,
     };
 
     return new HMSAudioTrackSettings(encodedObj);
@@ -143,7 +161,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 +171,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 +192,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 +216,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 +258,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,7 @@
-import { NativeModules } from 'react-native';
+import { NativeModules, Platform } from 'react-native';
 import { HMSAudioTrack } from './HMSAudioTrack';
 import type { HMSAudioTrackSettings } from './HMSAudioTrackSettings';
+import type { HMSTrackType } from './HMSTrackType';
 
 const {
   /**
@@ -11,6 +12,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 +21,32 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
    * @memberof HMSLocalAudioTrack
    */
   setMute(isMute: boolean) {
-    HmsManager.setLocalMute(isMute);
+    HmsManager.setLocalMute({ isMute, id: this.id });
   }
 
+  getVolume = async () => {
+    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

@@ -25,11 +25,13 @@ 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;
@@ -37,6 +39,7 @@ export class HMSLocalPeer extends HMSPeer {
       settings?: HMSAudioTrackSettings;
     };
     localVideoTrackData?: {
+      id: string;
       trackId: string;
       source?: number | string;
       trackDescription?: string;

package/src/classes/HMSLocalVideoTrack.ts

@@ -1,6 +1,7 @@
 import { NativeModules } from 'react-native';
 import { HMSVideoTrack } from './HMSVideoTrack';
 import type { HMSVideoTrackSettings } from './HMSVideoTrackSettings';
+import type { HMSTrackType } from './HMSTrackType';
 
 const {
   /**
@@ -13,6 +14,7 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
   settings?: HMSVideoTrackSettings;
   startCapturing?: Function;
   stopCapturing?: Function;
+  id: string;
 
   /**
    * switches camera between front/back
@@ -20,7 +22,7 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
    * @memberof HMSSDK
    */
   switchCamera = () => {
-    HmsManager.switchCamera();
+    HmsManager.switchCamera({ id: this.id });
   };
 
   /**
@@ -30,17 +32,20 @@ export class HMSLocalVideoTrack extends HMSVideoTrack {
    * @memberof HMSLocalVideoTrack
    */
   setMute(isMute: boolean) {
-    HmsManager.setLocalVideoMute(isMute);
+    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,11 @@
 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;
 
-  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;
@@ -31,7 +31,7 @@ export class HMSLogger {
     }
   }
 
-  updateLogLevel(level: HMSLogLevel, value: Boolean) {
+  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

@@ -1,29 +1,29 @@
 export class HMSPermissions {
   endRoom?: boolean;
   removeOthers?: boolean;
-  stopPresentation?: boolean;
+  unmute?: boolean;
   mute?: boolean;
-  askToUnmute?: boolean;
-  muteSelective?: boolean;
   changeRole?: boolean;
+  recording?: boolean;
+  rtmp?: boolean;
 
   constructor(params?: {
     endRoom?: boolean;
     removeOthers?: boolean;
-    stopPresentation?: boolean;
+    unmute?: boolean;
     mute?: boolean;
-    askToUnmute?: boolean;
-    muteSelective?: boolean;
     changeRole?: boolean;
+    recording?: boolean;
+    rtmp?: boolean;
   }) {
     if (params) {
       this.endRoom = params.endRoom;
       this.removeOthers = params.removeOthers;
-      this.stopPresentation = params.stopPresentation;
+      this.unmute = params.unmute;
       this.mute = params.mute;
-      this.askToUnmute = params.askToUnmute;
-      this.muteSelective = params.muteSelective;
       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,5 @@
 import { NativeModules } from 'react-native';
+import type { HMSTrackType } from './HMSTrackType';
 import { HMSAudioTrack } from './HMSAudioTrack';
 
 const {
@@ -16,12 +17,19 @@ export class HMSRemoteAudioTrack extends HMSAudioTrack {
    * @memberof HMSRemoteAudioTrack
    */
   setPlaybackAllowed(playbackAllowed: boolean) {
-    HmsManager.setPlaybackAllowed({ trackId: this.trackId, playbackAllowed });
+    HmsManager.setPlaybackAllowed({
+      id: this.id,
+      trackId: this.trackId,
+      playbackAllowed,
+    });
   }
 
   isPlaybackAllowed = async () => {
     try {
-      const val = await HmsManager.isPlaybackAllowed({ trackId: this.trackId });
+      const val = await HmsManager.isPlaybackAllowed({
+        id: this.id,
+        trackId: this.trackId,
+      });
       return val;
     } catch (e) {
       return true;
@@ -33,6 +41,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);

package/src/classes/HMSRemoteVideoTrack.ts

@@ -1,5 +1,6 @@
 import { NativeModules } from 'react-native';
 import { HMSVideoTrack } from './HMSVideoTrack';
+import type { HMSTrackType } from './HMSTrackType';
 
 const {
   /**
@@ -18,12 +19,19 @@ export class HMSRemoteVideoTrack extends HMSVideoTrack {
    * @memberof HMSRemoteVideoTrack
    */
   setPlaybackAllowed(playbackAllowed: boolean) {
-    HmsManager.setPlaybackAllowed({ trackId: this.trackId, playbackAllowed });
+    HmsManager.setPlaybackAllowed({
+      id: this.id,
+      trackId: this.trackId,
+      playbackAllowed,
+    });
   }
 
   isPlaybackAllowed = async () => {
     try {
-      const val = await HmsManager.isPlaybackAllowed({ trackId: this.trackId });
+      const val = await HmsManager.isPlaybackAllowed({
+        id: this.id,
+        trackId: this.trackId,
+      });
       return val;
     } catch (e) {
       return true;
@@ -36,6 +44,9 @@ export class HMSRemoteVideoTrack extends HMSVideoTrack {
     trackDescription?: string;
     isMute?: boolean;
     layer?: any;
+    playbackAllowed?: boolean;
+    id: string;
+    type?: HMSTrackType;
   }) {
     super(params);
     this.layer = params.layer;

package/src/classes/HMSRoom.ts

@@ -1,20 +1,32 @@
 import type { HMSPeer } from './HMSPeer';
+import type { HMSRtmpStreamingState } from './HMSRtmpStreamingState';
+import type { HMSServerRecordingState } from './HMSServerRecordingState';
+import type { HMSBrowserRecordingState } from './HMSBrowserRecordingState';
 
 export class HMSRoom {
   id: string;
   name: string;
   metaData?: string;
   peers: HMSPeer[];
+  browserRecordingState: HMSBrowserRecordingState;
+  rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
+  serverRecordingState: HMSServerRecordingState;
 
   constructor(params: {
     id: string;
     name: string;
     metaData?: string;
     peers: HMSPeer[];
+    browserRecordingState: HMSBrowserRecordingState;
+    rtmpHMSRtmpStreamingState: HMSRtmpStreamingState;
+    serverRecordingState: HMSServerRecordingState;
   }) {
     this.id = params.id;
     this.name = params.name;
     this.metaData = params.metaData;
     this.peers = params.peers;
+    this.browserRecordingState = params.browserRecordingState;
+    this.rtmpHMSRtmpStreamingState = params.rtmpHMSRtmpStreamingState;
+    this.serverRecordingState = params.serverRecordingState;
   }
 }

package/src/classes/HMSRtmpStreamingState.ts

@@ -0,0 +1,11 @@
+import type { HMSException } from './HMSException';
+
+export class HMSRtmpStreamingState {
+  running: string;
+  error: HMSException;
+
+  constructor(params: { running: string; error: HMSException }) {
+    this.running = params.running;
+    this.error = params.error;
+  }
+}