@100mslive/react-native-hms 1.10.3 → 1.10.5

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

@@ -2,6 +2,8 @@ import type { HMSPoll } from './polls/HMSPoll';
 import type { HMSPollCreateParams } from './polls/HMSPollCreateParams';
 import type { HMSPollUpdateType } from './polls/HMSPollUpdateType';
 import type { PollLeaderboardResponse } from './polls/PollLeaderboardResponse';
+import type { HMSWhiteboardUpdateType } from './whiteboard/HMSWhiteboardUpdateType';
+import type { HMSWhiteboard } from './whiteboard/HMSWhiteboard';
 type PollQuestionResponseCreateParams = {
     pollId: string;
     pollQuestionIndex: number;
@@ -15,9 +17,9 @@ type PollQuestionResponseCreateParams = {
 };
 export declare class HMSInteractivityCenter {
     private _eventEmitter;
-    private _pollUpdateListener;
-    private _onAllPollUpdateListenerRemoved;
+    private onUpdateListenerRemoved;
     constructor();
+    private _pollUpdateListener;
     /**
      * Adds a listener for poll updates
      * @param listener - Callback to be called when a poll is updated
@@ -41,5 +43,20 @@ export declare class HMSInteractivityCenter {
      * @returns Promise<PollLeaderboardResponse>
      */
     fetchLeaderboard(pollId: string, count: number, startIndex: number, includeCurrentPeer: boolean): Promise<PollLeaderboardResponse>;
+    private _whiteboardUpdateListener;
+    /**
+     * 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): import("../utils").EmitterSubscription;
+    /**
+     * Starts Whiteboard
+     */
+    startWhiteboard(title: string): Promise<any>;
+    /**
+     * Stops Whiteboard
+     */
+    stopWhiteboard(): Promise<any>;
 }
 export {};

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

@@ -1,7 +1,9 @@
 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 declare class HMSInteractivityEncoder {
     static transformPoll(poll: HMSPoll): HMSPoll;
     static transformPollLeaderboardResponse(decodedPollLeaderboardResponse: DecodedPollLeaderboardResponse): PollLeaderboardResponse;
+    static transformHMSWhiteboard(hmsWhiteboard: HMSWhiteboard): HMSWhiteboard;
 }

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

@@ -1,5 +1,6 @@
 /**
  * Class representing an HMS Noise Cancellation Plugin.
+ * Checkout {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/extend-capabilities/noise-cancellation} for more info
  */
 export declare class HMSNoiseCancellationPlugin {
     modelName: HMSNoiseCancellationModels;

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

@@ -1,3 +1,8 @@
+export interface HMSWhiteboardPermission {
+    admin?: boolean;
+    write?: boolean;
+    read?: boolean;
+}
 export declare class HMSPermissions {
     endRoom?: boolean;
     removeOthers?: boolean;
@@ -9,6 +14,7 @@ export declare class HMSPermissions {
     rtmpStreaming?: boolean;
     pollRead?: boolean;
     pollWrite?: boolean;
+    whiteboard?: HMSWhiteboardPermission;
     constructor(params?: {
         endRoom?: boolean;
         removeOthers?: boolean;
@@ -20,5 +26,6 @@ export declare class HMSPermissions {
         rtmpStreaming?: boolean;
         pollRead?: boolean;
         pollWrite?: boolean;
+        whiteboard?: HMSWhiteboardPermission;
     });
 }

package/lib/typescript/classes/whiteboard/HMSWhiteboard.d.ts

@@ -0,0 +1,10 @@
+import type { HMSPeer } from '../HMSPeer';
+import type { HMSWhiteboardState } from './HMSWhiteboardState';
+export interface HMSWhiteboard {
+    id: string;
+    title?: string;
+    state: HMSWhiteboardState;
+    isOwner: boolean;
+    owner?: HMSPeer;
+    url?: string;
+}

package/lib/typescript/classes/whiteboard/HMSWhiteboardListenerActions.d.ts

@@ -0,0 +1,3 @@
+export declare enum HMSWhiteboardListenerActions {
+    ON_WHITEBOARD_UPDATE = "ON_WHITEBOARD_UPDATE"
+}

package/lib/typescript/classes/whiteboard/HMSWhiteboardState.d.ts

@@ -0,0 +1,4 @@
+export declare enum HMSWhiteboardState {
+    STARTED = "STARTED",
+    STOPPED = "STOPPED"
+}

package/lib/typescript/classes/whiteboard/HMSWhiteboardUpdateType.d.ts

@@ -0,0 +1,4 @@
+export declare enum HMSWhiteboardUpdateType {
+    STARTED = "STARTED",
+    STOPPED = "STOPPED"
+}

package/lib/typescript/classes/whiteboard/index.d.ts

@@ -0,0 +1,3 @@
+export * from './HMSWhiteboard';
+export * from './HMSWhiteboardUpdateType';
+export * from './HMSWhiteboardListenerActions';

package/lib/typescript/classes/whiteboard/registerCallbacks.d.ts

@@ -0,0 +1,8 @@
+import type { HMSWhiteboard } from './HMSWhiteboard';
+import type { HMSWhiteboardUpdateType } from './HMSWhiteboardUpdateType';
+export type WhiteboardUpdateListener = (data: {
+    hmsWhiteboard: HMSWhiteboard;
+    updateType: HMSWhiteboardUpdateType;
+}) => void;
+export declare function registerWhiteboardUpdateListener(listener: WhiteboardUpdateListener): void;
+export declare function unregisterWhiteboardUpdateListener(): void;

package/lib/typescript/components/HMSHLSPlayer/HMSHLSPlayer.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import type { StyleProp, ViewStyle } from 'react-native';
+import type { HLSPlayerDurationDetails } from '../../types';
 export interface HMSHLSPlayerProps {
     url?: string;
     style?: StyleProp<ViewStyle>;
@@ -17,5 +18,10 @@ export interface HMSHLSPlayerRefProperties {
     seekBackward: (seconds: number) => void;
     seekToLivePosition: () => void;
     setVolume: (level: number) => void;
+    isClosedCaptionSupported: () => Promise<boolean>;
+    isClosedCaptionEnabled: () => Promise<boolean>;
+    enableClosedCaption: () => void;
+    disableClosedCaption: () => void;
+    getPlayerDurationDetails: () => Promise<HLSPlayerDurationDetails>;
 }
 export declare const HMSHLSPlayer: React.ForwardRefExoticComponent<HMSHLSPlayerProps & React.RefAttributes<HMSHLSPlayerRefProperties>>;

package/lib/typescript/components/HMSHLSPlayer/RCTHMSHLSPlayer.d.ts

@@ -1,7 +1,9 @@
 import type { StyleProp, NativeSyntheticEvent, ViewStyle, NativeMethods } from 'react-native';
-import type { HMSHLSPlayerPlaybackEvent, HMSHLSPlayerStatsEvent } from '../../types';
+import type { HMSHLSPlayerCuesEvent, HMSHLSPlayerPlaybackEvent, HMSHLSPlayerStatsEvent, RequestedDataEvent } from '../../types';
 export type HmsHlsPlaybackEventHandler = (event: NativeSyntheticEvent<HMSHLSPlayerPlaybackEvent>) => void;
 export type HmsHlsStatsEventHandler = (event: NativeSyntheticEvent<HMSHLSPlayerStatsEvent>) => void;
+export type HlsSPlayerCuesEventHandler = (event: NativeSyntheticEvent<HMSHLSPlayerCuesEvent>) => void;
+export type RequestedDataEventHandler = (event: NativeSyntheticEvent<RequestedDataEvent>) => void;
 export type RCTHMSHLSPlayerProps = {
     url?: string;
     style?: StyleProp<ViewStyle>;
@@ -9,6 +11,8 @@ export type RCTHMSHLSPlayerProps = {
     enableControls?: boolean;
     onHmsHlsPlaybackEvent?: HmsHlsPlaybackEventHandler;
     onHmsHlsStatsEvent?: HmsHlsStatsEventHandler;
+    onDataReturned?: RequestedDataEventHandler;
+    onHlsPlayerCuesEvent?: HlsSPlayerCuesEventHandler;
 };
 export declare const RCTHMSHLSPlayer: import("react-native").HostComponent<RCTHMSHLSPlayerProps>;
 export type RCTHMSHLSPlayerRef = React.Component<RCTHMSHLSPlayerProps> & Readonly<NativeMethods>;

package/lib/typescript/components/HMSHLSPlayer/hooks.d.ts

@@ -8,6 +8,8 @@ export declare const useHMSHLSPlayerStats: () => {
     error: HMSHLSPlayerStatsError;
 };
 export declare const useHMSHLSPlayerStat: <T extends keyof HMSHLSPlayerStatsUpdateEventData>(stat: T) => HMSHLSPlayerStatsUpdateEventData[T];
+export declare const useHMSHLSPlayerSubtitles: () => string | null;
+export declare const useIsHLSStreamLive: (liveOffsetMillis?: number) => boolean;
 export declare const useHMSHLSPlayerStatsError: (callback: (error: NonNullable<HMSHLSPlayerStatsError>) => void, deps: DependencyList) => void;
 export declare const useHMSHLSPlayerPlaybackError: (callback: (error: NonNullable<HMSHLSPlayerPlaybackError>) => void, deps: DependencyList) => void;
 export declare const useHMSHLSPlayerCue: (callback: (error: NonNullable<HMSHLSPlayerCue>) => void, deps: DependencyList) => void;
@@ -17,3 +19,4 @@ export declare const setHMSHLSPlayerCue: (cue: import("../../stores/types").HMSH
 export declare const setHMSHLSPlayerPlaybackError: (error: HMSHLSPlayerPlaybackError) => void;
 export declare const setHMSHLSPlayerStats: (stats: HMSHLSPlayerStatsUpdateEventData) => void;
 export declare const setHMSHLSPlayerStatsError: (error: HMSHLSPlayerStatsError) => void;
+export declare const setHMSHLSPlayerSubtitles: (subtitles: string | null) => void;

package/lib/typescript/components/HMSHLSPlayer/index.d.ts

@@ -1,2 +1,2 @@
 export * from './HMSHLSPlayer';
-export { useHMSHLSPlayerPlaybackState, useHMSHLSPlayerCue, useHMSHLSPlayerPlaybackError, useHMSHLSPlayerStats, useHMSHLSPlayerStat, useHMSHLSPlayerStatsError, useHMSHLSPlayerResolution, } from './hooks';
+export { useHMSHLSPlayerPlaybackState, useHMSHLSPlayerCue, useHMSHLSPlayerPlaybackError, useHMSHLSPlayerStats, useHMSHLSPlayerStat, useHMSHLSPlayerStatsError, useHMSHLSPlayerResolution, useHMSHLSPlayerSubtitles, useIsHLSStreamLive, } from './hooks';

package/lib/typescript/index.d.ts

@@ -83,12 +83,14 @@ export * from './classes/HMSCameraControl';
 export * from './classes/HMSIOSAudioMode';
 export * from './classes/HMSRecordingState';
 export * from './classes/HMSStreamingState';
+export * from './classes/HMSHLSPlaylistType';
 export type { HMSSessionStore, JsonArray, JsonMap, JsonPrimitive, JsonValue, } from './classes/HMSSessionStore';
 export type { HmsViewComponent as HMSView, HmsComponentProps as HMSViewProps, } from './classes/HmsView';
 export type { HMSPIPConfig } from './classes/HMSPIPConfig';
 export { HMSRecordingState } from './classes/HMSRecordingState';
 export type { HMSPoll } from './classes/polls/HMSPoll';
 export * from './classes/HMSNoiseCancellationPlugin';
+export * from './classes/whiteboard';
 export { HMSPollQuestionType } from './classes/polls/HMSPollQuestionType';
 export { HMSPollType } from './classes/polls/HMSPollType';
 export { HMSPollUserTrackingMode } from './classes/polls/HMSPollUserTrackingMode';

package/lib/typescript/stores/hls-player-stats-store.d.ts

@@ -1,7 +1,8 @@
-export declare const useHMSHLSPlayerStatsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<import("./types").HMSHLSPlayerStatsSlice>, "subscribe"> & {
+import type { HMSHLSPlayerStatsStore } from './types';
+export declare const useHMSHLSPlayerStatsStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<HMSHLSPlayerStatsStore>, "subscribe"> & {
     subscribe: {
-        (listener: (selectedState: import("./types").HMSHLSPlayerStatsSlice, previousSelectedState: import("./types").HMSHLSPlayerStatsSlice) => void): () => void;
-        <U>(selector: (state: import("./types").HMSHLSPlayerStatsSlice) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+        (listener: (selectedState: HMSHLSPlayerStatsStore, previousSelectedState: HMSHLSPlayerStatsStore) => void): () => void;
+        <U>(selector: (state: HMSHLSPlayerStatsStore) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
             equalityFn?: ((a: U, b: U) => boolean) | undefined;
             fireImmediately?: boolean | undefined;
         } | undefined): () => void;

package/lib/typescript/stores/types.d.ts

@@ -1,7 +1,7 @@
 import type { HMSPoll } from '../classes/polls/HMSPoll';
 import type { HMSHLSPlayerPlaybackState, HMSHLSPlayerPlaybackCueEventData, HMSHLSPlayerPlaybackFailureEventData, HMSHLSPlayerPlaybackResolutionChangeEventData, HMSHLSPlayerStatsErrorEventData, HMSHLSPlayerStatsUpdateEventData } from '../types';
 export type HMSStore = HMSHLSPlayerPlaybackSlice & HMSViewsSlice;
-export type HMSHLSPlayerStatsStore = HMSHLSPlayerStatsSlice;
+export type HMSHLSPlayerStatsStore = HMSHLSPlayerStatsSlice & HLSPlayerClosedCaptionsSlice;
 export type HMSInteractivityStore = HMSPollsSlice;
 export type TrackId = string;
 export type Resolution = {
@@ -28,6 +28,7 @@ export interface HMSHLSPlayerPlaybackSlice {
     setPlaybackState(playbackState: HMSHLSPlayerPlaybackState): void;
     setResolution(resolution: HMSHLSPlayerResolution): void;
     setPlaybackError(error: HMSHLSPlayerPlaybackError): void;
+    resetPlaybackSlice(): void;
 }
 export type HMSHLSPlayerStats = HMSHLSPlayerStatsUpdateEventData;
 export type HMSHLSPlayerStatsError = HMSHLSPlayerStatsErrorEventData | undefined;
@@ -36,6 +37,11 @@ export interface HMSHLSPlayerStatsSlice {
     error: HMSHLSPlayerStatsError | undefined;
     changeStats(stats: HMSHLSPlayerStats): void;
     setError(error: HMSHLSPlayerStatsError): void;
+    reset(): void;
+}
+export interface HLSPlayerClosedCaptionsSlice {
+    subtitles: string | null;
+    setSubtitles(subtitles: string | null): void;
 }
 export type HMSPollsSlice = {
     polls: Record<string, HMSPoll>;

package/lib/typescript/types.d.ts

@@ -66,4 +66,13 @@ export type HMSHLSPlayerStatsUpdateEventData = {
 type HMSHLSPlayerStatsErrorEvent = HMSHLSPlayerEvent<HMSHLSPlayerStatsEventTypes.ON_STATS_EVENT_ERROR, HMSHLSPlayerStatsErrorEventData>;
 type HMSHLSPlayerStatsUpdateEvent = HMSHLSPlayerEvent<HMSHLSPlayerStatsEventTypes.ON_STATS_EVENT_UPDATE, HMSHLSPlayerStatsUpdateEventData>;
 export type HMSHLSPlayerStatsEvent = HMSHLSPlayerStatsErrorEvent | HMSHLSPlayerStatsUpdateEvent;
+export type HMSHLSPlayerCuesEvent = HMSHLSPlayerEvent<'ON_CLOSED_CAPTION_UPDATE', string | null>;
+export type RequestedDataEvent = {
+    requestId: number;
+    data: any;
+};
+export type HLSPlayerDurationDetails = {
+    streamDuration?: number;
+    rollingWindowTime?: number;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@100mslive/react-native-hms",
-  "version": "1.10.3",
+  "version": "1.10.5",
   "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",

package/sdk-versions.json

@@ -1,7 +1,7 @@
 {
-  "ios": "1.8.0",
+  "ios": "1.10.0",
   "iOSBroadcastExtension": "0.0.9",
   "iOSHMSHLSPlayer": "0.0.2",
   "iOSNoiseCancellationModels": "1.0.0",
-  "android": "2.9.53"
+  "android": "2.9.56"
 }

package/src/classes/HMSEncoder.ts

@@ -40,6 +40,7 @@ import { HMSLayer } from './HMSLayer';
 import { HMSSimulcastLayerDefinition } from './HMSSimulcastLayerDefinition';
 import { HMSQualityLimitationReasons } from './HMSQualityLimitationReasons';
 import { HMSTrackType } from './HMSTrackType';
+import { HMSHLSPlaylistType } from './HMSHLSPlaylistType';
 
 interface InitialData {
   roles: Record<string, HMSRole>;
@@ -520,6 +521,9 @@ export class HMSEncoder {
         meetingUrl: item.meetingUrl,
         metadata: item?.metaData ? item?.metadata : undefined,
         startedAt: HMSEncoder.encodeDate(item?.startedAt),
+        playlistType: item?.playlistType
+          ? this.getHLSVariantPlaylistType(item.playlistType.toUpperCase())
+          : undefined,
       });
       variants.push(variant);
     });
@@ -527,6 +531,15 @@ export class HMSEncoder {
     return variants;
   }
 
+  static getHLSVariantPlaylistType(type: String) {
+    switch (type) {
+      case 'DVR':
+        return HMSHLSPlaylistType.DVR;
+      default:
+        return HMSHLSPlaylistType.noDVR;
+    }
+  }
+
   static encodeHMSNetworkQuality(data: any) {
     if (data) {
       return new HMSNetworkQuality({

package/src/classes/HMSHLSPlaylistType.ts

@@ -0,0 +1,4 @@
+export enum HMSHLSPlaylistType {
+  DVR = 'DVR',
+  noDVR = 'noDVR',
+}

package/src/classes/HMSHLSVariant.ts

@@ -1,18 +1,23 @@
+import type { HMSHLSPlaylistType } from './HMSHLSPlaylistType';
+
 export class HMSHLSVariant {
   hlsStreamUrl?: string;
   meetingUrl?: string;
   metadata?: string;
   startedAt?: Date;
+  playlistType?: HMSHLSPlaylistType;
 
   constructor(params: {
     hlsStreamUrl?: string;
     meetingUrl?: string;
     metadata?: string;
     startedAt?: Date;
+    playlistType?: HMSHLSPlaylistType;
   }) {
     this.hlsStreamUrl = params.hlsStreamUrl;
     this.meetingUrl = params.meetingUrl;
     this.metadata = params.metadata;
     this.startedAt = params.startedAt;
+    this.playlistType = params.playlistType;
   }
 }

package/src/classes/HMSInteractivityCenter.ts

@@ -12,6 +12,14 @@ 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;
@@ -56,6 +64,26 @@ function unregisterPollUpdateListener() {
 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', {
@@ -69,16 +97,6 @@ export class HMSInteractivityCenter {
     );
   };
 
-  private _onAllPollUpdateListenerRemoved = () => {
-    unregisterPollUpdateListener();
-  };
-
-  constructor() {
-    this._eventEmitter.registerOnAllListenersRemoved(
-      this._onAllPollUpdateListenerRemoved
-    );
-  }
-
   /**
    * Adds a listener for poll updates
    * @param listener - Callback to be called when a poll is updated
@@ -164,4 +182,65 @@ export class HMSInteractivityCenter {
       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

@@ -2,6 +2,7 @@ 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 {
@@ -81,4 +82,11 @@ export class HMSInteractivityEncoder {
 
     return decodedPollLeaderboardResponse as PollLeaderboardResponse;
   }
+
+  static transformHMSWhiteboard(hmsWhiteboard: HMSWhiteboard): HMSWhiteboard {
+    if (hmsWhiteboard.owner) {
+      hmsWhiteboard.owner = HMSEncoder.encodeHmsPeer(hmsWhiteboard.owner);
+    }
+    return hmsWhiteboard;
+  }
 }

package/src/classes/HMSNoiseCancellationPlugin.ts

@@ -4,6 +4,7 @@ import { logger } from './HMSLogger';
 
 /**
  * Class representing an HMS Noise Cancellation Plugin.
+ * Checkout {@link https://www.100ms.live/docs/react-native/v2/how-to-guides/extend-capabilities/noise-cancellation} for more info
  */
 export class HMSNoiseCancellationPlugin {
   modelName: HMSNoiseCancellationModels;

package/src/classes/HMSPermissions.ts

@@ -1,3 +1,9 @@
+export interface HMSWhiteboardPermission {
+  admin?: boolean;
+  write?: boolean;
+  read?: boolean;
+}
+
 export class HMSPermissions {
   endRoom?: boolean;
   removeOthers?: boolean;
@@ -9,6 +15,7 @@ export class HMSPermissions {
   rtmpStreaming?: boolean;
   pollRead?: boolean;
   pollWrite?: boolean;
+  whiteboard?: HMSWhiteboardPermission;
 
   constructor(params?: {
     endRoom?: boolean;
@@ -21,6 +28,7 @@ export class HMSPermissions {
     rtmpStreaming?: boolean;
     pollRead?: boolean;
     pollWrite?: boolean;
+    whiteboard?: HMSWhiteboardPermission;
   }) {
     if (params) {
       this.endRoom = params.endRoom;
@@ -33,6 +41,7 @@ export class HMSPermissions {
       this.rtmpStreaming = params.rtmpStreaming;
       this.pollRead = params.pollRead;
       this.pollWrite = params.pollWrite;
+      this.whiteboard = params.whiteboard;
     }
   }
 }

package/src/classes/whiteboard/HMSWhiteboard.tsx

@@ -0,0 +1,16 @@
+import type { HMSPeer } from '../HMSPeer';
+import type { HMSWhiteboardState } from './HMSWhiteboardState';
+
+export interface HMSWhiteboard {
+  id: string;
+
+  title?: string;
+
+  state: HMSWhiteboardState;
+
+  isOwner: boolean;
+
+  owner?: HMSPeer;
+
+  url?: string;
+}

package/src/classes/whiteboard/HMSWhiteboardListenerActions.ts

@@ -0,0 +1,3 @@
+export enum HMSWhiteboardListenerActions {
+  ON_WHITEBOARD_UPDATE = 'ON_WHITEBOARD_UPDATE',
+}

package/src/classes/whiteboard/HMSWhiteboardState.tsx

@@ -0,0 +1,4 @@
+export enum HMSWhiteboardState {
+  STARTED = 'STARTED',
+  STOPPED = 'STOPPED',
+}

package/src/classes/whiteboard/HMSWhiteboardUpdateType.tsx

@@ -0,0 +1,4 @@
+export enum HMSWhiteboardUpdateType {
+  STARTED = 'STARTED',
+  STOPPED = 'STOPPED',
+}

package/src/classes/whiteboard/index.ts

@@ -0,0 +1,3 @@
+export * from './HMSWhiteboard';
+export * from './HMSWhiteboardUpdateType';
+export * from './HMSWhiteboardListenerActions';

package/src/classes/whiteboard/registerCallbacks.ts

@@ -0,0 +1,34 @@
+import { HMSConstants } from '../HMSConstants';
+import type { HMSEventSubscription } from '../HMSNativeEventEmitter';
+import HMSNativeEventListener from '../HMSNativeEventListener';
+import type { HMSWhiteboard } from './HMSWhiteboard';
+import { HMSWhiteboardListenerActions } from './HMSWhiteboardListenerActions';
+import type { HMSWhiteboardUpdateType } from './HMSWhiteboardUpdateType';
+
+export type WhiteboardUpdateListener = (data: {
+  hmsWhiteboard: HMSWhiteboard;
+  updateType: HMSWhiteboardUpdateType;
+}) => void;
+
+let whiteboardUpdateSubscription: null | HMSEventSubscription = null;
+
+export function registerWhiteboardUpdateListener(
+  listener: WhiteboardUpdateListener
+) {
+  if (whiteboardUpdateSubscription !== null) {
+    return;
+  }
+  whiteboardUpdateSubscription = HMSNativeEventListener.addListener(
+    HMSConstants.DEFAULT_SDK_ID,
+    HMSWhiteboardListenerActions.ON_WHITEBOARD_UPDATE,
+    listener
+  );
+}
+
+export function unregisterWhiteboardUpdateListener() {
+  if (whiteboardUpdateSubscription === null) {
+    return;
+  }
+  whiteboardUpdateSubscription.remove();
+  whiteboardUpdateSubscription = null;
+}