@callstack/react-native-brownfield 1.2.0 → 2.0.1

package/README.md

@@ -31,6 +31,13 @@
 - Compatible with all native languages **Objective-C**, **Swift**, **Java** and **Kotlin**
 - Supports UIKit and SwiftUI on iOS and Fragments and Jetpack Compose on Android
 
+## React Native version compatibility matrix
+
+| Tested React Native Version | React Native Brownfield Version |
+| --------------------------- | ------------------------------- |
+| 0.81.x, 0.82.x              | ^2.0.0-rc.0                     |
+| 0.78.x                      | ^1.2.0                          |
+
 ## Installation
 
 The React Native Brownfield library is intended to be installed in a React Native app that is later consumed as a framework artifact by your native iOS or Android app.
@@ -51,16 +58,16 @@ npm install @callstack/react-native-brownfield
 
 First, we need to package our React Native app as an XCFramework or Fat-AAR.
 
-#### With RNEF
+#### With Rock
 
-Follow [Integrating with Native Apps](https://www.rnef.dev/docs/brownfield/intro) steps in RNEF docs and run:
+Follow [Integrating with Native Apps](https://www.rockjs.dev/docs/brownfield/intro) steps in Rock docs and run:
 
-- `rnef package:ios` for iOS
-- `rnef package:aar` for Android
+- `rock package:ios` for iOS
+- `rock package:aar` for Android
 
 #### With custom scripts
 
-Instead of using RNEF, you can create your own custom packaging scripts. Here are base versions for iOS and Android that you'll need to adjust for your project-specific setup:
+Instead of using Rock, you can create your own custom packaging scripts. Here are base versions for iOS and Android that you'll need to adjust for your project-specific setup:
 
 - [Example iOS script](https://github.com/callstackincubator/modern-brownfield-ref/blob/main/scripts/build-xcframework.sh)
 - [Example Android script](https://github.com/callstackincubator/modern-brownfield-ref/blob/main/scripts/build-aar.sh)
@@ -121,17 +128,13 @@ import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import androidx.fragment.app.Fragment
-import com.callstack.rnbrownfield.RNViewFactory # exposed by RN app framework
 
 class RNAppFragment : Fragment() {
     override fun onCreateView(
         inflater: LayoutInflater,
         container: ViewGroup?,
         savedInstanceState: Bundle?,
-    ): View? =
-        this.context?.let {
-            RNViewFactory.createFrameLayout(it)
-        }
+    ): View? = ReactNativeBrownfield.shared.createView(activity, "BrownFieldTest")
 }
 ```
 
@@ -166,7 +169,9 @@ class MainActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        ReactNativeHostManager.shared.initialize(this.application)
+        ReactNativeHostManager.shared.initialize(this.application) {
+          println("JS bundle loaded")
+        }
 
         showRNAppBtn = findViewById(R.id.show_rn_app_btn)
         showRNAppBtn.setOnClickListener {
@@ -228,7 +233,7 @@ Thanks goes to these wonderful people ([emoji key](https://github.com/kentcdodds
 <!-- ALL-CONTRIBUTORS-LIST:START - Do not remove or modify this section -->
 <!-- prettier-ignore -->
 | [<img src="https://avatars0.githubusercontent.com/u/7837457?s=460&v=4" width="100px;" alt="Michał Chudziak"/><br /><sub><b>Michał Chudziak</b></sub>](https://twitter.com/michalchudziak)<br />[💻](https://github.com/callstack/react-native-brownfield/commits?author=michalchudziak "Code") [📖](https://github.com/callstack/react-native-brownfield/commits?author=michalchudziak "Documentation") [🤔](#ideas-michalchudziak "Ideas, Planning, & Feedback") | [<img src="https://avatars1.githubusercontent.com/u/16336501?s=400&v=4" width="100px;" alt="Piotr Drapich"/><br /><sub><b>Piotr Drapich</b></sub>](https://twitter.com/dratwas)<br />[💻](https://github.com/callstack/react-native-brownfield/commits?author=dratwas "Code") [🤔](#ideas-dratwas "Ideas, Planning, & Feedback") |
-| :---: | :---: |
+| :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------: |
 
 <!-- ALL-CONTRIBUTORS-LIST:END -->
 

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactDelegateWrapper.kt

@@ -8,10 +8,15 @@ import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
 
 class ReactDelegateWrapper(
     private val activity: ComponentActivity?,
-    private val reactHost: ReactHost,
+    resolvedReactHost: ReactHost?,
     moduleName: String,
     launchOptions: Bundle?
-): ReactDelegate(activity, reactHost, moduleName, launchOptions){
+) : ReactDelegate(
+    activity = activity!!,
+    resolvedReactHost,
+    appKey = moduleName,
+    launchOptions = launchOptions,
+) {
     private lateinit var hardwareBackHandler: () -> Unit
     private val backBtnHandler = DefaultHardwareBackBtnHandler {
         hardwareBackHandler()
@@ -25,7 +30,7 @@ class ReactDelegateWrapper(
         hardwareBackHandler = backHandler
     }
 
-    override fun onHostResume() {
-        reactHost.onHostResume(activity, backBtnHandler)
+    fun onReactHostResume() {
+        super.reactHost?.onHostResume(activity, backBtnHandler)
     }
 }

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeBrownfield.kt

@@ -1,7 +1,6 @@
 package com.callstack.reactnativebrownfield
 
 import android.app.Application
-import android.content.Context
 import android.os.Bundle
 import android.widget.FrameLayout
 import androidx.activity.OnBackPressedCallback
@@ -9,21 +8,19 @@ import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
 import com.callstack.reactnativebrownfield.utils.VersionUtils
+import com.facebook.react.ReactHost
 import com.facebook.react.ReactInstanceEventListener
-import com.facebook.react.ReactInstanceManager
-import com.facebook.react.ReactNativeHost
 import com.facebook.react.ReactPackage
-import com.facebook.react.ReactRootView
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.defaults.DefaultReactNativeHost
+import com.facebook.react.common.build.ReactBuildConfig
+import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
+import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
 import com.facebook.react.soloader.OpenSourceMergedSoMapping
 import com.facebook.soloader.SoLoader
 import java.util.concurrent.atomic.AtomicBoolean
-import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
-import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
 
 fun interface OnJSBundleLoaded {
-  operator fun invoke(initialized: Boolean)
+    operator fun invoke(initialized: Boolean)
 }
 
 /**
@@ -33,154 +30,140 @@ fun interface OnJSBundleLoaded {
  */
 private const val RN_THRESHOLD_VERSION = "0.80.0"
 
-class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNativeHost) {
-  companion object {
-    private lateinit var instance: ReactNativeBrownfield
-    private val initialized = AtomicBoolean()
+class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
+    companion object {
+        private lateinit var instance: ReactNativeBrownfield
+        private val initialized = AtomicBoolean()
 
-    @JvmStatic
-    val shared: ReactNativeBrownfield get() = instance
+        @JvmStatic
+        val shared: ReactNativeBrownfield get() = instance
 
-    private fun loadNativeLibs (application: Application) {
-      val rnVersion = BuildConfig.RN_VERSION
+        private fun loadNativeLibs(application: Application) {
+            val rnVersion = BuildConfig.RN_VERSION
 
-      if (VersionUtils.isVersionLessThan(rnVersion, RN_THRESHOLD_VERSION)) {
-        SoLoader.init(application.applicationContext, OpenSourceMergedSoMapping)
-        if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-          // If you opted-in for the New Architecture, we load the native entry point for this app.
-          load()
+            if (VersionUtils.isVersionLessThan(rnVersion, RN_THRESHOLD_VERSION)) {
+                SoLoader.init(application.applicationContext, OpenSourceMergedSoMapping)
+                load()
+            }
         }
-      }
-    }
 
-    @JvmStatic
-    @JvmOverloads
-    fun initialize(application: Application, rnHost: ReactNativeHost, onJSBundleLoaded: OnJSBundleLoaded? = null) {
-      if (!initialized.getAndSet(true)) {
-        loadNativeLibs(application)
-        instance = ReactNativeBrownfield(rnHost)
+        @JvmStatic
+        @JvmOverloads
+        fun initialize(
+            application: Application,
+            reactHost: ReactHost,
+            onJSBundleLoaded: OnJSBundleLoaded? = null
+        ) {
+            if (!initialized.getAndSet(true)) {
+                loadNativeLibs(application)
+                instance = ReactNativeBrownfield(reactHost)
+
+                preloadReactNative {
+                    onJSBundleLoaded?.invoke(true)
+                }
+            }
+        }
 
-        preloadReactNative {
-          onJSBundleLoaded?.invoke(true)
+        @JvmStatic
+        @JvmOverloads
+        fun initialize(
+            application: Application,
+            options: HashMap<String, Any>,
+            onJSBundleLoaded: OnJSBundleLoaded? = null
+        ) {
+            val reactHost: ReactHost by lazy {
+                getDefaultReactHost(
+                    context = application,
+                    packageList = (options["packages"] as? List<*> ?: emptyList<ReactPackage>())
+                        .filterIsInstance<ReactPackage>(),
+                    jsMainModulePath = options["mainModuleName"] as? String ?: "index",
+                    jsBundleAssetPath = options["bundleAssetPath"] as? String ?: "index.android.bundle",
+                    useDevSupport = options["useDeveloperSupport"] as? Boolean
+                        ?: ReactBuildConfig.DEBUG,
+                    jsRuntimeFactory = null
+                )
+            }
+
+            initialize(application, reactHost, onJSBundleLoaded)
         }
-      }
-    }
 
-    @JvmStatic
-    @JvmOverloads
-    fun initialize(application: Application, options: HashMap<String, Any>, onJSBundleLoaded: OnJSBundleLoaded? = null) {
-      val reactNativeHost: ReactNativeHost =
-        object : DefaultReactNativeHost(application) {
+        @JvmStatic
+        @JvmOverloads
+        fun initialize(
+            application: Application,
+            packages: List<ReactPackage>,
+            onJSBundleLoaded: OnJSBundleLoaded? = null
+        ) {
+            val options = hashMapOf("packages" to packages, "mainModuleName" to "index")
 
-          override fun getJSMainModuleName(): String {
-            return options["mainModuleName"] as? String ?: super.getJSMainModuleName()
-          }
+            initialize(application, options, onJSBundleLoaded)
+        }
 
-          override fun getPackages(): List<ReactPackage> {
-            return (options["packages"] as? List<*> ?: emptyList<ReactPackage>())
-              .filterIsInstance<ReactPackage>()
-          }
+        private fun preloadReactNative(callback: ((Boolean) -> Unit)) {
+            shared.reactHost.addReactInstanceEventListener(object :
+                ReactInstanceEventListener {
+                override fun onReactContextInitialized(context: ReactContext) {
+                    callback(true)
+                    shared.reactHost.removeReactInstanceEventListener(this)
+                }
+            })
+            shared.reactHost.start()
+        }
+    }
 
-          override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+    fun createView(
+        activity: FragmentActivity?,
+        moduleName: String,
+        reactDelegate: ReactDelegateWrapper? = null,
+        launchOptions: Bundle? = null,
+    ): FrameLayout {
+        val reactHost = shared.reactHost
+        val resolvedDelegate =
+            reactDelegate ?: ReactDelegateWrapper(activity, reactHost, moduleName, launchOptions)
+
+        val mBackPressedCallback: OnBackPressedCallback = object : OnBackPressedCallback(true) {
+            override fun handleOnBackPressed() {
+                // invoked for JS stack back navigation
+                resolvedDelegate.onBackPressed()
+            }
+        }
+
+        // Register back press callback
+        activity?.onBackPressedDispatcher?.addCallback(mBackPressedCallback)
+        // invoked on the last RN screen exit
+        resolvedDelegate.setHardwareBackHandler {
+            mBackPressedCallback.isEnabled = false
+            activity?.onBackPressedDispatcher?.onBackPressed()
+        }
 
-          override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-          override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+        /**
+         * When createView method is called in ReactNativeFragment, a reactDelegate
+         * instance is required. In such a case, we use the lifeCycle events of the fragment.
+         * When createView method is called elsewhere, then reactDelegate is not required.
+         * In such a case, we set the lifeCycle observer.
+         */
+        if (reactDelegate == null) {
+            activity?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate))
         }
 
-      initialize(application, reactNativeHost, onJSBundleLoaded)
+        resolvedDelegate.loadApp()
+        return resolvedDelegate.reactRootView!!
     }
 
-    @JvmStatic
-    @JvmOverloads
-    fun initialize(application: Application, packages: List<ReactPackage>, onJSBundleLoaded: OnJSBundleLoaded? = null) {
-      val options = hashMapOf("packages" to packages, "mainModuleName" to "index")
+    private fun getLifeCycleObserver(reactDelegate: ReactDelegateWrapper): DefaultLifecycleObserver {
+        return object : DefaultLifecycleObserver {
+            override fun onResume(owner: LifecycleOwner) {
+                reactDelegate.onReactHostResume()
+            }
 
-      initialize(application, options, onJSBundleLoaded)
-    }
+            override fun onPause(owner: LifecycleOwner) {
+                reactDelegate.onHostPause()
+            }
 
-    private fun preloadReactNative(callback: ((Boolean) -> Unit)) {
-      val reactInstanceManager = shared.reactNativeHost.reactInstanceManager
-      reactInstanceManager.addReactInstanceEventListener(object :
-        ReactInstanceEventListener {
-        override fun onReactContextInitialized(reactContext: ReactContext) {
-          callback(true)
-          reactInstanceManager.removeReactInstanceEventListener(this)
+            override fun onDestroy(owner: LifecycleOwner) {
+                reactDelegate.onHostDestroy()
+                owner.lifecycle.removeObserver(this) // Cleanup to avoid leaks
+            }
         }
-      })
-      reactInstanceManager?.createReactContextInBackground()
     }
-  }
-
-  fun createView(
-    context: Context,
-    activity: FragmentActivity?,
-    moduleName: String,
-    reactDelegate: ReactDelegateWrapper? = null,
-    launchOptions: Bundle? = null,
-  ): FrameLayout {
-    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-      val reactHost = getDefaultReactHost(
-        context,
-        shared.reactNativeHost
-      )
-
-      val resolvedDelegate = reactDelegate ?: ReactDelegateWrapper(activity, reactHost, moduleName, launchOptions)
-
-      val mBackPressedCallback: OnBackPressedCallback = object : OnBackPressedCallback(true) {
-        override fun handleOnBackPressed() {
-          // invoked for JS stack back navigation
-          resolvedDelegate.onBackPressed()
-        }
-      }
-
-      // Register back press callback
-      activity?.onBackPressedDispatcher?.addCallback(mBackPressedCallback)
-      // invoked on the last RN screen exit
-      resolvedDelegate.setHardwareBackHandler {
-        mBackPressedCallback.isEnabled = false
-        activity?.onBackPressedDispatcher?.onBackPressed()
-      }
-
-      /**
-       * When createView method is called in ReactNativeFragment, a reactDelegate
-       * instance is required. In such a case, we use the lifeCycle events of the fragment.
-       * When createView method is called elsewhere, then reactDelegate is not required.
-       * In such a case, we set the lifeCycle observer.
-       */
-      if (reactDelegate == null) {
-        activity?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate))
-      }
-
-      resolvedDelegate.loadApp()
-      return resolvedDelegate.reactRootView!!
-    }
-
-    val instanceManager: ReactInstanceManager? = shared.reactNativeHost?.reactInstanceManager
-    val reactView = ReactRootView(context)
-    reactView.startReactApplication(
-      instanceManager,
-      moduleName,
-      launchOptions,
-    )
-
-    return reactView
-  }
-
-  private fun getLifeCycleObserver(reactDelegate: ReactDelegateWrapper): DefaultLifecycleObserver {
-    return object : DefaultLifecycleObserver {
-      override fun onResume(owner: LifecycleOwner) {
-        reactDelegate.onHostResume()
-      }
-
-      override fun onPause(owner: LifecycleOwner) {
-        reactDelegate.onHostPause()
-      }
-
-      override fun onDestroy(owner: LifecycleOwner) {
-        reactDelegate.onHostDestroy()
-        owner.lifecycle.removeObserver(this) // Cleanup to avoid leaks
-      }
-    }
-  }
 }
-

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeBrownfieldPackage.kt

@@ -1,23 +1,22 @@
 package com.callstack.reactnativebrownfield
 
 import android.view.View
-import java.util.Collections
-
 import com.facebook.react.ReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
 import com.facebook.react.uimanager.ReactShadowNode
+import com.facebook.react.uimanager.ViewManager
+import java.util.Collections
 
 
 class ReactNativeBrownfieldPackage : ReactPackage {
-  override fun createViewManagers(reactContext: ReactApplicationContext): MutableList<ViewManager<View, ReactShadowNode<*>>> {
-    return Collections.emptyList()
-  }
+    override fun createViewManagers(reactContext: ReactApplicationContext): MutableList<ViewManager<View, ReactShadowNode<*>>> {
+        return Collections.emptyList()
+    }
 
-  override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
-    val modules = ArrayList<NativeModule>()
-    modules.add(ReactNativeBrownfieldModule(reactContext))
-    return modules
-  }
+    override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
+        val modules = ArrayList<NativeModule>()
+        modules.add(ReactNativeBrownfieldModule(reactContext))
+        return modules
+    }
 }

package/android/src/main/java/com/callstack/reactnativebrownfield/ReactNativeFragment.kt

@@ -1,164 +1,140 @@
-package com.callstack.reactnativebrownfield;
+package com.callstack.reactnativebrownfield
 
-import android.annotation.TargetApi
-import android.os.Build
 import android.os.Bundle
 import android.util.Log
-import android.view.KeyEvent
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
-import com.facebook.infer.annotation.Assertions
+import com.callstack.reactnativebrownfield.constants.ReactNativeFragmentArgNames
 import com.facebook.react.ReactFragment
 import com.facebook.react.ReactHost
-import com.facebook.react.ReactNativeHost
 import com.facebook.react.bridge.Callback
 import com.facebook.react.bridge.WritableMap
-import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
-import com.facebook.react.devsupport.DoubleTapReloadRecognizer
 import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
 
 class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
-  private lateinit var doubleTapReloadRecognizer: DoubleTapReloadRecognizer
-  private lateinit var permissionsCallback: Callback
-  private var permissionListener: PermissionListener? = null
-  private lateinit var moduleName: String
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    /**
-     * ReactFragment.onCreate will throw an exception if we do not provide arg_component_name as arguments.
-     * We silently catch this exception. The reason is we want to invoke the super<Fragment>.onCreate in
-     * ReactFragment. Then initialise the mReactDelegate with ReactDelegateWrapper instead of ReactDelegate.
-     *
-     * So we purposely force ReactFragment.onCreate to throw an exception, so that we can provide our own
-     * implementation for mReactDelegate: ReactDelegateWrapper
-     */
-    try{
-      super.onCreate(savedInstanceState)
-    } catch (e: IllegalStateException){
-      Log.w("ReactNativeFragment", "ReactFragment threw due to missing arg_component_name: ${e.message} - This is an expected behaviour.")
+    private lateinit var permissionsCallback: Callback
+    private var permissionListener: PermissionListener? = null
+    private lateinit var moduleName: String
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        /**
+         * ReactFragment.onCreate will throw an exception if we do not provide arg_component_name as arguments.
+         * We silently catch this exception. The reason is we want to invoke the super<Fragment>.onCreate in
+         * ReactFragment. Then initialise the mReactDelegate with ReactDelegateWrapper instead of ReactDelegate.
+         *
+         * So we purposely force ReactFragment.onCreate to throw an exception, so that we can provide our own
+         * implementation for mReactDelegate: ReactDelegateWrapper
+         */
+        try {
+            super.onCreate(savedInstanceState)
+        } catch (e: IllegalStateException) {
+            Log.w(
+                "ReactNativeFragment",
+                "ReactFragment threw due to missing arg_component_name: ${e.message} - This is an expected behaviour."
+            )
+        }
+
+        moduleName = arguments?.getString(ReactNativeFragmentArgNames.ARG_MODULE_NAME)!!
+        this.reactDelegate =
+            ReactDelegateWrapper(
+                activity,
+                this.reactHost,
+                moduleName,
+                arguments?.getBundle(ReactNativeFragmentArgNames.ARG_LAUNCH_OPTIONS)
+            )
     }
 
-    moduleName = arguments?.getString(ARG_MODULE_NAME)!!
-    this.mReactDelegate = this.reactHost?.let {
-      ReactDelegateWrapper(activity,
-        it, moduleName, arguments?.getBundle("arg_launch_options"))
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        return ReactNativeBrownfield.shared.createView(
+            activity,
+            moduleName,
+            this.reactDelegate as ReactDelegateWrapper
+        )
     }
 
-    doubleTapReloadRecognizer = DoubleTapReloadRecognizer()
-  }
-
-  override fun onCreateView(
-    inflater: LayoutInflater,
-    container: ViewGroup?,
-    savedInstanceState: Bundle?
-  ): View {
-    return ReactNativeBrownfield.shared.createView(this.requireContext(), activity, moduleName, this.mReactDelegate as ReactDelegateWrapper)
-  }
+    override val reactHost: ReactHost?
+        get() = ReactNativeBrownfield.shared.reactHost
 
-  override fun getReactHost(): ReactHost? {
-    return activity?.let {
-      getDefaultReactHost(
-        it.applicationContext,
-        ReactNativeBrownfield.shared.reactNativeHost
-      )
+    override fun onResume() {
+        try {
+            super.onResume()
+        } catch (_: ClassCastException) {
+            (this.reactDelegate as ReactDelegateWrapper).onReactHostResume()
+        }
     }
-  }
-
-  override fun getReactNativeHost(): ReactNativeHost? {
-    return ReactNativeBrownfield.shared.reactNativeHost
-  }
-
-  override fun onRequestPermissionsResult(
-    requestCode: Int,
-    permissions: Array<String>,
-    grantResults: IntArray
-  ) {
-    permissionsCallback = Callback {
-      if (permissionListener != null) {
-        permissionListener?.onRequestPermissionsResult(
-          requestCode,
-          permissions,
-          grantResults
-        )
 
-        permissionListener = null
-      }
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray
+    ) {
+        permissionsCallback = Callback {
+            if (permissionListener != null) {
+                permissionListener?.onRequestPermissionsResult(
+                    requestCode,
+                    permissions,
+                    grantResults
+                )
+
+                permissionListener = null
+            }
+        }
     }
-  }
 
-  override fun checkPermission(permission: String, pid: Int, uid: Int): Int {
-    return requireActivity().checkPermission(permission, pid, uid)
-  }
-
-  @TargetApi(Build.VERSION_CODES.M)
-  override fun checkSelfPermission(permission: String): Int {
-    return requireActivity().checkSelfPermission(permission)
-  }
-
-  override fun requestPermissions(
-    permissions: Array<String>,
-    requestCode: Int,
-    listener: PermissionListener?
-  ) {
-    permissionListener = listener
-    this.requestPermissions(permissions, requestCode)
-  }
-
-  override fun onKeyUp(keyCode: Int, event: KeyEvent): Boolean {
-    var handled = false
-    if (ReactNativeBrownfield.shared.reactNativeHost.useDeveloperSupport && ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-      if (keyCode == KeyEvent.KEYCODE_MENU) {
-        ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.showDevOptionsDialog()
-        handled = true
-      }
-      val didDoubleTapR = activity?.currentFocus?.let {
-        Assertions.assertNotNull(doubleTapReloadRecognizer)
-          .didDoubleTapR(keyCode, it)
-      }
-      if (didDoubleTapR == true) {
-        reactDelegate.reload()
-        handled = true
-      }
+    override fun checkPermission(permission: String, pid: Int, uid: Int): Int {
+        return requireActivity().checkPermission(permission, pid, uid)
     }
-    return handled
-  }
 
-  companion object {
-    private const val ARG_MODULE_NAME = "arg_module_name"
-
-    @JvmStatic
-    @JvmOverloads
-    fun createReactNativeFragment(
-      moduleName: String,
-      initialProps: Bundle? = null
-    ): ReactNativeFragment {
-      val fragment = ReactNativeFragment()
-      val args = Bundle()
-      args.putString(ARG_MODULE_NAME, moduleName)
-      if (initialProps != null) {
-        args.putBundle(ARG_LAUNCH_OPTIONS, initialProps)
-      }
-      fragment.arguments = args
-      return fragment
+    override fun checkSelfPermission(permission: String): Int {
+        return requireActivity().checkSelfPermission(permission)
     }
 
-    @JvmStatic
-    fun createReactNativeFragment(
-      moduleName: String,
-      initialProps: HashMap<String, *>
-    ): ReactNativeFragment {
-      return createReactNativeFragment(moduleName, PropsBundle.fromHashMap(initialProps))
+    override fun requestPermissions(
+        permissions: Array<String>,
+        requestCode: Int,
+        listener: PermissionListener?
+    ) {
+        permissionListener = listener
+        this.requestPermissions(permissions, requestCode)
     }
 
-    @JvmStatic
-    fun createReactNativeFragment(
-      moduleName: String,
-      initialProps: WritableMap
-    ): ReactNativeFragment {
-      return createReactNativeFragment(moduleName, initialProps.toHashMap())
+    companion object {
+        @JvmStatic
+        @JvmOverloads
+        fun createReactNativeFragment(
+            moduleName: String,
+            initialProps: Bundle? = null
+        ): ReactNativeFragment {
+            val fragment = ReactNativeFragment()
+            val args = Bundle()
+            args.putString(ReactNativeFragmentArgNames.ARG_MODULE_NAME, moduleName)
+            if (initialProps != null) {
+                args.putBundle(ReactNativeFragmentArgNames.ARG_LAUNCH_OPTIONS, initialProps)
+            }
+            fragment.arguments = args
+            return fragment
+        }
+
+        @JvmStatic
+        fun createReactNativeFragment(
+            moduleName: String,
+            initialProps: HashMap<String, *>
+        ): ReactNativeFragment {
+            return createReactNativeFragment(moduleName, PropsBundle.fromHashMap(initialProps))
+        }
+
+        @JvmStatic
+        fun createReactNativeFragment(
+            moduleName: String,
+            initialProps: WritableMap
+        ): ReactNativeFragment {
+            return createReactNativeFragment(moduleName, initialProps.toHashMap())
+        }
     }
-  }
-
 }

package/android/src/main/java/com/callstack/reactnativebrownfield/constants/ReactNativeFragmentArgNames.kt

@@ -0,0 +1,20 @@
+package com.callstack.reactnativebrownfield.constants
+
+import com.facebook.react.ReactFragment
+
+/**
+ * Convenience export of arguments that can be used
+ */
+class ReactNativeFragmentArgNames private constructor() :
+    ReactFragment() // subclass to gain access to protected constants
+{
+    companion object {
+        /**
+         * The module name to be loaded
+         */
+        const val ARG_MODULE_NAME = "arg_module_name"
+
+        // re-export constants from ReactFragment to enable access
+        const val ARG_LAUNCH_OPTIONS: String = "arg_launch_options"
+    }
+}

package/android/src/newarch/ReactNativeBrownfieldModule.kt

@@ -4,34 +4,34 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 
 class ReactNativeBrownfieldModule(reactContext: ReactApplicationContext) :
-  NativeReactNativeBrownfieldModuleSpec(reactContext) {
-  companion object {
-    var shouldPopToNative: Boolean = false
-  }
+    NativeReactNativeBrownfieldModuleSpec(reactContext) {
+    companion object {
+        var shouldPopToNative: Boolean = false
+    }
 
-  @ReactMethod
-  override fun popToNative(animated: Boolean) {
-    shouldPopToNative = true
-    onBackPressed()
-  }
+    @ReactMethod
+    override fun popToNative(animated: Boolean) {
+        shouldPopToNative = true
+        onBackPressed()
+    }
 
-  @ReactMethod
-  override fun setPopGestureRecognizerEnabled(enabled: Boolean) {
-    shouldPopToNative = enabled
-  }
+    @ReactMethod
+    override fun setPopGestureRecognizerEnabled(enabled: Boolean) {
+        shouldPopToNative = enabled
+    }
 
-  @ReactMethod
-  override fun setHardwareBackButtonEnabled(enabled: Boolean) {
-    shouldPopToNative = enabled
-  }
+    @ReactMethod
+    override fun setHardwareBackButtonEnabled(enabled: Boolean) {
+        shouldPopToNative = enabled
+    }
 
-  private fun onBackPressed() {
-    reactApplicationContext.currentActivity?.runOnUiThread {
-      reactApplicationContext.currentActivity?.onBackPressed()
+    private fun onBackPressed() {
+        reactApplicationContext.currentActivity?.runOnUiThread {
+            reactApplicationContext.currentActivity?.onBackPressed()
+        }
     }
-  }
 
-  override fun getName(): String {
-    return "ReactNativeBrownfield"
-  }
+    override fun getName(): String {
+        return "ReactNativeBrownfield"
+    }
 }

package/ios/ReactNativeBrownfield.swift

@@ -88,7 +88,7 @@ class ReactNativeBrownfieldDelegate: RCTDefaultReactNativeFactoryDelegate {
     initialProps: [AnyHashable: Any]?,
     launchOptions: [AnyHashable: Any]? = nil
   ) -> UIView? {
-    reactNativeFactory?.rootViewFactory.view(
+    rootViewFactory?.view(
       withModuleName: moduleName,
       initialProperties: initialProps,
       launchOptions: launchOptions

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callstack/react-native-brownfield",
-  "version": "1.2.0",
+  "version": "2.0.1",
   "license": "MIT",
   "author": "Michal Chudziak <mike.chudziak@callstack.com>",
   "contributors": [
@@ -60,7 +60,7 @@
     "access": "public"
   },
   "resolutions": {
-    "@types/react": "19.0.0"
+    "@types/react": "19.1.1"
   },
   "peerDependencies": {
     "react": "*",
@@ -70,25 +70,25 @@
     "@babel/core": "^7.25.2",
     "@babel/preset-env": "^7.25.3",
     "@babel/runtime": "^7.25.0",
-    "@react-native/babel-preset": "0.78.0",
-    "@react-native/eslint-config": "0.78.0",
-    "@react-native/typescript-config": "0.78.0",
+    "@react-native/babel-preset": "0.82.1",
+    "@react-native/eslint-config": "0.82.1",
+    "@react-native/typescript-config": "0.82.1",
     "@release-it/conventional-changelog": "^5.0.0",
     "@types/jest": "^29.5.13",
-    "@types/react": "^19.0.0",
-    "@types/react-test-renderer": "^19.0.0",
+    "@types/react": "^19.1.1",
+    "@types/react-test-renderer": "^19.1.0",
     "babel-plugin-module-resolver": "5.0.0",
     "eslint": "^8.19.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.1.3",
     "jest": "^29.6.3",
     "prettier": "^3.5.3",
-    "react": "19.0.0",
-    "react-native": "0.78.0",
+    "react": "19.1.1",
+    "react-native": "0.82.1",
     "react-native-builder-bob": "^0.37.0",
-    "react-test-renderer": "19.0.0",
+    "react-test-renderer": "19.1.1",
     "release-it": "^18.1.2",
-    "typescript": "5.0.4"
+    "typescript": "5.8.3"
   },
   "release-it": {
     "git": {
@@ -172,7 +172,7 @@
     ]
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "packageManager": "yarn@3.6.4"
 }