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

package/android/local.properties

@@ -1 +1,8 @@
-sdk.dir=/Users/yogesh/Library/Android/sdk
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Mon Nov 14 20:51:00 IST 2022
+sdk.dir=/Users/jatinnagar/Library/Android/sdk

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

@@ -340,6 +340,8 @@ object HMSDecoder {
       permissions.putBoolean("hlsStreaming", hmsPermissions.hlsStreaming)
       permissions.putBoolean("rtmpStreaming", hmsPermissions.rtmpStreaming)
       permissions.putBoolean("changeRole", hmsPermissions.changeRole)
+      permissions.putBoolean("pollRead", hmsPermissions.pollRead)
+      permissions.putBoolean("pollWrite", hmsPermissions.pollWrite)
     }
     return permissions
   }

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

@@ -688,7 +688,7 @@ class HMSManager(reactContext: ReactApplicationContext) :
     hms?.getAuthTokenByRoomCode(data, promise)
   }
 
-  // region Person-In-Person Mode Action handing
+  // region Picture-In-Picture Mode Action handing
   private val pipReceiver by lazy {
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
       PipActionReceiver(
@@ -1342,6 +1342,64 @@ class HMSManager(reactContext: ReactApplicationContext) :
       .emit(event, data)
   }
 
+  // region Polls
+  @ReactMethod
+  fun quickStartPoll(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val rnSDK = HMSHelper.getHms(data, hmsCollection)
+    rnSDK?.let { sdk ->
+      sdk.interactivityCenter?.let { center ->
+        center.quickStartPoll(data, promise)
+        return
+      }
+    }
+    promise?.reject(
+      "6004",
+      "HMS SDK not initialized",
+    )
+  }
+
+  @ReactMethod
+  fun addResponseOnPollQuestion(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val rnSDK = HMSHelper.getHms(data, hmsCollection)
+    rnSDK?.let { sdk ->
+      sdk.interactivityCenter?.let { center ->
+        center.addResponseOnPollQuestion(data, promise)
+        return
+      }
+    }
+    promise?.reject(
+      "6004",
+      "HMS SDK not initialized",
+    )
+  }
+
+  @ReactMethod
+  fun stopPoll(
+    data: ReadableMap,
+    promise: Promise?,
+  ) {
+    val rnSDK = HMSHelper.getHms(data, hmsCollection)
+    rnSDK?.let { sdk ->
+      sdk.interactivityCenter?.let { center ->
+        center.stop(data, promise)
+        return
+      }
+    }
+    promise?.reject(
+      "6004",
+      "HMS SDK not initialized",
+    )
+  }
+  // endregion
+
+  // region ActivityLifecycleCallbacks
+
   override fun onActivityCreated(
     activity: Activity,
     savedInstanceState: Bundle?,
@@ -1377,7 +1435,8 @@ class HMSManager(reactContext: ReactApplicationContext) :
         }
       }
     } catch (e: Exception) {
-      //      Log.d("error", e.message)
     }
   }
+
+  // endregion
 }

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

@@ -49,12 +49,14 @@ class HMSRNSDK(
   private var audioMixingMode: AudioMixingMode = AudioMixingMode.TALK_AND_MUSIC
   private var id: String = sdkId
   private var self = this
-  private var eventsEnableStatus = mutableMapOf<String, Boolean>()
+  var eventsEnableStatus = mutableMapOf<String, Boolean>()
   private var sessionStore: HmsSessionStore? = null
   private val keyChangeObservers = mutableMapOf<String, HMSKeyChangeListener?>()
   private val peerListIterators = mutableMapOf<String, PeerListIterator>()
   private var roomMutedLocally = false
 
+  var interactivityCenter: HMSRNInteractivityCenter? = null
+
   init {
     val builder = HMSSDK.Builder(reactApplicationContext)
     if (HMSHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("trackSettings", "Map")))) {
@@ -85,6 +87,10 @@ class HMSRNSDK(
     }
 
     this.hmsSDK = builder.build()
+
+    hmsSDK?.let {
+      interactivityCenter = HMSRNInteractivityCenter(it, this)
+    }
   }
 
   private fun emitCustomError(message: String) {
@@ -1698,6 +1704,7 @@ class HMSRNSDK(
           if (eventsEnableStatus["ON_AUDIO_DEVICE_CHANGED"] != true) {
             return
           }
+
           val data: WritableMap = Arguments.createMap()
           data.putString("device", selectedAudioDevice.name)
           data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(availableAudioDevices))
@@ -1705,8 +1712,8 @@ class HMSRNSDK(
           delegate.emitEvent("ON_AUDIO_DEVICE_CHANGED", data)
         }
 
-        override fun onError(error: HMSException) {
-          self.emitHMSError(error)
+        override fun onError(e: HMSException) {
+          self.emitHMSError(e)
         }
       },
     )

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

@@ -0,0 +1,328 @@
+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.question.HMSPollQuestion
+import live.hms.video.polls.models.question.HMSPollQuestionOption
+import live.hms.video.polls.network.PollResultsDisplay
+
+object HMSInteractivityDecoder {
+  fun getPollUpdateType(hmsPollUpdateType: HMSPollUpdateType): Int {
+    return 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.toString())
+
+    poll.stoppedAt?.let {
+      data.putString("stoppedAt", it.toString())
+    }
+
+    poll.startedBy?.let {
+      data.putMap("startedBy", HMSDecoder.getHmsPeerSubset(it))
+    }
+
+    return data
+  }
+
+  private fun getPollStateOrdinal(pollState: HmsPollState): Int {
+    return when (pollState) {
+      HmsPollState.CREATED -> 0
+      HmsPollState.STARTED -> 1
+      HmsPollState.STOPPED -> 2
+      else -> 0
+    }
+  }
+
+  private fun getPollMode(poll: HmsPoll): Int {
+    return 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
+  }
+
+/*
+
+  static func getHMSPollQuestionResponseResults(_ hmsPollQuestionResponseResults: [HMSPollQuestionResponseResult]) -> [[String: AnyHashable]] {
+    var results = [[String: AnyHashable]]()
+
+    hmsPollQuestionResponseResults.forEach { result in
+      results.append(getHMSPollQuestionResponseResult(result))
+    }
+    return results
+  }
+
+  static func getHMSPollQuestionResponseResult(_ hmsPollQuestionResponseResult: HMSPollQuestionResponseResult) -> [String: AnyHashable] {
+    var result: [String: AnyHashable] = [
+    "question": hmsPollQuestionResponseResult.question
+    ]
+    if let correct = hmsPollQuestionResponseResult.correct {
+      result["correct"] = correct
+    }
+    if let error = hmsPollQuestionResponseResult.error {
+      result["error"] = error.localizedDescription
+    }
+    return result
+  }
+
+ */
+  fun getHMSPollQuestionResponseResults(hmsPollQuestionResponseResults: PollAnswerResponse): WritableArray {
+    val results = Arguments.createArray()
+
+    hmsPollQuestionResponseResults.result.forEach { result ->
+      results.pushMap(getHMSPollQuestionResponseResult(result))
+    }
+    return results
+  }
+
+  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
+  }
+}