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

package/lib/typescript/classes/HMSTrack.d.ts

@@ -6,7 +6,7 @@ export declare class HMSTrack {
     mute?: boolean;
     id: string;
     type?: HMSTrackType;
-    isMute: () => Promise<any>;
+    isMute: () => boolean | undefined;
     constructor(params: {
         trackId: string;
         source?: number | string;

package/lib/typescript/classes/HMSVideoResolution.d.ts

@@ -0,0 +1,8 @@
+export declare class HMSVideoResolution {
+    height?: number;
+    width?: number;
+    constructor(params: {
+        height: number;
+        width: number;
+    });
+}

package/lib/typescript/classes/HMSVideoSettings.d.ts

@@ -1,15 +1,15 @@
-import type { HMSAudioCodec } from './HMSAudioCodec';
+import type { HMSVideoCodec } from '..';
 export declare class HMSVideoSettings {
     bitrate?: number;
     frameRate: number;
     width: number;
     height: number;
-    codec: HMSAudioCodec;
+    codec: HMSVideoCodec;
     constructor(params: {
         bitrate?: number;
         frameRate: number;
         width: number;
         height: number;
-        codec: HMSAudioCodec;
+        codec: HMSVideoCodec;
     });
 }

package/lib/typescript/classes/HMSVideoTrackSettings.d.ts

@@ -1,18 +1,21 @@
+import type { HMSVideoCodec } from './HMSVideoCodec';
 import type { HMSSimulcastLayerSettings } from './HMSSimulcastLayerSettings';
+import type { HMSCameraFacing } from './HMSCameraFacing';
+import type { HMSVideoResolution } from './HMSVideoResolution';
 export declare class HMSVideoTrackSettings {
-    codec?: any;
-    resolution?: any;
-    maxBitrate?: number;
-    maxFrameRate?: number;
-    cameraFacing?: any;
+    codec: HMSVideoCodec;
+    resolution: HMSVideoResolution;
+    maxBitrate: number;
+    maxFrameRate: number;
+    cameraFacing: HMSCameraFacing;
     trackDescription?: string;
     simulcastSettings?: HMSSimulcastLayerSettings[];
     constructor(params: {
-        codec?: any;
-        resolution?: any;
-        maxBitrate?: number;
-        maxFrameRate?: number;
-        cameraFacing?: any;
+        codec: HMSVideoCodec;
+        resolution: HMSVideoResolution;
+        maxBitrate: number;
+        maxFrameRate: number;
+        cameraFacing: HMSCameraFacing;
         trackDescription?: string;
         simulcastSettings?: HMSSimulcastLayerSettings[];
     });

package/lib/typescript/index.d.ts

@@ -40,5 +40,11 @@ export * from './classes/HMSVideoViewMode';
 export * from './classes/HMSChangeTrackStateRequest';
 export * from './classes/HMSSpeaker';
 export * from './classes/HMSSpeakerUpdate';
+export * from './classes/HMSCameraFacing';
+export * from './classes/HMSException';
+export * from './classes/HMSRtmpStreamingState';
+export * from './classes/HMSServerRecordingState';
+export * from './classes/HMSBrowserRecordingState';
+export * from './classes/HMSRTMPConfig';
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
 export default HmsManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100mslive/react-native-hms",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "The React Native package for 100ms SDK",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/classes/HMSAudioTrackSettings.ts

@@ -1,8 +1,16 @@
+import type { HMSAudioCodec } from './HMSAudioCodec';
+
 export class HMSAudioTrackSettings {
   maxBitrate?: number;
   trackDescription?: string;
-  constructor(params: { maxBitrate: number; trackDescription?: string }) {
+  codec?: HMSAudioCodec;
+  constructor(params: {
+    maxBitrate: number;
+    trackDescription?: string;
+    codec: HMSAudioCodec;
+  }) {
     this.maxBitrate = params.maxBitrate;
     this.trackDescription = params.trackDescription;
+    this.codec = params.codec;
   }
 }

package/src/classes/HMSBrowserRecordingState.ts

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

package/src/classes/HMSCameraFacing.ts

@@ -0,0 +1,4 @@
+export enum HMSCameraFacing {
+  FRONT = 'FRONT',
+  BACK = 'BACK',
+}

package/src/classes/HMSConfig.ts

@@ -1,16 +1,18 @@
 export class HMSConfig {
-  // endpoint: string;
   username: string;
   authToken: string;
   endpoint?: string;
+  metadata?: string;
 
   constructor(params: {
     username: string;
     authToken: string;
     endpoint?: string;
+    metadata?: string;
   }) {
     this.username = params.username;
     this.authToken = params.authToken;
     this.endpoint = params.endpoint;
+    this.metadata = params.metadata;
   }
 }

package/src/classes/HMSEncoder.ts

@@ -14,14 +14,18 @@ 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, id: string) {
+  static encodeHmsRoom(room: HMSRoom, id: string) {
     const encodedObj = {
       id: room?.id,
       metaData: room?.metaData,
       name: room?.name,
       peers: HMSEncoder.encodeHmsPeers(room?.peers, id),
+      browserRecordingState: room?.browserRecordingState,
+      rtmpHMSRtmpStreamingState: room?.rtmpHMSRtmpStreamingState,
+      serverRecordingState: room?.serverRecordingState,
     };
 
     return new HMSRoom(encodedObj);
@@ -44,6 +48,7 @@ export class HMSEncoder {
       role: HMSEncoder.encodeHmsRole(peer?.role),
       customerUserID: peer?.customerUserID,
       customerDescription: peer?.customerDescription,
+      metadata: peer.metadata,
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer?.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer?.videoTrack, id),
       auxiliaryTracks: HMSEncoder.encodeHmsAuxiliaryTracks(
@@ -110,6 +115,7 @@ export class HMSEncoder {
       isLocal: peer.isLocal,
       customerUserID: peer.customerUserID,
       customerDescription: peer.customerDescription,
+      metadata: peer.metadata,
       role: HMSEncoder.encodeHmsRole(peer?.role),
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),
@@ -146,6 +152,7 @@ export class HMSEncoder {
     const encodedObj = {
       maxBitrate: settings?.maxBitrate,
       trackDescription: settings?.trackDescription,
+      codec: settings?.codec,
     };
 
     return new HMSAudioTrackSettings(encodedObj);
@@ -154,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,
@@ -164,6 +171,15 @@ export class HMSEncoder {
     return new HMSVideoTrackSettings(encodedObj);
   }
 
+  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[] = [];
 
@@ -183,6 +199,7 @@ export class HMSEncoder {
       isLocal: peer.isLocal,
       customerUserID: peer.customerUserID,
       customerDescription: peer.customerDescription,
+      metadata: peer.metadata,
       role: HMSEncoder.encodeHmsRole(peer?.role),
       audioTrack: HMSEncoder.encodeHmsAudioTrack(peer.audioTrack, id),
       videoTrack: HMSEncoder.encodeHmsVideoTrack(peer.videoTrack, id),

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,4 +1,4 @@
-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';
@@ -24,6 +24,18 @@ export class HMSLocalAudioTrack extends HMSAudioTrack {
     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;

package/src/classes/HMSLocalPeer.ts

@@ -25,6 +25,7 @@ export class HMSLocalPeer extends HMSPeer {
     isLocal?: boolean;
     customerUserID?: string;
     customerDescription?: string;
+    metadata?: string;
     audioTrack?: HMSAudioTrack;
     videoTrack?: HMSVideoTrack;
     role?: HMSRole;

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/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;

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

package/src/classes/HMSSDK.tsx

@@ -15,6 +15,8 @@ import type { HMSLogger } from './HMSLogger';
 import type { HMSPeer } from './HMSPeer';
 import { HmsView as HMSViewComponent } from './HmsView';
 import { HMSVideoViewMode } from './HMSVideoViewMode';
+import type { HMSTrackSettings } from './HMSTrackSettings';
+import type { HMSRTMPConfig } from './HMSRTMPConfig';
 
 interface HmsComponentProps {
   trackId: string;
@@ -43,6 +45,7 @@ export class HMSSDK {
   knownRoles?: HMSRole[];
   logger?: HMSLogger;
   id: string;
+  private muteStatus: boolean | undefined;
 
   onPreviewDelegate?: any;
   onJoinDelegate?: any;
@@ -70,8 +73,8 @@ export class HMSSDK {
    * @returns
    * @memberof HMSSDK
    */
-  static async build() {
-    let id = await HmsManager.build();
+  static async build(params?: { trackSettings?: HMSTrackSettings }) {
+    let id = await HmsManager.build(params?.trackSettings || {});
     HmsSdk = new HMSSDK(id);
     HmsSdk.attachPreviewListener();
     HmsSdk.attachListeners();
@@ -261,6 +264,7 @@ export class HMSSDK {
     };
 
     await HmsManager.leave(data);
+    this.muteStatus = undefined;
     this.localPeer = undefined;
     this.remotePeers = undefined;
     this.room = undefined;
@@ -296,6 +300,24 @@ export class HMSSDK {
     });
   };
 
+  changeMetadata = (metadata: string) => {
+    this.logger?.verbose('CHANGE_METADATA', { metadata });
+    HmsManager.changeMetadata({ metadata, id: this.id });
+  };
+
+  startRTMPOrRecording = async (data: HMSRTMPConfig) => {
+    this.logger?.verbose('START_RTMP_OR_RECORDING', { data });
+
+    const op = await HmsManager.startRTMPOrRecording({ ...data, id: this.id });
+    return op;
+  };
+
+  stopRtmpAndRecording = async () => {
+    this.logger?.verbose('STOP_RTMP_OR_RECORDING', {});
+    const op = await HmsManager.stopRtmpAndRecording({ id: this.id });
+    return op;
+  };
+
   changeRole = (peer: HMSPeer, role: HMSRole, force: boolean = false) => {
     const data = {
       peerId: peer?.peerID,
@@ -370,6 +392,7 @@ export class HMSSDK {
 
   muteAllPeersAudio = (mute: boolean) => {
     this.logger?.verbose('ON_MUTE_ALL_PEERS', { mute });
+    this.muteStatus = mute;
     HmsManager.muteAllPeersAudio({ mute, id: this.id });
   };
 
@@ -381,6 +404,16 @@ export class HMSSDK {
     return encodedHmsRoom;
   };
 
+  setVolume = (track: HMSTrack, volume: number) => {
+    this.logger?.verbose('SET_VOLUME_CALL', { track, volume });
+    HmsManager.setVolume({
+      id: this.id,
+      trackId: track.trackId,
+      volume,
+    });
+    return;
+  };
+
   /**
    * - This is a prototype event listener that takes action and listens for updates related to that particular action
    * - This method will be @deprecated in future and event listener will be passed in join method
@@ -640,6 +673,9 @@ export class HMSSDK {
       data.remotePeers,
       this.id
     );
+    if (this.muteStatus && data?.type === 'TRACK_ADDED') {
+      this.muteAllPeersAudio(this.muteStatus);
+    }
     this.room = room;
     this.localPeer = localPeer;
     this.remotePeers = remotePeers;
@@ -676,7 +712,9 @@ export class HMSSDK {
       return;
     }
     this.logger?.warn('ON_ERROR', data);
+    this.logger?.verbose('ON_ERROR', data);
     if (this.onErrorDelegate) {
+      this.logger?.verbose('ON_ERROR_LISTENER_CALL', data);
       this.logger?.warn('ON_ERROR_LISTENER_CALL', data);
       this.onErrorDelegate(data);
     }

package/src/classes/HMSServerRecordingState.ts

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

package/src/classes/HMSTrack.ts

@@ -1,13 +1,5 @@
-import { NativeModules } from 'react-native';
 import type { HMSTrackType } from './HMSTrackType';
 
-const {
-  /**
-   * @ignore
-   */
-  HmsManager,
-} = NativeModules;
-
 export class HMSTrack {
   trackId: string;
   source?: number | string;
@@ -16,13 +8,8 @@ export class HMSTrack {
   id: string;
   type?: HMSTrackType;
 
-  isMute = async () => {
-    try {
-      let val = await HmsManager.isMute({ trackId: this.trackId, id: this.id });
-      return val;
-    } catch (err) {
-      return true;
-    }
+  isMute = () => {
+    return this.mute;
   };
 
   constructor(params: {

package/src/classes/HMSVideoResolution.ts

@@ -0,0 +1,9 @@
+export class HMSVideoResolution {
+  height?: number;
+  width?: number;
+
+  constructor(params: { height: number; width: number }) {
+    this.height = params.height;
+    this.width = params.width;
+  }
+}

package/src/classes/HMSVideoSettings.ts

@@ -1,18 +1,18 @@
-import type { HMSAudioCodec } from './HMSAudioCodec';
+import type { HMSVideoCodec } from '..';
 
 export class HMSVideoSettings {
   bitrate?: number;
   frameRate: number;
   width: number;
   height: number;
-  codec: HMSAudioCodec;
+  codec: HMSVideoCodec;
 
   constructor(params: {
     bitrate?: number;
     frameRate: number;
     width: number;
     height: number;
-    codec: HMSAudioCodec;
+    codec: HMSVideoCodec;
   }) {
     this.bitrate = params.bitrate;
     this.frameRate = params.frameRate;

package/src/classes/HMSVideoTrackSettings.ts

@@ -1,20 +1,23 @@
+import type { HMSVideoCodec } from './HMSVideoCodec';
 import type { HMSSimulcastLayerSettings } from './HMSSimulcastLayerSettings';
+import type { HMSCameraFacing } from './HMSCameraFacing';
+import type { HMSVideoResolution } from './HMSVideoResolution';
 
 export class HMSVideoTrackSettings {
-  codec?: any; //TODO: make it HMSCodec Type
-  resolution?: any; //TODO: make it HMSVideoResolution Type
-  maxBitrate?: number;
-  maxFrameRate?: number;
-  cameraFacing?: any; //TODO: make it HMSCameraFacing type
+  codec: HMSVideoCodec;
+  resolution: HMSVideoResolution;
+  maxBitrate: number;
+  maxFrameRate: number;
+  cameraFacing: HMSCameraFacing;
   trackDescription?: string;
   simulcastSettings?: HMSSimulcastLayerSettings[];
 
   constructor(params: {
-    codec?: any; //TODO: make it HMSCodec Type
-    resolution?: any; //TODO: make it HMSVideoResolution Type
-    maxBitrate?: number;
-    maxFrameRate?: number;
-    cameraFacing?: any; //TODO: make it HMSCameraFacing type
+    codec: HMSVideoCodec;
+    resolution: HMSVideoResolution;
+    maxBitrate: number;
+    maxFrameRate: number;
+    cameraFacing: HMSCameraFacing;
     trackDescription?: string;
     simulcastSettings?: HMSSimulcastLayerSettings[];
   }) {

package/src/index.ts

@@ -40,6 +40,12 @@ export * from './classes/HMSVideoViewMode';
 export * from './classes/HMSChangeTrackStateRequest';
 export * from './classes/HMSSpeaker';
 export * from './classes/HMSSpeakerUpdate';
+export * from './classes/HMSCameraFacing';
+export * from './classes/HMSException';
+export * from './classes/HMSRtmpStreamingState';
+export * from './classes/HMSServerRecordingState';
+export * from './classes/HMSBrowserRecordingState';
+export * from './classes/HMSRTMPConfig';
 
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
 export default HmsManager;