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

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

@@ -0,0 +1,435 @@
+package com.reactnativehmssdk.Interactivity
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.WritableArray
+import com.facebook.react.bridge.WritableMap
+import com.reactnativehmssdk.HMSDecoder
+import live.hms.video.polls.models.*
+import live.hms.video.polls.models.answer.HMSPollQuestionAnswer
+import live.hms.video.polls.models.answer.HmsPollAnswer
+import live.hms.video.polls.models.answer.PollAnswerItem
+import live.hms.video.polls.models.answer.PollAnswerResponse
+import live.hms.video.polls.models.network.HMSPollResponsePeerInfo
+import live.hms.video.polls.models.question.HMSPollQuestion
+import live.hms.video.polls.models.question.HMSPollQuestionOption
+import live.hms.video.polls.network.HMSPollLeaderboardEntry
+import live.hms.video.polls.network.HMSPollLeaderboardSummary
+import live.hms.video.polls.network.PollLeaderboardResponse
+import live.hms.video.polls.network.PollResultsDisplay
+import live.hms.video.whiteboard.HMSWhiteboard
+import live.hms.video.whiteboard.HMSWhiteboardUpdate
+import live.hms.video.whiteboard.State
+
+object HMSInteractivityDecoder {
+  //region poll methods
+  fun getPollUpdateType(hmsPollUpdateType: HMSPollUpdateType): Int =
+    when (hmsPollUpdateType) {
+      HMSPollUpdateType.started -> 0
+      HMSPollUpdateType.resultsupdated -> 1
+      HMSPollUpdateType.stopped -> 2
+      else -> {
+        0
+      }
+    }
+
+  fun getPoll(poll: HmsPoll): WritableMap {
+    val data = Arguments.createMap()
+
+    data.putBoolean("anonymous", poll.anonymous)
+    data.putInt("type", poll.category.ordinal)
+    poll.duration?.let { data.putDouble("duration", it.toDouble()) }
+    data.putString("pollId", poll.pollId)
+    data.putArray("rolesThatCanViewResponses", HMSDecoder.getAllRoles(poll.rolesThatCanViewResponses))
+    data.putArray("rolesThatCanVote", HMSDecoder.getAllRoles(poll.rolesThatCanVote))
+    data.putInt("state", getPollStateOrdinal(poll.state))
+    data.putString("title", poll.title)
+
+    poll.createdBy?.let {
+      data.putMap("createdBy", HMSDecoder.getHmsPeerSubset(it))
+    }
+
+    poll.mode?.let {
+      data.putInt("mode", getPollMode(poll))
+    }
+
+    poll.questionCount?.let {
+      data.putInt("questionCount", it)
+    }
+
+    poll.questions?.let {
+      data.putArray("questions", getPollQuestions(it))
+    }
+
+    poll.result?.let {
+      data.putMap("result", getPollResult(it))
+    }
+
+    data.putString("startedAt", (poll.startedAt * 1000).toString())
+
+    poll.stoppedAt?.let {
+      data.putString("stoppedAt", (it * 1000).toString())
+    }
+
+    poll.startedBy?.let {
+      data.putMap("startedBy", HMSDecoder.getHmsPeerSubset(it))
+    }
+
+    return data
+  }
+
+  private fun getPollStateOrdinal(pollState: HmsPollState): Int =
+    when (pollState) {
+      HmsPollState.CREATED -> 0
+      HmsPollState.STARTED -> 1
+      HmsPollState.STOPPED -> 2
+      else -> 0
+    }
+
+  private fun getPollMode(poll: HmsPoll): Int =
+    when (poll.mode) {
+      HmsPollUserTrackingMode.PEER_ID -> 0
+      HmsPollUserTrackingMode.USER_ID -> 1
+      HmsPollUserTrackingMode.USERNAME -> 2
+      else -> {
+        0
+      }
+    }
+
+  private fun getPollQuestions(questions: List<HMSPollQuestion>): WritableArray {
+    val data = Arguments.createArray()
+
+    for (question in questions) {
+      data.pushMap(getPollQuestion(question))
+    }
+
+    return data
+  }
+
+  private fun getPollQuestion(question: HMSPollQuestion): WritableMap {
+    val data = Arguments.createMap()
+
+    data.putInt("index", question.questionID)
+
+    question.duration.let { data.putDouble("duration", it.toDouble()) }
+
+    question.myResponses.let {
+      data.putArray("myResponses", getPollAnswers(it))
+    }
+
+    data.putBoolean("skippable", question.canSkip)
+
+    data.putString("text", question.text)
+
+    data.putInt("type", question.type.ordinal)
+
+    data.putBoolean("voted", question.voted)
+
+    data.putInt("weight", question.weight)
+
+    question.correctAnswer?.let {
+      data.putMap("answer", getPollQuestionAnswer(it))
+    }
+
+    question.answerLongMinLength?.let {
+      data.putDouble("answerMaxLen", it.toDouble())
+    }
+
+    question.answerShortMinLength?.let {
+      data.putDouble("answerMinLen", it.toDouble())
+    }
+
+    question.options?.let {
+      data.putArray("options", getPollQuestionOptions(it))
+    }
+
+    return data
+  }
+
+  private fun getPollQuestionOptions(options: List<HMSPollQuestionOption>): WritableArray {
+    val data = Arguments.createArray()
+
+    for (option in options) {
+      data.pushMap(getPollQuestionOption(option))
+    }
+
+    return data
+  }
+
+  private fun getPollQuestionOption(option: HMSPollQuestionOption): WritableMap {
+    val data = Arguments.createMap()
+
+    data.putString("text", option.text)
+    data.putInt("index", option.index)
+    data.putInt("voteCount", option.voteCount.toInt())
+    option.weight?.let { data.putInt("weight", it) }
+
+    return data
+  }
+
+  private fun getPollQuestionAnswer(answer: HMSPollQuestionAnswer): WritableMap {
+    val data = Arguments.createMap()
+
+    answer.option?.let { data.putInt("option", it) }
+
+    answer.options?.let { data.putArray("options", convertListToReadableArray(it)) }
+
+    data.putBoolean("hidden", answer.hidden)
+
+    return data
+  }
+
+  private fun getPollAnswers(answers: List<HmsPollAnswer>): WritableArray {
+    val data = Arguments.createArray()
+
+    for (answer in answers) {
+      data.pushMap(getPollAnswer(answer))
+    }
+
+    return data
+  }
+
+  private fun getPollAnswer(answer: HmsPollAnswer): WritableMap {
+    val data = Arguments.createMap()
+
+    answer.durationMillis?.let { data.putDouble("duration", (it * 1000).toDouble()) }
+
+    data.putInt("option", answer.selectedOption)
+
+    data.putInt("questionId", answer.questionId)
+
+    data.putBoolean("skipped", answer.skipped)
+
+    data.putString("text", answer.answerText)
+
+    data.putInt("type", answer.questionType.ordinal)
+
+    data.putBoolean("update", answer.update)
+
+    answer.selectedOptions?.let {
+      data.putArray("options", convertListToReadableArray(it))
+    }
+
+    return data
+  }
+
+  private fun getPollResult(result: PollResultsDisplay): WritableMap {
+    val data = Arguments.createMap()
+
+    result.totalResponses?.let {
+      data.putDouble("totalResponse", it.toDouble())
+    }
+
+    result.votingUsers?.let {
+      data.putDouble("userCount", it.toDouble())
+    }
+
+    result.totalDistinctUsers?.let {
+      data.putDouble("maxUserCount", it.toDouble())
+    }
+
+    result.questions.let {
+      data.putArray("questions", getPollStatsQuestion(it))
+    }
+
+    return data
+  }
+
+  private fun getPollStatsQuestion(questions: List<PollStatsQuestions>): WritableArray {
+    val data = Arguments.createArray()
+
+    for (question in questions) {
+      data.pushMap(getPollStatsQuestion(question))
+    }
+
+    return data
+  }
+
+  private fun getPollStatsQuestion(question: PollStatsQuestions): WritableMap {
+    val data = Arguments.createMap()
+
+    data.putInt("question", question.index)
+
+    data.putInt("type", question.questionType.ordinal)
+
+    question.correct?.let { data.putDouble("correctVotes", it.toDouble()) }
+
+    data.putDouble("skippedVotes", question.skipped.toDouble())
+
+    data.putInt("totalVotes", question.attemptedTimes)
+
+    question.options?.let {
+      data.putArray("optionVoteCounts", convertLongListToReadableArray(it))
+    }
+
+    return data
+  }
+
+  private fun convertLongListToReadableArray(list: List<Long>): ReadableArray {
+    val readableArray = Arguments.createArray()
+    list.forEach {
+      readableArray.pushInt(it.toInt())
+    }
+    return readableArray
+  }
+
+  private fun convertListToReadableArray(list: List<Int>): ReadableArray {
+    val readableArray = Arguments.createArray()
+    list.forEach {
+      readableArray.pushInt(it.toInt())
+    }
+    return readableArray
+  }
+
+  fun getHMSPollQuestionResponseResults(hmsPollQuestionResponseResults: PollAnswerResponse): WritableArray {
+    val results = Arguments.createArray()
+
+    hmsPollQuestionResponseResults.result.forEach { result ->
+      results.pushMap(getHMSPollQuestionResponseResult(result))
+    }
+    return results
+  }
+
+  fun getPollLeaderboardResponse(pollLeaderboardResponse: PollLeaderboardResponse): WritableMap {
+    val results = Arguments.createMap()
+
+    pollLeaderboardResponse.hasNext?.let {
+      results.putBoolean("hasNext", it)
+    }
+    pollLeaderboardResponse.summary?.let {
+      results.putMap("summary", getHMSPollLeaderboardSummary(it))
+    }
+    pollLeaderboardResponse.entries?.let {
+      results.putArray("entries", getHMSPollLeaderboardEntries(it))
+    }
+    return results
+  }
+
+  private fun getHMSPollLeaderboardSummary(pollLeaderboardSummary: HMSPollLeaderboardSummary): WritableMap {
+    val summary = Arguments.createMap()
+    pollLeaderboardSummary.averageScore?.let {
+      summary.putDouble("averageScore", it.toDouble())
+    }
+    pollLeaderboardSummary.averageTime?.let {
+      summary.putString("averageTime", it.toString())
+    }
+    pollLeaderboardSummary.totalPeersCount?.let {
+      summary.putInt("totalPeersCount", it)
+    }
+    pollLeaderboardSummary.respondedCorrectlyPeersCount?.let {
+      summary.putInt("respondedCorrectlyPeersCount", it)
+    }
+    pollLeaderboardSummary.respondedPeersCount?.let {
+      summary.putInt("respondedPeersCount", it)
+    }
+    return summary
+  }
+
+  private fun getHMSPollLeaderboardEntries(pollLeaderboardEntries: List<HMSPollLeaderboardEntry>): WritableArray {
+    val list = Arguments.createArray()
+    pollLeaderboardEntries.forEach {
+      list.pushMap(getHMSPollLeaderboardEntry(it))
+    }
+    return list
+  }
+
+  private fun getHMSPollLeaderboardEntry(pollLeaderboardEntry: HMSPollLeaderboardEntry): WritableMap {
+    val entry = Arguments.createMap()
+    pollLeaderboardEntry.duration?.let {
+      entry.putString("duration", it.toString())
+    }
+    pollLeaderboardEntry.peer?.let {
+      entry.putMap("peer", getHMSPollResponsePeerInfo(it))
+    }
+    pollLeaderboardEntry.totalResponses?.let {
+      entry.putString("totalResponses", it.toString())
+    }
+    pollLeaderboardEntry.correctResponses?.let {
+      entry.putString("correctResponses", it.toString())
+    }
+    pollLeaderboardEntry.position?.let {
+      entry.putString("position", it.toString())
+    }
+    pollLeaderboardEntry.score?.let {
+      entry.putString("score", it.toString())
+    }
+    return entry
+  }
+
+  private fun getHMSPollResponsePeerInfo(pollResponsePeerInfo: HMSPollResponsePeerInfo): WritableMap {
+    val peerInfo = Arguments.createMap()
+    peerInfo.putString("userHash", pollResponsePeerInfo.hash)
+    pollResponsePeerInfo.peerid?.let {
+      peerInfo.putString("peerId", it)
+    }
+    pollResponsePeerInfo.userid?.let {
+      peerInfo.putString("customerUserId", it)
+    }
+    pollResponsePeerInfo.username?.let {
+      peerInfo.putString("userName", it)
+    }
+    return peerInfo
+  }
+
+  private fun getHMSPollQuestionResponseResult(hmsPollQuestionResponseResult: PollAnswerItem): WritableMap {
+    val result = Arguments.createMap()
+
+    result.putInt("question", hmsPollQuestionResponseResult.questionIndex)
+
+    hmsPollQuestionResponseResult.correct.let {
+      result.putBoolean("correct", it)
+    }
+
+    hmsPollQuestionResponseResult.error?.let {
+      result.putString("error", it.localizedMessage)
+    }
+
+    return result
+  }
+  //endregion
+
+  //region whiteboard methods
+  fun getHMSWhiteboard(hmsWhiteboard: HMSWhiteboard): WritableMap {
+    val data: WritableMap = Arguments.createMap()
+
+    data.putString("id", hmsWhiteboard.id)
+    data.putBoolean("isOwner", hmsWhiteboard.isOwner)
+    data.putString("state", getWhiteboardState(hmsWhiteboard.state))
+    hmsWhiteboard.title?.let { title ->
+      data.putString("title", title)
+    }
+    hmsWhiteboard.owner?.let { owner ->
+      data.putMap("owner", HMSDecoder.getHmsPeerSubset(owner))
+    }
+    data.putString("url", hmsWhiteboard.url)
+    return data
+  }
+
+  enum class JSWhiteboardState(
+    val label: String,
+  ) {
+    Start("STARTED"),
+    Stop("STOPPED"),
+  }
+
+  private fun getWhiteboardState(hmsWhiteboardState: State): String =
+    when (hmsWhiteboardState) {
+      State.Started -> {
+        JSWhiteboardState.Start.label
+      }
+      State.Stopped -> {
+        JSWhiteboardState.Stop.label
+      }
+    }
+
+  fun getWhiteboardUpdateType(hmsWhiteboardUpdate: HMSWhiteboardUpdate): String =
+    when (hmsWhiteboardUpdate) {
+      is HMSWhiteboardUpdate.Start -> {
+        JSWhiteboardState.Start.label
+      }
+      is HMSWhiteboardUpdate.Stop -> {
+        JSWhiteboardState.Stop.label
+      }
+    }
+  //endregion
+}