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

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

@@ -0,0 +1,353 @@
+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 =
+    when (type) {
+      0 -> HMSPollQuestionType.singleChoice
+      1 -> HMSPollQuestionType.multiChoice
+      2 -> HMSPollQuestionType.shortAnswer
+      3 -> HMSPollQuestionType.longAnswer
+      else -> HMSPollQuestionType.singleChoice
+    }
+
+  private fun getUserTrackingMode(data: ReadableMap): HmsPollUserTrackingMode =
+    when (data.getInt("mode")) {
+      0 -> HmsPollUserTrackingMode.PEER_ID
+      1 -> HmsPollUserTrackingMode.USER_ID
+      2 -> HmsPollUserTrackingMode.USERNAME
+      else -> HmsPollUserTrackingMode.PEER_ID
+    }
+
+  fun getPollCategory(data: ReadableMap): HmsPollCategory =
+    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["isCorrectAnswer"] != 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,245 @@
+package com.reactnativehmssdk
+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.polls.network.PollLeaderboardResponse
+import live.hms.video.sdk.HMSActionResultListener
+import live.hms.video.sdk.HMSSDK
+import live.hms.video.sdk.HmsTypedActionResultListener
+import live.hms.video.whiteboard.HMSWhiteboardUpdate
+import live.hms.video.whiteboard.HMSWhiteboardUpdateListener
+
+class HMSRNInteractivityCenter(
+  private val sdk: HMSSDK,
+  private val rnSDK: HMSRNSDK,
+) {
+  init {
+    //region 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)
+        }
+      }
+    //endregion
+
+    //region Listen for whiteboard updates
+    this.sdk.getHmsInteractivityCenter().setWhiteboardUpdateListener(
+      object : HMSWhiteboardUpdateListener {
+        override fun onUpdate(hmsWhiteboardUpdate: HMSWhiteboardUpdate) {
+          if (rnSDK.eventsEnableStatus["ON_WHITEBOARD_UPDATE"] != true) {
+            return
+          }
+          val data: WritableMap = Arguments.createMap()
+          when (hmsWhiteboardUpdate) {
+            is HMSWhiteboardUpdate.Start -> {
+              data.putMap("hmsWhiteboard", HMSInteractivityDecoder.getHMSWhiteboard(hmsWhiteboardUpdate.hmsWhiteboard))
+              data.putString("updateType", HMSInteractivityDecoder.getWhiteboardUpdateType(hmsWhiteboardUpdate))
+            }
+            is HMSWhiteboardUpdate.Stop -> {
+              data.putMap("hmsWhiteboard", HMSInteractivityDecoder.getHMSWhiteboard(hmsWhiteboardUpdate.hmsWhiteboard))
+              data.putString("updateType", HMSInteractivityDecoder.getWhiteboardUpdateType(hmsWhiteboardUpdate))
+            }
+          }
+          rnSDK.delegate.emitEvent("ON_WHITEBOARD_UPDATE", data)
+        }
+      },
+    )
+    //endregion
+  }
+
+  //region poll methods
+  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)
+        }
+      },
+    )
+  }
+
+  fun addResponseOnPollQuestion(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val pollId = data.getString("pollId")
+    if (pollId == null) {
+      promise?.reject("6004", "pollId is required")
+      return
+    }
+    val poll =
+      this.sdk
+        .getHmsInteractivityCenter()
+        .polls
+        .find { it.pollId == pollId }
+    if (poll == null) {
+      promise?.reject("6004", "No HMSPoll with pollId `$pollId`")
+      return
+    }
+    val pollQuestionIndex = data.getInt("pollQuestionIndex")
+    val pollQuestion = poll.questions?.find { it.questionID == pollQuestionIndex }
+    if (pollQuestion == null) {
+      promise?.reject("6004", "No HMSPollQuestion in poll with given question index")
+      return
+    }
+    val responses = data.getMap("responses")
+    if (responses == null) {
+      promise?.reject("6004", "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("6004", "pollId is required")
+      return
+    }
+    val poll =
+      this.sdk
+        .getHmsInteractivityCenter()
+        .polls
+        .find { it.pollId == pollId }
+    if (poll == null) {
+      promise?.reject("6004", "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)
+        }
+      },
+    )
+  }
+
+  fun fetchLeaderboard(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val pollId = data.getString("pollId")
+    if (pollId == null) {
+      promise?.reject("6004", "pollId is required")
+      return
+    }
+    val poll =
+      this.sdk
+        .getHmsInteractivityCenter()
+        .polls
+        .find { it.pollId == pollId }
+    if (poll == null) {
+      promise?.reject("6004", "No HMSPoll with pollId `$pollId`")
+      return
+    }
+    val count = data.getInt("count")
+    val startIndex = data.getInt("startIndex")
+    val includeCurrentPeer = data.getBoolean("includeCurrentPeer")
+
+    this.sdk.getHmsInteractivityCenter().fetchLeaderboard(
+      pollId = poll.pollId,
+      count = count.toLong(),
+      startIndex = startIndex.toLong(),
+      includeCurrentPeer = includeCurrentPeer,
+      object : HmsTypedActionResultListener<PollLeaderboardResponse> {
+        override fun onSuccess(result: PollLeaderboardResponse) {
+          promise?.resolve(HMSInteractivityDecoder.getPollLeaderboardResponse(result))
+        }
+
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.description)
+        }
+      },
+    )
+  }
+  //endregion
+
+  //region whiteboard methods
+  fun startWhiteboard(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val whiteboardTitle = data.getString("title")
+    if (whiteboardTitle == null) {
+      promise?.reject("6004", "whiteboard title is required")
+      return
+    }
+    sdk.getHmsInteractivityCenter().startWhiteboard(
+      whiteboardTitle,
+      object : HMSActionResultListener {
+        override fun onSuccess() {
+          promise?.resolve(true)
+        }
+
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.description)
+        }
+      },
+    )
+  }
+
+  fun stopWhiteboard(promise: Promise?) {
+    sdk.getHmsInteractivityCenter().stopWhiteboard(
+      object : HMSActionResultListener {
+        override fun onSuccess() {
+          promise?.resolve(true)
+        }
+
+        override fun onError(error: HMSException) {
+          promise?.reject(error.code.toString(), error.description)
+        }
+      },
+    )
+  }
+  //endregion
+}

package/android/src/main/java/com/reactnativehmssdk/PipActionReceiver.kt

@@ -7,10 +7,20 @@ import android.content.Intent
 import android.content.IntentFilter
 import android.os.Build
 import androidx.annotation.RequiresApi
+import androidx.core.content.ContextCompat
+import androidx.core.content.ContextCompat.RECEIVER_NOT_EXPORTED
 
-data class PIPAction(val title: String, val description: String, val requestCode: Int)
+data class PIPAction(
+  val title: String,
+  val description: String,
+  val requestCode: Int,
+)
 
-data class PIPActions(val endMeet: PIPAction, val localAudio: PIPAction, val localVideo: PIPAction)
+data class PIPActions(
+  val endMeet: PIPAction,
+  val localAudio: PIPAction,
+  val localVideo: PIPAction,
+)
 
 @RequiresApi(Build.VERSION_CODES.O)
 class PipActionReceiver(
@@ -54,7 +64,7 @@ class PipActionReceiver(
 
     IntentFilter().also {
       it.addAction(PIP_INTENT_ACTION)
-      activity.registerReceiver(this, it)
+      ContextCompat.registerReceiver(activity, this, it, RECEIVER_NOT_EXPORTED)
     }
     registered = true
   }