@100mslive/react-native-hms 1.4.0 → 1.6.0

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

@@ -1,7 +1,7 @@
 import React from 'react';
-import { ViewStyle } from 'react-native';
 import { HMSTrackType } from './HMSTrackType';
 import { HMSUpdateListenerActions } from './HMSUpdateListenerActions';
+import { HmsComponentProps } from './HmsView';
 import type { HMSConfig } from './HMSConfig';
 import type { HMSLocalPeer } from './HMSLocalPeer';
 import type { HMSRemotePeer } from './HMSRemotePeer';
@@ -10,7 +10,6 @@ import type { HMSRole } from './HMSRole';
 import type { HMSTrack } from './HMSTrack';
 import type { HMSLogger } from './HMSLogger';
 import type { HMSPeer } from './HMSPeer';
-import type { HMSVideoViewMode } from './HMSVideoViewMode';
 import type { HMSTrackSettings } from './HMSTrackSettings';
 import type { HMSRTMPConfig } from './HMSRTMPConfig';
 import type { HMSHLSConfig } from './HMSHLSConfig';
@@ -20,13 +19,7 @@ import type { HMSAudioMixingMode } from './HMSAudioMixingMode';
 import type { HMSLogSettings } from './HMSLogSettings';
 import { HMSMessageType } from './HMSMessageType';
 import { HMSPIPListenerActions } from './HMSPIPListenerActions';
-interface HmsViewProps {
-    trackId: string;
-    style?: ViewStyle;
-    mirror?: boolean;
-    scaleType?: HMSVideoViewMode;
-    setZOrderMediaOverlay?: boolean;
-}
+type HmsViewProps = Omit<HmsComponentProps, 'id'>;
 interface PIPConfig {
     aspectRatio?: [number, number];
     endButton?: boolean;
@@ -56,6 +49,7 @@ export declare class HMSSDK {
     private onRemoteAudioStatsDelegate?;
     private onRemoteVideoStatsDelegate?;
     private onAudioDeviceChangedDelegate?;
+    private onSessionStoreAvailableDelegate?;
     private onPIPRoomLeaveDelegate?;
     private emitterSubscriptions;
     private constructor();
@@ -133,6 +127,7 @@ export declare class HMSSDK {
      * - The appearance of tile is completely customizable with style prop.
      * - Scale type can determine how the incoming video will fit in the canvas check {@link HMSVideoViewMode} for more information.
      * - Mirror to flip the video vertically.
+     * - Auto Simulcast to automatically select the best Streaming Quality of track if feature is enabled in Room.
      *
      * checkout {@link https://www.100ms.live/docs/react-native/v2/features/render-video} for more info
      *
@@ -417,28 +412,6 @@ export declare class HMSSDK {
      * @memberof HMSSDK
      */
     stopScreenshare: () => Promise<any>;
-    /**
-     * - enableRTCStats sets a boolean in native side which in turn allows several events to be passed
-     * through the bridge these events are {@link RTCStatsListener}, {@link onRemoteVideoStatsListener},
-     * {@link onRemoteAudioStatsListener}, {@link onLocalAudioStatsListener} and {@link onLocalVideoStatsListener}
-     *
-     * - These listeners get various dataPoints for current peers and their connectivity to the room
-     * such as jitter, latency etc.
-     *
-     * - currently available for iOS only
-     *
-     * @memberof HMSSDK
-     */
-    enableRTCStats: () => void;
-    /**
-     * - disable RTCStats sets the same boolean to false that was set true by enableRTCStats.
-     * that activates a check which filters out the events acquired in native listeners and don't
-     * let them pass through bridge
-     *
-     * - currently available for iOS only.
-     * @memberof HMSSDK
-     */
-    disableRTCStats: () => void;
     enableNetworkQualityUpdates: () => void;
     disableNetworkQualityUpdates: () => void;
     /**
@@ -529,8 +502,22 @@ export declare class HMSSDK {
      * @memberof HMSSDK
      */
     setAudioDeviceChangeListener: (callback: Function) => any;
+    /**
+     * @deprecated Older SessionMetaData APIs has been deprecated in favour of newer Session Store APIs.
+     * You can subscribe to `ON_SESSION_STORE_AVAILABLE` event to get notified when the `HMSSessionStore`
+     * is available and use `set` method on `HMSSessionStore` instance
+     * checkout {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/}
+     */
     setSessionMetaData: (sessionMetaData: string | null) => Promise<any>;
+    /**
+     * @deprecated Older SessionMetaData APIs has been deprecated in favour of newer Session Store APIs.
+     * You can subscribe to `ON_SESSION_STORE_AVAILABLE` event to get notified when the `HMSSessionStore`
+     * is available and use `get` or `addKeyChangeListener` method on `HMSSessionStore` instance
+     * checkout {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/}
+     */
     getSessionMetaData: () => Promise<any>;
+    getRemoteVideoTrackFromTrackId: (trackId: string) => Promise<import("./HMSRemoteVideoTrack").HMSRemoteVideoTrack>;
+    getRemoteAudioTrackFromTrackId: (trackId: string) => Promise<import("./HMSRemoteAudioTrack").HMSRemoteAudioTrack>;
     /**
      * - This is a prototype event listener that takes action and listens for updates related to that particular action
      *
@@ -590,6 +577,9 @@ export declare class HMSSDK {
         device: string;
         audioDevicesList: string[];
     }) => void;
+    onSessionStoreAvailableListener: (data: {
+        id: string;
+    }) => void;
     onPIPRoomLeaveListener: (data: {
         id: string;
     }) => void;

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

@@ -0,0 +1,63 @@
+type Nullable<T> = T | null | undefined;
+export type HMSSessionStoreValue = Nullable<string>;
+/**
+ * Session store is a shared realtime key-value store that is accessible by everyone in the room.
+ * It can be utilized to implement features such as pinned text, spotlight (which brings a particular
+ * peer to the center stage for everyone in the room) and more.
+ *
+ * To get an instance of `HMSSessionStore` class, You can add an event listener for `ON_SESSION_STORE_AVAILABLE`
+ * event on the `HMSSDK` instance
+ *
+ * For example:
+ * ```
+ * hmsInstance.addEventListener(HMSUpdateListenerActions.ON_SESSION_STORE_AVAILABLE, <your callback function>);
+ * ```
+ *
+ * Checkout Session Store docs fore more details ${@link https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/room/session-store}
+ */
+export declare class HMSSessionStore {
+    private _deviceEventEmitterSubscription?;
+    private _eventEmitter?;
+    private _addedKeyChangeListenerCount;
+    /**
+     * This method sets a value for a specific key on session store.
+     * Once a value is assigned, it will be available for other peers in the room
+     * who are listening for changes in value for that specific key.
+     *
+     * @param {HMSSessionStoreValue} value
+     * @param {string} key
+     * @returns {Promise}
+     */
+    set(value: HMSSessionStoreValue, key: string): Promise<{
+        success: true;
+        finalValue: HMSSessionStoreValue;
+    }>;
+    /**
+     * This method returns the value of any specified key on session store.
+     * Note that you will not get updates for any change in value of the specified key,
+     * It returns the latest value at the time it was called.
+     *
+     * To listen to value change updates use `addKeyChangeListener` method instead.
+     *
+     * @param {string} key
+     * @returns {Promise}
+     */
+    get(key: string): Promise<HMSSessionStoreValue>;
+    /**
+     * This method registers a callback function for listening to value changes of a particular key.
+     * Registered Callback function will be called initially with latest value and whenever the value updates
+     *
+     * @param {string[]} forKeys
+     * @param {Function} callback
+     * @returns {Object} subscription object
+     */
+    addKeyChangeListener<T extends string[]>(forKeys: T, callback: (error: string | null, data: {
+        key: T[number];
+        value: HMSSessionStoreValue;
+    } | null) => void): {
+        remove: () => void;
+    };
+    private _cleanup;
+    private _deviceEventEmitterListener;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import type { HMSLayer } from './HMSLayer';
+import type { HMSVideoResolution } from './HMSVideoResolution';
+export declare class HMSSimulcastLayerDefinition {
+    layer: HMSLayer;
+    resolution: HMSVideoResolution;
+    constructor(params: {
+        layer: HMSLayer;
+        resolution: HMSVideoResolution;
+    });
+}

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

@@ -0,0 +1,12 @@
+export declare class HMSSimulcastLayerSettingsPolicy {
+    rid?: string;
+    scaleResolutionDownBy?: number;
+    maxBitrate?: number;
+    maxFramerate?: number;
+    constructor(params: {
+        rid?: string;
+        scaleResolutionDownBy?: number;
+        maxBitrate?: number;
+        maxFramerate?: number;
+    });
+}

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

@@ -1,5 +1,9 @@
+import type { HMSSimulcastSettingsPolicy } from './HMSSimulcastSettingsPolicy';
 export declare class HMSSimulcastSettings {
-    low: any;
-    med: any;
-    high: any;
+    video?: HMSSimulcastSettingsPolicy;
+    screen?: HMSSimulcastSettingsPolicy;
+    constructor(params: {
+        video?: HMSSimulcastSettingsPolicy;
+        screen?: HMSSimulcastSettingsPolicy;
+    });
 }

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

@@ -0,0 +1,7 @@
+import type { HMSSimulcastLayerSettingsPolicy } from './HMSSimulcastLayerSettingsPolicy';
+export declare class HMSSimulcastSettingsPolicy {
+    layers?: HMSSimulcastLayerSettingsPolicy[];
+    constructor(params: {
+        layers?: HMSSimulcastLayerSettingsPolicy[];
+    });
+}

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

@@ -0,0 +1,10 @@
+export declare class HMSSubscribeDegradationPolicy {
+    packetLossThreshold?: number;
+    degradeGracePeriodSeconds?: number;
+    recoverGracePeriodSeconds?: number;
+    constructor(params: {
+        packetLossThreshold?: number;
+        degradeGracePeriodSeconds?: number;
+        recoverGracePeriodSeconds?: number;
+    });
+}

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

@@ -1,8 +1,11 @@
+import type { HMSSubscribeDegradationPolicy } from './HMSSubscribeDegradationPolicy';
 export declare class HMSSubscribeSettings {
-    subscribeTo?: [string];
+    subscribeTo?: string[];
     maxSubsBitRate: number;
+    subscribeDegradation?: HMSSubscribeDegradationPolicy;
     constructor(params: {
-        subscribeTo?: [string];
+        subscribeTo?: string[];
         maxSubsBitRate: number;
+        subscribeDegradation?: HMSSubscribeDegradationPolicy;
     });
 }

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

@@ -1,3 +1,9 @@
+/**
+ * These are the available events emitted by the `HMSSDK`
+ *
+ * For more info about these events, checkout Event Listener docs
+ * {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/listen-to-room-updates/event-listeners}
+ */
 export declare enum HMSUpdateListenerActions {
     ON_PREVIEW = "ON_PREVIEW",
     ON_JOIN = "ON_JOIN",
@@ -17,5 +23,7 @@ export declare enum HMSUpdateListenerActions {
     ON_LOCAL_VIDEO_STATS = "ON_LOCAL_VIDEO_STATS",
     ON_REMOTE_AUDIO_STATS = "ON_REMOTE_AUDIO_STATS",
     ON_REMOTE_VIDEO_STATS = "ON_REMOTE_VIDEO_STATS",
-    ON_AUDIO_DEVICE_CHANGED = "ON_AUDIO_DEVICE_CHANGED"
+    ON_AUDIO_DEVICE_CHANGED = "ON_AUDIO_DEVICE_CHANGED",
+    ON_SESSION_STORE_AVAILABLE = "ON_SESSION_STORE_AVAILABLE",
+    ON_SESSION_STORE_CHANGED = "ON_SESSION_STORE_CHANGED"
 }

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

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

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

@@ -1,6 +1,11 @@
 import type { HMSSimulcastLayerSettings } from './HMSSimulcastLayerSettings';
 import type { HMSCameraFacing } from './HMSCameraFacing';
 import type { HMSTrackSettingsInitState } from './HMSTrackSettingsInitState';
+/**
+ * Customize local peer's Video track settings before Joining the Room.
+ *
+ * Checkout Track Settings docs for more details {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/track/track-settings}
+ */
 export declare class HMSVideoTrackSettings {
     readonly simulcastSettings?: HMSSimulcastLayerSettings[];
     initialState?: HMSTrackSettingsInitState;

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

@@ -1,13 +1,13 @@
 import React from 'react';
 import { ViewStyle } from 'react-native';
 import { HMSVideoViewMode } from './HMSVideoViewMode';
-interface HmsComponentProps {
+export interface HmsComponentProps {
     trackId: string;
     style?: ViewStyle;
     mirror?: boolean;
+    autoSimulcast?: boolean;
     scaleType?: HMSVideoViewMode;
     setZOrderMediaOverlay?: boolean;
     id: string;
 }
 export declare const HmsViewComponent: React.ForwardRefExoticComponent<HmsComponentProps & React.RefAttributes<any>>;
-export {};

package/lib/typescript/index.d.ts

@@ -75,6 +75,13 @@ export * from './classes/HMSLogSettings';
 export * from './classes/HMSLogAlarmManager';
 export * from './classes/HMSMessageType';
 export * from './classes/HMSPIPListenerActions';
+export * from './classes/HMSLayer';
+export * from './classes/HMSSimulcastLayerDefinition';
+export * from './classes/HMSQualityLimitationReasons';
+export * from './classes/HMSQualityLimitationReason';
+export * from './classes/HMSCameraControl';
+export * from './classes/HMSIOSAudioMode';
+export type { HMSSessionStore, HMSSessionStoreValue, } from './classes/HMSSessionStore';
 export type { HmsViewComponent as HMSView } from './classes/HmsView';
 import { HMSSDK as HmsManager } from './classes/HMSSDK';
 export default HmsManager;

package/lib/typescript/utils/emitter/EventEmitter.d.ts

@@ -0,0 +1,91 @@
+import { EmitterSubscription } from './_EmitterSubscription';
+import { EventSubscriptionVendor } from './_EventSubscriptionVendor';
+export { EmitterSubscription } from './_EmitterSubscription';
+/**
+ * @class EventEmitter
+ * @description
+ * An EventEmitter is responsible for managing a set of listeners and publishing
+ * events to them when it is told that such events happened. In addition to the
+ * data for the given event it also sends a event control object which allows
+ * the listeners/handlers to prevent the default behavior of the given event.
+ *
+ * The emitter is designed to be generic enough to support all the different
+ * contexts in which one might want to emit events. It is a simple multicast
+ * mechanism on top of which extra functionality can be composed. For example, a
+ * more advanced emitter may use an EventHolder and EventFactory.
+ */
+export declare class EventEmitter {
+    _subscriber: EventSubscriptionVendor;
+    /**
+     * @constructor
+     *
+     * @param {EventSubscriptionVendor} subscriber - Optional subscriber instance
+     *   to use. If omitted, a new subscriber will be created for the emitter.
+     */
+    constructor(subscriber?: EventSubscriptionVendor | null);
+    /**
+     * Adds a listener to be invoked when events of the specified type are
+     * emitted. An optional calling context may be provided. The data arguments
+     * emitted will be passed to the listener function.
+     *
+     * TODO: Annotate the listener arg's type. This is tricky because listeners
+     *       can be invoked with varargs.
+     *
+     * @param {string} eventType - Name of the event to listen to
+     * @param {function} listener - Function to invoke when the specified event is
+     *   emitted
+     * @param {*} context - Optional context object to use when invoking the
+     *   listener
+     */
+    addListener(eventType: string, listener: Function, context: Object | null | undefined): EmitterSubscription;
+    /**
+     * Removes all of the registered listeners, including those registered as
+     * listener maps.
+     *
+     * @param {?string} eventType - Optional name of the event whose registered
+     *   listeners to remove
+     */
+    removeAllListeners(eventType: string | undefined | null): void;
+    /**
+     * Removes a specific subscription. Called by the `remove()` method of the
+     * subscription itself to ensure any necessary cleanup is performed.
+     */
+    removeSubscription(subscription: EmitterSubscription): void;
+    /**
+     * Returns the number of listeners that are currently registered for the given
+     * event.
+     *
+     * @param {string} eventType - Name of the event to query
+     * @returns {number}
+     */
+    listenerCount(eventType: string): number;
+    /**
+     * Emits an event of the given type with the given data. All handlers of that
+     * particular type will be notified.
+     *
+     * @param {string} eventType - Name of the event to emit
+     * @param {...*} Arbitrary arguments to be passed to each registered listener
+     *
+     * @example
+     *   emitter.addListener('someEvent', function(message) {
+     *     console.log(message);
+     *   });
+     *
+     *   emitter.emit('someEvent', 'abc'); // logs 'abc'
+     */
+    emit(eventType: string, ...args: any[]): void;
+    /**
+     * Removes the given listener for event of specific type.
+     *
+     * @param {string} eventType - Name of the event to emit
+     * @param {function} listener - Function to invoke when the specified event is
+     *   emitted
+     *
+     * @example
+     *   emitter.removeListener('someEvent', function(message) {
+     *     console.log(message);
+     *   }); // removes the listener if already registered
+     *
+     */
+    removeListener(eventType: string, listener: Function): void;
+}

package/lib/typescript/utils/emitter/_EmitterSubscription.d.ts

@@ -0,0 +1,29 @@
+import { EventSubscription } from './_EventSubscription';
+import type { EventEmitter } from './EventEmitter';
+import type { EventSubscriptionVendor } from './_EventSubscriptionVendor';
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+export declare class EmitterSubscription extends EventSubscription {
+    emitter: EventEmitter;
+    listener: Function;
+    context: Object | null | undefined;
+    /**
+     * @param {EventEmitter} emitter - The event emitter that registered this
+     *   subscription
+     * @param {EventSubscriptionVendor} subscriber - The subscriber that controls
+     *   this subscription
+     * @param {function} listener - Function to invoke when the specified event is
+     *   emitted
+     * @param {*} context - Optional context object to use when invoking the
+     *   listener
+     */
+    constructor(emitter: EventEmitter, subscriber: EventSubscriptionVendor, listener: Function, context: Object | undefined | null);
+    /**
+     * Removes this subscription from the emitter that registered it.
+     * Note: we're overriding the `remove()` method of EventSubscription here
+     * but deliberately not calling `super.remove()` as the responsibility
+     * for removing the subscription lies with the EventEmitter.
+     */
+    remove(): void;
+}

package/lib/typescript/utils/emitter/_EventSubscription.d.ts

@@ -0,0 +1,19 @@
+import type { EventSubscriptionVendor } from './_EventSubscriptionVendor';
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+export declare class EventSubscription {
+    eventType: string;
+    key: number;
+    subscriber: EventSubscriptionVendor;
+    /**
+     * @param {EventSubscriptionVendor} subscriber the subscriber that controls
+     *   this subscription.
+     */
+    constructor(subscriber: EventSubscriptionVendor);
+    /**
+     * Removes this subscription from the subscriber that controls it.
+     */
+    remove(): void;
+}

package/lib/typescript/utils/emitter/_EventSubscriptionVendor.d.ts

@@ -0,0 +1,44 @@
+import type { EventSubscription } from './_EventSubscription';
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+export declare class EventSubscriptionVendor {
+    _subscriptionsForType: Record<string, EventSubscription[] | null | undefined>;
+    _currentSubscription: EventSubscription | null | undefined;
+    constructor();
+    /**
+     * Adds a subscription keyed by an event type.
+     *
+     * @param {string} eventType
+     * @param {EventSubscription} subscription
+     */
+    addSubscription(eventType: string, subscription: EventSubscription): EventSubscription;
+    /**
+     * Removes a bulk set of the subscriptions.
+     *
+     * @param {?string} eventType - Optional name of the event type whose
+     *   registered supscriptions to remove, if null or undefined remove all subscriptions.
+     */
+    removeAllSubscriptions(eventType: string | undefined | null): void;
+    /**
+     * Removes a specific subscription. Instead of calling this function, call
+     * `subscription.remove()` directly.
+     *
+     * @param {object} subscription
+     */
+    removeSubscription(subscription: EventSubscription): void;
+    /**
+     * Returns the array of subscriptions that are currently registered for the
+     * given event type.
+     *
+     * Note: This array can be potentially sparse as subscriptions are deleted
+     * from it when they are removed.
+     *
+     * TODO: This returns a nullable array. wat?
+     *
+     * @param {string} eventType
+     * @returns {?array}
+     */
+    getSubscriptionsForType(eventType: string): EventSubscription[] | null | undefined;
+}

package/lib/typescript/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './emitter/EventEmitter';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100mslive/react-native-hms",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Integrate Real Time Audio and Video conferencing, Interactive Live Streaming, and Chat in your apps with 100ms React Native SDK. With support for HLS and RTMP Live Streaming and Recording, Picture-in-Picture (PiP), one-to-one Video Call Modes, Audio Rooms, Video Player and much more, add immersive real-time communications to your apps.",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -68,7 +68,26 @@
     "ios",
     "android",
     "web",
-    "interactive"
+    "interactive",
+    "hls",
+    "rtmp",
+    "pip",
+    "voip",
+    "player",
+    "webrtc",
+    "stream",
+    "communication",
+    "conference",
+    "whiteboard",
+    "session",
+    "polls",
+    "quiz",
+    "call",
+    "callkit",
+    "connection",
+    "service",
+    "telecom",
+    "reaction"
   ],
   "repository": "https://github.com/100mslive/100ms-react-native",
   "author": "Yogesh <yogesh@100ms.live> (https://www.100ms.live/)",

package/sdk-versions.json

@@ -1,5 +1,5 @@
 {
-  "ios": "0.9.1",
-  "iOSBroadcastExtension": "0.0.8",
-  "android": "2.6.0"
+  "ios": "0.9.3",
+  "iOSBroadcastExtension": "0.0.9",
+  "android": "2.6.2"
 }

package/src/classes/HMSAudioTrackSettings.ts

@@ -1,17 +1,33 @@
+import type { HMSIOSAudioMode } from './HMSIOSAudioMode';
 import type { HMSTrackSettingsInitState } from './HMSTrackSettingsInitState';
 
+/**
+ * Customize local peer's Audio track settings before Joining the Room.
+ *
+ * Checkout Track Settings docs for more details {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/interact-with-room/track/track-settings}
+ */
 export class HMSAudioTrackSettings {
   initialState?: HMSTrackSettingsInitState;
   useHardwareEchoCancellation?: boolean; // android only
   audioSource?: string[]; // ios only
 
+  /**
+   * [iOS only] `audioMode` allows you to capture audio in its highest quality
+   * by disabling voice processing and increasing the maximum bandwidth limit
+   *
+   * Checkout Music Mode docs for more details {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/configure-your-device/microphone/music-mode}
+   */
+  audioMode?: HMSIOSAudioMode; // ios only
+
   constructor(params: {
     initialState?: HMSTrackSettingsInitState;
     useHardwareEchoCancellation?: boolean;
     audioSource?: string[];
+    audioMode?: HMSIOSAudioMode;
   }) {
     this.useHardwareEchoCancellation = params.useHardwareEchoCancellation;
     this.initialState = params.initialState;
     this.audioSource = params.audioSource;
+    this.audioMode = params.audioMode;
   }
 }

package/src/classes/HMSCameraControl.ts

@@ -0,0 +1,21 @@
+import { NativeModules } from 'react-native';
+import { HMSConstants } from './HMSConstants';
+
+const { HMSManager } = NativeModules;
+
+export class HMSCameraControl {
+  /**
+   * It captures the image from the device camera at max possible resolution.
+   *
+   * @param {boolean} [flash=false] flash - value indicating whether to use flash while capturing image or not
+   * @returns Promise - which is resolved with the file path of the captured image saved on the disk
+   */
+  static captureImageAtMaxSupportedResolution(
+    flash: boolean = false
+  ): Promise<string> {
+    return HMSManager.captureImageAtMaxSupportedResolution({
+      id: HMSConstants.DEFAULT_SDK_ID,
+      flash,
+    });
+  }
+}