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

package/android/src/main/java/com/reactnativehmssdk/Interactivity/HMSInteractivityHelper.kt

@@ -0,0 +1,352 @@
+package com.reactnativehmssdk
+
+import com.facebook.react.bridge.ReadableMap
+import live.hms.video.polls.HMSPollBuilder
+import live.hms.video.polls.HMSPollQuestionBuilder
+import live.hms.video.polls.HMSPollResponseBuilder
+import live.hms.video.polls.models.HmsPoll
+import live.hms.video.polls.models.HmsPollCategory
+import live.hms.video.polls.models.HmsPollUserTrackingMode
+import live.hms.video.polls.models.question.HMSPollQuestion
+import live.hms.video.polls.models.question.HMSPollQuestionType
+import live.hms.video.sdk.models.role.HMSRole
+
+object HMSInteractivityHelper {
+  // region Create a poll
+  fun getPollBuilder(
+    data: ReadableMap,
+    roles: List<HMSRole>,
+  ): HMSPollBuilder {
+    val pollBuilder = HMSPollBuilder.Builder()
+
+    if (data.hasKey("isAnonymous")) {
+      pollBuilder.withAnonymous(data.getBoolean("isAnonymous"))
+    }
+
+    if (data.hasKey("duration")) {
+      pollBuilder.withDuration(data.getInt("duration").toLong())
+    }
+
+    if (data.hasKey("mode")) {
+      pollBuilder.withUserTrackingMode(getUserTrackingMode(data))
+    }
+
+    if (data.hasKey("type")) {
+      pollBuilder.withCategory(getPollCategory(data))
+    } else {
+      pollBuilder.withCategory(HmsPollCategory.POLL)
+    }
+
+    data.getString("pollId")?.let {
+      pollBuilder.withPollId(it)
+    }
+    data.getString("title")?.let {
+      pollBuilder.withTitle(it)
+    }
+
+    if (data.hasKey("rolesThatCanViewResponses")) {
+      pollBuilder.withRolesThatCanViewResponses(getRolesThatCanViewResponses(data, roles))
+    }
+
+    if (data.hasKey("rolesThatCanVote")) {
+      pollBuilder.withRolesThatCanVote(getRolesThatCanVote(data, roles))
+    }
+
+    if (data.hasKey("questions")) {
+      val questions = data.getArray("questions")?.toArrayList() as? ArrayList<HashMap<String, Any>>
+
+      if (questions != null) {
+        addQuestions(questions, pollBuilder)
+      }
+    }
+
+    return pollBuilder.build()
+  }
+
+  // endregion
+
+  // region Poll Builder Helpers
+  private fun getQuestionType(type: Int): HMSPollQuestionType {
+    return when (type) {
+      0 -> HMSPollQuestionType.singleChoice
+      1 -> HMSPollQuestionType.multiChoice
+      2 -> HMSPollQuestionType.shortAnswer
+      3 -> HMSPollQuestionType.longAnswer
+      else -> HMSPollQuestionType.singleChoice
+    }
+  }
+
+  private fun getUserTrackingMode(data: ReadableMap): HmsPollUserTrackingMode {
+    return when (data.getInt("mode")) {
+      0 -> HmsPollUserTrackingMode.PEER_ID
+      1 -> HmsPollUserTrackingMode.USER_ID
+      2 -> HmsPollUserTrackingMode.USERNAME
+      else -> HmsPollUserTrackingMode.PEER_ID
+    }
+  }
+
+  fun getPollCategory(data: ReadableMap): HmsPollCategory {
+    return when (data.getInt("type")) {
+      0 -> HmsPollCategory.POLL
+      1 -> HmsPollCategory.QUIZ
+      else -> HmsPollCategory.POLL
+    }
+  }
+
+  private fun getRolesThatCanViewResponses(
+    data: ReadableMap,
+    roles: List<HMSRole>,
+  ): List<HMSRole> {
+    val rolesThatCanViewResponsesString =
+      data.getArray("rolesThatCanViewResponses")?.toArrayList() as? ArrayList<String>
+    val encodedTargetedRoles =
+      return HMSHelper.getRolesFromRoleNames(rolesThatCanViewResponsesString, roles)
+  }
+
+  private fun getRolesThatCanVote(
+    data: ReadableMap,
+    roles: List<HMSRole>,
+  ): List<HMSRole> {
+    val rolesThatCanVoteString =
+      data.getArray("rolesThatCanVote")?.toArrayList() as? ArrayList<String>
+    return HMSHelper.getRolesFromRoleNames(rolesThatCanVoteString, roles)
+  }
+
+  private fun addQuestions(
+    questions: ArrayList<HashMap<String, Any>>,
+    pollBuilder: HMSPollBuilder.Builder,
+  ) {
+    for (question in questions) {
+      val type = question["type"] as? Double
+      type?.let {
+        addPollBuilderQuestion(getQuestionType(it.toInt()), question, pollBuilder)
+      }
+    }
+  }
+
+  private fun addSingleChoiceQuestion(
+    item: HashMap<String, Any>,
+    pollBuilder: HMSPollBuilder.Builder,
+  ) {
+    if (item["title"] != null && item["options"] != null) {
+      val title = item["title"] as? String
+      val options = item["options"] as? ArrayList<String>
+
+      if (title != null && options != null) {
+        val questionBuilder =
+          HMSPollQuestionBuilder.Builder(HMSPollQuestionType.singleChoice)
+            .withTitle(title)
+
+        for (i in 0 until options.size) {
+          questionBuilder.addOption(options[i])
+        }
+        pollBuilder.addQuestion(questionBuilder.build())
+      }
+    }
+  }
+
+  private fun addMultipleChoiceQuestion(
+    item: HashMap<String, Any>,
+    pollBuilder: HMSPollBuilder.Builder,
+  ) {
+    if (item["title"] != null && item["options"] != null) {
+      val title = item["title"] as? String
+      val options = item["options"] as? ArrayList<String>
+
+      if (title != null && options != null) {
+        val questionBuilder =
+          HMSPollQuestionBuilder.Builder(HMSPollQuestionType.multiChoice)
+            .withTitle(title)
+
+        for (i in 0 until options.size) {
+          questionBuilder.addOption(options[i])
+        }
+        pollBuilder.addQuestion(questionBuilder.build())
+      }
+    }
+  }
+
+  private fun addShortAnswerQuestion(
+    item: HashMap<String, Any>,
+    pollBuilder: HMSPollBuilder.Builder,
+  ) {
+    if (item["title"] != null) {
+      val title = item["title"] as? String
+
+      if (title != null) {
+        val questionBuilder =
+          HMSPollQuestionBuilder.Builder(HMSPollQuestionType.shortAnswer)
+            .withTitle(title)
+        pollBuilder.addQuestion(questionBuilder.build())
+      }
+    }
+  }
+
+  private fun addLongAnswerQuestion(
+    item: HashMap<String, Any>,
+    pollBuilder: HMSPollBuilder.Builder,
+  ) {
+    if (item["title"] != null) {
+      val title = item["title"] as? String
+
+      if (title != null) {
+        val questionBuilder =
+          HMSPollQuestionBuilder.Builder(HMSPollQuestionType.longAnswer)
+            .withTitle(title)
+        pollBuilder.addQuestion(questionBuilder.build())
+      }
+    }
+  }
+
+  private fun addPollBuilderQuestion(
+    type: HMSPollQuestionType,
+    item: HashMap<String, Any>,
+    pollBuilder: HMSPollBuilder.Builder,
+  ) {
+    val questionBuilder = HMSPollQuestionBuilder.Builder(type)
+
+//    val answerHidden = item["answerHidden"] as? Boolean
+//    if (answerHidden != null) {
+//      questionBuilder.withAnswerHidden(answerHidden)
+//    }
+
+    val canBeSkipped = item["skippable"] as? Boolean
+    if (canBeSkipped != null) {
+      questionBuilder.withCanBeSkipped(canBeSkipped)
+    }
+
+    val canChangeResponse = item["once"] as? Boolean
+    if (canChangeResponse != null) {
+      questionBuilder.withCanChangeResponse(!canChangeResponse)
+    }
+
+    val duration = item["duration"] as? Int
+    if (duration != null) {
+      questionBuilder.withDuration(duration.toLong())
+    }
+
+    val maxLength = item["answerMaxLen"] as? Int
+    if (maxLength != null) {
+      questionBuilder.withMaxLength(maxLength.toLong())
+    }
+
+    val minLength = item["answerMinLen"] as? Int
+    if (minLength != null) {
+      questionBuilder.withMinLength(minLength.toLong())
+    }
+
+    val title = item["text"] as? String
+    if (title != null) {
+      questionBuilder.withTitle(title)
+    }
+
+    val weight = item["weight"] as? Int
+    if (weight != null) {
+      questionBuilder.withWeight(weight)
+    }
+
+    val options = item["options"] as? ArrayList<HashMap<String, Any>>
+    options?.let {
+      addOptions(it, questionBuilder)
+    }
+
+    questionBuilder.build().let {
+      pollBuilder.addQuestion(it)
+    }
+  }
+
+  private fun addOptions(
+    options: ArrayList<HashMap<String, Any>>,
+    questionBuilder: HMSPollQuestionBuilder.Builder,
+  ) {
+    for (i in 0 until options.size) {
+      val option = options[i]
+
+      if (option["isCorrect"] != null) {
+        val isCorrect = option["isCorrectAnswer"] as? Boolean
+        if (isCorrect != null) {
+          questionBuilder.addQuizOption(
+            option["text"] as? String ?: "",
+            isCorrect,
+          )
+        }
+      } else {
+        questionBuilder.addOption(option["text"] as? String ?: "")
+      }
+    }
+  }
+
+  // endregion
+
+  // region Poll Response
+
+  fun getPollResponseBuilder(
+    response: ReadableMap,
+    poll: HmsPoll,
+    pollQuestion: HMSPollQuestion,
+  ): HMSPollResponseBuilder {
+    val pollResponseBuilder = HMSPollResponseBuilder(hmsPoll = poll, userId = null)
+
+    when (pollQuestion.type) {
+      HMSPollQuestionType.longAnswer, HMSPollQuestionType.shortAnswer -> {
+        val responseText = response.getString("text")
+        if (responseText != null) {
+          if (response.hasKey("duration")) {
+            val duration = response.getInt("duration")
+            pollResponseBuilder.addResponse(pollQuestion, responseText, duration.toLong())
+          } else {
+            pollResponseBuilder.addResponse(pollQuestion, responseText)
+          }
+        }
+      }
+      HMSPollQuestionType.singleChoice -> {
+        val options = response.getArray("options")?.toArrayList() as? ArrayList<Double>
+        val pollQuestionOptions = pollQuestion.options
+
+        if (options != null && pollQuestionOptions != null && options.isNotEmpty()) {
+          pollQuestionOptions.firstOrNull()?.let { pollQuestionOption ->
+            val questionOption =
+              pollQuestionOptions.firstOrNull { pollQuestionOption ->
+                pollQuestionOption.index == options[0].toInt()
+              }
+
+            if (questionOption != null) {
+              if (response.hasKey("duration")) {
+                val duration = response.getInt("duration")
+                pollResponseBuilder.addResponse(pollQuestion, questionOption, duration.toLong())
+              } else {
+                pollResponseBuilder.addResponse(pollQuestion, questionOption)
+              }
+            }
+          }
+        }
+      }
+      HMSPollQuestionType.multiChoice -> {
+        val options = response.getArray("options")?.toArrayList() as? ArrayList<Int>
+        val pollQuestionOptions = pollQuestion.options
+
+        if (options != null && pollQuestionOptions != null) {
+          val questionOptions =
+            options.mapNotNull { optionIndex ->
+              pollQuestionOptions.firstOrNull { pollQuestionOption ->
+                pollQuestionOption.index == optionIndex
+              }
+            }
+
+          if (response.hasKey("duration")) {
+            val duration = response.getInt("duration")
+            pollResponseBuilder.addResponse(pollQuestion, questionOptions, duration.toLong())
+          } else {
+            pollResponseBuilder.addResponse(pollQuestion, questionOptions)
+          }
+        }
+      }
+      else -> {
+        // @unknown default case: Invalid pollQuestionType
+      }
+    }
+    return pollResponseBuilder
+  }
+
+  // endregion
+}

package/android/src/main/java/com/reactnativehmssdk/Interactivity/HMSRNInteractivityCenter.kt

@@ -0,0 +1,184 @@
+package com.reactnativehmssdk
+import android.util.Log
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
+import com.reactnativehmssdk.Interactivity.HMSInteractivityDecoder
+import live.hms.video.error.HMSException
+import live.hms.video.interactivity.HmsPollUpdateListener
+import live.hms.video.polls.models.HMSPollUpdateType
+import live.hms.video.polls.models.HmsPoll
+import live.hms.video.polls.models.answer.PollAnswerResponse
+import live.hms.video.sdk.HMSActionResultListener
+import live.hms.video.sdk.HMSSDK
+import live.hms.video.sdk.HmsTypedActionResultListener
+
+class HMSRNInteractivityCenter(private val sdk: HMSSDK, private val rnSDK: HMSRNSDK) {
+  init {
+    // Listen for poll updates
+    this.sdk.getHmsInteractivityCenter().pollUpdateListener =
+      object : HmsPollUpdateListener {
+        override fun onPollUpdate(
+          hmsPoll: HmsPoll,
+          hmsPollUpdateType: HMSPollUpdateType,
+        ) {
+          if (rnSDK.eventsEnableStatus["ON_POLL_UPDATE"] != true) {
+            return
+          }
+
+          val data: WritableMap = Arguments.createMap()
+
+          data.putInt("update", HMSInteractivityDecoder.getPollUpdateType(hmsPollUpdateType))
+          data.putMap("updatedPoll", HMSInteractivityDecoder.getPoll(hmsPoll))
+
+          rnSDK.delegate.emitEvent("ON_POLL_UPDATE", data)
+        }
+      }
+  }
+
+  // region Create Polls
+
+  fun quickStartPoll(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    this.sdk.getHmsInteractivityCenter().quickStartPoll(
+      HMSInteractivityHelper.getPollBuilder(data, sdk.getRoles()),
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          // Error
+          promise?.reject(error.message, error)
+        }
+
+        override fun onSuccess() {
+          // Success
+          promise?.resolve(null)
+        }
+      },
+    )
+  }
+
+  /*
+
+  func add(_ data: NSDictionary, _ resolve: RCTPromiseResolveBlock?, _ reject: RCTPromiseRejectBlock?) {
+        guard let pollId = data["pollId"] as? String,
+              let poll = self.hmssdk?.interactivityCenter.polls.first(where: {poll in poll.pollID == pollId}) else {
+            reject?("6004", "Unable to find HMSPoll with given pollId", nil)
+            return
+        }
+        guard let pollQuestionIndex = data["pollQuestionIndex"] as? Int,
+              let pollQuestion = poll.questions?.first(where: {question in question.index == pollQuestionIndex}) else {
+            reject?("6004", "Unable to find HMSPollQuestion in poll with given question index", nil)
+            return
+        }
+        guard let responses = data["responses"] as? NSDictionary else {
+            reject?("6004", "responses field is required", nil)
+            return
+        }
+
+        let pollResponseBuilder = HMSInteractivityHelper.getPollResponseBuilder(responses, poll: poll, pollQuestion: pollQuestion)
+
+        self.hmssdk?.interactivityCenter.add(response: pollResponseBuilder) { pollQuestionResponseResult, error in
+            if let nonnilError = error {
+                reject?("6004", nonnilError.localizedDescription, nil)
+                return
+            }
+            if let pollQuestionResponseResult = pollQuestionResponseResult {
+                resolve?(HMSInteractivityDecoder.getHMSPollQuestionResponseResults(pollQuestionResponseResult))
+            } else {
+                resolve?(nil)
+            }
+        }
+    }
+
+   */
+
+  fun addResponseOnPollQuestion(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val pollId = data.getString("pollId")
+    if (pollId == null) {
+      promise?.reject("6002", "pollId is required")
+      return
+    }
+    val poll = this.sdk.getHmsInteractivityCenter().polls.find { it.pollId == pollId }
+    if (poll == null) {
+      promise?.reject("6002", "No HMSPoll with pollId `$pollId`")
+      return
+    }
+    val pollQuestionIndex = data.getInt("pollQuestionIndex")
+    val pollQuestion = poll.questions?.find { it.questionID == pollQuestionIndex }
+    if (pollQuestion == null) {
+      promise?.reject("6002", "No HMSPollQuestion in poll with given question index")
+      return
+    }
+    val responses = data.getMap("responses")
+    if (responses == null) {
+      promise?.reject("6002", "responses field is required")
+      return
+    }
+    val pollResponseBuilder = HMSInteractivityHelper.getPollResponseBuilder(responses, poll, pollQuestion)
+    this.sdk.getHmsInteractivityCenter().add(
+      pollResponseBuilder,
+      object : HmsTypedActionResultListener<PollAnswerResponse> {
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.description)
+        }
+
+        override fun onSuccess(result: PollAnswerResponse) {
+          promise?.resolve(HMSInteractivityDecoder.getHMSPollQuestionResponseResults(result))
+        }
+      },
+    )
+  }
+
+  fun stop(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val pollId = data.getString("pollId")
+    if (pollId == null) {
+      promise?.reject("6002", "pollId is required")
+      return
+    }
+    val poll = this.sdk.getHmsInteractivityCenter().polls.find { it.pollId == pollId }
+    if (poll == null) {
+      promise?.reject("6002", "No HMSPoll with pollId `$pollId`")
+      return
+    }
+    this.sdk.getHmsInteractivityCenter().stop(
+      poll,
+      object : HMSActionResultListener {
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.description)
+        }
+
+        override fun onSuccess() {
+          promise?.resolve(true)
+        }
+      },
+    )
+  }
+
+  // endregion
+
+  // region Poll Update Listener
+
+  fun showPollStartedToast() {
+    // Show toast
+    Log.e("Interactivity", "showPollStartedToast")
+  }
+
+  fun loadResultsSummaryIfNeeded() {
+    // Load results summary
+    Log.e("Interactivity", "loadResultsSummaryIfNeeded")
+  }
+
+  fun updateResultsScreen() {
+    // Update results screen
+    Log.e("Interactivity", "updateResultsScreen")
+  }
+  // endregion
+}

package/ios/HMSConstants.swift

@@ -31,4 +31,5 @@ struct HMSConstants {
     static let ON_REMOTE_VIDEO_STATS = "ON_REMOTE_VIDEO_STATS"
     static let ON_SESSION_STORE_AVAILABLE = "ON_SESSION_STORE_AVAILABLE"
     static let ON_SESSION_STORE_CHANGED = "ON_SESSION_STORE_CHANGED"
+    static let ON_POLL_UPDATE = "ON_POLL_UPDATE"
 }

package/ios/HMSDecoder.swift

@@ -448,7 +448,9 @@ class HMSDecoder: NSObject {
             "rtmpStreaming": permissions.rtmpStreaming ?? false,
             "mute": permissions.mute ?? false,
             "unmute": permissions.unmute ?? false,
-            "changeRole": permissions.changeRole ?? false
+            "changeRole": permissions.changeRole ?? false,
+            "pollRead": permissions.pollRead ?? false,
+            "pollWrite": permissions.pollWrite ?? false
         ]
     }