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

package/README.md

@@ -3,6 +3,7 @@
 </a>
 
 [![npm](https://img.shields.io/npm/v/@100mslive/react-native-hms)](https://www.npmjs.com/package/@100mslive/react-native-hms)
+[![Build](https://github.com/100mslive/100ms-react-native/actions/workflows/build.yml/badge.svg?branch=develop)](https://github.com/100mslive/100ms-react-native/actions/workflows/build.yml)
 [![license](https://img.shields.io/npm/l/@100mslive/react-native-hms)](https://www.100ms.live/)
 [![quality](https://img.shields.io/npms-io/quality-score/@100mslive/react-native-hms)](https://www.npmjs.com/package/@100mslive/react-native-hms)
 [![collaborators](https://img.shields.io/npm/collaborators/@100mslive/react-native-hms)](https://www.npmjs.com/package/@100mslive/react-native-hms)
@@ -21,10 +22,10 @@ With support for HLS and RTMP Live Streaming and Recording, Picture-in-Picture (
 
 📖 Read the Complete Documentation here: https://www.100ms.live/docs/react-native/v2/foundation/basics
 
-| Package                                | Version                                                                                                                                  |
-| -------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- |
-| @100mslive/react-native-room-kit       | [![npm](https://img.shields.io/npm/v/@100mslive/react-native-room-kit)](https://www.npmjs.com/package/@100mslive/react-native-room-kit)  |
-| @100mslive/react-native-hms            | [![npm](https://img.shields.io/npm/v/@100mslive/react-native-hms)](https://www.npmjs.com/package/@100mslive/react-native-hms)            |
+| Package                          | Version                                                                                                                                 |
+| -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
+| @100mslive/react-native-room-kit | [![npm](https://img.shields.io/npm/v/@100mslive/react-native-room-kit)](https://www.npmjs.com/package/@100mslive/react-native-room-kit) |
+| @100mslive/react-native-hms      | [![npm](https://img.shields.io/npm/v/@100mslive/react-native-hms)](https://www.npmjs.com/package/@100mslive/react-native-hms)           |
 
 ## 🏃 Example App
 

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

@@ -12,6 +12,8 @@ import android.util.Rational
 import android.view.WindowManager
 import androidx.annotation.RequiresApi
 import androidx.core.app.NotificationManagerCompat
+import androidx.core.view.WindowCompat
+import androidx.core.view.WindowInsetsCompat
 import com.facebook.react.bridge.*
 import com.facebook.react.module.annotations.ReactModule
 import com.facebook.react.modules.core.DeviceEventManagerModule
@@ -686,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(
@@ -778,7 +780,9 @@ class HMSManager(reactContext: ReactApplicationContext) :
                 PendingIntent.getBroadcast(
                   reactApplicationContext,
                   PipActionReceiver.PIPActions.localAudio.requestCode,
-                  Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(PipActionReceiver.PIPActions.localAudio.title, PipActionReceiver.PIPActions.localAudio.requestCode),
+                  Intent(
+                    PipActionReceiver.PIP_INTENT_ACTION,
+                  ).putExtra(PipActionReceiver.PIPActions.localAudio.title, PipActionReceiver.PIPActions.localAudio.requestCode),
                   PendingIntent.FLAG_IMMUTABLE,
                 ),
               )
@@ -803,7 +807,9 @@ class HMSManager(reactContext: ReactApplicationContext) :
                 PendingIntent.getBroadcast(
                   reactApplicationContext,
                   PipActionReceiver.PIPActions.localVideo.requestCode,
-                  Intent(PipActionReceiver.PIP_INTENT_ACTION).putExtra(PipActionReceiver.PIPActions.localVideo.title, PipActionReceiver.PIPActions.localVideo.requestCode),
+                  Intent(
+                    PipActionReceiver.PIP_INTENT_ACTION,
+                  ).putExtra(PipActionReceiver.PIPActions.localVideo.title, PipActionReceiver.PIPActions.localVideo.requestCode),
                   PendingIntent.FLAG_IMMUTABLE,
                 ),
               )
@@ -1298,6 +1304,35 @@ class HMSManager(reactContext: ReactApplicationContext) :
     return attributes.softInputMode
   }
 
+  @ReactMethod
+  fun hideSystemBars() {
+    val window = reactApplicationContext?.currentActivity?.window
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && window != null) {
+      UiThreadUtil.runOnUiThread {
+        window.attributes.layoutInDisplayCutoutMode =
+          WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+          window.insetsController?.hide(WindowInsetsCompat.Type.systemBars())
+        }
+        WindowCompat.setDecorFitsSystemWindows(window, false)
+      }
+    }
+  }
+
+  @ReactMethod
+  fun showSystemBars() {
+    val window = reactApplicationContext?.currentActivity?.window
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P && window != null) {
+      UiThreadUtil.runOnUiThread {
+        window.attributes.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_DEFAULT
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+          window.insetsController?.show(WindowInsetsCompat.Type.systemBars())
+        }
+        WindowCompat.setDecorFitsSystemWindows(window, true)
+      }
+    }
+  }
+
   fun emitEvent(
     event: String,
     data: WritableMap,
@@ -1307,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?,
@@ -1342,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) {
@@ -1692,21 +1698,22 @@ class HMSRNSDK(
     hmsSDK?.setAudioDeviceChangeListener(
       object : HMSAudioManager.AudioManagerDeviceChangeListener {
         override fun onAudioDeviceChanged(
-          device: HMSAudioManager.AudioDevice?,
-          audioDevicesList: Set<HMSAudioManager.AudioDevice>?,
+          selectedAudioDevice: HMSAudioManager.AudioDevice,
+          availableAudioDevices: Set<HMSAudioManager.AudioDevice>,
         ) {
           if (eventsEnableStatus["ON_AUDIO_DEVICE_CHANGED"] != true) {
             return
           }
+
           val data: WritableMap = Arguments.createMap()
-          data.putString("device", device?.name)
-          data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(audioDevicesList))
+          data.putString("device", selectedAudioDevice.name)
+          data.putArray("audioDevicesList", HMSHelper.getAudioDevicesSet(availableAudioDevices))
           data.putString("id", id)
           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
+  }
+}