@100mslive/react-native-hms 1.3.0 → 1.5.0

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

@@ -8,6 +8,7 @@ import kotlinx.coroutines.launch
 import live.hms.video.audio.HMSAudioManager
 import live.hms.video.connection.stats.*
 import live.hms.video.error.HMSException
+import live.hms.video.media.settings.HMSLayer
 import live.hms.video.media.tracks.*
 import live.hms.video.sdk.*
 import live.hms.video.sdk.models.*
@@ -16,8 +17,13 @@ import live.hms.video.sdk.models.enums.HMSPeerUpdate
 import live.hms.video.sdk.models.enums.HMSRoomUpdate
 import live.hms.video.sdk.models.enums.HMSTrackUpdate
 import live.hms.video.sdk.models.trackchangerequest.HMSChangeTrackStateRequest
+import live.hms.video.signal.init.HMSTokenListener
+import live.hms.video.signal.init.TokenRequest
+import live.hms.video.signal.init.TokenRequestOptions
 import live.hms.video.utils.HMSCoroutineScope
 import live.hms.video.utils.HmsUtilities
+import java.io.File
+import java.util.Date
 
 class HMSRNSDK(
   data: ReadableMap?,
@@ -34,7 +40,6 @@ class HMSRNSDK(
   private var context: ReactApplicationContext = reactApplicationContext
   private var previewInProgress: Boolean = false
   private var reconnectingStage: Boolean = false
-  private var rtcStatsAttached: Boolean = false
   private var networkQualityUpdatesAttached: Boolean = false
   private var audioMixingMode: AudioMixingMode = AudioMixingMode.TALK_AND_MUSIC
   private var id: String = sdkId
@@ -430,18 +435,15 @@ class HMSRNSDK(
               hmsTrack: HMSTrack?,
               hmsPeer: HMSPeer?
             ) {
-              if (eventsEnableStatus["ON_LOCAL_AUDIO_STATS"] != true) {
+              if (eventsEnableStatus["ON_LOCAL_AUDIO_STATS"] != true || hmsPeer == null || hmsTrack == null) {
                 return
               }
-              if (!rtcStatsAttached) {
-                return
-              }
-              val localAudioStats = HMSDecoder.getLocalAudioStats(audioStats)
+              val localAudioStats = HMSDecoder.getLocalAudioStats(audioStats) // [bitrate, bytesSent, roundTripTime]
               val track = HMSDecoder.getHmsLocalAudioTrack(hmsTrack as HMSLocalAudioTrack)
               val peer = HMSDecoder.getHmsPeerSubset(hmsPeer)
 
               val data: WritableMap = Arguments.createMap()
-              data.putMap("localAudioStats", localAudioStats)
+              data.putArray("localAudioStats", localAudioStats)
               data.putMap("track", track)
               data.putMap("peer", peer)
               data.putString("id", id)
@@ -453,14 +455,10 @@ class HMSRNSDK(
               hmsTrack: HMSTrack?,
               hmsPeer: HMSPeer?
             ) {
-              if (eventsEnableStatus["ON_LOCAL_VIDEO_STATS"] != true) {
+              if (eventsEnableStatus["ON_LOCAL_VIDEO_STATS"] != true || hmsPeer == null || hmsTrack == null) {
                 return
               }
-              if (!rtcStatsAttached && hmsPeer != null && hmsTrack != null) {
-                return
-              }
-
-              val localVideoStats = HMSDecoder.getLocalVideoStats(videoStats)
+              val localVideoStats = HMSDecoder.getLocalVideoStats(videoStats) // List<[bitrate, bytesSent, roundTripTime, frameRate, resolution]>
               val track = HMSDecoder.getHmsLocalVideoTrack(hmsTrack as HMSLocalVideoTrack)
               val peer = HMSDecoder.getHmsPeerSubset(hmsPeer)
 
@@ -476,17 +474,14 @@ class HMSRNSDK(
               if (eventsEnableStatus["ON_RTC_STATS"] != true) {
                 return
               }
-              if (!rtcStatsAttached) {
-                return
-              }
-              val video = HMSDecoder.getHMSRTCStats(rtcStats.video)
-              val audio = HMSDecoder.getHMSRTCStats(rtcStats.audio)
-              val combined = HMSDecoder.getHMSRTCStats(rtcStats.combined)
+              val video = HMSDecoder.getHMSRTCStats(rtcStats.video) // [bitrateReceived, bitrateSent, bytesReceived, bytesSent, packetsLost, packetsReceived, roundTripTime]
+              val audio = HMSDecoder.getHMSRTCStats(rtcStats.audio) // [bitrateReceived, bitrateSent, bytesReceived, bytesSent, packetsLost, packetsReceived, roundTripTime]
+              val combined = HMSDecoder.getHMSRTCStats(rtcStats.combined) // [bitrateReceived, bitrateSent, bytesReceived, bytesSent, packetsLost, packetsReceived, roundTripTime]
 
               val data: WritableMap = Arguments.createMap()
-              data.putMap("video", video)
-              data.putMap("audio", audio)
-              data.putMap("combined", combined)
+              data.putArray("video", video)
+              data.putArray("audio", audio)
+              data.putArray("combined", combined)
               data.putString("id", id)
               delegate.emitEvent("ON_RTC_STATS", data)
             }
@@ -496,19 +491,15 @@ class HMSRNSDK(
               hmsTrack: HMSTrack?,
               hmsPeer: HMSPeer?
             ) {
-              if (eventsEnableStatus["ON_REMOTE_AUDIO_STATS"] != true) {
-                return
-              }
-              if (!rtcStatsAttached) {
+              if (eventsEnableStatus["ON_REMOTE_AUDIO_STATS"] != true || hmsPeer == null || hmsTrack == null) {
                 return
               }
-
-              val remoteAudioStats = HMSDecoder.getRemoteAudioStats(audioStats)
+              val remoteAudioStats = HMSDecoder.getRemoteAudioStats(audioStats) // [bitrate, bytesReceived, jitter, packetsLost, packetsReceived]
               val track = HMSDecoder.getHmsRemoteAudioTrack(hmsTrack as HMSRemoteAudioTrack)
               val peer = HMSDecoder.getHmsPeerSubset(hmsPeer)
 
               val data: WritableMap = Arguments.createMap()
-              data.putMap("remoteAudioStats", remoteAudioStats)
+              data.putArray("remoteAudioStats", remoteAudioStats)
               data.putMap("track", track)
               data.putMap("peer", peer)
               data.putString("id", id)
@@ -520,19 +511,15 @@ class HMSRNSDK(
               hmsTrack: HMSTrack?,
               hmsPeer: HMSPeer?
             ) {
-              if (eventsEnableStatus["ON_REMOTE_VIDEO_STATS"] != true) {
-                return
-              }
-              if (!rtcStatsAttached) {
+              if (eventsEnableStatus["ON_REMOTE_VIDEO_STATS"] != true || hmsPeer == null || hmsTrack == null) {
                 return
               }
-
-              val remoteVideoStats = HMSDecoder.getRemoteVideoStats(videoStats)
+              val remoteVideoStats = HMSDecoder.getRemoteVideoStats(videoStats) // [bitrate, bytesReceived, frameRate, jitter, packetsLost, packetsReceived, resolution]
               val track = HMSDecoder.getHmsRemoteVideoTrack(hmsTrack as HMSRemoteVideoTrack)
               val peer = HMSDecoder.getHmsPeerSubset(hmsPeer)
 
               val data: WritableMap = Arguments.createMap()
-              data.putMap("remoteVideoStats", remoteVideoStats)
+              data.putArray("remoteVideoStats", remoteVideoStats)
               data.putMap("track", track)
               data.putMap("peer", peer)
               data.putString("id", id)
@@ -547,6 +534,41 @@ class HMSRNSDK(
     }
   }
 
+  fun getAuthTokenByRoomCode(data: ReadableMap, promise: Promise) {
+    val requiredKeys =
+      HMSHelper.getUnavailableRequiredKey(
+        data,
+        arrayOf(Pair("roomCode", "String"))
+      )
+
+    if (requiredKeys === null) {
+      val roomCode = data.getString("roomCode")!!
+      val userId = data.getString("userId")
+      val endpoint = data.getString("endpoint")
+
+      val tokenRequest = TokenRequest(roomCode, userId)
+      val tokenRequestOptions: TokenRequestOptions? = endpoint?.let { TokenRequestOptions(endpoint = it) }
+
+      hmsSDK?.getAuthTokenByRoomCode(
+        tokenRequest,
+        tokenRequestOptions,
+        object : HMSTokenListener {
+          override fun onError(error: HMSException) {
+            promise.reject(error.code.toString(), "${error.message}: ${error.description}")
+          }
+
+          override fun onTokenSuccess(string: String) {
+            promise.resolve(string)
+          }
+        }
+      )
+    } else {
+      val errorMessage = "getAuthTokenByRoomCode: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
   fun setLocalMute(data: ReadableMap) {
     val isMute = data.getBoolean("isMute")
     hmsSDK?.getLocalPeer()?.audioTrack?.setMute(isMute)
@@ -580,7 +602,6 @@ class HMSRNSDK(
             screenshareCallback = null
             audioshareCallback = null
             networkQualityUpdatesAttached = false
-            rtcStatsAttached = false
             HMSDecoder.clearRestrictDataStates()
             if (fromPIP) {
               context.currentActivity?.moveTaskToBack(false)
@@ -1363,14 +1384,6 @@ class HMSRNSDK(
     }
   }
 
-  fun enableRTCStats() {
-    rtcStatsAttached = true
-  }
-
-  fun disableRTCStats() {
-    rtcStatsAttached = false
-  }
-
   fun enableNetworkQualityUpdates() {
     networkQualityUpdatesAttached = true
   }
@@ -1544,7 +1557,9 @@ class HMSRNSDK(
     val peerId = data.getString("peerId")!!
     val property = data.getString("property")!!
 
-    val peer = HMSHelper.getPeerFromPeerId(peerId, nativeHmsSDK.getRoom())
+    val hmsRoom = nativeHmsSDK.getRoom()
+
+    val peer = HMSHelper.getPeerFromPeerId(peerId, hmsRoom)
 
     if (peer !== null) {
       val result: WritableMap = Arguments.createMap()
@@ -1702,4 +1717,183 @@ class HMSRNSDK(
       rejectCallback(promise, errorMessage)
     }
   }
+
+  fun getRemoteVideoTrackFromTrackId(data: ReadableMap, promise: Promise) {
+    val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("trackId", "String")))
+    if (requiredKeys === null) {
+      val trackId = data.getString("trackId")
+      val remoteVideoTrack = HMSHelper.getRemoteVideoTrackFromTrackId(trackId, hmsSDK?.getRoom())
+      if (remoteVideoTrack === null) {
+        promise.reject("101", "TRACK_NOT_FOUND")
+      } else {
+        promise.resolve(HMSDecoder.getHmsRemoteVideoTrack(remoteVideoTrack))
+      }
+    } else {
+      val errorMessage = "getRemoteVideoTrackFromTrackId: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
+  fun getRemoteAudioTrackFromTrackId(data: ReadableMap, promise: Promise) {
+    val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("trackId", "String")))
+    if (requiredKeys === null) {
+      val trackId = data.getString("trackId")
+      val remoteAudioTrack = HMSHelper.getRemoteAudioTrackFromTrackId(trackId, hmsSDK?.getRoom())
+      if (remoteAudioTrack === null) {
+        promise.reject("101", "TRACK_NOT_FOUND")
+      } else {
+        promise.resolve(HMSDecoder.getHmsRemoteAudioTrack(remoteAudioTrack))
+      }
+    } else {
+      val errorMessage = "getRemoteAudioTrackFromTrackId: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
+  fun getVideoTrackLayer(data: ReadableMap, promise: Promise) {
+    val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("trackId", "String")))
+    if (requiredKeys === null) {
+      val trackId = data.getString("trackId")
+      val remoteVideoTrack = HMSHelper.getRemoteVideoTrackFromTrackId(trackId, hmsSDK?.getRoom())
+      if (remoteVideoTrack === null) {
+        promise.reject("101", "TRACK_NOT_FOUND")
+      } else {
+        val layer = remoteVideoTrack.getLayer()
+        promise.resolve(layer.name)
+      }
+    } else {
+      val errorMessage = "getVideoTrackLayer: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
+  fun getVideoTrackLayerDefinition(data: ReadableMap, promise: Promise) {
+    val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("trackId", "String")))
+    if (requiredKeys === null) {
+      val trackId = data.getString("trackId")
+      val remoteVideoTrack = HMSHelper.getRemoteVideoTrackFromTrackId(trackId, hmsSDK?.getRoom())
+      if (remoteVideoTrack === null) {
+        promise.reject("101", "TRACK_NOT_FOUND")
+      } else {
+        val layerDefinition = remoteVideoTrack.getLayerDefinition()
+
+        promise.resolve(HMSDecoder.getSimulcastLayerDefinitions(layerDefinition))
+      }
+    } else {
+      val errorMessage = "getVideoTrackLayerDefinition: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
+  fun setVideoTrackLayer(data: ReadableMap, promise: Promise?) {
+    val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("trackId", "String"), Pair("layer", "String")))
+    if (requiredKeys === null) {
+      val trackId = data.getString("trackId")
+      val layerString = data.getString("layer")
+
+      if (HMSLayer.values().find { it.name == layerString } === null) {
+        // DOUBT: which error to throw here?
+        // emitError or 101 or 6000?
+        promise?.reject("6000", "INVALID_LAYER")
+        return
+      }
+
+      val remoteVideoTrack = HMSHelper.getRemoteVideoTrackFromTrackId(trackId, hmsSDK?.getRoom())
+
+      if (remoteVideoTrack === null) {
+        promise?.reject("101", "TRACK_NOT_FOUND")
+      } else {
+        val layer = HMSLayer.valueOf(layerString!!)
+        remoteVideoTrack.setLayer(layer)
+        promise?.resolve(true)
+      }
+    } else {
+      val errorMessage = "setVideoTrackLayer: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
+
+  fun captureImageAtMaxSupportedResolution(data: ReadableMap, promise: Promise?) {
+    val requiredKeys = HMSHelper.getUnavailableRequiredKey(data, arrayOf(Pair("flash", "Boolean")))
+    if (requiredKeys === null) {
+      val localPeer = hmsSDK?.getLocalPeer().let {
+        if (it == null) {
+          promise?.reject("6004", "An instance of Local Peer could not be found! Please check if a Room is joined.")
+          return
+        } else {
+          it
+        }
+      }
+      val localVideoTrack = localPeer.videoTrack.let {
+        if (it == null) {
+          promise?.reject("6004", "Video Track of Local Peer could not be found! Please check if the Local Peer has permission to publish video & video is unmuted currently.")
+          return
+        } else {
+          it
+        }
+      }
+      val cameraControl = localVideoTrack.getCameraControl().let {
+        if (it == null) {
+          promise?.reject("6004", "Camera Controls not available!")
+          return
+        } else {
+          it
+        }
+      }
+
+      val flashSupported = cameraControl.isFlashSupported()
+      var flashActionOnSuccess = 0 // 0 - Do nothing on success, 1 - set flash on, 2 - set flash off
+      if (flashSupported) {
+        val useFlash = data.getBoolean("flash")
+
+        val flashEnabled = cameraControl.isFlashEnabled()
+
+        // if flash option is true, and flash is already on
+        // -> do nothing now and on success
+
+        // if flash option is true, and flash is off
+        // -> turn it on and later turn it off
+        if (useFlash && !flashEnabled) {
+          cameraControl.setFlash(true)
+          flashActionOnSuccess = 2
+        }
+
+        // if flash option is false, and flash is on
+        // -> turn it off and later turn it on
+        if (!useFlash && flashEnabled) {
+          cameraControl.setFlash(false)
+          flashActionOnSuccess = 1
+        }
+
+        // if flash option is false, and flash is off
+        // -> do nothing now and on success
+      }
+
+      val dir = context.getExternalFilesDir("images")
+      val imagePath = "$dir/hms_${Date().time}.jpg"
+      val savePath = File(imagePath)
+
+      cameraControl.captureImageAtMaxSupportedResolution(
+        savePath
+      ) { success ->
+        if (flashActionOnSuccess > 0) {
+          cameraControl.setFlash(flashActionOnSuccess === 1)
+        }
+        if (success) {
+          promise?.resolve(imagePath)
+        } else {
+          promise?.reject("6004", "Could Not Capture Image!")
+        }
+      }
+    } else {
+      val errorMessage = "captureImageAtMaxSupportedResolution: $requiredKeys"
+      self.emitRequiredKeysError(errorMessage)
+      rejectCallback(promise, errorMessage)
+    }
+  }
 }

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

@@ -80,6 +80,11 @@ class HMSSDKViewManager : SimpleViewManager<HMSView>() {
     view.updateZOrderMediaOverlay(data)
   }
 
+  @ReactProp(name = "autoSimulcast")
+  fun setAutoSimulcast(view: HMSView, data: Boolean?) {
+    data?.let { view.updateAutoSimulcast(it) }
+  }
+
   private fun getHms(): MutableMap<String, HMSRNSDK>? {
     return reactContext?.getNativeModule(HMSManager::class.java)?.getHmsInstance()
   }

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

@@ -13,30 +13,33 @@ import com.facebook.react.bridge.WritableMap
 import com.facebook.react.uimanager.events.RCTEventEmitter
 import live.hms.video.media.tracks.HMSVideoTrack
 import live.hms.video.utils.HmsUtilities
-import live.hms.video.utils.SharedEglContext
+import live.hms.videoview.HMSVideoView
 import org.webrtc.RendererCommon
-import org.webrtc.SurfaceViewRenderer
 
 @SuppressLint("ViewConstructor")
 class HMSView(context: ReactContext) : FrameLayout(context) {
-  private var surfaceView: SurfaceViewRenderer = SurfaceViewRenderer(context)
+  private var hmsVideoView: HMSVideoView = HMSVideoView(context)
   private var videoTrack: HMSVideoTrack? = null
   private var scaleTypeApplied: Boolean = false
   private var sdkId: String = "12345"
   private var currentScaleType: RendererCommon.ScalingType =
-      RendererCommon.ScalingType.SCALE_ASPECT_FILL
+    RendererCommon.ScalingType.SCALE_ASPECT_FILL
+  private var disableAutoSimulcastLayerSelect = false
 
   init {
     val inflater = getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
     val view = inflater.inflate(R.layout.hms_view, this)
 
-    surfaceView = view.findViewById(R.id.surfaceView)
-    surfaceView.setEnableHardwareScaler(false)
+    hmsVideoView = view.findViewById(R.id.hmsVideoView)
+    hmsVideoView.setEnableHardwareScaler(false)
+    hmsVideoView.setScalingType(currentScaleType)
+    hmsVideoView.setMirror(false)
+    hmsVideoView.disableAutoSimulcastLayerSelect(disableAutoSimulcastLayerSelect)
   }
 
   @RequiresApi(Build.VERSION_CODES.N)
   fun captureHmsView(args: ReadableArray?) {
-    HMSHelper.captureSurfaceView(surfaceView, sdkId, args, context, id)
+    HMSHelper.captureSurfaceView(hmsVideoView, sdkId, args, context, id)
   }
 
   private fun onReceiveNativeEvent() {
@@ -48,14 +51,12 @@ class HMSView(context: ReactContext) : FrameLayout(context) {
 
   override fun onDetachedFromWindow() {
     super.onDetachedFromWindow()
-    videoTrack?.removeSink(surfaceView)
-    surfaceView.release()
+    hmsVideoView.removeTrack()
   }
 
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
-    surfaceView.init(SharedEglContext.context, null)
-    videoTrack?.addSink(surfaceView)
+    hmsVideoView.addTrack(videoTrack!!) // DOUBT: Handle case when videoTrack is null
     if (!scaleTypeApplied) {
       if (currentScaleType != RendererCommon.ScalingType.SCALE_ASPECT_FILL) {
         onReceiveNativeEvent()
@@ -66,8 +67,8 @@ class HMSView(context: ReactContext) : FrameLayout(context) {
 
   fun updateZOrderMediaOverlay(setZOrderMediaOverlay: Boolean?) {
     if (setZOrderMediaOverlay != null && setZOrderMediaOverlay) {
-      // surfaceView.setZOrderOnTop(true);
-      surfaceView.setZOrderMediaOverlay(setZOrderMediaOverlay)
+      // hmsVideoView.setZOrderOnTop(true);
+      hmsVideoView.setZOrderMediaOverlay(setZOrderMediaOverlay)
     }
   }
 
@@ -75,17 +76,17 @@ class HMSView(context: ReactContext) : FrameLayout(context) {
     if (scaleType != null) {
       when (scaleType) {
         "ASPECT_FIT" -> {
-          surfaceView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
+          hmsVideoView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FIT)
           currentScaleType = RendererCommon.ScalingType.SCALE_ASPECT_FIT
           return
         }
         "ASPECT_FILL" -> {
-          surfaceView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL)
+          hmsVideoView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_FILL)
           currentScaleType = RendererCommon.ScalingType.SCALE_ASPECT_FILL
           return
         }
         "ASPECT_BALANCED" -> {
-          surfaceView.setScalingType((RendererCommon.ScalingType.SCALE_ASPECT_BALANCED))
+          hmsVideoView.setScalingType(RendererCommon.ScalingType.SCALE_ASPECT_BALANCED)
           currentScaleType = RendererCommon.ScalingType.SCALE_ASPECT_BALANCED
           return
         }
@@ -97,10 +98,10 @@ class HMSView(context: ReactContext) : FrameLayout(context) {
   }
 
   fun setData(
-      id: String?,
-      trackId: String?,
-      hmsCollection: MutableMap<String, HMSRNSDK>,
-      mirror: Boolean?
+    id: String?,
+    trackId: String?,
+    hmsCollection: MutableMap<String, HMSRNSDK>,
+    mirror: Boolean?
   ) {
     if (id != null) {
       sdkId = id
@@ -109,9 +110,16 @@ class HMSView(context: ReactContext) : FrameLayout(context) {
 
     if (trackId != null && hms != null) {
       if (mirror != null) {
-        surfaceView.setMirror(mirror)
+        hmsVideoView.setMirror(mirror)
       }
+      // TODO: can be optimized here
       videoTrack = hms.getRoom()?.let { HmsUtilities.getVideoTrack(trackId, it) }
     }
   }
+
+  fun updateAutoSimulcast(autoSimulcast: Boolean?) {
+    autoSimulcast?.let {
+      hmsVideoView.disableAutoSimulcastLayerSelect(!it)
+    }
+  }
 }

package/android/src/main/res/layout/hms_view.xml

@@ -6,8 +6,8 @@
   android:layout_height="match_parent"
   android:background="#000">
 
-  <org.webrtc.SurfaceViewRenderer
-    android:id="@+id/surfaceView"
+  <live.hms.videoview.HMSVideoView
+    android:id="@+id/hmsVideoView"
     android:layout_width="wrap_content"
     android:layout_height="wrap_content"
     android:layout_gravity="center"

package/ios/HMSConstants.swift

@@ -0,0 +1,31 @@
+//
+//  HMSConstants.swift
+//  HMSSDK
+//
+//  Created by Yogesh Singh on 27/12/22.
+//  Copyright © 2023 100ms. All rights reserved.
+//
+
+import Foundation
+
+struct HMSConstants {
+
+    static let ON_PREVIEW = "ON_PREVIEW"
+    static let ON_JOIN = "ON_JOIN"
+    static let ON_ROOM_UPDATE = "ON_ROOM_UPDATE"
+    static let ON_PEER_UPDATE = "3"
+    static let ON_TRACK_UPDATE = "ON_TRACK_UPDATE"
+    static let ON_ROLE_CHANGE_REQUEST = "ON_ROLE_CHANGE_REQUEST"
+    static let ON_CHANGE_TRACK_STATE_REQUEST = "ON_CHANGE_TRACK_STATE_REQUEST" // new
+    static let ON_REMOVED_FROM_ROOM = "ON_REMOVED_FROM_ROOM"
+    static let ON_ERROR = "ON_ERROR"
+    static let ON_MESSAGE = "ON_MESSAGE"
+    static let ON_SPEAKER = "ON_SPEAKER"
+    static let RECONNECTING = "RECONNECTING"
+    static let RECONNECTED = "RECONNECTED"
+    static let ON_RTC_STATS = "ON_RTC_STATS"
+    static let ON_LOCAL_AUDIO_STATS = "ON_LOCAL_AUDIO_STATS"
+    static let ON_LOCAL_VIDEO_STATS = "ON_LOCAL_VIDEO_STATS"
+    static let ON_REMOTE_AUDIO_STATS = "ON_REMOTE_AUDIO_STATS"
+    static let ON_REMOTE_VIDEO_STATS = "ON_REMOTE_VIDEO_STATS"
+}