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

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

@@ -0,0 +1,29 @@
+package com.reactnativehmssdk
+
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.uimanager.events.Event
+
+/**
+ * Generic view-event wrapper used by `<HMSView />` and `<HMSHLSPlayer />`.
+ *
+ * Replaces the legacy paper-only `getJSModule(RCTEventEmitter::class.java).receiveEvent(...)`
+ * call. Dispatched through `UIManagerHelper.getEventDispatcherForReactTag(...)`,
+ * which routes to paper's RCTEventEmitter or Fabric's typed event emitter
+ * depending on which arch is active — including bridgeless mode.
+ *
+ * The event-name → JSX-prop mapping is registered separately in each view
+ * manager via `getExportedCustomDirectEventTypeConstants()`.
+ */
+class HMSReactNativeEvent(
+  surfaceId: Int,
+  viewId: Int,
+  // Renamed from `eventName` to `name` because RN 0.82's `Event<T>` introduced
+  // a same-named member on the supertype; Kotlin 2.x (default in Gradle 8.13)
+  // promotes the hides-supertype-member warning to an error.
+  private val name: String,
+  private val payload: WritableMap?,
+) : Event<HMSReactNativeEvent>(surfaceId, viewId) {
+  override fun getEventName(): String = name
+
+  override fun getEventData(): WritableMap? = payload
+}

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

@@ -0,0 +1,119 @@
+package com.reactnativehmssdk
+
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.common.MapBuilder
+import com.facebook.react.uimanager.ThemedReactContext
+
+/**
+ * HMSSDKViewManagerImpl — shared view-manager logic for `<HMSView />`.
+ *
+ * Phase 1 / 1C-3 of the New Architecture migration. View-manager
+ * responsibilities (creating the view, prop dispatch, command handling,
+ * event-type registration) live here as static helpers. Arch-specific
+ * wrappers live at:
+ *   - android/src/oldarch/.../HMSSDKViewManager.kt
+ *     (extends SimpleViewManager — paper)
+ *   - android/src/newarch/.../HMSSDKViewManager.kt
+ *     (extends SimpleViewManager + implements the Codegen-generated
+ *     HMSViewManagerInterface — Fabric)
+ *
+ * Both wrappers delegate every call here, so the actual logic stays
+ * in one place.
+ */
+class HMSSDKViewManagerImpl {
+  companion object {
+    const val REACT_CLASS = "HMSView"
+
+    fun createViewInstance(reactContext: ThemedReactContext): HMSView = HMSView(reactContext)
+
+    /**
+     * Set the `data` prop. Resolves the active SDK instance via the
+     * passed-in `reactContext` (route through `reactApplicationContext`
+     * for new-arch interop / bridgeless safety).
+     */
+    fun setData(
+      view: HMSView,
+      data: ReadableMap,
+      reactContext: ThemedReactContext?,
+    ) {
+      val trackId = data.getString("trackId")
+      val id = data.getString("id")
+      val mirror = data.getBoolean("mirror")
+      val scaleType = data.getString("scaleType")
+      val hmsCollection = getHmsCollection(reactContext) ?: return
+      view.setData(id, trackId, hmsCollection, mirror, scaleType)
+    }
+
+    fun setScaleType(
+      view: HMSView,
+      data: String?,
+    ) = view.updateScaleType(data)
+
+    fun setZOrderMediaOverlay(
+      view: HMSView,
+      data: Boolean?,
+    ) = view.updateZOrderMediaOverlay(data)
+
+    fun setAutoSimulcast(
+      view: HMSView,
+      data: Boolean?,
+    ) {
+      data?.let { view.updateAutoSimulcast(it) }
+    }
+
+    /** Imperative `capture` command (paper — args is a numeric-array). */
+    fun capture(
+      view: HMSView,
+      args: ReadableArray?,
+    ) = view.captureHmsView(args)
+
+    /** Imperative `capture` command (Fabric — typed `requestId`). */
+    fun capture(
+      view: HMSView,
+      requestId: Int,
+    ) {
+      val args = Arguments.createArray().apply { pushInt(requestId) }
+      view.captureHmsView(args)
+    }
+
+    fun getCommandsMap(): Map<String, Int> = MapBuilder.of("capture", 1)
+
+    /**
+     * Called from both arch wrappers' `onDropViewInstance` override.
+     * Forwards to `HMSView.cleanup()` to release the listener registered
+     * in `init`, avoiding a memory leak across mount/unmount cycles.
+     */
+    fun onDropViewInstance(view: HMSView) = view.cleanup()
+
+    /**
+     * Both events are DIRECT, matching the Codegen spec which declares both as
+     * `DirectEventHandler<...>`. The names are deliberately unique (not the
+     * default `topChange`) to avoid colliding with RN's built-in `topChange`
+     * (which RN registers as bubbling on every RCTView), which would trigger
+     * "Event cannot be both direct and bubbling" at runtime.
+     *
+     * - `topResolutionChange` → JS receives as `onResolutionChange`.
+     * - `captureFrame`        → JS receives as `onDataReturned`.
+     */
+    fun getExportedCustomDirectEventTypeConstants(): Map<String, Any> =
+      MapBuilder
+        .builder<String, Any>()
+        .put("topResolutionChange", MapBuilder.of("registrationName", "onResolutionChange"))
+        .put("captureFrame", MapBuilder.of("registrationName", "onDataReturned"))
+        .build()
+
+    /**
+     * Look up the active SDK instances map. Routes through
+     * `reactApplicationContext` rather than `themedContext.getNativeModule`
+     * directly — the themed-context lookup is unreliable under the New
+     * Architecture Interop Layer / bridgeless mode.
+     */
+    fun getHmsCollection(reactContext: ThemedReactContext?): MutableMap<String, HMSRNSDK>? =
+      reactContext
+        ?.reactApplicationContext
+        ?.getNativeModule(HMSManager::class.java)
+        ?.getHmsInstance()
+  }
+}

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

@@ -11,21 +11,29 @@ import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactContext
 import com.facebook.react.bridge.ReadableArray
 import com.facebook.react.bridge.WritableMap
-import com.facebook.react.uimanager.events.RCTEventEmitter
+import com.facebook.react.uimanager.UIManagerHelper
+import hms.webrtc.RendererCommon
 import live.hms.video.media.tracks.HMSVideoTrack
 import live.hms.video.utils.HmsUtilities
 import live.hms.videoview.HMSVideoView
 import live.hms.videoview.VideoViewStateChangeListener
-import org.webrtc.RendererCommon
 
 @SuppressLint("ViewConstructor")
-class HMSView(context: ReactContext) : FrameLayout(context) {
+class HMSView(
+  context: ReactContext,
+) : FrameLayout(context) {
   private var hmsVideoView: HMSVideoView? = null
   private var videoTrack: HMSVideoTrack? = null
   private var sdkId: String = "12345"
   private var disableAutoSimulcastLayerSelect = false
   private var jsCanApplyStyles = false
 
+  // Held so `cleanup()` can clear the listener from `HMSVideoView` on view
+  // drop. The anonymous VideoViewStateChangeListener captures `this`, so
+  // leaking it across mount/unmount cycles prevents GC of HMSView instances.
+  // Mirrors the same fix applied to HMSHLSPlayer's Player.Listener.
+  private var videoViewStateChangeListener: VideoViewStateChangeListener? = null
+
   init {
     val inflater = getContext().getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
     val view = inflater.inflate(R.layout.hms_view, this)
@@ -36,21 +44,63 @@ class HMSView(context: ReactContext) : FrameLayout(context) {
     hmsVideoView?.setMirror(false)
     hmsVideoView?.disableAutoSimulcastLayerSelect(disableAutoSimulcastLayerSelect)
 
-    hmsVideoView?.addVideoViewStateChangeListener(
+    val listener =
       object : VideoViewStateChangeListener {
         override fun onResolutionChange(
           newWidth: Int,
           newHeight: Int,
         ) {
           super.onResolutionChange(newWidth, newHeight)
-          if (!jsCanApplyStyles) {
-            val event: WritableMap = Arguments.createMap()
-            context.getJSModule(RCTEventEmitter::class.java).receiveEvent(id, "topChange", event)
-            jsCanApplyStyles = true
+
+          videoTrack?.let { nonnullVideoTrack ->
+            // emit when source is screen or `jsCanApplyStyles` is `false`
+            if (nonnullVideoTrack.source == "screen" || !jsCanApplyStyles) {
+              jsCanApplyStyles = true
+
+              val data = Arguments.createMap()
+              data.putInt("width", newWidth)
+              data.putInt("height", newHeight)
+
+              sendEventToJS("ON_RESOLUTION_CHANGE_EVENT", data)
+            }
           }
         }
-      },
-    )
+      }
+    videoViewStateChangeListener = listener
+    hmsVideoView?.addVideoViewStateChangeListener(listener)
+  }
+
+  /**
+   * Called from `HMSSDKViewManager.onDropViewInstance` when RN destroys the
+   * view. Clears the VideoViewStateChangeListener registered in `init` so
+   * the anonymous listener doesn't retain `this` across mount/unmount.
+   */
+  fun cleanup() {
+    if (videoViewStateChangeListener != null) {
+      hmsVideoView?.addVideoViewStateChangeListener(null)
+      videoViewStateChangeListener = null
+    }
+  }
+
+  private fun sendEventToJS(
+    eventName: String,
+    data: WritableMap,
+  ) {
+    val event: WritableMap = Arguments.createMap()
+    event.putString("event", eventName)
+    event.putMap("data", data)
+
+    val reactContext = context as ReactContext
+    val surfaceId = UIManagerHelper.getSurfaceId(this)
+    val dispatcher = UIManagerHelper.getEventDispatcherForReactTag(reactContext, id)
+    if (dispatcher != null) {
+      dispatcher.dispatchEvent(HMSReactNativeEvent(surfaceId, id, "topResolutionChange", event))
+    } 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. Same pattern as HMSHLSPlayer.kt.
+      Log.w("HMSView", "Event 'topResolutionChange' dropped — dispatcher null for tag $id")
+    }
   }
 
   @RequiresApi(Build.VERSION_CODES.N)
@@ -68,9 +118,11 @@ class HMSView(context: ReactContext) : FrameLayout(context) {
   override fun onAttachedToWindow() {
     super.onAttachedToWindow()
 
-    videoTrack?.let { // Safe Call Operator to check if videoTrack is not null
+    videoTrack?.let {
+      // Safe Call Operator to check if videoTrack is not null
       hmsVideoView?.addTrack(it) // add the videoTrack to the hmsVideoView
-    } ?: run { // Elvis Operator to handle the case when videoTrack is null
+    } ?: run {
+      // Elvis Operator to handle the case when videoTrack is null
       Log.e(
         "HMSView",
         "HMSView attached to window, but it's videoTrack is null",

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

@@ -17,17 +17,16 @@ class HmsScreenshareActivity : ComponentActivity() {
       if (result.resultCode == Activity.RESULT_OK) {
         val mediaProjectionPermissionResultData: Intent? = result.data
         val id = intent.getStringExtra("id")
-        HMSManager.hmsCollection[id]?.hmsSDK?.startScreenshare(
+        HMSManagerImpl.hmsCollection[id]?.hmsSDK?.startScreenshare(
           object : HMSActionResultListener {
             override fun onError(error: HMSException) {
               finish()
-              HMSManager.hmsCollection[id]?.screenshareCallback?.reject(error)
-              HMSManager.hmsCollection[id]?.emitHMSError(error)
+              HMSManagerImpl.hmsCollection[id]?.screenshareCallback?.reject(error)
             }
 
             override fun onSuccess() {
-              HMSManager.hmsCollection[id]?.screenshareCallback?.resolve(
-                HMSManager.hmsCollection[id]?.emitHMSSuccess(),
+              HMSManagerImpl.hmsCollection[id]?.screenshareCallback?.resolve(
+                HMSManagerImpl.hmsCollection[id]?.getPromiseResolveData(),
               )
               finish()
             }
@@ -44,8 +43,7 @@ class HmsScreenshareActivity : ComponentActivity() {
             "RESULT_CANCELED",
             "RESULT_CANCELED",
           )
-        HMSManager.hmsCollection[id]?.screenshareCallback?.reject(error)
-        HMSManager.hmsCollection[id]?.emitHMSError(error)
+        HMSManagerImpl.hmsCollection[id]?.screenshareCallback?.reject(error)
         finish()
       }
     }
@@ -57,7 +55,7 @@ class HmsScreenshareActivity : ComponentActivity() {
 
   private fun startScreenshare() {
     val id = intent.getStringExtra("id")
-    val isScreenShared = HMSManager.hmsCollection[id]?.hmsSDK?.isScreenShared()
+    val isScreenShared = HMSManagerImpl.hmsCollection[id]?.hmsSDK?.isScreenShared()
     if (isScreenShared !== null && !isScreenShared) {
       try {
         val mediaProjectionManager =
@@ -66,8 +64,10 @@ class HmsScreenshareActivity : ComponentActivity() {
       } catch (e: Exception) {
         println(e)
       }
+      HMSManagerImpl.startingScreenShare = false
     } else {
-      HMSManager.hmsCollection[id]?.emitHMSError(
+      HMSManagerImpl.startingScreenShare = false
+      HMSManagerImpl.hmsCollection[id]?.emitHMSError(
         HMSException(
           103,
           "SCREENSHARE_IS_ALREADY_RUNNING",

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

@@ -1,16 +1,52 @@
 package com.reactnativehmssdk
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.facebook.react.uimanager.ViewManager
 
-class HmssdkPackage : ReactPackage {
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(HMSManager(reactContext))
-  }
+/**
+ * HmssdkPackage — Phase 1 / 1C-2 of the New Architecture migration.
+ *
+ * Converted from `ReactPackage` to `BaseReactPackage` so that under New
+ * Architecture, modules are instantiated lazily via `getModule(name)` —
+ * matching how TurboModules are registered. `getReactModuleInfoProvider()`
+ * advertises which modules this package owns.
+ *
+ * The same package class works under both arches; the active source set
+ * (oldarch or newarch) determines which `HMSManager` class is on the
+ * classpath. View managers are still registered eagerly via
+ * `createViewManagers()` — Fabric component-view migration for them
+ * lives in 1C-3 (HMSSDKViewManager) and 1C-4 (HMSHLSPlayerManager).
+ */
+class HmssdkPackage : BaseReactPackage() {
+  override fun getModule(
+    name: String,
+    reactContext: ReactApplicationContext,
+  ): NativeModule? =
+    when (name) {
+      HMSManagerImpl.REACT_CLASS -> HMSManager(reactContext)
+      else -> null
+    }
 
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return listOf<ViewManager<*, *>>(HMSSDKViewManager(), HMSHLSPlayerManager())
-  }
+  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider =
+    ReactModuleInfoProvider {
+      mapOf(
+        HMSManagerImpl.REACT_CLASS to
+          ReactModuleInfo(
+            HMSManagerImpl.REACT_CLASS, // name
+            "com.reactnativehmssdk.HMSManager", // className (the wrapper, set per source set)
+            false, // canOverrideExistingModule
+            false, // needsEagerInit
+            false, // hasConstants (deprecated, ignored under New Arch)
+            false, // isCxxModule
+            BuildConfig.IS_NEW_ARCHITECTURE_ENABLED, // isTurboModule
+          ),
+      )
+    }
+
+  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
+    listOf<ViewManager<*, *>>(HMSSDKViewManager(), HMSHLSPlayerManager())
 }