@100mslive/react-native-hms 1.5.0 → 1.6.1

package/lib/module/utils/emitter/_EmitterSubscription.js

@@ -0,0 +1,39 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { EventSubscription } from './_EventSubscription';
+/**
+ * EmitterSubscription represents a subscription with listener and context data.
+ */
+export class EmitterSubscription extends EventSubscription {
+  /**
+   * @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, subscriber, listener, context) {
+    super(subscriber);
+    _defineProperty(this, "emitter", void 0);
+    _defineProperty(this, "listener", void 0);
+    _defineProperty(this, "context", void 0);
+    this.emitter = emitter;
+    this.listener = listener;
+    this.context = context;
+  }
+
+  /**
+   * 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() {
+    this.emitter.removeSubscription(this);
+  }
+}
+//# sourceMappingURL=_EmitterSubscription.js.map

package/lib/module/utils/emitter/_EmitterSubscription.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventSubscription","EmitterSubscription","constructor","emitter","subscriber","listener","context","_defineProperty","remove","removeSubscription"],"sources":["_EmitterSubscription.ts"],"sourcesContent":["import { EventSubscription } from './_EventSubscription';\nimport type { EventEmitter } from './EventEmitter';\nimport type { EventSubscriptionVendor } from './_EventSubscriptionVendor';\n\n/**\n * EmitterSubscription represents a subscription with listener and context data.\n */\nexport class EmitterSubscription extends EventSubscription {\n  emitter: EventEmitter;\n  listener: Function;\n  context: Object | null | undefined;\n\n  /**\n   * @param {EventEmitter} emitter - The event emitter that registered this\n   *   subscription\n   * @param {EventSubscriptionVendor} subscriber - The subscriber that controls\n   *   this subscription\n   * @param {function} listener - Function to invoke when the specified event is\n   *   emitted\n   * @param {*} context - Optional context object to use when invoking the\n   *   listener\n   */\n  constructor(\n    emitter: EventEmitter,\n    subscriber: EventSubscriptionVendor,\n    listener: Function,\n    context: Object | undefined | null\n  ) {\n    super(subscriber);\n    this.emitter = emitter;\n    this.listener = listener;\n    this.context = context;\n  }\n\n  /**\n   * Removes this subscription from the emitter that registered it.\n   * Note: we're overriding the `remove()` method of EventSubscription here\n   * but deliberately not calling `super.remove()` as the responsibility\n   * for removing the subscription lies with the EventEmitter.\n   */\n  remove() {\n    this.emitter.removeSubscription(this);\n  }\n}\n"],"mappings":";;;AAAA,SAASA,iBAAiB,QAAQ,sBAAsB;AAIxD;AACA;AACA;AACA,OAAO,MAAMC,mBAAmB,SAASD,iBAAiB,CAAC;EAKzD;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEE,WAAWA,CACTC,OAAqB,EACrBC,UAAmC,EACnCC,QAAkB,EAClBC,OAAkC,EAClC;IACA,KAAK,CAACF,UAAU,CAAC;IAACG,eAAA;IAAAA,eAAA;IAAAA,eAAA;IAClB,IAAI,CAACJ,OAAO,GAAGA,OAAO;IACtB,IAAI,CAACE,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACC,OAAO,GAAGA,OAAO;EACxB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEE,MAAMA,CAAA,EAAG;IACP,IAAI,CAACL,OAAO,CAACM,kBAAkB,CAAC,IAAI,CAAC;EACvC;AACF"}

package/lib/module/utils/emitter/_EventSubscription.js

@@ -0,0 +1,29 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * EventSubscription represents a subscription to a particular event. It can
+ * remove its own subscription.
+ */
+export class EventSubscription {
+  /**
+   * @param {EventSubscriptionVendor} subscriber the subscriber that controls
+   *   this subscription.
+   */
+  constructor(subscriber) {
+    // @ts-ignore this value is assigned after creating instance of class
+    _defineProperty(this, "eventType", void 0);
+    // @ts-ignore this value is assigned after creating instance of class
+    _defineProperty(this, "key", void 0);
+    _defineProperty(this, "subscriber", void 0);
+    this.subscriber = subscriber;
+  }
+
+  /**
+   * Removes this subscription from the subscriber that controls it.
+   */
+  remove() {
+    this.subscriber.removeSubscription(this);
+  }
+}
+//# sourceMappingURL=_EventSubscription.js.map

package/lib/module/utils/emitter/_EventSubscription.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventSubscription","constructor","subscriber","_defineProperty","remove","removeSubscription"],"sources":["_EventSubscription.ts"],"sourcesContent":["import type { EventSubscriptionVendor } from './_EventSubscriptionVendor';\n\n/**\n * EventSubscription represents a subscription to a particular event. It can\n * remove its own subscription.\n */\nexport class EventSubscription {\n  // @ts-ignore this value is assigned after creating instance of class\n  eventType: string;\n  // @ts-ignore this value is assigned after creating instance of class\n  key: number;\n  subscriber: EventSubscriptionVendor;\n\n  /**\n   * @param {EventSubscriptionVendor} subscriber the subscriber that controls\n   *   this subscription.\n   */\n  constructor(subscriber: EventSubscriptionVendor) {\n    this.subscriber = subscriber;\n  }\n\n  /**\n   * Removes this subscription from the subscriber that controls it.\n   */\n  remove() {\n    this.subscriber.removeSubscription(this);\n  }\n}\n"],"mappings":";;;AAEA;AACA;AACA;AACA;AACA,OAAO,MAAMA,iBAAiB,CAAC;EAO7B;AACF;AACA;AACA;EACEC,WAAWA,CAACC,UAAmC,EAAE;IAVjD;IAAAC,eAAA;IAEA;IAAAA,eAAA;IAAAA,eAAA;IASE,IAAI,CAACD,UAAU,GAAGA,UAAU;EAC9B;;EAEA;AACF;AACA;EACEE,MAAMA,CAAA,EAAG;IACP,IAAI,CAACF,UAAU,CAACG,kBAAkB,CAAC,IAAI,CAAC;EAC1C;AACF"}

package/lib/module/utils/emitter/_EventSubscriptionVendor.js

@@ -0,0 +1,83 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * EventSubscriptionVendor stores a set of EventSubscriptions that are
+ * subscribed to a particular event type.
+ */
+export class EventSubscriptionVendor {
+  constructor() {
+    _defineProperty(this, "_subscriptionsForType", void 0);
+    _defineProperty(this, "_currentSubscription", void 0);
+    this._subscriptionsForType = {};
+    this._currentSubscription = null;
+  }
+
+  /**
+   * Adds a subscription keyed by an event type.
+   *
+   * @param {string} eventType
+   * @param {EventSubscription} subscription
+   */
+  addSubscription(eventType, subscription) {
+    if (subscription.subscriber !== this) {
+      console.warn('The subscriber of the subscription is incorrectly set.'); // TODO: throw error or use logger?
+    }
+
+    if (!this._subscriptionsForType[eventType]) {
+      this._subscriptionsForType[eventType] = [];
+    }
+    const eventSubscriptions = this._subscriptionsForType[eventType];
+    const key = eventSubscriptions.length;
+    eventSubscriptions.push(subscription);
+    subscription.eventType = eventType;
+    subscription.key = key;
+    return subscription;
+  }
+
+  /**
+   * 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) {
+    if (eventType === undefined || eventType === null) {
+      this._subscriptionsForType = {};
+    } else {
+      delete this._subscriptionsForType[eventType];
+    }
+  }
+
+  /**
+   * Removes a specific subscription. Instead of calling this function, call
+   * `subscription.remove()` directly.
+   *
+   * @param {object} subscription
+   */
+  removeSubscription(subscription) {
+    const eventType = subscription.eventType;
+    const key = subscription.key;
+    const subscriptionsForType = this._subscriptionsForType[eventType];
+    if (subscriptionsForType) {
+      delete subscriptionsForType[key];
+    }
+  }
+
+  /**
+   * 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) {
+    return this._subscriptionsForType[eventType];
+  }
+}
+//# sourceMappingURL=_EventSubscriptionVendor.js.map

package/lib/module/utils/emitter/_EventSubscriptionVendor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["EventSubscriptionVendor","constructor","_defineProperty","_subscriptionsForType","_currentSubscription","addSubscription","eventType","subscription","subscriber","console","warn","eventSubscriptions","key","length","push","removeAllSubscriptions","undefined","removeSubscription","subscriptionsForType","getSubscriptionsForType"],"sources":["_EventSubscriptionVendor.ts"],"sourcesContent":["import type { EventSubscription } from './_EventSubscription';\n\n/**\n * EventSubscriptionVendor stores a set of EventSubscriptions that are\n * subscribed to a particular event type.\n */\nexport class EventSubscriptionVendor {\n  _subscriptionsForType: Record<string, EventSubscription[] | null | undefined>;\n  _currentSubscription: EventSubscription | null | undefined;\n\n  constructor() {\n    this._subscriptionsForType = {};\n    this._currentSubscription = null;\n  }\n\n  /**\n   * Adds a subscription keyed by an event type.\n   *\n   * @param {string} eventType\n   * @param {EventSubscription} subscription\n   */\n  addSubscription(\n    eventType: string,\n    subscription: EventSubscription\n  ): EventSubscription {\n    if (subscription.subscriber !== this) {\n      console.warn('The subscriber of the subscription is incorrectly set.'); // TODO: throw error or use logger?\n    }\n    if (!this._subscriptionsForType[eventType]) {\n      this._subscriptionsForType[eventType] = [];\n    }\n    const eventSubscriptions = this._subscriptionsForType[\n      eventType\n    ] as EventSubscription[];\n    const key = eventSubscriptions.length;\n    eventSubscriptions.push(subscription);\n    subscription.eventType = eventType;\n    subscription.key = key;\n    return subscription;\n  }\n\n  /**\n   * Removes a bulk set of the subscriptions.\n   *\n   * @param {?string} eventType - Optional name of the event type whose\n   *   registered supscriptions to remove, if null or undefined remove all subscriptions.\n   */\n  removeAllSubscriptions(eventType: string | undefined | null) {\n    if (eventType === undefined || eventType === null) {\n      this._subscriptionsForType = {};\n    } else {\n      delete this._subscriptionsForType[eventType];\n    }\n  }\n\n  /**\n   * Removes a specific subscription. Instead of calling this function, call\n   * `subscription.remove()` directly.\n   *\n   * @param {object} subscription\n   */\n  removeSubscription(subscription: EventSubscription) {\n    const eventType = subscription.eventType;\n    const key = subscription.key;\n\n    const subscriptionsForType = this._subscriptionsForType[eventType];\n    if (subscriptionsForType) {\n      delete subscriptionsForType[key];\n    }\n  }\n\n  /**\n   * Returns the array of subscriptions that are currently registered for the\n   * given event type.\n   *\n   * Note: This array can be potentially sparse as subscriptions are deleted\n   * from it when they are removed.\n   *\n   * TODO: This returns a nullable array. wat?\n   *\n   * @param {string} eventType\n   * @returns {?array}\n   */\n  getSubscriptionsForType(\n    eventType: string\n  ): EventSubscription[] | null | undefined {\n    return this._subscriptionsForType[eventType];\n  }\n}\n"],"mappings":";;;AAEA;AACA;AACA;AACA;AACA,OAAO,MAAMA,uBAAuB,CAAC;EAInCC,WAAWA,CAAA,EAAG;IAAAC,eAAA;IAAAA,eAAA;IACZ,IAAI,CAACC,qBAAqB,GAAG,CAAC,CAAC;IAC/B,IAAI,CAACC,oBAAoB,GAAG,IAAI;EAClC;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEC,eAAeA,CACbC,SAAiB,EACjBC,YAA+B,EACZ;IACnB,IAAIA,YAAY,CAACC,UAAU,KAAK,IAAI,EAAE;MACpCC,OAAO,CAACC,IAAI,CAAC,wDAAwD,CAAC,CAAC,CAAC;IAC1E;;IACA,IAAI,CAAC,IAAI,CAACP,qBAAqB,CAACG,SAAS,CAAC,EAAE;MAC1C,IAAI,CAACH,qBAAqB,CAACG,SAAS,CAAC,GAAG,EAAE;IAC5C;IACA,MAAMK,kBAAkB,GAAG,IAAI,CAACR,qBAAqB,CACnDG,SAAS,CACa;IACxB,MAAMM,GAAG,GAAGD,kBAAkB,CAACE,MAAM;IACrCF,kBAAkB,CAACG,IAAI,CAACP,YAAY,CAAC;IACrCA,YAAY,CAACD,SAAS,GAAGA,SAAS;IAClCC,YAAY,CAACK,GAAG,GAAGA,GAAG;IACtB,OAAOL,YAAY;EACrB;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEQ,sBAAsBA,CAACT,SAAoC,EAAE;IAC3D,IAAIA,SAAS,KAAKU,SAAS,IAAIV,SAAS,KAAK,IAAI,EAAE;MACjD,IAAI,CAACH,qBAAqB,GAAG,CAAC,CAAC;IACjC,CAAC,MAAM;MACL,OAAO,IAAI,CAACA,qBAAqB,CAACG,SAAS,CAAC;IAC9C;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;EACEW,kBAAkBA,CAACV,YAA+B,EAAE;IAClD,MAAMD,SAAS,GAAGC,YAAY,CAACD,SAAS;IACxC,MAAMM,GAAG,GAAGL,YAAY,CAACK,GAAG;IAE5B,MAAMM,oBAAoB,GAAG,IAAI,CAACf,qBAAqB,CAACG,SAAS,CAAC;IAClE,IAAIY,oBAAoB,EAAE;MACxB,OAAOA,oBAAoB,CAACN,GAAG,CAAC;IAClC;EACF;;EAEA;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;EACEO,uBAAuBA,CACrBb,SAAiB,EACuB;IACxC,OAAO,IAAI,CAACH,qBAAqB,CAACG,SAAS,CAAC;EAC9C;AACF"}

package/lib/module/utils/index.js

@@ -0,0 +1,2 @@
+export * from './emitter/EventEmitter';
+//# sourceMappingURL=index.js.map

package/lib/module/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from './emitter/EventEmitter';\n"],"mappings":"AAAA,cAAc,wBAAwB"}

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

@@ -1,11 +1,25 @@
+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 declare class HMSAudioTrackSettings {
     initialState?: HMSTrackSettingsInitState;
     useHardwareEchoCancellation?: boolean;
     audioSource?: string[];
+    /**
+     * [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;
     constructor(params: {
         initialState?: HMSTrackSettingsInitState;
         useHardwareEchoCancellation?: boolean;
         audioSource?: string[];
+        audioMode?: HMSIOSAudioMode;
     });
 }

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

@@ -0,0 +1,4 @@
+export declare enum HMSIOSAudioMode {
+    VOICE = "voice",
+    MUSIC = "music"
+}

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

@@ -49,6 +49,7 @@ export declare class HMSSDK {
     private onRemoteAudioStatsDelegate?;
     private onRemoteVideoStatsDelegate?;
     private onAudioDeviceChangedDelegate?;
+    private onSessionStoreAvailableDelegate?;
     private onPIPRoomLeaveDelegate?;
     private emitterSubscriptions;
     private constructor();
@@ -501,7 +502,19 @@ 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>;
@@ -564,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/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/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/index.d.ts

@@ -80,6 +80,8 @@ 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.5.0",
+  "version": "1.6.1",
   "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.2",
+  "ios": "0.9.4",
   "iOSBroadcastExtension": "0.0.9",
-  "android": "2.6.1"
+  "android": "2.6.3"
 }

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

@@ -196,6 +196,7 @@ export class HMSEncoder {
     const encodedObj = {
       useHardwareEchoCancellation: settings?.useHardwareAcousticEchoCanceler,
       initialState: settings?.initialState,
+      audioMode: settings?.audioMode,
     };
 
     return new HMSAudioTrackSettings(encodedObj);

package/src/classes/HMSIOSAudioMode.ts

@@ -0,0 +1,4 @@
+export enum HMSIOSAudioMode {
+  VOICE = 'voice',
+  MUSIC = 'music',
+}