@callstack/react-native-brownfield 0.1.0 → 1.0.0-rc.1

package/README.md

@@ -23,11 +23,13 @@
 
 - **Easily integrate** React Native with existing native app
 - Start React Native with **one method** and invoke code as soon as it's loaded
-- Reuse the same instance of React Native **bridge** between different components
+- Compatible with **both old 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
 - 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
@@ -42,6 +44,26 @@ or
 yarn add @callstack/react-native-brownfield
 ```
 
+## Enabling New Architecture
+
+### Android
+Add the following to your `android/gradle.properties`:
+
+```
+# Enable new architecture
+newArchEnabled=true
+```
+
+### iOS
+Install cocoapods with the flag:
+
+```
+RCT_NEW_ARCH_ENABLED=1 pod install
+```
+
+> [!NOTE]
+> New Architecture is enabled by default from React Native 0.76
+
 ## Usage
 
 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:
@@ -79,6 +101,7 @@ ReactNativeBrownfield.popToNative(true);
 
 > NOTE: Those methods works only with native components provided by this library.
 
+
 ## Made with ❤️ at Callstack
 
 React Native Brownfield is an open source project and will always remain free to use. If you think it's cool, please star it 🌟. [Callstack](https://callstack.com) is a group of React and React Native geeks, contact us at [hello@callstack.com](mailto:hello@callstack.com) if you need any help with these or just want to say hi!

package/ReactBrownfield.podspec

@@ -0,0 +1,22 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, 'package.json')))
+
+Pod::Spec.new do |spec|
+  spec.name         = "ReactBrownfield"
+  spec.version      = package['version']
+  spec.summary      = package['description']
+  spec.license      = package['license']
+
+  spec.authors      = package['author']
+  spec.homepage     = package['homepage']
+  spec.platform     = :ios, "14.0"
+
+  spec.module_name = "ReactBrownfield"
+  spec.source       = { :git => "git@github.com:callstack/react-native-brownfield.git", :tag => "#{spec.version}" }
+  spec.source_files  = "ios/**/*.{h,m,mm,swift}"
+  spec.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' }
+
+  spec.dependency 'ReactAppDependencyProvider'
+  install_modules_dependencies(spec)
+end

package/android/build.gradle

@@ -1,29 +1,117 @@
-apply plugin: 'com.android.library'
-apply plugin: 'kotlin-android'
+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"]
 
-def safeExtGet(prop, fallback) {
-    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.1"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+  }
 }
 
-repositories {
-    google()
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+def isHermesEnabled() {
+  return rootProject.hasProperty("hermesEnabled") && rootProject.getProperty("hermesEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["RNBrownfield_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["RNBrownfield_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
 }
 
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', 28)
+   if (supportsNamespace()) {
+     namespace "com.callstack.reactnativebrownfield"
+
+     sourceSets {
+       main {
+         manifest.srcFile "src/main/AndroidManifest.xml"
+       }
+     }
+   }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    buildConfigField "boolean", "IS_HERMES_ENABLED", isHermesEnabled().toString()
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
 
-    defaultConfig {
-        minSdkVersion safeExtGet('minSdkVersion', 21)
-        targetSdkVersion safeExtGet('targetSdkVersion', 28)
+  buildTypes {
+    release {
+      minifyEnabled false
     }
+  }
 
-    lintOptions {
-        abortOnError false
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+        java.srcDirs += [
+          "src/newarch",
+          // Codegen specs
+          "generated/java",
+          "generated/jni"
+        ]
+      } else {
+        java.srcDirs += ["src/oldarch"]
+      }
     }
+  }
+}
 
+repositories {
+  mavenCentral()
+  google()
 }
 
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
 dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${safeExtGet('kotlinVersion', '1.3.40')}"
-    implementation "com.facebook.react:react-native:+"
-}
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+RNBrownfield_kotlinVersion=1.7.0
+RNBrownfield_minSdkVersion=21
+RNBrownfield_targetSdkVersion=31
+RNBrownfield_compileSdkVersion=31
+RNBrownfield_ndkversion=21.4.7075529

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

@@ -1,12 +1,25 @@
 package com.callstack.reactnativebrownfield
 
 import android.app.Application
+import android.content.Context
+import android.os.Bundle
+import android.widget.FrameLayout
+import androidx.fragment.app.FragmentActivity
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import com.facebook.react.ReactDelegate
 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.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)
@@ -22,30 +35,33 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
 
     @JvmStatic
     fun initialize(application: Application, rnHost: ReactNativeHost) {
-      if(!initialized.getAndSet(true)) {
+      if (!initialized.getAndSet(true)) {
         instance = ReactNativeBrownfield(rnHost)
-        SoLoader.init(application.applicationContext,false)
+        SoLoader.init(application.applicationContext, OpenSourceMergedSoMapping)
       }
     }
 
     @JvmStatic
     fun initialize(application: Application, options: HashMap<String, Any>) {
-      val rnHost = object : ReactNativeHost(application) {
-        override fun getUseDeveloperSupport(): Boolean {
-          return options["useDeveloperSupport"] as? Boolean ?: BuildConfig.DEBUG
-        }
+      val reactNativeHost: ReactNativeHost =
+        object : DefaultReactNativeHost(application) {
 
-        override fun getPackages(): List<ReactPackage> {
-          return (options["packages"] as? List<*> ?: emptyList<ReactPackage>())
-            .filterIsInstance<ReactPackage>()
-        }
+          override fun getJSMainModuleName(): String {
+            return options["mainModuleName"] as? String ?: super.getJSMainModuleName()
+          }
+
+          override fun getPackages(): List<ReactPackage> {
+            return (options["packages"] as? List<*> ?: emptyList<ReactPackage>())
+              .filterIsInstance<ReactPackage>()
+          }
 
-        override fun getJSMainModuleName(): String {
-          return options["mainModuleName"] as? String ?: super.getJSMainModuleName()
+          override fun getUseDeveloperSupport(): Boolean = BuildConfig.DEBUG
+
+          override val isNewArchEnabled: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+          override val isHermesEnabled: Boolean = BuildConfig.IS_HERMES_ENABLED
         }
-      }
 
-      initialize(application, rnHost)
+      initialize(application, reactNativeHost)
     }
 
     @JvmStatic
@@ -54,6 +70,8 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
 
       initialize(application, options)
     }
+
+
   }
 
   fun startReactNative(callback: InitializedCallback?) {
@@ -62,13 +80,62 @@ class ReactNativeBrownfield private constructor(val reactNativeHost: ReactNative
 
   @JvmName("startReactNativeKotlin")
   fun startReactNative(callback: ((initialized: Boolean) -> Unit)?) {
-    reactNativeHost.reactInstanceManager.addReactInstanceEventListener(object : ReactInstanceEventListener {
+    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()
+        }
+
+        override fun onPause(owner: LifecycleOwner) {
+          reactDelegate.onHostPause()
+        }
+
+        override fun onDestroy(owner: LifecycleOwner) {
+          reactDelegate.onHostDestroy()
+          owner.lifecycle.removeObserver(this) // Cleanup to avoid leaks
+        }
+      })
+
+      reactDelegate.loadApp()
+      return reactDelegate.reactRootView!!
+    }
+
+    val instanceManager: ReactInstanceManager? = shared.reactNativeHost?.reactInstanceManager
+    val reactView = ReactRootView(context)
+    reactView.startReactApplication(
+      instanceManager,
+      moduleName,
+      launchOptions,
+    )
+
+    return reactView
   }
 }
 

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

@@ -11,13 +11,13 @@ import com.facebook.react.uimanager.ReactShadowNode
 
 
 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
+  }
+}