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

package/src/classes/{HMSSDK.ts → HMSSDK.tsx}

@@ -1,4 +1,5 @@
-import { NativeEventEmitter, NativeModules } from 'react-native';
+import React from 'react';
+import { NativeEventEmitter, NativeModules, ViewStyle } from 'react-native';
 import { HMSUpdateListenerActions } from './HMSUpdateListenerActions';
 import type { HMSConfig } from './HMSConfig';
 import type { HMSLocalPeer } from './HMSLocalPeer';
@@ -9,7 +10,22 @@ import { HMSEncoder } from './HMSEncoder';
 import { HMSMessage } from './HMSMessage';
 import { HMSHelper } from './HMSHelper';
 import type { HMSTrack } from './HMSTrack';
+import type { HMSTrackType } from './HMSTrackType';
 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;
+  sink: boolean;
+  style: ViewStyle;
+  mirror?: boolean;
+  scaleType: HMSVideoViewMode;
+  id?: string | null;
+}
 
 const {
   /**
@@ -28,6 +44,8 @@ export class HMSSDK {
   remotePeers?: HMSRemotePeer[];
   knownRoles?: HMSRole[];
   logger?: HMSLogger;
+  id: string;
+  private muteStatus: boolean | undefined;
 
   onPreviewDelegate?: any;
   onJoinDelegate?: any;
@@ -43,6 +61,10 @@ export class HMSSDK {
   onChangeTrackStateRequestDelegate?: any;
   onRemovedFromRoomDelegate?: any;
 
+  constructor(id: string) {
+    this.id = id;
+  }
+
   /**
    * - Returns an instance of [HMSSDK]{@link HMSSDK}
    * - This function must be called to get an instance of HMSSDK class and only then user can interact with its methods
@@ -51,15 +73,18 @@ export class HMSSDK {
    * @returns
    * @memberof HMSSDK
    */
-  static build() {
-    if (HmsSdk) {
-      return HmsSdk;
-    }
-    HmsManager.build();
-    HmsSdk = new HMSSDK();
+  static async build(params?: { trackSettings?: HMSTrackSettings }) {
+    let id = await HmsManager.build(params?.trackSettings || {});
+    HmsSdk = new HMSSDK(id);
+    HmsSdk.attachPreviewListener();
+    HmsSdk.attachListeners();
     return HmsSdk;
   }
 
+  destroy = () => {
+    this.removeListeners();
+  };
+
   attachPreviewListener = () => {
     HmsEventEmitter.addListener(
       HMSUpdateListenerActions.ON_PREVIEW,
@@ -129,6 +154,68 @@ export class HMSSDK {
     );
   };
 
+  removeListeners = () => {
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_JOIN,
+      this.onJoinListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_ROOM_UPDATE,
+      this.onRoomListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_PEER_UPDATE,
+      this.onPeerListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_TRACK_UPDATE,
+      this.onTrackListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_ERROR,
+      this.onErrorListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_MESSAGE,
+      this.onMessageListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_SPEAKER,
+      this.onSpeakerListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.RECONNECTING,
+      this.reconnectingListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.RECONNECTED,
+      this.reconnectedListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_ROLE_CHANGE_REQUEST,
+      this.onRoleChangeRequestListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_CHANGE_TRACK_STATE_REQUEST,
+      this.onChangeTrackStateRequestListener
+    );
+
+    HmsEventEmitter.removeListener(
+      HMSUpdateListenerActions.ON_REMOVED_FROM_ROOM,
+      this.onRemovedFromRoomListener
+    );
+  };
+
   /**
    * takes an instance of [HMSConfig]{@link HMSConfig} and joins the room
    * after joining the room user will start receiving the events and updates of the room
@@ -138,14 +225,31 @@ export class HMSSDK {
    */
   join = async (config: HMSConfig) => {
     this.logger?.verbose('JOIN', { config });
-    this.attachListeners();
-    await HmsManager.join(config);
+    await HmsManager.join({ ...config, id: this.id });
   };
 
   preview = (config: HMSConfig) => {
     this.logger?.verbose('PREVIEW', { config });
-    this.attachPreviewListener();
-    HmsManager.preview(config);
+    HmsManager.preview({ ...config, id: this.id });
+  };
+
+  HmsView = ({
+    sink,
+    trackId,
+    style,
+    mirror,
+    scaleType = HMSVideoViewMode.ASPECT_FIT,
+  }: HmsComponentProps) => {
+    return (
+      <HMSViewComponent
+        sink={sink}
+        trackId={trackId}
+        style={style}
+        mirror={mirror}
+        scaleType={scaleType}
+        id={this.id}
+      />
+    );
   };
 
   /**
@@ -153,37 +257,73 @@ export class HMSSDK {
    *
    * @memberof HMSSDK
    */
-  leave = () => {
+  leave = async () => {
     this.logger?.verbose('LEAVE', {});
-    HmsManager.leave();
+    const data = {
+      id: this.id,
+    };
+
+    await HmsManager.leave(data);
+    this.muteStatus = undefined;
+    this.localPeer = undefined;
+    this.remotePeers = undefined;
+    this.room = undefined;
+    this.knownRoles = undefined;
   };
 
-  sendBroadcastMessage = (message: string) => {
+  sendBroadcastMessage = (message: string, type?: string) => {
     this.logger?.verbose('SEND_BROADCAST_MESSAGE', { message });
-    HmsManager.sendBroadcastMessage({ message });
+    HmsManager.sendBroadcastMessage({
+      message,
+      type: type || null,
+      id: this.id,
+    });
   };
 
-  sendGroupMessage = (message: string, roles: HMSRole[]) => {
+  sendGroupMessage = (message: string, roles: HMSRole[], type?: string) => {
     this.logger?.verbose('SEND_GROUP_MESSAGE', { message, roles });
     HmsManager.sendGroupMessage({
       message,
       roles: HMSHelper.getRoleNames(roles),
+      id: this.id,
+      type: type || null,
     });
   };
 
-  sendDirectMessage = (message: string, peerId: string) => {
+  sendDirectMessage = (message: string, peerId: string, type?: string) => {
     this.logger?.verbose('SEND_DIRECT_MESSAGE', { message, peerId });
     HmsManager.sendDirectMessage({
       message,
       peerId,
+      id: this.id,
+      type: type || null,
     });
   };
 
-  changeRole = (peerId: string, role: string, force: boolean = false) => {
+  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: peerId,
-      role: role,
+      peerId: peer?.peerID,
+      role: role?.name,
       force: force,
+      id: this.id,
     };
     this.logger?.verbose('CHANGE_ROLE', data);
     HmsManager.changeRole(data);
@@ -194,16 +334,41 @@ export class HMSSDK {
     const data = {
       trackId: track.trackId,
       mute,
+      id: this.id,
     };
 
     HmsManager.changeTrackState(data);
   };
 
+  changeTrackStateRoles = (
+    type: HMSTrackType,
+    mute: boolean,
+    source: string,
+    roles: Array<HMSRole>
+  ) => {
+    this.logger?.verbose('CHANGE_TRACK_STATE_ROLES', {
+      source,
+      mute,
+      type,
+      roles,
+    });
+    const data = {
+      source,
+      mute,
+      type,
+      roles: HMSHelper.getRoleNames(roles),
+      id: this.id,
+    };
+
+    HmsManager.changeTrackStateRoles(data);
+  };
+
   removePeer = (peerId: string, reason: string) => {
     this.logger?.verbose('REMOVE_PEER', { peerId, reason });
     const data = {
       peerId,
       reason,
+      id: this.id,
     };
 
     HmsManager.removePeer(data);
@@ -214,6 +379,7 @@ export class HMSSDK {
     const data = {
       lock,
       reason,
+      id: this.id,
     };
 
     HmsManager.endRoom(data);
@@ -221,12 +387,31 @@ export class HMSSDK {
 
   acceptRoleChange = () => {
     this.logger?.verbose('ACCEPT_ROLE_CHANGE', {});
-    HmsManager.acceptRoleChange();
+    HmsManager.acceptRoleChange({ id: this.id });
   };
 
   muteAllPeersAudio = (mute: boolean) => {
     this.logger?.verbose('ON_MUTE_ALL_PEERS', { mute });
-    HmsManager.muteAllPeersAudio(mute);
+    this.muteStatus = mute;
+    HmsManager.muteAllPeersAudio({ mute, id: this.id });
+  };
+
+  getRoom = async () => {
+    this.logger?.verbose('GET_ROOM_API_CALL', { roomID: this.id });
+    const hmsRoom = await HmsManager.getRoom({ id: this.id });
+
+    const encodedHmsRoom = HMSEncoder.encodeHmsRoom(hmsRoom, this.id);
+    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;
   };
 
   /**
@@ -366,10 +551,14 @@ export class HMSSDK {
   };
 
   onPreviewListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_PREVIEW', data);
-    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
 
     const previewTracks = HMSEncoder.encodeHmsPreviewTracks(data.previewTracks);
@@ -388,14 +577,19 @@ export class HMSSDK {
   };
 
   onJoinListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_JOIN', data);
     // Preprocessing
-    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
     const roles: HMSRole[] = HMSEncoder.encodeHmsRoles(data.roles);
     this.room = room;
@@ -414,13 +608,18 @@ export class HMSSDK {
   };
 
   onRoomListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_ROOM', data);
-    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
     this.room = room;
     this.localPeer = localPeer;
@@ -437,41 +636,59 @@ export class HMSSDK {
   };
 
   onPeerListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_PEER', data);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
     // this.room = room;
     this.localPeer = localPeer;
     this.remotePeers = remotePeers;
+    this.room = room;
     if (this.onPeerDelegate) {
       this.logger?.verbose('ON_PEER_LISTENER_CALL', data);
-      this.onPeerDelegate({ ...data, localPeer, remotePeers });
+      this.onPeerDelegate({ ...data, localPeer, remotePeers, room });
     }
   };
 
   onTrackListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_TRACK', data);
-    // const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room);
+    const room: HMSRoom = HMSEncoder.encodeHmsRoom(data.room, this.id);
     const localPeer: HMSLocalPeer = HMSEncoder.encodeHmsLocalPeer(
-      data.localPeer
+      data.localPeer,
+      this.id
     );
     const remotePeers: HMSRemotePeer[] = HMSEncoder.encodeHmsRemotePeers(
-      data.remotePeers
+      data.remotePeers,
+      this.id
     );
-    // this.room = room;
+    if (this.muteStatus && data?.type === 'TRACK_ADDED') {
+      this.muteAllPeersAudio(this.muteStatus);
+    }
+    this.room = room;
     this.localPeer = localPeer;
     this.remotePeers = remotePeers;
     if (this.onTrackDelegate) {
       this.logger?.verbose('ON_TRACK_LISTENER_CALL', data);
-      this.onTrackDelegate({ ...data, localPeer, remotePeers });
+      this.onTrackDelegate({ ...data, localPeer, remotePeers, room });
     }
   };
 
   onMessageListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_MESSAGE', data);
     const message = new HMSMessage(data);
     if (this.onMessageDelegate) {
@@ -481,6 +698,9 @@ export class HMSSDK {
   };
 
   onSpeakerListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_SPEAKER', data);
     if (this.onSpeakerDelegate) {
       this.onSpeakerDelegate(data);
@@ -488,18 +708,28 @@ export class HMSSDK {
   };
 
   onErrorListener = (data: any) => {
+    if (data.id !== this.id) {
+      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);
     }
   };
 
   onRoleChangeRequestListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_ROLE_CHANGE_REQUEST', data);
     if (this.onRoleChangeRequestDelegate) {
-      const encodedRoleChangeRequest =
-        HMSEncoder.encodeHmsRoleChangeRequest(data);
+      const encodedRoleChangeRequest = HMSEncoder.encodeHmsRoleChangeRequest(
+        data,
+        this.id
+      );
       this.logger?.verbose(
         'ON_ROLE_CHANGE_LISTENER_CALL',
         encodedRoleChangeRequest
@@ -512,7 +742,7 @@ export class HMSSDK {
     this.logger?.verbose('ON_CHANGE_TRACK_STATE_REQUEST', data);
     if (this.onChangeTrackStateRequestDelegate) {
       const encodedRoleChangeRequest =
-        HMSEncoder.encodeHmsChangeTrackStateRequest(data);
+        HMSEncoder.encodeHmsChangeTrackStateRequest(data, this.id);
       this.logger?.verbose(
         'ON_CHANGE_TRACK_STATE_REQUEST_LISTENER_CALL',
         encodedRoleChangeRequest
@@ -522,9 +752,15 @@ export class HMSSDK {
   };
 
   onRemovedFromRoomListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_REMOVED_FROM_ROOM', data);
     if (this.onRemovedFromRoomDelegate) {
-      const requestedBy = HMSEncoder.encodeHmsPeer(data.requestedBy);
+      let requestedBy = null;
+      if (data.requestedBy) {
+        requestedBy = HMSEncoder.encodeHmsPeer(data.requestedBy, this.id);
+      }
       const reason = data.reason;
       const roomEnded = data.roomEnded;
 
@@ -538,6 +774,9 @@ export class HMSSDK {
   };
 
   reconnectingListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_RECONNECTING', data);
     if (this.onReconnectingDelegate) {
       this.onReconnectingDelegate(data);
@@ -545,6 +784,9 @@ export class HMSSDK {
   };
 
   reconnectedListener = (data: any) => {
+    if (data.id !== this.id) {
+      return;
+    }
     this.logger?.verbose('ON_RECONNECTED', data);
     if (this.onReconnectedDelegate) {
       this.onReconnectedDelegate(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,25 +1,15 @@
-import { NativeModules } from 'react-native';
-
-const {
-  /**
-   * @ignore
-   */
-  HmsManager,
-} = NativeModules;
+import type { HMSTrackType } from './HMSTrackType';
 
 export class HMSTrack {
   trackId: string;
   source?: number | string;
   trackDescription?: string;
   mute?: boolean;
+  id: string;
+  type?: HMSTrackType;
 
-  isMute = async () => {
-    try {
-      let val = await HmsManager.isMute({ trackId: this.trackId });
-      return val;
-    } catch (e) {
-      return true;
-    }
+  isMute = () => {
+    return this.mute;
   };
 
   constructor(params: {
@@ -27,10 +17,14 @@ export class HMSTrack {
     source?: number | string;
     trackDescription?: string;
     isMute?: boolean;
+    id: string;
+    type?: HMSTrackType;
   }) {
     this.trackId = params.trackId;
     this.source = params.source;
     this.trackDescription = params.trackDescription;
     this.mute = params.isMute;
+    this.id = params.id;
+    this.type = params.type;
   }
 }

package/src/classes/HMSTrackType.ts

@@ -0,0 +1,4 @@
+export enum HMSTrackType {
+  AUDIO = 'AUDIO',
+  VIDEO = 'VIDEO',
+}

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

@@ -1,7 +1,8 @@
 import { HMSTrack } from './HMSTrack';
+import type { HMSTrackType } from './HMSTrackType';
 
 export class HMSVideoTrack extends HMSTrack {
-  isDegraded?: Function;
+  isDegraded?: boolean;
   addSink?: Function;
   removeSink?: Function;
 
@@ -10,7 +11,11 @@ export class HMSVideoTrack extends HMSTrack {
     source?: number | string;
     trackDescription?: string;
     isMute?: boolean;
+    id: string;
+    isDegraded?: boolean;
+    type?: HMSTrackType;
   }) {
     super(params);
+    this.isDegraded = params.isDegraded;
   }
 }