@100mslive/react-native-hms 2.0.0-alpha.0 → 2.0.0-alpha.1

package/src/classes/HMSInteractivityCenter.ts

@@ -0,0 +1,246 @@
+import { EventEmitter } from '../utils';
+import HMSManager from '../modules/HMSManagerModule';
+import { HMSConstants } from './HMSConstants';
+import { logger } from './HMSLogger';
+import type { HMSPoll } from './polls/HMSPoll';
+import type { HMSPollCreateParams } from './polls/HMSPollCreateParams';
+import type { HMSPollUpdateType } from './polls/HMSPollUpdateType';
+import { HMSPollsListenerActions } from './HMSPollsListenerActions';
+import HMSNativeEventListener from './HMSNativeEventListener';
+import type { HMSEventSubscription } from './HMSNativeEventEmitter';
+import { HMSInteractivityEncoder } from './HMSInteractivityEncoder';
+import { HMSHelper } from './HMSHelper';
+import type { PollLeaderboardResponse } from './polls/PollLeaderboardResponse';
+import type { DecodedPollLeaderboardResponse } from './polls/DecodedPollLeaderboardResponse';
+import type { HMSWhiteboardUpdateType } from './whiteboard/HMSWhiteboardUpdateType';
+import type { HMSWhiteboard } from './whiteboard/HMSWhiteboard';
+import { HMSWhiteboardListenerActions } from './whiteboard/HMSWhiteboardListenerActions';
+import {
+  WhiteboardUpdateListener,
+  registerWhiteboardUpdateListener,
+  unregisterWhiteboardUpdateListener,
+} from './whiteboard/registerCallbacks';
+
+type PollUpdateListener = (data: {
+  updatedPoll: HMSPoll;
+  update: HMSPollUpdateType;
+}) => void;
+
+type PollQuestionResponseCreateParams = {
+  pollId: string;
+  pollQuestionIndex: number;
+  responses:
+    | {
+        text: string;
+        duration?: number;
+      }
+    | {
+        options: number[];
+        duration?: number;
+      };
+};
+
+let pollUpdateSubscription: null | HMSEventSubscription = null;
+
+function registerPollUpdateListener(listener: PollUpdateListener) {
+  if (pollUpdateSubscription !== null) {
+    return;
+  }
+  pollUpdateSubscription = HMSNativeEventListener.addListener(
+    HMSConstants.DEFAULT_SDK_ID,
+    HMSPollsListenerActions.ON_POLL_UPDATE,
+    listener
+  );
+}
+
+function unregisterPollUpdateListener() {
+  if (pollUpdateSubscription === null) {
+    return;
+  }
+  pollUpdateSubscription.remove();
+  pollUpdateSubscription = null;
+}
+
+export class HMSInteractivityCenter {
+  private _eventEmitter = new EventEmitter();
+
+  private onUpdateListenerRemoved(eventType: string) {
+    if (eventType === HMSPollsListenerActions.ON_POLL_UPDATE) {
+      unregisterPollUpdateListener();
+    } else if (
+      eventType === HMSWhiteboardListenerActions.ON_WHITEBOARD_UPDATE
+    ) {
+      unregisterWhiteboardUpdateListener();
+    } else {
+      console.warn('Unknown update listener removed: ', eventType);
+    }
+  }
+
+  constructor() {
+    this._eventEmitter.registerOnAllListenersRemoved(
+      this.onUpdateListenerRemoved
+    );
+  }
+
+  //#region Poll Methods & Listeners
+
+  private _pollUpdateListener = (...args: Parameters<PollUpdateListener>) => {
+    const { updatedPoll, update } = args[0];
+    logger?.verbose('#Listener ON_POLL_UPDATE', {
+      update,
+      updatedPoll,
+    });
+    this._eventEmitter.emit(
+      HMSPollsListenerActions.ON_POLL_UPDATE,
+      HMSInteractivityEncoder.transformPoll(updatedPoll),
+      update
+    );
+  };
+
+  /**
+   * Adds a listener for poll updates
+   * @param listener - Callback to be called when a poll is updated
+   * @returns HMSEventSubscription
+   */
+  addPollUpdateListener(
+    listener: (updatedPoll: HMSPoll, update: HMSPollUpdateType) => void
+  ) {
+    registerPollUpdateListener(this._pollUpdateListener);
+    return this._eventEmitter.addListener(
+      HMSPollsListenerActions.ON_POLL_UPDATE,
+      listener,
+      null
+    );
+  }
+
+  /**
+   * Starts a poll
+   *
+   * @param pollParams
+   */
+  async startPoll(pollParams: HMSPollCreateParams) {
+    const transformedPollParams = {
+      ...pollParams,
+      rolesThatCanVote: pollParams.rolesThatCanVote
+        ? HMSHelper.getRoleNames(pollParams.rolesThatCanVote)
+        : undefined,
+      rolesThatCanViewResponses: pollParams.rolesThatCanViewResponses
+        ? HMSHelper.getRoleNames(pollParams.rolesThatCanViewResponses)
+        : undefined,
+    };
+
+    const data = {
+      ...transformedPollParams,
+      id: HMSConstants.DEFAULT_SDK_ID,
+    };
+    logger?.verbose('#Function startPoll', JSON.stringify(data));
+    return HMSManager.quickStartPoll(data);
+  }
+
+  async add(pollQuestionResponseParams: PollQuestionResponseCreateParams) {
+    const data = {
+      ...pollQuestionResponseParams,
+      id: HMSConstants.DEFAULT_SDK_ID,
+    };
+    logger?.verbose('#Function add', JSON.stringify(data));
+    return HMSManager.addResponseOnPollQuestion(data);
+  }
+
+  async stop(pollId: string) {
+    const data = {
+      id: HMSConstants.DEFAULT_SDK_ID,
+      pollId,
+    };
+    logger?.verbose('#Function stop', JSON.stringify(data));
+    return HMSManager.stopPoll(data);
+  }
+
+  /**
+   * Fetches the leaderboard for a poll
+   * @param pollId - The id of the poll
+   * @param count - The number of entries to fetch
+   * @param startIndex - The index to start fetching from
+   * @param includeCurrentPeer - Whether to include the current peer in the fetched leaderboard entries
+   * @returns Promise<PollLeaderboardResponse>
+   */
+  async fetchLeaderboard(
+    pollId: string,
+    count: number,
+    startIndex: number,
+    includeCurrentPeer: boolean
+  ): Promise<PollLeaderboardResponse> {
+    const data = {
+      id: HMSConstants.DEFAULT_SDK_ID,
+      pollId,
+      count,
+      startIndex,
+      includeCurrentPeer,
+    };
+    logger?.verbose('#Function fetchLeaderboard', data);
+
+    const response: DecodedPollLeaderboardResponse =
+      await HMSManager.fetchLeaderboard(data);
+    return HMSInteractivityEncoder.transformPollLeaderboardResponse(response);
+  }
+  //#endregion Poll Methods & Listeners
+
+  //#region Whiteboard Methods & Listeners
+
+  private _whiteboardUpdateListener = (
+    ...args: Parameters<WhiteboardUpdateListener>
+  ) => {
+    const { hmsWhiteboard, updateType } = args[0];
+    logger?.verbose('#Listener ON_WHITEBOARD_UPDATE', {
+      updateType,
+      hmsWhiteboard,
+    });
+    this._eventEmitter.emit(
+      HMSWhiteboardListenerActions.ON_WHITEBOARD_UPDATE,
+      HMSInteractivityEncoder.transformHMSWhiteboard(hmsWhiteboard),
+      updateType
+    );
+  };
+
+  /**
+   * Adds a listener for Whiteboard updates
+   * @param listener - Callback to be called when whiteboard is updated
+   * @returns HMSEventSubscription
+   */
+  addWhiteboardUpdateListener(
+    listener: (
+      hmsWhiteboard: HMSWhiteboard,
+      updateType: HMSWhiteboardUpdateType
+    ) => void
+  ) {
+    registerWhiteboardUpdateListener(this._whiteboardUpdateListener);
+    return this._eventEmitter.addListener(
+      HMSWhiteboardListenerActions.ON_WHITEBOARD_UPDATE,
+      listener,
+      null
+    );
+  }
+
+  /**
+   * Starts Whiteboard
+   */
+  async startWhiteboard(title: string) {
+    const data = {
+      id: HMSConstants.DEFAULT_SDK_ID,
+      title,
+    };
+    logger?.verbose('#Function startWhiteboard', data);
+    return HMSManager.startWhiteboard(data);
+  }
+
+  /**
+   * Stops Whiteboard
+   */
+  async stopWhiteboard() {
+    const data = {
+      id: HMSConstants.DEFAULT_SDK_ID,
+    };
+    logger?.verbose('#Function stopWhiteboard', data);
+    return HMSManager.stopWhiteboard(data);
+  }
+  //#endregion Whiteboard Methods & Listeners
+}

package/src/classes/HMSInteractivityEncoder.ts

@@ -0,0 +1,92 @@
+import { HMSEncoder } from './HMSEncoder';
+import type { DecodedPollLeaderboardResponse } from './polls/DecodedPollLeaderboardResponse';
+import type { HMSPoll } from './polls/HMSPoll';
+import type { PollLeaderboardResponse } from './polls/PollLeaderboardResponse';
+import type { HMSWhiteboard } from './whiteboard/HMSWhiteboard';
+
+export class HMSInteractivityEncoder {
+  static transformPoll(poll: HMSPoll): HMSPoll {
+    if (poll.startedAt) {
+      const dateNum = parseInt(poll.startedAt as unknown as string);
+
+      if (isNaN(dateNum)) {
+        poll.startedAt = undefined;
+      } else {
+        poll.startedAt = new Date(dateNum);
+      }
+    }
+    if (poll.stoppedAt) {
+      const dateNum = parseInt(poll.stoppedAt as unknown as string);
+
+      if (isNaN(dateNum)) {
+        poll.stoppedAt = undefined;
+      } else {
+        poll.stoppedAt = new Date(dateNum);
+      }
+    }
+    if (poll.createdBy) {
+      poll.createdBy = HMSEncoder.encodeHmsPeer(poll.createdBy);
+    }
+    if (poll.startedBy) {
+      poll.startedBy = HMSEncoder.encodeHmsPeer(poll.startedBy);
+    }
+    if (poll.stoppedBy) {
+      poll.stoppedBy = HMSEncoder.encodeHmsPeer(poll.stoppedBy);
+    }
+    if (poll.rolesThatCanVote) {
+      poll.rolesThatCanVote = poll.rolesThatCanVote.map((role) =>
+        HMSEncoder.encodeHmsRole(role)
+      );
+    }
+    if (poll.rolesThatCanViewResponses) {
+      poll.rolesThatCanViewResponses = poll.rolesThatCanViewResponses.map(
+        (role) => HMSEncoder.encodeHmsRole(role)
+      );
+    }
+
+    // --- poll.questions: HMSPollQuestion[]
+    // --- poll.result: HMSPollResult
+    return poll;
+  }
+
+  static transformPollLeaderboardResponse(
+    decodedPollLeaderboardResponse: DecodedPollLeaderboardResponse
+  ): PollLeaderboardResponse {
+    const summary = decodedPollLeaderboardResponse.summary;
+    if (summary) {
+      if (typeof summary.averageTime === 'string') {
+        summary.averageTime = parseInt(summary.averageTime);
+      }
+    }
+
+    const entries = decodedPollLeaderboardResponse.entries;
+    if (entries) {
+      entries.forEach((entry) => {
+        if (typeof entry.duration === 'string') {
+          entry.duration = parseInt(entry.duration);
+        }
+        if (typeof entry.totalResponses === 'string') {
+          entry.totalResponses = parseInt(entry.totalResponses);
+        }
+        if (typeof entry.correctResponses === 'string') {
+          entry.correctResponses = parseInt(entry.correctResponses);
+        }
+        if (typeof entry.position === 'string') {
+          entry.position = parseInt(entry.position);
+        }
+        if (typeof entry.score === 'string') {
+          entry.score = parseInt(entry.score);
+        }
+      });
+    }
+
+    return decodedPollLeaderboardResponse as PollLeaderboardResponse;
+  }
+
+  static transformHMSWhiteboard(hmsWhiteboard: HMSWhiteboard): HMSWhiteboard {
+    if (hmsWhiteboard.owner) {
+      hmsWhiteboard.owner = HMSEncoder.encodeHmsPeer(hmsWhiteboard.owner);
+    }
+    return hmsWhiteboard;
+  }
+}

package/src/classes/HMSLogAlarmManager.ts

@@ -1,3 +1,15 @@
+/**
+ * Enumeration for managing log alarm settings in HMS SDK for React Native applications. Android only.
+ *
+ * This enumeration defines constants used to configure the alarm manager for log files in the HMS SDK.
+ * It includes settings for the default directory size, default log file name, and maximum directory size,
+ * allowing for detailed control over how log files are managed and stored.
+ *
+ * @enum {string}
+ * @property {string} DEFAULT_DIR_SIZE - Represents the default size for the log directory.
+ * @property {string} DEFAULT_LOGS_FILE_NAME - Represents the default name for log files.
+ * @property {string} MAX_DIR_SIZE - Represents the maximum size for the log directory.
+ */
 export enum HMSLogAlarmManager {
   DEFAULT_DIR_SIZE = 'DEFAULT_DIR_SIZE',
   DEFAULT_LOGS_FILE_NAME = 'DEFAULT_LOGS_FILE_NAME',

package/src/classes/HMSLogLevel.ts

@@ -1,3 +1,15 @@
+/**
+ * Enumeration for defining log levels in the HMS SDK for React Native applications.
+ *
+ * This enumeration provides a set of predefined log levels that can be used to control the verbosity of logging
+ * within the HMS SDK. It allows developers to specify how much detail they want in their logs, which can be
+ * helpful for debugging or monitoring the application's behavior.
+ *
+ * @enum {string}
+ * @property {string} VERBOSE - Represents the most verbose log level, including detailed debug information.
+ * @property {string} WARNING - Represents a log level for warning messages that might indicate potential issues.
+ * @property {string} ERROR - Represents a log level for error messages indicating failures that need attention.
+ */
 export enum HMSLogLevel {
   VERBOSE = 'VERBOSE',
   WARNING = 'WARNING',

package/src/classes/HMSLogSettings.ts

@@ -1,6 +1,20 @@
 import type { HMSLogAlarmManager } from './HMSLogAlarmManager';
 import type { HMSLogLevel } from './HMSLogLevel';
 
+/**
+ * Represents the logging settings for the HMS SDK.
+ *
+ * This class encapsulates the settings related to logging within the HMS SDK, including the log level,
+ * whether log storage is enabled, and the maximum directory size for log storage.
+ * It is used to configure how logs are handled by the SDK, allowing for customization of log verbosity and storage requirements.
+ *
+ * @class HMSLogSettings
+ * @property {HMSLogLevel} level - The log level setting, determining the verbosity of the logs.
+ * @property {boolean} isLogStorageEnabled - Flag indicating whether log storage is enabled. Android only.
+ * @property {HMSLogAlarmManager} maxDirSizeInBytes - The maximum size of the log directory in bytes, managed by an instance of HMSLogAlarmManager. Android only.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/debugging/logger
+ */
 export class HMSLogSettings {
   level: HMSLogLevel;
   isLogStorageEnabled: boolean;

package/src/classes/HMSNativeEventEmitter.ts

@@ -61,15 +61,9 @@ export class HMSNativeEventEmitter {
 
     return {
       remove: () => {
-        if (
-          subscription &&
-          Object.getOwnPropertyNames(subscription).includes('remove') &&
-          typeof subscription.remove === 'function'
-        ) {
+        if (subscription) {
           subscription.remove();
           subscription = null;
-        } else {
-          this._nativeEventEmitter.removeListener(eventType, listener);
         }
 
         // disable `eventType` on `HMSSDK`, if all listeners has been removed

package/src/classes/HMSNativeEventListener.ts

@@ -1,4 +1,4 @@
-import HMSManager from './HMSManagerModule';
+import HMSManager from '../modules/HMSManagerModule';
 import { HMSNativeEventEmitter } from './HMSNativeEventEmitter';
 
 export type { HMSEventSubscription as HMSNativeEventSubscription } from './HMSNativeEventEmitter';

package/src/classes/HMSNetworkQuality.ts

@@ -1,3 +1,14 @@
+/**
+ * Represents the network quality of a connection in the HMS (100ms) system.
+ *
+ * This class encapsulates the network quality information, specifically focusing on the downlink quality of the connection.
+ * The downlink quality is represented as a numerical value, providing a quantifiable measure of the receiving end's network performance.
+ *
+ * @param {Object} params - The constructor parameters.
+ * @param {number} params.downlinkQuality - The downlink quality of the network connection.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/measure-network-quality-and-performance/network-quality
+ */
 export class HMSNetworkQuality {
   downlinkQuality: number;
 

package/src/classes/HMSNoiseCancellationPlugin.ts

@@ -0,0 +1,162 @@
+import HMSManagerModule from '../modules/HMSManagerModule';
+import { HMSConstants } from './HMSConstants';
+import { logger } from './HMSLogger';
+
+/**
+ * Represents the HMS Noise Cancellation Plugin.
+ * This class encapsulates the functionality for managing noise cancellation within a room, including enabling, disabling, and checking the availability and current state of noise cancellation.
+ *
+ * @property {HMSNoiseCancellationModels} modelName - Specifies the model of noise cancellation to be used.
+ * This property determines the algorithm and intensity of noise cancellation, allowing for customization
+ * based on the requirements of the room or application.
+ *
+ * @property {HMSNoiseCancellationInitialState} initialState - Defines the initial state of noise cancellation
+ * when the plugin is instantiated. This can be either enabled or disabled, providing control over the
+ * noise cancellation feature's activation upon initialization.
+ *
+ * @see https://www.100ms.live/docs/react-native/v2/how-to-guides/extend-capabilities/noise-cancellation
+ */
+export class HMSNoiseCancellationPlugin {
+  /**
+   * The `modelName` property specifies the model of noise cancellation to be used within the HMS Noise Cancellation Plugin.
+   * This property determines the algorithm and intensity of noise cancellation, allowing for customization
+   * based on the specific requirements of the room or application. It is of type `HMSNoiseCancellationModels`,
+   * an enum that defines the available noise cancellation models.
+   */
+  modelName: HMSNoiseCancellationModels;
+
+  /**
+   * Defines the initial state of noise cancellation when the plugin is instantiated.
+   * This property can be set to either `HMSNoiseCancellationInitialState.Enabled`
+   * or `HMSNoiseCancellationInitialState.Disabled`, determining whether noise cancellation should be active
+   * immediately upon the plugin's instantiation. This allows for control over the feature's initial activation state,
+   * catering to scenarios where noise cancellation needs to be either immediately available or manually activated later.
+   */
+  initialState: HMSNoiseCancellationInitialState;
+
+  /**
+   * Constructs a new HMSNoiseCancellationPlugin instance with optional configuration settings.
+   * This constructor allows for the initialization of the plugin with specific noise cancellation
+   * model and initial state settings, providing flexibility in how noise cancellation is applied
+   * within the application.
+   *
+   * @param {Object} [config] - Optional configuration object for the plugin.
+   * @param {HMSNoiseCancellationModels} [config.modelName] - Specifies the noise cancellation model to be used.
+   *        This determines the algorithm and intensity of noise cancellation. If not provided, a default
+   *        model is used.
+   * @param {HMSNoiseCancellationInitialState} [config.initialState] - Sets the initial state of noise cancellation
+   *        (enabled or disabled) when the plugin is instantiated. Defaults to disabled if not specified.
+   */
+  constructor(config?: {
+    modelName: HMSNoiseCancellationModels;
+    initialState: HMSNoiseCancellationInitialState;
+  }) {
+    const data = {
+      modelName: HMSNoiseCancellationModels.SmallFullBand,
+      initialState: HMSNoiseCancellationInitialState.Disabled,
+      ...config,
+    };
+    this.modelName = data.modelName;
+    this.initialState = data.initialState;
+  }
+
+  /**
+   * To make noise cancellation work your room needs to have noise cancellation feature enabled.
+   *
+   * Gets whether noise cancellation is available for your room.
+   * @returns {boolean} True if noise cancellation is available, false otherwise.
+   *
+   * Note: You can call this API to check the state of noise cancellation only after successfully joining the room.
+   */
+  async isNoiseCancellationAvailable(): Promise<boolean> {
+    const data = { id: HMSConstants.DEFAULT_SDK_ID };
+    logger?.verbose(
+      '#Function HMSNoiseCancellationPlugin#isNoiseCancellationAvailable',
+      data
+    );
+
+    try {
+      return await HMSManagerModule.isNoiseCancellationPluginAvailable(data);
+    } catch (e) {
+      logger?.error(
+        '#Error in #Function HMSNoiseCancellationPlugin#isNoiseCancellationAvailable ',
+        e
+      );
+      return Promise.reject(e);
+    }
+  }
+
+  /**
+   * Enables noise cancellation.
+   * @returns {Promise<boolean>} A promise that resolves to true if noise cancellation is enabled, otherwise, rejected promise is returned
+   */
+  async enable(): Promise<boolean> {
+    const data = { id: HMSConstants.DEFAULT_SDK_ID };
+    logger?.verbose('#Function HMSNoiseCancellationPlugin#enable', data);
+
+    try {
+      return await HMSManagerModule.enableNoiseCancellationPlugin(data);
+    } catch (e) {
+      logger?.error(
+        '#Error in #Function HMSNoiseCancellationPlugin#enable ',
+        e
+      );
+      return Promise.reject(e);
+    }
+  }
+
+  /**
+   * Disables noise cancellation.
+   * @returns {Promise<boolean>} A promise that resolves to true if noise cancellation is disabled, otherwise, rejected promise is returned
+   */
+  async disable(): Promise<boolean> {
+    const data = { id: HMSConstants.DEFAULT_SDK_ID };
+    logger?.verbose('#Function HMSNoiseCancellationPlugin#disable', data);
+
+    try {
+      return await HMSManagerModule.disableNoiseCancellationPlugin(data);
+    } catch (e) {
+      logger?.error(
+        '#Error in #Function HMSNoiseCancellationPlugin#disable ',
+        e
+      );
+      return Promise.reject(e);
+    }
+  }
+
+  /**
+   * Checks if noise cancellation is enabled.
+   * @returns {boolean} true if noise cancellation is enabled, false otherwise.
+   */
+  async isEnabled(): Promise<boolean> {
+    const data = { id: HMSConstants.DEFAULT_SDK_ID };
+    logger?.verbose('#Function HMSNoiseCancellationPlugin#isEnabled', data);
+
+    try {
+      return await HMSManagerModule.isNoiseCancellationPluginEnabled(data);
+    } catch (e) {
+      logger?.error(
+        '#Error in #Function HMSNoiseCancellationPlugin#isEnabled ',
+        e
+      );
+      return Promise.reject(e);
+    }
+  }
+}
+
+/**
+ * Enum for HMS Noise Cancellation Models.
+ * @enum {String}
+ */
+export enum HMSNoiseCancellationModels {
+  SmallFullBand = 'SMALL_FULL_BAND',
+}
+
+/**
+ * Enum for HMS Noise Cancellation Initial State.
+ * @enum {String}
+ */
+export enum HMSNoiseCancellationInitialState {
+  Enabled = 'ENABLED',
+  Disabled = 'DISABLED',
+}

package/src/classes/HMSPIPConfig.ts

@@ -0,0 +1,54 @@
+import type { HMSVideoViewMode } from './HMSVideoViewMode';
+
+/**
+ * Configuration options for Picture-in-Picture (PIP) mode in a React Native application using HMS.
+ *
+ * This interface defines the settings available for customizing the PIP window that can appear when the app enters background mode.
+ * It includes options for automatically entering PIP mode, adjusting the aspect ratio and scale type of the PIP window, and toggling
+ * the visibility of various control buttons specific to Android or iOS platforms.
+ *
+ * @interface HMSPIPConfig
+ * @property {boolean} [autoEnterPipMode] - Determines whether the app should automatically enter PIP mode when it goes into the background.
+ * @property {[number, number]} [aspectRatio] - Sets the aspect ratio of the PIP window. Defaults are platform-specific: [16, 9] for Android and [9, 16] for iOS.
+ * @property {HMSVideoViewMode} [scaleType] - Defines the scaling behavior of the video within the PIP window. Options are `ASPECT_FILL` (default), `ASPECT_FIT`, and `ASPECT_BALANCED`. Applies only to iOS.
+ * @property {boolean} [useActiveSpeaker] - Whether the PIP window should automatically show the active speaker. Default is true. Applies only to iOS.
+ * @property {boolean} [endButton] - Controls the visibility of the end call button within the PIP window. Default is true. Applies only to Android.
+ * @property {boolean} [audioButton] - Controls the visibility of the audio mute/unmute button within the PIP window. Default is true. Applies only to Android.
+ * @property {boolean} [videoButton] - Controls the visibility of the video mute/unmute button within the PIP window. Default is true. Applies only to Android.
+ */
+export interface HMSPIPConfig {
+  /**
+   * Whether to automatically enter PIP mode when app enters background.
+   */
+  autoEnterPipMode?: boolean;
+
+  /**
+   * The aspect ratio of the PIP window. Default is [16, 9] on Android & [9, 16] on iOS. Other values can be [3, 4], [1, 1], [4, 3], [16, 9].
+   */
+  aspectRatio?: [number, number];
+
+  /**
+   * The scale type of the PIP window. Default is ASPECT_FILL. Other values can be ASPECT_FIT, ASPECT_BALANCED. iOS Only.
+   */
+  scaleType?: HMSVideoViewMode;
+
+  /**
+   * Whether to show the Active Speaker in the PIP window. Default is true. iOS only.
+   */
+  useActiveSpeaker?: boolean;
+
+  /**
+   * Whether to show the end button in the PIP window. Default is true. Android only.
+   */
+  endButton?: boolean;
+
+  /**
+   * Whether to show the audio mute/unmute button in the PIP window. Default is true. Android only.
+   */
+  audioButton?: boolean;
+
+  /**
+   * Whether to show the video mute/unmute button in the PIP window. Default is true. Android only.
+   */
+  videoButton?: boolean;
+}

package/src/classes/HMSPIPListenerActions.ts

@@ -1,4 +1,22 @@
+/**
+ * Enum for HMS Picture-in-Picture (PIP) Listener Actions.
+ *
+ * This enum defines the types of actions/events related to the Picture-in-Picture (PIP) mode that can be listened to
+ * within the HMS SDK. These actions allow the application to respond to changes in PIP mode or when the room is left
+ * while in PIP mode.
+ *
+ * @enum {string}
+ */
 export enum HMSPIPListenerActions {
+  /**
+   * Action triggered when the Picture-in-Picture mode changes.
+   * This can be used to handle UI changes or other logic when entering or exiting PIP mode.
+   */
   ON_PIP_MODE_CHANGED = 'ON_PIP_MODE_CHANGED',
+
+  /**
+   * Action triggered when the room is left while in Picture-in-Picture mode. Android only.
+   * This can be used to clean up resources or update the UI accordingly.
+   */
   ON_PIP_ROOM_LEAVE = 'ON_PIP_ROOM_LEAVE',
 }