@callstack/react-native-brownfield 6.0.1 → 6.1.1

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @callstack/react-native-brownfield
 
+## 6.1.1
+
+### Patch Changes
+
+- [#516](https://github.com/callstack/react-native-brownfield/pull/516) [`66ac701`](https://github.com/callstack/react-native-brownfield/commit/66ac701d71cb3990732e701a0ab1abd40a7bd271) Thanks [@malopezr7](https://github.com/malopezr7)! - Android: `ReactNativeBrownfield.initialize` can now be called again after it throws. Before, a failure while loading native libraries or creating the `ReactHost` left it marked as initialized, so the next call returned without error and `ReactNativeBrownfield.shared` was never set.
+
+- [#517](https://github.com/callstack/react-native-brownfield/pull/517) [`5884ce9`](https://github.com/callstack/react-native-brownfield/commit/5884ce96bcccf73de33835e7db2785aa3ab8c2a9) Thanks [@tlq5l](https://github.com/tlq5l)! - Fix an iOS crash (`std::bad_function_call`) when native code posts a message to JS while the Brownfield module's JS emitter is still being set up. If the Brownfield module exists but its JS emitter is not ready when delivery happens, the message is dropped and a log line is written. If the module does not exist yet, the message is dropped without a log line.
+- Updated dependencies [[`a9726c1`](https://github.com/callstack/react-native-brownfield/commit/a9726c137c61fe2e59c039555a955632a5d86aec)]:
+  - @callstack/brownfield-cli@6.1.1
+
+## 6.1.0
+
+### Minor Changes
+
+- [#520](https://github.com/callstack/react-native-brownfield/pull/520) [`b87cdff`](https://github.com/callstack/react-native-brownfield/commit/b87cdff0de1cb147289a7497973b6f191dc74134) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: pick the right `.so` files for the Android AAR. With `useStrippedSoFiles = false`, the AAR now has `libappmodules.so` and `libreact_codegen_*.so`. Before this fix, those libs were missing and host apps crashed. The AAR also stops embedding the `.so` files of Maven dependencies. The host already gets those through the POM, so its build no longer fails with `2 files found with path 'lib/<abi>/<name>.so'`. If your app module builds or ships a `.so` of its own, list it in `reactBrownfield.dynamicLibs`, which is back. The build lists the `.so` files it left out in `<brownfield module>/build/reports/brownfield/<variant>/skipped-so.txt`. After upgrading, check that file: it lists the `.so` files that used to be in the AAR and now aren't.
+
+- [#522](https://github.com/callstack/react-native-brownfield/pull/522) [`20776bb`](https://github.com/callstack/react-native-brownfield/commit/20776bb714c2de1e962515aa7c88235b60c7dabf) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - feat: the published POM and `module.json` now follow the brownfield module's Gradle exclude rules (`configurations.all { exclude(...) }`). Before, the plugin re-added an excluded dependency when it injected the embedded libraries' dependencies, so the host app still resolved it. The excludes are also written onto every dependency the plugin injects, so the excluded library can't arrive through one of them. On Expo, list them in `android.excludeDependencies` (as `group:module` or `group`), which the config plugin writes into the generated module.
+
+### Patch Changes
+
+- [#512](https://github.com/callstack/react-native-brownfield/pull/512) [`520811c`](https://github.com/callstack/react-native-brownfield/commit/520811c47a122cacd1ec15f1b064ad08d699eebb) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: package classes from libraries' local jars (`libs/*.jar`) into the Android AAR; previously host apps crashed with NoClassDefFoundError. If your app also has those classes, because it added the jar itself as a workaround or depends on a library that the jar bundles, the build now fails with duplicate classes: remove the app's copy
+
+- [#513](https://github.com/callstack/react-native-brownfield/pull/513) [`f3dbbd1`](https://github.com/callstack/react-native-brownfield/commit/f3dbbd1c2579f905a358faac0ad1677b3740cebc) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: keep the resources of every library embedded in the Android AAR; previously only one library's `res/values` survived and host apps failed at resource linking. As in a regular app, the module's own `res` and `resValue`s win over a library's, and when two libraries define the same resource the first one wins (previously the last one won for files such as drawables)
+
+- [#521](https://github.com/callstack/react-native-brownfield/pull/521) [`58aedad`](https://github.com/callstack/react-native-brownfield/commit/58aedad94f38098424937533f2ce0b0c3df62067) Thanks [@KisaneNeko](https://github.com/KisaneNeko)! - fix: the AAR build no longer fails with duplicate resources when an embedded library ships the same drawables Metro generates for the app's bundle. Metro's copy wins.
+
+- [#503](https://github.com/callstack/react-native-brownfield/pull/503) [`6a258da`](https://github.com/callstack/react-native-brownfield/commit/6a258da42f2bd2cbb112f56948108323aeba74d9) Thanks [@RaphaelFakhri](https://github.com/RaphaelFakhri)! - `ReactNativeBrownfield.onMessage` no longer calls the callback a second time, with the raw message text, when the callback throws. The error now propagates instead of being swallowed.
+- Updated dependencies [[`20776bb`](https://github.com/callstack/react-native-brownfield/commit/20776bb714c2de1e962515aa7c88235b60c7dabf)]:
+  - @callstack/brownfield-cli@6.1.0
+
 ## 6.0.1
 
 ### Patch Changes

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

@@ -18,7 +18,6 @@ import com.facebook.react.defaults.DefaultReactHost.getDefaultReactHost
 import com.facebook.react.soloader.OpenSourceMergedSoMapping
 import com.facebook.soloader.SoLoader
 import java.util.concurrent.CopyOnWriteArrayList
-import java.util.concurrent.atomic.AtomicBoolean
 
 fun interface OnJSBundleLoaded {
     operator fun invoke(timings: JSBundleTimings)
@@ -33,17 +32,15 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
 
     companion object {
         private lateinit var instance: ReactNativeBrownfield
-        private val initialized = AtomicBoolean()
-        private val nativeLibsLoaded = AtomicBoolean()
+        private val initialization = RetryableOnce()
+        private val nativeLibsLoading = RetryableOnce()
         private lateinit var applicationContext: Application
 
         @JvmStatic
         val shared: ReactNativeBrownfield get() = instance
 
         private fun loadNativeLibs(application: Application) {
-            if (!nativeLibsLoaded.getAndSet(true)) {
-                loadNativeLibsInternal(application)
-            }
+            nativeLibsLoading.run { loadNativeLibsInternal(application) }
         }
 
         private fun loadNativeLibsInternal(application: Application) {
@@ -65,11 +62,12 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             onJSBundleLoaded: OnJSBundleLoaded? = null
         ) {
             applicationContext = application
-            if (!initialized.getAndSet(true)) {
+            val ranNow = initialization.run {
                 AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 installAndPreload(reactHost, onJSBundleLoaded)
-            } else {
+            }
+            if (!ranNow) {
                 invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
@@ -81,11 +79,12 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             reactHostFactory: () -> ReactHost
         ) {
             applicationContext = application
-            if (!initialized.getAndSet(true)) {
+            val ranNow = initialization.run {
                 AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 installAndPreload(reactHostFactory(), onJSBundleLoaded)
-            } else {
+            }
+            if (!ranNow) {
                 invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
@@ -98,7 +97,7 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             onJSBundleLoaded: OnJSBundleLoaded? = null
         ) {
             applicationContext = application
-            if (!initialized.getAndSet(true)) {
+            val ranNow = initialization.run {
                 AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 val reactHost = getDefaultReactHost(
@@ -114,7 +113,8 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
                     jsRuntimeFactory = null
                 )
                 installAndPreload(reactHost, onJSBundleLoaded)
-            } else {
+            }
+            if (!ranNow) {
                 invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }

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

@@ -0,0 +1,27 @@
+package com.callstack.reactnativebrownfield
+
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Runs a block at most once, counting only a run that completes.
+ *
+ * If the block throws, the next [run] call runs it again instead of treating
+ * the work as done. Calls made while a run is in progress are skipped.
+ */
+internal class RetryableOnce {
+    private val claimed = AtomicBoolean()
+
+    /** Returns `true` when [block] ran and completed during this call. */
+    fun run(block: () -> Unit): Boolean {
+        if (claimed.getAndSet(true)) {
+            return false
+        }
+        try {
+            block()
+        } catch (error: Throwable) {
+            claimed.set(false)
+            throw error
+        }
+        return true
+    }
+}

package/android/src/test/java/com/callstack/reactnativebrownfield/RetryableOnceTest.kt

@@ -0,0 +1,37 @@
+package com.callstack.reactnativebrownfield
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Test
+
+class RetryableOnceTest {
+    @Test fun `runs the block once after it completes`() {
+        val once = RetryableOnce()
+        var runs = 0
+
+        assertTrue(once.run { runs++ })
+        assertFalse(once.run { runs++ })
+        assertEquals(1, runs)
+    }
+
+    @Test fun `runs the block again after it throws`() {
+        val once = RetryableOnce()
+        var runs = 0
+
+        try {
+            once.run {
+                runs++
+                throw UnsatisfiedLinkError("dlopen failed")
+            }
+            fail("expected the error to propagate")
+        } catch (expected: UnsatisfiedLinkError) {
+            assertEquals("dlopen failed", expected.message)
+        }
+
+        assertTrue(once.run { runs++ })
+        assertFalse(once.run { runs++ })
+        assertEquals(2, runs)
+    }
+}

package/gradle-plugin/brownfield/build.gradle.kts

@@ -113,10 +113,14 @@ dependencies {
     // minimum Gradle version) for every app that applies this plugin.
     compileOnly(libs.agp)
     compileOnly(libs.common)
+    compileOnly(libs.sdk.common)
+    compileOnly(libs.layoutlib.api)
     implementation(libs.asm.commons)
     implementation(libs.versioncompare)
     testImplementation(libs.agp)
     testImplementation(libs.common)
+    testImplementation(libs.sdk.common)
+    testImplementation(libs.layoutlib.api)
     testImplementation(libs.junit.jupiter)
     testImplementation(gradleTestKit())
     testImplementation(kotlin("test"))

package/gradle-plugin/brownfield/gradle/libs.versions.toml

@@ -19,6 +19,8 @@ detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 [libraries]
 agp = { module = "com.android.tools.build:gradle", name = "agp", version.ref = "agp" }
 common = { module = "com.android.tools:common", version.ref = "common" }
+sdk-common = { module = "com.android.tools:sdk-common", version.ref = "common" }
+layoutlib-api = { module = "com.android.tools.layoutlib:layoutlib-api", version.ref = "common" }
 asm-commons = { module = "org.ow2.asm:asm-commons", version.ref = "asm-commons" }
 versioncompare = { module = "io.github.g00fy2:versioncompare", version.ref = "versioncompare" }
 junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit" }

package/gradle-plugin/brownfield/gradle.properties

@@ -1,6 +1,6 @@
 PROJECT_ID=com.callstack.react.brownfield
 ARTIFACT_ID=brownfield-gradle-plugin
-VERSION=2.0.0-alpha11
+VERSION=2.0.0-alpha14
 GROUP=com.callstack.react
 IMPLEMENTATION_CLASS=com.callstack.react.brownfield.plugin.RNBrownfieldPlugin
 

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/plugin/RNBrownfieldPlugin.kt

@@ -19,11 +19,13 @@ import com.callstack.react.brownfield.processors.VariantTaskProvider
 import com.callstack.react.brownfield.shared.BaseProject
 import com.callstack.react.brownfield.shared.Constants
 import com.callstack.react.brownfield.shared.Constants.PROJECT_ID
+import com.callstack.react.brownfield.shared.GradleExclude
 import com.callstack.react.brownfield.shared.Logging
 import com.callstack.react.brownfield.shared.PublishingMetadataInjector
 import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
 import com.callstack.react.brownfield.shared.VersionMediatingDependencySet
 import com.callstack.react.brownfield.shared.dropHardExcludedDependencies
+import com.callstack.react.brownfield.shared.gradleExcludes
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.DirectoryManager
 import com.callstack.react.brownfield.utils.Extension
@@ -33,6 +35,24 @@ import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.ProjectConfigurationException
 
+/**
+ * Coordinates that must never be published: embedded in the AAR (not resolvable from Maven), or
+ * excluded by the brownfield module's own Gradle rules.
+ */
+internal fun hardExcludePredicate(
+    project: Project,
+    expoPublishingHelper: ExpoPublishingHelper?,
+    artifacts: List<UnresolvedArtifactInfo>,
+    expoProjects: List<ExpoGradleProjectProjection>,
+    excludes: List<GradleExclude>,
+): (String, String) -> Boolean =
+    { groupId, artifactId ->
+        (expoPublishingHelper?.shouldExcludeDependency(groupId, artifactId) ?: (groupId == project.rootProject.name)) ||
+            artifacts.any { it.moduleGroup == groupId && it.moduleName == artifactId } ||
+            expoProjects.any { it.publication?.groupId == groupId && it.publication?.artifactId == artifactId } ||
+            excludes.any { it.matches(groupId, artifactId) }
+    }
+
 class RNBrownfieldPlugin : Plugin<Project> {
     private lateinit var extension: Extension
     private lateinit var project: Project
@@ -140,11 +160,8 @@ class RNBrownfieldPlugin : Plugin<Project> {
             // Coordinates that must never be published: they're embedded in the AAR, not
             // resolvable from Maven. Distinct from "superseded" coordinates, which ARE re-injected
             // (replacing a stale entry) and so must not be dropped here.
-            val hardExcludePredicate: (String, String) -> Boolean = { groupId, artifactId ->
-                (expoPublishingHelper?.shouldExcludeDependency(groupId, artifactId) ?: (groupId == project.rootProject.name)) ||
-                    artifacts.any { it.moduleGroup == groupId && it.moduleName == artifactId } ||
-                    expoProjects.any { it.publication?.groupId == groupId && it.publication?.artifactId == artifactId }
-            }
+            val excludes = gradleExcludes(project)
+            val hardExcludePredicate = hardExcludePredicate(project, expoPublishingHelper, artifacts, expoProjects, excludes)
             dropHardExcludedDependencies(transitiveDeps, hardExcludePredicate)
 
             Logging.log(
@@ -155,7 +172,7 @@ class RNBrownfieldPlugin : Plugin<Project> {
                 hardExcludePredicate(groupId, artifactId) || rncSupersededCoordinates.contains(groupId to artifactId)
             }
 
-            injector.configure(transitiveDeps, removalPredicate)
+            injector.configure(transitiveDeps, removalPredicate, excludes)
             Logging.log("PublishingMetadataInjector ran: injected merged transitive dependencies into POM and Gradle Module Metadata")
 
             // Informational only — throwing would recreate the upgrade break that the namespaced
@@ -277,7 +294,7 @@ class RNBrownfieldPlugin : Plugin<Project> {
 
         /** ===== jniLibsProcessor ===== */
         val jniLibsProcessor = JNILibsProcessor(project)
-        jniLibsProcessor.processJniLibs(aarLibraries, variant)
+        jniLibsProcessor.processJniLibs(aarLibraries, variant, explodeTask)
 
         /** ===== proguardProcessor ===== */
         val proguardProcessor = ProguardProcessor(project)

package/gradle-plugin/brownfield/src/main/kotlin/com/callstack/react/brownfield/plugin/RNSourceSets.kt

@@ -8,8 +8,7 @@ import com.callstack.react.brownfield.exceptions.NameSpaceNotFound
 import com.callstack.react.brownfield.processors.VariantHelper
 import com.callstack.react.brownfield.utils.Extension
 import com.callstack.react.brownfield.utils.Utils
-import com.callstack.react.brownfield.utils.capitalized
-import org.gradle.api.GradleException
+import com.callstack.react.brownfield.utils.directoryGetter
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.file.DirectoryProperty
@@ -57,16 +56,9 @@ object RNSourceSets {
         // 2. Use the onVariants block to wire RN bundle outputs via the Variant Sources API
         componentsExtension.onVariants { variant ->
             val variantName = variant.name
-            val bundledAssetsVariantName =
-                VariantHelper.getBundledAssetsVariantName(
-                    variantName = variantName,
-                    buildTypeName = variant.buildType,
-                    isDebuggable = variant.debuggable,
-                )
-            val capitalizedBundledAssetsVariantName = bundledAssetsVariantName.capitalized()
             val appProject = getAppProject()
 
-            val jsBundleTaskName = "createBundle${capitalizedBundledAssetsVariantName}JsAndAssets"
+            val jsBundleTaskName = VariantHelper.getMetroBundleTaskName(variant)
 
             /**
              * Wire the bundle task's own `jsBundleDir`/`resourcesDir` outputs as *generated*
@@ -89,12 +81,7 @@ object RNSourceSets {
 
     /**
      * Wires `taskName`'s `getterName` output (expected to be a `DirectoryProperty`) as a
-     * generated source directory for `sources`.
-     *
-     * Resolving the task by name (rather than importing its class) keeps this plugin from
-     * depending on RNGP's/expo-updates' internal task types. If the task, or its expected output
-     * property, isn't there, this fails the build immediately with a clear message instead of
-     * silently producing an empty/stale source directory.
+     * generated source directory for `sources`. See [directoryGetter] for the checks.
      */
     private fun wireGeneratedSourceDirectory(
         appProject: Project,
@@ -104,27 +91,7 @@ object RNSourceSets {
     ) {
         if (sources == null) return
 
-        val task =
-            appProject.tasks.findByName(taskName)
-                ?: throw GradleException(
-                    "brownfield: expected task '$taskName' was not found in project " +
-                        "'${appProject.path}'. Check that the plugin producing it is applied there.",
-                )
-
-        val getter =
-            runCatching { task.javaClass.getMethod(getterName) }.getOrElse {
-                throw GradleException(
-                    "brownfield: task '$taskName' (${task.javaClass.name}) does not expose " +
-                        "'$getterName()'. The plugin that registers it most likely changed its " +
-                        "API; the brownfield Gradle plugin needs updating to match.",
-                    it,
-                )
-            }
-
-        check(DirectoryProperty::class.java.isAssignableFrom(getter.returnType)) {
-            "brownfield: '$taskName.$getterName()' no longer returns a DirectoryProperty."
-        }
-
+        val getter = directoryGetter(appProject, taskName, getterName)
         val taskProvider = appProject.tasks.named(taskName)
         sources.addGeneratedSourceDirectory(taskProvider) { t -> getter.invoke(t) as DirectoryProperty }
     }