@callstack/react-native-brownfield 1.0.1 → 1.2.0

package/README.md

@@ -1,9 +1,9 @@
-<p align="center">
-  <img alt="React Native Brownfield" src="https://user-images.githubusercontent.com/7837457/63594721-7f7b8800-c5b7-11e9-87ef-a0898cd22fcc.png" width="600">
-</p>
+<a href="https://www.callstack.com/open-source?utm_campaign=generic&utm_source=github&utm_medium=referral&utm_content=react-native-brownfield" align="center">
+  <img alt="React Native Brownfield" src="https://github.com/user-attachments/assets/55fcdff5-54f0-4081-adf6-55dfa5c29af2">
+</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,199 @@
 
 ## 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
 
-
 ## 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 RNEF
+
+Follow [Integrating with Native Apps](https://www.rnef.dev/docs/brownfield/intro) steps in RNEF docs and run:
+
+- `rnef package:ios` for iOS
+- `rnef 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:
+
+- [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
+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)
+        }
+}
 ```
-# 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)
+
+        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
 
@@ -122,6 +235,7 @@ Thanks goes to these wonderful people ([emoji key](https://github.com/kentcdodds
 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,31 @@
+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?,
+    private val reactHost: ReactHost,
+    moduleName: String,
+    launchOptions: Bundle?
+): ReactDelegate(activity, reactHost, moduleName, 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
+    }
+
+    override fun onHostResume() {
+        reactHost.onHostResume(activity, backBtnHandler)
+    }
+}

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

@@ -4,10 +4,11 @@ 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.ReactInstanceEventListener
 import com.facebook.react.ReactInstanceManager
 import com.facebook.react.ReactNativeHost
@@ -21,10 +22,17 @@ import java.util.concurrent.atomic.AtomicBoolean
 import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint.load
 import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
 
-interface InitializedCallback {
+fun interface OnJSBundleLoaded {
   operator fun invoke(initialized: Boolean)
 }
 
+/**
+ * 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"
+
 class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNativeHost) {
   companion object {
     private lateinit var instance: ReactNativeBrownfield
@@ -33,16 +41,34 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
     @JvmStatic
     val shared: ReactNativeBrownfield get() = instance
 
+    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()
+        }
+      }
+    }
+
     @JvmStatic
-    fun initialize(application: Application, rnHost: ReactNativeHost) {
+    @JvmOverloads
+    fun initialize(application: Application, rnHost: ReactNativeHost, onJSBundleLoaded: OnJSBundleLoaded? = null) {
       if (!initialized.getAndSet(true)) {
+        loadNativeLibs(application)
         instance = ReactNativeBrownfield(rnHost)
-        SoLoader.init(application.applicationContext, OpenSourceMergedSoMapping)
+
+        preloadReactNative {
+          onJSBundleLoaded?.invoke(true)
+        }
       }
     }
 
     @JvmStatic
-    fun initialize(application: Application, options: HashMap<String, Any>) {
+    @JvmOverloads
+    fun initialize(application: Application, options: HashMap<String, Any>, onJSBundleLoaded: OnJSBundleLoaded? = null) {
       val reactNativeHost: ReactNativeHost =
         object : DefaultReactNativeHost(application) {
 
@@ -61,37 +87,27 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
           override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
         }
 
-      initialize(application, reactNativeHost)
+      initialize(application, reactNativeHost, onJSBundleLoaded)
     }
 
     @JvmStatic
-    fun initialize(application: Application, packages: List<ReactPackage>) {
+    @JvmOverloads
+    fun initialize(application: Application, packages: List<ReactPackage>, onJSBundleLoaded: OnJSBundleLoaded? = null) {
       val options = hashMapOf("packages" to packages, "mainModuleName" to "index")
 
-      initialize(application, options)
+      initialize(application, options, onJSBundleLoaded)
     }
 
-
-  }
-
-  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()
+    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)
+        }
+      })
+      reactInstanceManager?.createReactContextInBackground()
     }
   }
 
@@ -99,6 +115,7 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
     context: Context,
     activity: FragmentActivity?,
     moduleName: String,
+    reactDelegate: ReactDelegateWrapper? = null,
     launchOptions: Bundle? = null,
   ): FrameLayout {
     if (BuildConfig.IS_NEW_ARCHITECTURE_ENABLED) {
@@ -106,25 +123,36 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
         context,
         shared.reactNativeHost
       )
-      val reactDelegate = ReactDelegate(activity, reactHost, moduleName, launchOptions)
 
-      activity?.lifecycle?.addObserver(object : DefaultLifecycleObserver {
-        override fun onResume(owner: LifecycleOwner) {
-          reactDelegate.onHostResume()
-        }
+      val resolvedDelegate = reactDelegate ?: ReactDelegateWrapper(activity, reactHost, moduleName, launchOptions)
 
-        override fun onPause(owner: LifecycleOwner) {
-          reactDelegate.onHostPause()
+      val mBackPressedCallback: OnBackPressedCallback = object : OnBackPressedCallback(true) {
+        override fun handleOnBackPressed() {
+          // invoked for JS stack back navigation
+          resolvedDelegate.onBackPressed()
         }
+      }
 
-        override fun onDestroy(owner: LifecycleOwner) {
-          reactDelegate.onHostDestroy()
-          owner.lifecycle.removeObserver(this) // Cleanup to avoid leaks
-        }
-      })
+      // 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))
+      }
 
-      reactDelegate.loadApp()
-      return reactDelegate.reactRootView!!
+      resolvedDelegate.loadApp()
+      return resolvedDelegate.reactRootView!!
     }
 
     val instanceManager: ReactInstanceManager? = shared.reactNativeHost?.reactInstanceManager
@@ -137,5 +165,22 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
 
     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/ReactNativeFragment.kt

@@ -3,17 +3,19 @@ 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.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
 
@@ -21,12 +23,40 @@ 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?) {
-    super.onCreate(savedInstanceState)
+    /**
+     * 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(ARG_MODULE_NAME)!!
+    this.mReactDelegate = this.reactHost?.let {
+      ReactDelegateWrapper(activity,
+        it, moduleName, arguments?.getBundle("arg_launch_options"))
+    }
+
     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 fun getReactHost(): ReactHost? {
     return activity?.let {
       getDefaultReactHost(
@@ -40,36 +70,6 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
     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
-      )
-    }
-  }
-
-  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>,
@@ -118,22 +118,16 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
           .didDoubleTapR(keyCode, it)
       }
       if (didDoubleTapR == true) {
-        ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.devSupportManager.handleReloadJS()
+        reactDelegate.reload()
         handled = true
       }
     }
     return handled
   }
 
-  fun onBackPressed(backBtnHandler: DefaultHardwareBackBtnHandler) {
-    if (ReactNativeBrownfieldModule.shouldPopToNative) {
-      backBtnHandler.invokeDefaultOnBackPressed()
-    } else if (ReactNativeBrownfield.shared.reactNativeHost.hasInstance()) {
-      ReactNativeBrownfield.shared.reactNativeHost.reactInstanceManager.onBackPressed()
-    }
-  }
-
   companion object {
+    private const val ARG_MODULE_NAME = "arg_module_name"
+
     @JvmStatic
     @JvmOverloads
     fun createReactNativeFragment(
@@ -142,7 +136,7 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
     ): ReactNativeFragment {
       val fragment = ReactNativeFragment()
       val args = Bundle()
-      args.putString(ARG_COMPONENT_NAME, moduleName)
+      args.putString(ARG_MODULE_NAME, moduleName)
       if (initialProps != null) {
         args.putBundle(ARG_LAUNCH_OPTIONS, initialProps)
       }

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

@@ -6,6 +6,7 @@ internal import ReactAppDependencyProvider
 class ReactNativeBrownfieldDelegate: RCTDefaultReactNativeFactoryDelegate {
   var entryFile = "index"
   var bundlePath = "main.jsbundle"
+  var bundle = Bundle.main
   // MARK: - RCTReactNativeFactoryDelegate Methods
   
   override func sourceURL(for bridge: RCTBridge) -> URL? {
@@ -21,7 +22,7 @@ class ReactNativeBrownfieldDelegate: RCTDefaultReactNativeFactoryDelegate {
     let resourceName = withoutLast.joined()
     let fileExtension = resourceURLComponents.last ?? ""
     
-    return Bundle.main.url(forResource: resourceName, withExtension: fileExtension)
+    return bundle.url(forResource: resourceName, withExtension: fileExtension)
 #endif
   }
 }
@@ -54,6 +55,15 @@ class ReactNativeBrownfieldDelegate: RCTDefaultReactNativeFactoryDelegate {
       delegate.bundlePath = bundlePath
     }
   }
+  /**
+   * Bundle instance to lookup the JavaScript bundle.
+   * Default value: Bundle.main
+   */
+  @objc public var bundle: Bundle = Bundle.main {
+    didSet {
+      delegate.bundle = bundle
+    }
+  }
   /**
    * React Native factory instance created when starting React Native.
    * Default value: nil

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.0.1",
+  "version": "1.2.0",
   "license": "MIT",
   "author": "Michal Chudziak <mike.chudziak@callstack.com>",
   "contributors": [