@100mslive/react-native-hms 1.9.9 → 1.9.11

package/src/classes/HMSInteractivityCenter.ts

@@ -0,0 +1,137 @@
+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';
+
+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 _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
+    );
+  };
+
+  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
+   * @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);
+  }
+}

package/src/classes/HMSInteractivityEncoder.ts

@@ -0,0 +1,29 @@
+import type { HMSPoll } from './polls/HMSPoll';
+
+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);
+      }
+    }
+    // poll.rolesThatCanVote: HMSRole[];
+    // poll.rolesThatCanViewResponses: HMSRole[];
+    // --- poll.questions: HMSPollQuestion[]
+    // --- poll.result: HMSPollResult
+    return poll;
+  }
+}

package/src/classes/HMSPermissions.ts

@@ -7,6 +7,8 @@ export class HMSPermissions {
   browserRecording?: boolean;
   hlsStreaming?: boolean;
   rtmpStreaming?: boolean;
+  pollRead?: boolean;
+  pollWrite?: boolean;
 
   constructor(params?: {
     endRoom?: boolean;
@@ -17,6 +19,8 @@ export class HMSPermissions {
     browserRecording?: boolean;
     hlsStreaming?: boolean;
     rtmpStreaming?: boolean;
+    pollRead?: boolean;
+    pollWrite?: boolean;
   }) {
     if (params) {
       this.endRoom = params.endRoom;
@@ -27,6 +31,8 @@ export class HMSPermissions {
       this.browserRecording = params.browserRecording;
       this.hlsStreaming = params.hlsStreaming;
       this.rtmpStreaming = params.rtmpStreaming;
+      this.pollRead = params.pollRead;
+      this.pollWrite = params.pollWrite;
     }
   }
 }

package/src/classes/HMSPollsListenerActions.ts

@@ -0,0 +1,3 @@
+export enum HMSPollsListenerActions {
+  ON_POLL_UPDATE = 'ON_POLL_UPDATE',
+}

package/src/classes/HMSSDK.tsx

@@ -46,6 +46,7 @@ import { HMSSessionStore } from './HMSSessionStore';
 import type { HMSPeerListIteratorOptions } from './HMSPeerListIteratorOptions';
 import { HMSPeerListIterator } from './HMSPeerListIterator';
 import type { HMSPIPConfig } from './HMSPIPConfig';
+import { HMSInteractivityCenter } from './HMSInteractivityCenter';
 
 type HmsViewProps = Omit<HmsComponentProps, 'id'>;
 
@@ -55,6 +56,8 @@ let HmsSdk: HMSSDK | undefined;
 
 export class HMSSDK {
   id: string;
+  private _interactivityCenter: HMSInteractivityCenter | null = null;
+
   private appStateSubscription?: any;
   private onPreviewDelegate?: any;
   private onJoinDelegate?: any;
@@ -2491,6 +2494,13 @@ export class HMSSDK {
     });
   }
 
+  get interactivityCenter() {
+    if (!this._interactivityCenter) {
+      this._interactivityCenter = new HMSInteractivityCenter();
+    }
+    return this._interactivityCenter;
+  }
+
   /**
    * - Returns the instance of logger which can be used to manipulate log levels.
    * @returns @instance HMSLogger

package/src/classes/polls/HMSPoll.ts

@@ -0,0 +1,108 @@
+import type { HMSPollState } from './HMSPollState';
+import type { HMSPollQuestion } from './HMSPollQuestion';
+import type { HMSPollResult } from './HMSPollResult';
+import type { HMSRole } from '../HMSRole';
+import type { HMSPollUserTrackingMode } from './HMSPollUserTrackingMode';
+import type { HMSPollType } from './HMSPollType';
+import type { HMSPeer } from '../HMSPeer';
+
+type HMSPeerSubset = {
+  peerID: HMSPeer['peerID'];
+  name: HMSPeer['name'];
+};
+
+type HMSRoleSubset = {
+  name: HMSRole['name'];
+};
+
+export interface HMSPoll {
+  /**
+   The unique identifier of the poll.
+   */
+  pollId: string;
+
+  /**
+   The title of the poll.
+   */
+  title: string;
+
+  /**
+   The duration of the poll in seconds.
+   */
+  duration?: number;
+
+  /**
+   A flag indicating whether the poll is anonymous or not.
+   */
+  anonymous?: boolean;
+
+  /**
+   The tracking mode for user participation in the poll.
+   */
+  mode?: HMSPollUserTrackingMode;
+
+  /**
+   The roles that can vote in the poll.
+   */
+  rolesThatCanVote?: HMSRoleSubset[];
+
+  /**
+   The roles that can view the poll responses.
+   */
+  rolesThatCanViewResponses?: HMSRoleSubset[];
+
+  /**
+   The peer who started the poll.
+   */
+  startedBy?: HMSPeerSubset;
+
+  /**
+   The peer who stopped the poll.
+   */
+  stoppedBy?: HMSPeerSubset;
+
+  /**
+   The peer who created the poll.
+   */
+  createdBy?: HMSPeerSubset;
+
+  /**
+   The date and time when the poll was started.
+   */
+  startedAt?: Date;
+
+  /**
+   The date and time when the poll was stopped.
+   */
+  stoppedAt?: Date;
+
+  /**
+   The type of the poll.
+   */
+  type: HMSPollType;
+
+  /**
+   The current state of the poll.
+   */
+  state?: HMSPollState;
+
+  /**
+   The list of questions in the poll.
+   */
+  questions?: HMSPollQuestion[];
+
+  /**
+   The result of the poll.
+   */
+  result?: HMSPollResult;
+
+  // /**
+  //  The visiblity of the poll. (Not available on iOS)
+  //  */
+  // visibility?: boolean;
+
+  // /**
+  //  * Is poll locked currently? (Not available on iOS)
+  //  */
+  // locked?: boolean;
+}

package/src/classes/polls/HMSPollCategory.ts

@@ -0,0 +1,11 @@
+export enum HMSPollCategory {
+  /**
+   The poll is a standard poll.
+   */
+  poll,
+
+  /**
+   The poll is a quiz.
+   */
+  quiz,
+}

package/src/classes/polls/HMSPollCreateParams.ts

@@ -0,0 +1,20 @@
+import type { HMSRole } from '../HMSRole';
+import type { HMSPoll } from './HMSPoll';
+import type { HMSPollQuestionCreateParams } from './HMSPollQuestionCreateParams';
+
+export interface HMSPollCreateParams
+  extends Pick<
+    HMSPoll,
+    | 'title'
+    | 'type'
+    | 'duration'
+    | 'anonymous'
+    // | 'visibility'
+    // | 'locked'
+    | 'mode'
+  > {
+  pollId?: HMSPoll['pollId'];
+  questions?: HMSPollQuestionCreateParams[];
+  rolesThatCanVote?: HMSRole[];
+  rolesThatCanViewResponses?: HMSRole[];
+}

package/src/classes/polls/HMSPollQuestion.ts

@@ -0,0 +1,92 @@
+import type { HMSPollQuestionAnswer } from './HMSPollQuestionAnswer';
+import type { HMSPollQuestionOption } from './HMSPollQuestionOption';
+import type { HMSPollQuestionResponse } from './HMSPollQuestionResponse';
+import type { HMSPollQuestionType } from './HMSPollQuestionType';
+
+/**
+ Represents a question in a poll.
+ */
+export interface HMSPollQuestion {
+  /**
+   The index of the question within the poll.
+   */
+  index: number;
+
+  /**
+   The text of the question.
+   */
+  text: string;
+
+  /**
+   A flag indicating whether the question is skippable or not.
+   */
+  skippable: boolean;
+
+  /**
+   The duration hint of the question in seconds. Can be used for setting a timeframe withing which a question can be responded to. Not enforced by the server.
+   */
+  duration: number;
+
+  /**
+   A flag indicating whether the question can be answered only once.
+   */
+  once: boolean;
+
+  /**
+   The weight of the question in scoring.
+   */
+  weight: number;
+
+  /**
+   The minimum length of the answer (if applicable).
+   */
+  answerMinLen?: number;
+
+  /**
+   The maximum length of the answer (if applicable).
+   */
+  answerMaxLen?: number;
+
+  /**
+   The type of the question.
+   */
+  type: HMSPollQuestionType;
+
+  /**
+   The list of options for the question (if applicable).
+   */
+  options?: HMSPollQuestionOption[];
+
+  /**
+   The answer for the question (if it is a quiz).
+   */
+  answer?: HMSPollQuestionAnswer;
+
+  /**
+   The list of responses for the question.
+   */
+  responses?: HMSPollQuestionResponse[];
+
+  /**
+   The responses provided by the current user for the question.
+   */
+  myResponses: HMSPollQuestionResponse[];
+}
+
+// Web Inteface -
+// export interface HMSPollQuestion {
+//   index: number;
+//   text: string;
+//   type: HMSPollQuestionType;
+//   skippable?: boolean;
+//   duration?: number;
+//   once?: boolean;
+//   weight?: number;
+//   negative?: boolean;
+//   answerMinLen?: number;
+//   answerMaxLen?: number;
+//   options?: HMSPollQuestionOption[];
+//   answer?: HMSPollQuestionAnswer;
+//   responses?: HMSPollQuestionResponse[];
+//   result?: HMSPollQuestionResult;
+// }

package/src/classes/polls/HMSPollQuestionAnswer.ts

@@ -0,0 +1,29 @@
+/**
+ Provides the correct answer for a quiz question to check users' responses against.
+ */
+export interface HMSPollQuestionAnswer {
+  /**
+   A flag indicating whether the answer should be hidden or not.
+   */
+  hidden: boolean;
+
+  /**
+   The index of the selected option (in case of single choice question).
+   */
+  option?: number;
+
+  /**
+   The list of indexes of selected options (in case of multiple choice question).
+   */
+  options?: number[];
+}
+
+// Web Inteface -
+// export interface HMSPollQuestionAnswer {
+//   hidden: boolean; // if true answer will not be returned when poll is running
+//   option?: number; // option index for correct answer, in case of single choice
+//   options?: number[]; // list of options that shoould be in answer
+//   text?: string; // answer text for answer.
+//   case?: boolean; // if false case is ignored when comparing.
+//   trim?: boolean; // if true, empty space is trimmer from start and end of asnwer.
+// }

package/src/classes/polls/HMSPollQuestionCreateParams.ts

@@ -0,0 +1,36 @@
+import type { HMSPollQuestion } from './HMSPollQuestion';
+import type { HMSPollQuestionOptionCreateParams } from './HMSPollQuestionOptionCreateParams';
+import type { HMSPollQuestionQuizOptionCreateParams } from './HMSPollQuestionQuizOptionCreateParams';
+
+export interface HMSPollQuestionCreateParams
+  extends Pick<
+    HMSPollQuestion,
+    'text' | 'skippable' | 'type' | 'answerMinLen' | 'answerMaxLen'
+  > {
+  /**
+   * A flag indicating whether the question can be answered only once.
+   */
+  once?: HMSPollQuestion['once'];
+
+  /**
+   * The duration hint of the question in seconds. Can be used for setting a timeframe withing which a question can be responded to. Not enforced by the server.
+   */
+  duration?: HMSPollQuestion['duration'];
+
+  /**
+   * The index of the question within the poll.
+   */
+  index?: HMSPollQuestion['index'];
+
+  /**
+   * The options of the question.
+   */
+  options?:
+    | HMSPollQuestionOptionCreateParams[]
+    | HMSPollQuestionQuizOptionCreateParams[];
+
+  /**
+   * The weight of the question in scoring.
+   */
+  weight?: number;
+}

package/src/classes/polls/HMSPollQuestionOption.ts

@@ -0,0 +1,24 @@
+/**
+ Represents an option for a poll question.
+ */
+export interface HMSPollQuestionOption {
+  /**
+   The index of the option within the question.
+   */
+  index: number;
+
+  /**
+   The text of the option.
+   */
+  text: string;
+
+  /**
+   The weight of the option in scoring.
+   */
+  weight: number; // (optional on web)
+
+  /**
+   The count of votes received for the option. `0` is the default value.
+   */
+  voteCount: number; // (optional on web)
+}

package/src/classes/polls/HMSPollQuestionOptionCreateParams.ts

@@ -0,0 +1,8 @@
+import type { HMSPollQuestionOption } from './HMSPollQuestionOption';
+
+export interface HMSPollQuestionOptionCreateParams
+  extends Pick<
+    HMSPollQuestionOption,
+    'text'
+    // | 'weight' // `weight` field is not required as of now
+  > {}

package/src/classes/polls/HMSPollQuestionQuizOptionCreateParams.ts

@@ -0,0 +1,6 @@
+import type { HMSPollQuestionOptionCreateParams } from './HMSPollQuestionOptionCreateParams';
+
+export interface HMSPollQuestionQuizOptionCreateParams
+  extends HMSPollQuestionOptionCreateParams {
+  isCorrectAnswer: boolean;
+}

package/src/classes/polls/HMSPollQuestionResponse.ts

@@ -0,0 +1,72 @@
+import type { HMSPollQuestionType } from './HMSPollQuestionType';
+import type { HMSPollResponsePeerInfo } from './HMSPollResponsePeerInfo';
+
+/**
+ Represents a response for a poll question.
+ */
+export interface HMSPollQuestionResponse {
+  /**
+   The ID of the question associated with the response.
+   */
+  questionID: number;
+
+  /**
+   The type of the question associated with the response.
+   */
+  type: HMSPollQuestionType;
+
+  /**
+   A flag indicating whether the question was skipped or not.
+   */
+  skipped: boolean;
+
+  /**
+   The index of the selected option (in case of single choice question).
+   */
+  option: number;
+
+  /**
+   The list of indexes of selected options (in case of multiple choice question).
+   */
+  options?: number[];
+
+  /**
+   The text answer provided (in case of short/long answer question).
+   */
+  text: string;
+
+  /**
+   A flag indicating whether the response was updated from previous response.
+   */
+  update: boolean;
+
+  /**
+   Time taken to respond.
+   */
+  duration: number;
+
+  /**
+   The peer information associated with the response. Depends on the tracking type selected for poll.
+   */
+  peer?: HMSPollResponsePeerInfo;
+
+  /**
+   A flag indicating whether the response is final in case multiple responses were sent for this question.
+   */
+  responseFinal?: boolean;
+}
+
+// Web Interface -
+// export interface HMSPollQuestionResponse {
+//   id?: string;
+//   questionIndex: number;
+//   peer?: HMSPollResponsePeerInfo;
+//   type?: HMSPollQuestionType;
+//   skipped?: boolean;
+//   option?: number;
+//   options?: number[];
+//   text?: string;
+//   update?: boolean; // SDK Needs to track whether we previously answered and set accordingly
+//   duration?: number; // Time it took to answer the question for leaderboard
+//   responseFinal?: boolean; // Indicates whether this is last update when fetching responses
+// }

package/src/classes/polls/HMSPollQuestionResponseCreateParams.ts

@@ -0,0 +1,6 @@
+import type { HMSPollQuestionResponse } from './HMSPollQuestionResponse';
+
+export type HMSPollQuestionResponseCreateParams = Omit<
+  HMSPollQuestionResponse,
+  'type' | 'peer' | 'update' | 'responseFinal'
+>;

package/src/classes/polls/HMSPollQuestionResponseResult.ts

@@ -0,0 +1,19 @@
+/**
+ * Represents the result of a poll question response.
+ */
+export interface HMSPollQuestionResponse {
+  /**
+   * The ID of the question associated with the response result.
+   */
+  question: number;
+
+  /**
+   * A flag indicating whether the response was correct or not in case of quiz.
+   */
+  correct?: boolean;
+
+  /**
+   * An error associated with the response result (if any).
+   */
+  error?: string;
+}