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

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

@@ -2,30 +2,43 @@ package com.reactnativehmssdk
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.util.Log
 import android.view.LayoutInflater
+import android.view.View
 import android.widget.FrameLayout
 import androidx.media3.common.Player
 import androidx.media3.common.VideoSize
-import androidx.media3.ui.AspectRatioFrameLayout.RESIZE_MODE_FIT
-import androidx.media3.ui.AspectRatioFrameLayout.RESIZE_MODE_ZOOM
+import androidx.media3.common.text.CueGroup
 import androidx.media3.ui.PlayerView
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
-import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.UIManagerHelper
 import live.hms.hls_player.*
 import live.hms.stats.PlayerStatsListener
 import live.hms.stats.model.PlayerStatsModel
 import live.hms.video.error.HMSException
 import live.hms.video.sdk.HMSSDK
+import live.hms.video.sdk.models.enums.HMSStreamingState
 import java.util.concurrent.TimeUnit
 
 @SuppressLint("ViewConstructor")
-class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
+class HMSHLSPlayer(
+  context: ThemedReactContext,
+) : FrameLayout(context) {
   private var playerView: PlayerView? = null // Exoplayer View
   private var hmsHlsPlayer: HmsHlsPlayer? = null // 100ms HLS Player
   private var hmssdkInstance: HMSSDK? = null
   private var statsMonitorAttached = false
+  private var shouldSendCaptionsToJS = false
+
+  // Held so `cleanup()` can remove the listener from ExoPlayer on unmount.
+  // The anonymous Player.Listener captures `this`, so leaking it across
+  // mount/unmount cycles prevents GC of HMSHLSPlayer view instances.
+  private var playerListener: Player.Listener? = null
   private val hmsHlsPlaybackEventsObject =
     object : HmsHlsPlaybackEvents {
       override fun onCue(cue: HmsHlsCue) {
@@ -116,8 +129,10 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
     val localPlayerView = view.findViewById<PlayerView>(R.id.hls_view)
     playerView = localPlayerView
     localPlayerView.useController = false
+    localPlayerView.subtitleView?.visibility = View.GONE
 
-    val hmssdkCollection = context.getNativeModule(HMSManager::class.java)?.getHmsInstance()
+    // Route through reactApplicationContext for new arch interop compatibility.
+    val hmssdkCollection = context.reactApplicationContext.getNativeModule(HMSManager::class.java)?.getHmsInstance()
     hmssdkInstance = hmssdkCollection?.get("12345")?.hmsSDK
 
     // creating 100ms HLS Player
@@ -130,15 +145,8 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
     // setting 100ms HLS Player on Exoplayer
     localPlayerView.player = localHmsHlsPlayer.getNativePlayer()
 
-    localPlayerView?.player?.addListener(
+    val listener =
       object : Player.Listener {
-        override fun onSurfaceSizeChanged(
-          width: Int,
-          height: Int,
-        ) {
-          super.onSurfaceSizeChanged(width, height)
-        }
-
         override fun onVideoSizeChanged(videoSize: VideoSize) {
           super.onVideoSizeChanged(videoSize)
 
@@ -146,26 +154,38 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
             val width = videoSize.width.toDouble()
             val height = videoSize.height.toDouble()
 
-            if (width >= height) {
-              playerView?.resizeMode = RESIZE_MODE_FIT
-            } else {
-              playerView?.resizeMode = RESIZE_MODE_ZOOM
-            }
-
             val data = Arguments.createMap()
-            data.putString("state", "onVideoSizeChanged")
-            data.putDouble("aspectRatio", (width / height))
-            sendHLSPlaybackEventToJS(HMSHLSPlayerConstants.ON_PLAYBACK_STATE_CHANGE_EVENT, data)
+            data.putDouble("width", width)
+            data.putDouble("height", height)
+            sendHLSPlaybackEventToJS(HMSHLSPlayerConstants.ON_PLAYBACK_RESOLUTION_CHANGE_EVENT, data)
           }
         }
-      },
-    )
+
+        override fun onCues(cueGroup: CueGroup) {
+          super.onCues(cueGroup)
+          if (!shouldSendCaptionsToJS) return
+          val ccText =
+            cueGroup.cues
+              .firstOrNull()
+              ?.text
+              ?.toString()
+          sendHLSPlayerCuesEventToJS(ccText)
+        }
+      }
+    playerListener = listener
+    localPlayerView?.player?.addListener(listener)
   }
 
   fun cleanup() {
     hmsHlsPlayer?.stop()
     hmsHlsPlayer?.addPlayerEventListener(null)
     hmsHlsPlayer?.setStatsMonitor(null)
+    // Remove the ExoPlayer Player.Listener registered in init. Without
+    // this, the anonymous listener (which captures `this`) leaks across
+    // mount/unmount cycles — visible in long-running video conferencing
+    // sessions where users repeatedly join and leave rooms.
+    playerListener?.let { listener -> playerView?.player?.removeListener(listener) }
+    playerListener = null
   }
 
   fun play(url: String?) {
@@ -178,7 +198,7 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
 
     val defaultURL: String? =
       hlsStreamingState?.let {
-        if (it.running) {
+        if (it.state == HMSStreamingState.STARTED) {
           it.variants?.get(0)?.hlsStreamUrl
         } else {
           null
@@ -218,6 +238,43 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
     hmsHlsPlayer?.volume = level
   }
 
+  fun areClosedCaptionSupported(requestId: Int) {
+    hmsHlsPlayer.let {
+      if (it == null) {
+        sendHLSDataRequestEventToJS(requestId, false)
+      } else {
+        sendHLSDataRequestEventToJS(requestId, it.areClosedCaptionsSupported())
+      }
+    }
+  }
+
+  fun isClosedCaptionEnabled(requestId: Int) {
+    sendHLSDataRequestEventToJS(requestId, shouldSendCaptionsToJS)
+  }
+
+  fun enableClosedCaption() {
+    shouldSendCaptionsToJS = true
+  }
+
+  fun disableClosedCaption() {
+    shouldSendCaptionsToJS = false
+    sendHLSPlayerCuesEventToJS(null)
+  }
+
+  fun getPlayerDurationDetails(requestId: Int) {
+    val data: WritableMap = Arguments.createMap()
+    hmsHlsPlayer?.getNativePlayer()?.let { exoPlayer ->
+      data.putInt(
+        "rollingWindowTime",
+        exoPlayer.seekParameters.toleranceAfterUs
+          .div(1000)
+          .toInt(),
+      )
+      data.putInt("streamDuration", exoPlayer.duration.toInt())
+    }
+    sendHLSDataRequestEventToJS(requestId, data)
+  }
+
   fun enableStats(enable: Boolean) {
     if (enable) {
       attachStatsMonitor()
@@ -229,11 +286,13 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
   fun enableControls(show: Boolean) {
     playerView?.let {
       if (show) {
+        it.subtitleView?.visibility = View.VISIBLE
         it.useController = true
         it.showController()
       } else {
         it.hideController()
         it.useController = false
+        it.subtitleView?.visibility = View.GONE
       }
     }
   }
@@ -254,6 +313,23 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
     statsMonitorAttached = false
   }
 
+  private fun dispatchViewEvent(
+    eventName: String,
+    payload: WritableMap,
+  ) {
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+    if (dispatcher != null) {
+      dispatcher.dispatchEvent(HMSReactNativeEvent(surfaceId, id, eventName, payload))
+    } else {
+      // Bridgeless mode: dispatcher can be null if the view is detaching or
+      // the React tag is no longer valid. Log instead of silently dropping
+      // so the event loss is debuggable.
+      Log.w("HMSHLSPlayer", "Event '$eventName' dropped — dispatcher null for tag $id")
+    }
+  }
+
   private fun sendHLSPlaybackEventToJS(
     eventName: String,
     data: WritableMap,
@@ -262,8 +338,7 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
     event.putString("event", eventName)
     event.putMap("data", data)
 
-    val reactContext = context as ReactContext
-    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, HMSHLSPlayerConstants.HMS_HLS_PLAYBACK_EVENT, event)
+    dispatchViewEvent(HMSHLSPlayerConstants.HMS_HLS_PLAYBACK_EVENT, event)
   }
 
   private fun sendHLSStatsEventToJS(
@@ -274,8 +349,45 @@ class HMSHLSPlayer(context: ReactContext) : FrameLayout(context) {
     event.putString("event", eventName)
     event.putMap("data", data)
 
-    val reactContext = context as ReactContext
-    reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, HMSHLSPlayerConstants.HMS_HLS_STATS_EVENT, event)
+    dispatchViewEvent(HMSHLSPlayerConstants.HMS_HLS_STATS_EVENT, event)
+  }
+
+  private fun sendHLSDataRequestEventToJS(
+    requestId: Int,
+    data: Any,
+  ) {
+    val event: WritableMap = Arguments.createMap()
+    event.putInt("requestId", requestId)
+
+    if (data is Boolean) {
+      event.putBoolean("data", data)
+    } else if (data is String) {
+      event.putString("data", data)
+    } else if (data is Int) {
+      event.putInt("data", data)
+    } else if (data is Double) {
+      event.putDouble("data", data)
+    } else if (data is ReadableMap) {
+      event.putMap("data", data)
+    } else if (data is ReadableArray) {
+      event.putArray("data", data)
+    } else {
+      event.putNull("data")
+    }
+
+    dispatchViewEvent(HMSHLSPlayerConstants.HLS_DATA_REQUEST_EVENT, event)
+  }
+
+  private fun sendHLSPlayerCuesEventToJS(ccText: String?) {
+    val event: WritableMap = Arguments.createMap()
+    event.putString("event", HMSHLSPlayerConstants.ON_CLOSED_CAPTION_UPDATE)
+
+    if (ccText is String) {
+      event.putString("data", ccText)
+    } else {
+      event.putNull("data")
+    }
+    dispatchViewEvent(HMSHLSPlayerConstants.HLS_PLAYER_CUES_EVENT, event)
   }
 }
 
@@ -285,9 +397,17 @@ object HMSHLSPlayerConstants {
   const val ON_PLAYBACK_CUE_EVENT = "ON_PLAYBACK_CUE_EVENT"
   const val ON_PLAYBACK_FAILURE_EVENT = "ON_PLAYBACK_FAILURE_EVENT"
   const val ON_PLAYBACK_STATE_CHANGE_EVENT = "ON_PLAYBACK_STATE_CHANGE_EVENT"
+  const val ON_PLAYBACK_RESOLUTION_CHANGE_EVENT = "ON_PLAYBACK_RESOLUTION_CHANGE_EVENT"
 
   // HLS Playback Stats Events
   const val HMS_HLS_STATS_EVENT = "hmsHlsStatsEvent"
   const val ON_STATS_EVENT_UPDATE = "ON_STATS_EVENT_UPDATE"
   const val ON_STATS_EVENT_ERROR = "ON_STATS_EVENT_ERROR"
+
+  // HLS Requested Data Returned
+  const val HLS_DATA_REQUEST_EVENT = "hlsDataRequestEvent"
+
+  // HLS Player Cues Events
+  const val HLS_PLAYER_CUES_EVENT = "hlsPlayerCuesEvent"
+  const val ON_CLOSED_CAPTION_UPDATE = "ON_CLOSED_CAPTION_UPDATE"
 }

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

@@ -0,0 +1,185 @@
+package com.reactnativehmssdk
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+
+/**
+ * HMSHLSPlayerManagerImpl — shared view-manager logic for `<HMSHLSPlayer />`.
+ *
+ * Phase 1 / 1C-4 of the New Architecture migration. View-manager
+ * responsibilities (creating/cleanup, prop dispatch, 13 commands, event
+ * registration) live here as static helpers. Arch-specific wrappers at:
+ *   - android/src/oldarch/.../HMSHLSPlayerManager.kt — paper, @ReactProp + numeric command IDs
+ *   - android/src/newarch/.../HMSHLSPlayerManager.kt — Fabric, implements the
+ *     Codegen-generated HMSHLSPlayerManagerInterface for typed prop + command dispatch
+ */
+class HMSHLSPlayerManagerImpl {
+  companion object {
+    const val REACT_CLASS = "HMSHLSPlayer"
+
+    fun createViewInstance(reactContext: ThemedReactContext): HMSHLSPlayer = HMSHLSPlayer(reactContext)
+
+    fun onDropViewInstance(view: HMSHLSPlayer) {
+      view.cleanup()
+    }
+
+    // ─────────────────────────────────────────────────────────────────
+    // Prop setters
+    // ─────────────────────────────────────────────────────────────────
+
+    fun setUrl(
+      view: HMSHLSPlayer,
+      data: String?,
+    ) = view.play(data)
+
+    fun setEnableStats(
+      view: HMSHLSPlayer,
+      data: Boolean,
+    ) = view.enableStats(data)
+
+    fun setEnableControls(
+      view: HMSHLSPlayer,
+      data: Boolean,
+    ) = view.enableControls(data)
+
+    // ─────────────────────────────────────────────────────────────────
+    // Imperative commands (13)
+    // ─────────────────────────────────────────────────────────────────
+
+    fun play(
+      view: HMSHLSPlayer,
+      url: String?,
+    ) = view.play(url)
+
+    fun stop(view: HMSHLSPlayer) = view.stop()
+
+    fun pause(view: HMSHLSPlayer) = view.pause()
+
+    fun resume(view: HMSHLSPlayer) = view.resume()
+
+    fun seekToLivePosition(view: HMSHLSPlayer) = view.seekToLivePosition()
+
+    fun seekForward(
+      view: HMSHLSPlayer,
+      seconds: Double,
+    ) = view.seekForward(seconds)
+
+    fun seekBackward(
+      view: HMSHLSPlayer,
+      seconds: Double,
+    ) = view.seekBackward(seconds)
+
+    fun setVolume(
+      view: HMSHLSPlayer,
+      level: Int,
+    ) = view.setVolume(level)
+
+    fun areClosedCaptionSupported(
+      view: HMSHLSPlayer,
+      requestId: Int,
+    ) = view.areClosedCaptionSupported(requestId)
+
+    fun isClosedCaptionEnabled(
+      view: HMSHLSPlayer,
+      requestId: Int,
+    ) = view.isClosedCaptionEnabled(requestId)
+
+    fun enableClosedCaption(view: HMSHLSPlayer) = view.enableClosedCaption()
+
+    fun disableClosedCaption(view: HMSHLSPlayer) = view.disableClosedCaption()
+
+    fun getPlayerDurationDetails(
+      view: HMSHLSPlayer,
+      requestId: Int,
+    ) = view.getPlayerDurationDetails(requestId)
+
+    // ─────────────────────────────────────────────────────────────────
+    // Paper-side dispatch helpers (used by the oldarch wrapper)
+    // ─────────────────────────────────────────────────────────────────
+
+    /**
+     * Numeric command IDs preserved from the original view manager so
+     * paper-side dispatch keeps the same wire protocol.
+     */
+    fun getCommandsMap(): Map<String, Int> =
+      MapBuilder
+        .builder<String, Int>()
+        .put("play", 10)
+        .put("stop", 20)
+        .put("pause", 30)
+        .put("resume", 40)
+        .put("seekToLivePosition", 50)
+        .put("seekForward", 60)
+        .put("seekBackward", 70)
+        .put("setVolume", 80)
+        .put("areClosedCaptionSupported", 90)
+        .put("isClosedCaptionEnabled", 100)
+        .put("enableClosedCaption", 110)
+        .put("disableClosedCaption", 120)
+        .put("getPlayerDurationDetails", 130)
+        .build()
+
+    /** Paper command dispatch by numeric ID. */
+    fun receiveCommandById(
+      view: HMSHLSPlayer,
+      commandId: Int,
+      args: ReadableArray?,
+    ) {
+      when (commandId) {
+        10 -> play(view, args?.getString(0))
+        20 -> stop(view)
+        30 -> pause(view)
+        40 -> resume(view)
+        50 -> seekToLivePosition(view)
+        60 -> args?.let { seekForward(view, it.getDouble(0)) }
+        70 -> args?.let { seekBackward(view, it.getDouble(0)) }
+        80 -> args?.let { setVolume(view, it.getInt(0)) }
+        90 -> args?.let { areClosedCaptionSupported(view, it.getInt(0)) }
+        100 -> args?.let { isClosedCaptionEnabled(view, it.getInt(0)) }
+        110 -> enableClosedCaption(view)
+        120 -> disableClosedCaption(view)
+        130 -> args?.let { getPlayerDurationDetails(view, it.getInt(0)) }
+      }
+    }
+
+    /** Fabric command dispatch by string name. */
+    fun receiveCommandByName(
+      view: HMSHLSPlayer,
+      commandName: String,
+      args: ReadableArray?,
+    ) {
+      when (commandName) {
+        "play" -> play(view, args?.getString(0))
+        "stop" -> stop(view)
+        "pause" -> pause(view)
+        "resume" -> resume(view)
+        "seekToLivePosition" -> seekToLivePosition(view)
+        "seekForward" -> args?.let { seekForward(view, it.getDouble(0)) }
+        "seekBackward" -> args?.let { seekBackward(view, it.getDouble(0)) }
+        "setVolume" -> args?.let { setVolume(view, it.getInt(0)) }
+        "areClosedCaptionSupported" -> args?.let { areClosedCaptionSupported(view, it.getInt(0)) }
+        "isClosedCaptionEnabled" -> args?.let { isClosedCaptionEnabled(view, it.getInt(0)) }
+        "enableClosedCaption" -> enableClosedCaption(view)
+        "disableClosedCaption" -> disableClosedCaption(view)
+        "getPlayerDurationDetails" -> args?.let { getPlayerDurationDetails(view, it.getInt(0)) }
+      }
+    }
+
+    // ─────────────────────────────────────────────────────────────────
+    // Event registration — 4 events on `<HMSHLSPlayer />`
+    // ─────────────────────────────────────────────────────────────────
+
+    fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> =
+      MapBuilder.of(
+        HMSHLSPlayerConstants.HMS_HLS_PLAYBACK_EVENT,
+        MapBuilder.of("registrationName", "onHmsHlsPlaybackEvent"),
+        HMSHLSPlayerConstants.HMS_HLS_STATS_EVENT,
+        MapBuilder.of("registrationName", "onHmsHlsStatsEvent"),
+        HMSHLSPlayerConstants.HLS_DATA_REQUEST_EVENT,
+        MapBuilder.of("registrationName", "onDataReturned"),
+        HMSHLSPlayerConstants.HLS_PLAYER_CUES_EVENT,
+        MapBuilder.of("registrationName", "onHlsPlayerCuesEvent"),
+      )
+  }
+}

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

@@ -10,24 +10,30 @@ import android.view.PixelCopy
 import android.webkit.URLUtil
 import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.*
-import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.facebook.react.uimanager.UIManagerHelper
+import hms.webrtc.SurfaceViewRenderer
 import live.hms.video.audio.HMSAudioManager
 import live.hms.video.error.HMSException
 import live.hms.video.events.AgentType
 import live.hms.video.media.settings.*
+import live.hms.video.media.tracks.HMSAudioTrack
 import live.hms.video.media.tracks.HMSRemoteAudioTrack
 import live.hms.video.media.tracks.HMSRemoteVideoTrack
 import live.hms.video.media.tracks.HMSTrack
+import live.hms.video.sdk.HMSSDK
+import live.hms.video.sdk.listeners.PeerListResultListener
 import live.hms.video.sdk.models.*
 import live.hms.video.sdk.models.enums.AudioMixingMode
 import live.hms.video.sdk.models.role.HMSRole
 import live.hms.video.services.LogAlarmManager
 import live.hms.video.utils.HMSLogger
 import live.hms.video.utils.HmsUtilities
-import org.webrtc.SurfaceViewRenderer
 import java.io.ByteArrayOutputStream
 import java.util.*
 import kotlin.collections.ArrayList
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
 
 object HMSHelper {
   fun areAllRequiredKeysAvailable(
@@ -106,15 +112,38 @@ object HMSHelper {
     return null
   }
 
-  fun getRemotePeerFromPeerId(
+  suspend fun getRemotePeerFromPeerId(
     peerId: String?,
-    room: HMSRoom?,
-  ): HMSRemotePeer? {
-    if (peerId != null && room != null) {
-      return HmsUtilities.getPeer(peerId, room) as? HMSRemotePeer
+    hmsSDK: HMSSDK?,
+  ): HMSRemotePeer? =
+    suspendCoroutine {
+      val room = hmsSDK?.getRoom()
+
+      if (peerId != null && room != null) {
+        val peerFromRoom = HmsUtilities.getPeer(peerId, room) as? HMSRemotePeer
+        if (peerFromRoom != null) {
+          it.resume(peerFromRoom)
+        } else {
+          val limit = 1
+          val peerIds = arrayListOf(peerId)
+          val peerListIterator = hmsSDK.getPeerListIterator(PeerListIteratorOptions(limit = limit, byPeerIds = peerIds))
+          peerListIterator.next(
+            object : PeerListResultListener {
+              override fun onError(error: HMSException) {
+                it.resumeWithException(error)
+              }
+
+              override fun onSuccess(result: ArrayList<HMSPeer>) {
+                val peerFromIterator = result[0]
+                it.resume(peerFromIterator as? HMSRemotePeer)
+              }
+            },
+          )
+        }
+      } else {
+        it.resume(null)
+      }
     }
-    return null
-  }
 
   fun getRolesFromRoleNames(
     targetedRoles: ArrayList<String>?,
@@ -158,6 +187,13 @@ object HMSHelper {
     return null
   }
 
+  fun getAllAudioTracks(room: HMSRoom?): ArrayList<HMSAudioTrack>? {
+    if (room != null) {
+      return HmsUtilities.getAllAudioTracks(room)
+    }
+    return null
+  }
+
   fun getRemoteVideoTrackFromTrackId(
     trackId: String?,
     room: HMSRoom?,
@@ -269,19 +305,33 @@ object HMSHelper {
     if (data == null) {
       return null
     }
+
     val builder = HMSAudioTrackSettings.Builder()
     if (areAllRequiredKeysAvailable(data, arrayOf(Pair("useHardwareEchoCancellation", "Boolean")))
     ) {
       val useHardwareEchoCancellation = data.getBoolean("useHardwareEchoCancellation")
       builder.setUseHardwareAcousticEchoCanceler(useHardwareEchoCancellation)
-    } else {
-      builder.setUseHardwareAcousticEchoCanceler(false)
     }
 
     if (areAllRequiredKeysAvailable(data, arrayOf(Pair("initialState", "String")))) {
       val initialState = getHMSTrackSettingsInitState(data.getString("initialState"))
       builder.initialState(initialState)
     }
+
+    if (areAllRequiredKeysAvailable(data, arrayOf(Pair("noiseCancellationPlugin", "Map")))) {
+      val plugin = data.getMap("noiseCancellationPlugin")
+
+      /**
+       * ***** Plugin Signature *****
+       *  {
+       *    modelName: "SMALL_FULL_BAND"
+       *    initialState: "ENABLED" | "DISABLED"
+       *  }
+       */
+      val initialState = plugin?.getString("initialState") ?: "DISABLED"
+      builder.enableNoiseCancellation(initialState == "ENABLED")
+    }
+
     return builder.build()
   }
 
@@ -584,6 +634,20 @@ object HMSHelper {
       output.putInt("requestId", -1)
     }
     val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
+
+    // Bridgeless mode: dispatcher can be null if the view is detaching or
+    // the React tag is no longer valid. Log instead of silently dropping
+    // so the event loss is debuggable.
+    fun dispatchCaptureFrameEvent() {
+      val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+      if (dispatcher != null) {
+        dispatcher.dispatchEvent(HMSReactNativeEvent(surfaceId, id, "captureFrame", output))
+      } else {
+        Log.w("captureSurfaceView", "captureFrame event dropped — dispatcher null for tag $id")
+      }
+    }
+
     try {
       val bitmap: Bitmap =
         Bitmap.createBitmap(surfaceView.width, surfaceView.height, Bitmap.Config.ARGB_8888)
@@ -599,12 +663,10 @@ object HMSHelper {
             val encoded: String = Base64.encodeToString(byteArray, Base64.DEFAULT)
             Log.d("captureSurfaceView", "Base64: $encoded")
             output.putString("result", encoded)
-            reactContext
-              .getJSModule(RCTEventEmitter::class.java)
-              .receiveEvent(id, "captureFrame", output)
+            dispatchCaptureFrameEvent()
           } else {
             Log.e("captureSurfaceView", "copyResult: $copyResult")
-            HMSManager.hmsCollection[sdkId]?.emitHMSError(
+            HMSManagerImpl.hmsCollection[sdkId]?.emitHMSError(
               HMSException(
                 103,
                 copyResult.toString(),
@@ -614,18 +676,16 @@ object HMSHelper {
               ),
             )
             output.putString("error", copyResult.toString())
-            reactContext
-              .getJSModule(RCTEventEmitter::class.java)
-              .receiveEvent(id, "captureFrame", output)
+            dispatchCaptureFrameEvent()
           }
         },
         Handler(),
       )
     } catch (e: Exception) {
       Log.e("captureSurfaceView", "error: $e")
-      HMSManager.hmsCollection[sdkId]?.emitHMSError(e as HMSException)
+      HMSManagerImpl.hmsCollection[sdkId]?.emitHMSError(e as HMSException)
       output.putString("error", e.message)
-      reactContext.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "captureFrame", output)
+      dispatchCaptureFrameEvent()
     }
   }