@callstack/react-native-brownfield 1.1.0 → 2.0.0

package/README.md

@@ -3,7 +3,7 @@
 </a>
 
 <p align="center">
-  Set of helpers to make your brownfield integration smooth and easy.
+  A set of helpers to make your brownfield integration smooth and easy.
 </p>
 
 ---
@@ -21,86 +21,204 @@
 
 ## Features
 
-- **Easily integrate** React Native with existing native app
+- **Easily integrate** React Native with an existing native app
 - Start React Native with **one method** and invoke code as soon as it's loaded
-- Compatible with **both old and new React Native architecture**! 
+- Compatible with **both legacy and new React Native architecture**!
 - Reuse the same instance of React Native between different components
 - Use predefined **native building blocks** - crafted for React Native
 - Disable and enable **native gestures and hardware buttons** from JavaScript
-- Works well with **any native navigation** pattern, as well as every React Native JavaScript based navigation
+- Works well with **any native navigation** pattern, as well as any React Native JavaScript-based navigation
 - 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.
+
+In your React Native project run:
+
 ```sh
 npm install @callstack/react-native-brownfield
 ```
 
-or
+## Usage
 
-```sh
-yarn add @callstack/react-native-brownfield
+<a href="https://www.callstack.com/ebooks/incremental-react-native-adoption-in-native-apps?utm_campaign=brownfield&utm_source=github&utm_medium=referral&utm_content=react-native-brownfield" align="center">
+  <img alt="Download a free copy of Incremental React Native adoption in native apps ebook" src="https://github.com/user-attachments/assets/ba42bb29-1e7a-4683-80c5-2602afb1a7e6">
+</a>
+
+### Packaging React Native app as a framework
+
+First, we need to package our React Native app as an XCFramework or Fat-AAR.
+
+#### With Rock
+
+Follow [Integrating with Native Apps](https://www.rockjs.dev/docs/brownfield/intro) steps in Rock docs and run:
+
+- `rock package:ios` for iOS
+- `rock package:aar` for Android
+
+#### With custom scripts
+
+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)
+
+### Native iOS app
+
+In your native iOS app, initialize React Native and display it where you like. For example, to display React Native views in SwiftUI, use the provided `ReactNativeView` component:
+
+```swift
+import SwiftUI
+import ReactBrownfield # exposed by RN app framework
+
+@main
+struct MyApp: App {
+  init() {
+    ReactNativeBrownfield.shared.startReactNative {
+      print("React Native bundle loaded")
+    }
+  }
+
+  var body: some Scene {
+    WindowGroup {
+      ContentView()
+    }
+  }
+}
+
+struct ContentView: View {
+  var body: some View {
+    NavigationView {
+      VStack {
+        Text("Welcome to the Native App")
+          .padding()
+
+        NavigationLink("Push React Native Screen") {
+          ReactNativeView(moduleName: "ReactNative")
+            .navigationBarHidden(true)
+        }
+      }
+    }
+  }
+}
 ```
 
-## Enabling New Architecture
+For more detailed instructions and API for iOS, see docs for:
+
+- [Objective C](docs/OBJECTIVE_C.md)
+- [Swift](docs/SWIFT.md)
+
+### Native Android app
 
-### Android
-Add the following to your `android/gradle.properties`:
+In your native Android app, create a new `RNAppFragment.kt`:
 
+```kt
+
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.Fragment
+
+class RNAppFragment : Fragment() {
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?,
+    ): View? = ReactNativeBrownfield.shared.createView(activity, "BrownFieldTest")
+}
 ```
-# Enable new architecture
-newArchEnabled=true
+
+Add a button to your `activity_main.xml`:
+
+```xml
+<Button
+    android:id="@+id/show_rn_app_btn"
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:text="Show RN App"
+    app:layout_constraintBottom_toBottomOf="parent"
+    app:layout_constraintEnd_toEndOf="parent"
+    app:layout_constraintStart_toStartOf="parent"
+    app:layout_constraintTop_toTopOf="parent" />
 ```
 
-### iOS
-Install cocoapods with the flag:
+Add a fragment container:
 
-```
-RCT_NEW_ARCH_ENABLED=1 pod install
+```xml
+<FrameLayout
+    android:id="@+id/fragmentContainer"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent" />
 ```
 
-> [!NOTE]
-> New Architecture is enabled by default from React Native 0.76
+Update your `MainActivity` to initialize React Native and show the fragment:
 
-## Usage
+```kt
+class MainActivity : AppCompatActivity() {
+    private lateinit var showRNAppBtn: Button
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        ReactNativeHostManager.shared.initialize(this.application) {
+          println("JS bundle loaded")
+        }
+
+        showRNAppBtn = findViewById(R.id.show_rn_app_btn)
+        showRNAppBtn.setOnClickListener {
+            supportFragmentManager
+                .beginTransaction()
+                .replace(R.id.fragmentContainer, RNAppFragment())
+                .commit()
+        }
+    }
+
+}
+```
 
-React Native Brownfield library works with all major native programming languages. Majority of its API is exposed on the native side. Click on the logo to choose the one that interests you:
+For more detailed instructions and API for Android, see docs for:
 
-| [<img src="https://user-images.githubusercontent.com/7837457/63374769-cafd1e80-c38a-11e9-9724-e797a199ebab.png" width="100px;" alt="Objective-C"/><br /><sub><b>Objective-C</b></sub>](docs/OBJECTIVE_C.md) | [<img src="https://user-images.githubusercontent.com/7837457/63374778-ce90a580-c38a-11e9-8f37-72a9a5b9a52f.png" width="100px;" alt="Swift"/><br /><sub><b>Swift</b></sub>](docs/SWIFT.md) | [<img src="https://user-images.githubusercontent.com/7837457/63374794-d2bcc300-c38a-11e9-9a7f-d538563b75db.png" width="100px;" alt="Java"/><br /><sub><b>Java</b></sub>](docs/JAVA.md) | [<img src="https://user-images.githubusercontent.com/7837457/63374783-d0f2ff80-c38a-11e9-9790-041cad53b259.png" width="100px;" alt="Kotlin"/><br /><sub><b>Kotlin</b></sub>](docs/KOTLIN.md) |
-| :---: | :---: | :---: | :---: |
+- [Java](docs/JAVA.md)
+- [Kotlin](docs/KOTLIN.md)
 
 ### JavaScript Module
 
-Besides native components, we are exposing JavaScript functions to control the behavior of those components.
+Besides native components, we are exposing JavaScript functions to control the behavior of those components from React Native app.
 
-To use the module, simply import it:
+To use the module, import it:
 
 ```js
 import ReactNativeBrownfield from '@callstack/react-native-brownfield';
 ```
 
-### JavaScript API Reference:
+and use the available methods:
 
-**setNativeBackGestureAndButtonEnabled(enabled: boolean)**
+#### setNativeBackGestureAndButtonEnabled(enabled: boolean)
 
-A method used to toggle iOS native back gesture and Android hardware back button. 
+A method used to toggle iOS native back gesture and Android hardware back button.
 
-```js
+```ts
 ReactNativeBrownfield.setNativeBackGestureAndButtonEnabled(true);
 ```
 
-**popToNative(animated[iOS only]: boolean)**
+#### popToNative(animated[iOS only]: boolean)
 
-A method to pop to native screen used to push React Native experience. 
+A method to pop to native screen used to push React Native experience.
 
-```js
+```ts
 ReactNativeBrownfield.popToNative(true);
 ```
 
-> NOTE: Those methods works only with native components provided by this library.
-
+> **Note:** These methods work only with native components provided by this library.
 
 ## Made with ❤️ at Callstack
 
@@ -115,13 +233,14 @@ 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 -->
 
 This project follows the [all-contributors](https://github.com/kentcdodds/all-contributors) specification. Contributions of any kind welcome!
 
 <!-- badges -->
+
 [build-badge]: https://img.shields.io/circleci/build/github/callstack/react-native-brownfield/master.svg?style=flat-square
 [build]: https://circleci.com/gh/callstack/react-native-brownfield
 [version-badge]: https://img.shields.io/npm/v/@callstack/react-native-brownfield.svg?style=flat-square

package/android/build.gradle

@@ -1,3 +1,15 @@
+import groovy.json.JsonSlurper
+
+def reactNativeVersion = null
+def packageJsonFile = rootProject.file("../node_modules/react-native/package.json")
+
+if (packageJsonFile.exists()) {
+  def json = new JsonSlurper().parse(packageJsonFile)
+  reactNativeVersion = json.version
+} else {
+  reactNativeVersion = "unknown"
+}
+
 buildscript {
   // Buildscript is evaluated before everything else so we can't use getExtOrDefault
   def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["RNBrownfield_kotlinVersion"]
@@ -64,6 +76,7 @@ android {
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
     buildConfigField "boolean", "IS_HERMES_ENABLED", isHermesEnabled().toString()
+    buildConfigField "String", "RN_VERSION", "\"$reactNativeVersion\""
   }
 
   buildFeatures {

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

@@ -0,0 +1,36 @@
+package com.callstack.reactnativebrownfield
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import com.facebook.react.ReactDelegate
+import com.facebook.react.ReactHost
+import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
+
+class ReactDelegateWrapper(
+    private val activity: ComponentActivity?,
+    resolvedReactHost: ReactHost?,
+    moduleName: String,
+    launchOptions: Bundle?
+) : ReactDelegate(
+    activity = activity!!,
+    resolvedReactHost,
+    appKey = moduleName,
+    launchOptions = launchOptions,
+) {
+    private lateinit var hardwareBackHandler: () -> Unit
+    private val backBtnHandler = DefaultHardwareBackBtnHandler {
+        hardwareBackHandler()
+    }
+
+    /**
+     * This is invoked when there is no more RN Stack to pop.
+     * What it means that this is now the initial RN screen.
+     */
+    fun setHardwareBackHandler(backHandler: () -> Unit) {
+        hardwareBackHandler = backHandler
+    }
+
+    fun onReactHostResume() {
+        super.reactHost?.onHostResume(activity, backBtnHandler)
+    }
+}

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

@@ -1,141 +1,168 @@
 package com.callstack.reactnativebrownfield
 
 import android.app.Application
-import android.content.Context
 import android.os.Bundle
 import android.widget.FrameLayout
+import androidx.activity.OnBackPressedCallback
 import androidx.fragment.app.FragmentActivity
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
-import com.facebook.react.ReactDelegate
+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
 
-interface InitializedCallback {
-  operator fun invoke(initialized: Boolean)
+fun interface OnJSBundleLoaded {
+    operator fun invoke(initialized: Boolean)
 }
 
-class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNativeHost) {
-  companion object {
-    private lateinit var instance: ReactNativeBrownfield
-    private val initialized = AtomicBoolean()
-
-    @JvmStatic
-    val shared: ReactNativeBrownfield get() = instance
+/**
+ * The threshold RN version based on which we decide whether to
+ * load JNI libs or not. We only load JNI libs on version less
+ * than this.
+ */
+private const val RN_THRESHOLD_VERSION = "0.80.0"
 
-    @JvmStatic
-    fun initialize(application: Application, rnHost: ReactNativeHost) {
-      if (!initialized.getAndSet(true)) {
-        instance = ReactNativeBrownfield(rnHost)
-        SoLoader.init(application.applicationContext, OpenSourceMergedSoMapping)
-      }
-    }
+class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
+    companion object {
+        private lateinit var instance: ReactNativeBrownfield
+        private val initialized = AtomicBoolean()
 
-    @JvmStatic
-    fun initialize(application: Application, options: HashMap<String, Any>) {
-      val reactNativeHost: ReactNativeHost =
-        object : DefaultReactNativeHost(application) {
+        @JvmStatic
+        val shared: ReactNativeBrownfield get() = instance
 
-          override fun getJSMainModuleName(): String {
-            return options["mainModuleName"] as? String ?: super.getJSMainModuleName()
-          }
+        private fun loadNativeLibs(application: Application) {
+            val rnVersion = BuildConfig.RN_VERSION
 
-          override fun getPackages(): List<ReactPackage> {
-            return (options["packages"] as? List<*> ?: emptyList<ReactPackage>())
-              .filterIsInstance<ReactPackage>()
-          }
+            if (VersionUtils.isVersionLessThan(rnVersion, RN_THRESHOLD_VERSION)) {
+                SoLoader.init(application.applicationContext, OpenSourceMergedSoMapping)
+                load()
+            }
+        }
 
-          override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+        @JvmStatic
+        @JvmOverloads
+        fun initialize(
+            application: Application,
+            reactHost: ReactHost,
+            onJSBundleLoaded: OnJSBundleLoaded? = null
+        ) {
+            if (!initialized.getAndSet(true)) {
+                loadNativeLibs(application)
+                instance = ReactNativeBrownfield(reactHost)
+
+                preloadReactNative {
+                    onJSBundleLoaded?.invoke(true)
+                }
+            }
+        }
 
-          override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-          override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
+        @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",
+                    useDevSupport = options["useDeveloperSupport"] as? Boolean
+                        ?: ReactBuildConfig.DEBUG,
+                    jsRuntimeFactory = null
+                )
+            }
+
+            initialize(application, reactHost, onJSBundleLoaded)
         }
 
-      initialize(application, reactNativeHost)
-    }
+        @JvmStatic
+        @JvmOverloads
+        fun initialize(
+            application: Application,
+            packages: List<ReactPackage>,
+            onJSBundleLoaded: OnJSBundleLoaded? = null
+        ) {
+            val options = hashMapOf("packages" to packages, "mainModuleName" to "index")
 
-    @JvmStatic
-    fun initialize(application: Application, packages: List<ReactPackage>) {
-      val options = hashMapOf("packages" to packages, "mainModuleName" to "index")
+            initialize(application, options, onJSBundleLoaded)
+        }
 
-      initialize(application, options)
+        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()
+        }
     }
 
-
-  }
-
-  fun startReactNative(callback: InitializedCallback?) {
-    startReactNative { callback?.invoke(it) }
-  }
-
-  @JvmName("startReactNativeKotlin")
-  fun startReactNative(callback: ((initialized: Boolean) -> Unit)?) {
-    reactNativeHost.reactInstanceManager.addReactInstanceEventListener(object :
-      ReactInstanceEventListener {
-      override fun onReactContextInitialized(reactContext: ReactContext) {
-        callback?.let { it(true) }
-        reactNativeHost.reactInstanceManager.removeReactInstanceEventListener(this)
-      }
-    })
-    reactNativeHost.reactInstanceManager?.createReactContextInBackground()
-
-    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-      // If you opted-in for the New Architecture, we load the native entry point for this app.
-      load()
-    }
-  }
-
-  fun createView(
-    context: Context,
-    activity: FragmentActivity?,
-    moduleName: String,
-    launchOptions: Bundle? = null,
-  ): FrameLayout {
-    if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
-      val reactHost = getDefaultReactHost(
-        context,
-        shared.reactNativeHost
-      )
-      val reactDelegate = ReactDelegate(activity, reactHost, moduleName, launchOptions)
-
-      activity?.lifecycle?.addObserver(object : DefaultLifecycleObserver {
-        override fun onResume(owner: LifecycleOwner) {
-          reactDelegate.onHostResume()
+    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()
+            }
         }
 
-        override fun onPause(owner: LifecycleOwner) {
-          reactDelegate.onHostPause()
+        // Register back press callback
+        activity?.onBackPressedDispatcher?.addCallback(mBackPressedCallback)
+        // invoked on the last RN screen exit
+        resolvedDelegate.setHardwareBackHandler {
+            mBackPressedCallback.isEnabled = false
+            activity?.onBackPressedDispatcher?.onBackPressed()
         }
 
-        override fun onDestroy(owner: LifecycleOwner) {
-          reactDelegate.onHostDestroy()
-          owner.lifecycle.removeObserver(this) // Cleanup to avoid leaks
+        /**
+         * 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))
         }
-      })
 
-      reactDelegate.loadApp()
-      return reactDelegate.reactRootView!!
+        resolvedDelegate.loadApp()
+        return resolvedDelegate.reactRootView!!
     }
 
-    val instanceManager: ReactInstanceManager? = shared.reactNativeHost?.reactInstanceManager
-    val reactView = ReactRootView(context)
-    reactView.startReactApplication(
-      instanceManager,
-      moduleName,
-      launchOptions,
-    )
+    private fun getLifeCycleObserver(reactDelegate: ReactDelegateWrapper): DefaultLifecycleObserver {
+        return object : DefaultLifecycleObserver {
+            override fun onResume(owner: LifecycleOwner) {
+                reactDelegate.onReactHostResume()
+            }
 
-    return reactView
-  }
-}
+            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,170 +1,140 @@
-package com.callstack.reactnativebrownfield;
+package com.callstack.reactnativebrownfield
 
-import android.annotation.TargetApi
-import android.os.Build
 import android.os.Bundle
-import android.view.KeyEvent
-import com.facebook.infer.annotation.Assertions
+import android.util.Log
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+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.common.LifecycleState
-import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
-import com.facebook.react.devsupport.DoubleTapReloadRecognizer
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler
 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
-
-  override fun onCreate(savedInstanceState: Bundle?) {
-    super.onCreate(savedInstanceState)
-    doubleTapReloadRecognizer = DoubleTapReloadRecognizer()
-  }
-
-  override fun getReactHost(): ReactHost? {
-    return activity?.let {
-      getDefaultReactHost(
-        it.applicationContext,
-        ReactNativeBrownfield.shared.reactNativeHost
-      )
-    }
-  }
-
-  override fun getReactNativeHost(): ReactNativeHost? {
-    return ReactNativeBrownfield.shared.reactNativeHost
-  }
-
-  override fun onResume() {
-    super.onResume()
-    if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-      ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager?.onHostResume(
-        activity,
-        activity as DefaultHardwareBackBtnHandler
-      )
-    }
-  }
-
-  override fun onPause() {
-    super.onPause()
-    if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-      ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager?.onHostPause(
-        activity
-      )
+    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)
+            )
     }
-  }
 
-  override fun onDestroy() {
-    super.onDestroy()
-    if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-      val reactInstanceMgr = ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager
-
-      if (reactInstanceMgr.lifecycleState != LifecycleState.RESUMED) {
-        reactInstanceMgr.onHostDestroy(activity)
-      }
-    }
-  }
-
-  override fun onRequestPermissionsResult(
-    requestCode: Int,
-    permissions: Array<String>,
-    grantResults: IntArray
-  ) {
-    permissionsCallback = Callback {
-      if (permissionListener != null) {
-        permissionListener?.onRequestPermissionsResult(
-          requestCode,
-          permissions,
-          grantResults
+    override fun onCreateView(
+        inflater: LayoutInflater,
+        container: ViewGroup?,
+        savedInstanceState: Bundle?
+    ): View {
+        return ReactNativeBrownfield.shared.createView(
+            activity,
+            moduleName,
+            this.reactDelegate as ReactDelegateWrapper
         )
-
-        permissionListener = null
-      }
     }
-  }
 
-  override fun checkPermission(permission: String, pid: Int, uid: Int): Int {
-    return requireActivity().checkPermission(permission, pid, uid)
-  }
+    override val reactHost: ReactHost?
+        get() = ReactNativeBrownfield.shared.reactHost
 
-  @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) {
-        ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.devSupportManager.handleReloadJS()
-        handled = true
-      }
+    override fun onResume() {
+        try {
+            super.onResume()
+        } catch (_: ClassCastException) {
+            (this.reactDelegate as ReactDelegateWrapper).onReactHostResume()
+        }
     }
-    return handled
-  }
 
-  fun onBackPressed(backBtnHandler: DefaultHardwareBackBtnHandler) {
-    if (ReactNativeBrownfieldModule.shouldPopToNative) {
-      backBtnHandler.invokeDefaultOnBackPressed()
-    } else if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-      ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.onBackPressed()
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray
+    ) {
+        permissionsCallback = Callback {
+            if (permissionListener != null) {
+                permissionListener?.onRequestPermissionsResult(
+                    requestCode,
+                    permissions,
+                    grantResults
+                )
+
+                permissionListener = null
+            }
+        }
     }
-  }
 
-  companion object {
-    @JvmStatic
-    @JvmOverloads
-    fun createReactNativeFragment(
-      moduleName: String,
-      initialProps: Bundle? = null
-    ): ReactNativeFragment {
-      val fragment = ReactNativeFragment()
-      val args = Bundle()
-      args.putString(ARG_COMPONENT_NAME, moduleName)
-      if (initialProps != null) {
-        args.putBundle(ARG_LAUNCH_OPTIONS, initialProps)
-      }
-      fragment.arguments = args
-      return fragment
+    override fun checkPermission(permission: String, pid: Int, uid: Int): Int {
+        return requireActivity().checkPermission(permission, pid, uid)
     }
 
-    @JvmStatic
-    fun createReactNativeFragment(
-      moduleName: String,
-      initialProps: HashMap<String, *>
-    ): ReactNativeFragment {
-      return createReactNativeFragment(moduleName, PropsBundle.fromHashMap(initialProps))
+    override fun checkSelfPermission(permission: String): Int {
+        return requireActivity().checkSelfPermission(permission)
     }
 
-    @JvmStatic
-    fun createReactNativeFragment(
-      moduleName: String,
-      initialProps: WritableMap
-    ): ReactNativeFragment {
-      return createReactNativeFragment(moduleName, initialProps.toHashMap())
+    override fun requestPermissions(
+        permissions: Array<String>,
+        requestCode: Int,
+        listener: PermissionListener?
+    ) {
+        permissionListener = listener
+        this.requestPermissions(permissions, requestCode)
     }
-  }
 
+    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/main/java/com/callstack/reactnativebrownfield/utils/VersionUtils.kt

@@ -0,0 +1,17 @@
+package com.callstack.reactnativebrownfield.utils
+
+object VersionUtils {
+    fun isVersionLessThan(version: String, threshold: String): Boolean {
+        val versionParts = version.split(".").map { it.toIntOrNull() ?: 0 }
+        val thresholdParts = threshold.split(".").map { it.toIntOrNull() ?: 0 }
+
+        val maxLength = maxOf(versionParts.size, thresholdParts.size)
+        for (i in 0 until maxLength) {
+            val vPart = versionParts.getOrNull(i) ?: 0
+            val tPart = thresholdParts.getOrNull(i) ?: 0
+            if (vPart != tPart) return vPart < tPart
+        }
+        
+        return false // equal versions are not less than
+    }
+}

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/ios/ReactNativeView.swift

@@ -8,7 +8,10 @@ struct ReactNativeViewRepresentable: UIViewControllerRepresentable {
   var initialProperties: [String: Any] = [:]
 
   func makeUIViewController(context: Context) -> UIViewController {
-    return ReactNativeViewController(moduleName: moduleName)
+    return ReactNativeViewController(
+      moduleName: moduleName,
+      initialProperties: initialProperties
+    )
   }
 
   func updateUIViewController(_ uiViewController: UIViewController, context: Context) {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@callstack/react-native-brownfield",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "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"
 }