@callstack/react-native-brownfield 5.3.0 → 6.0.1

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

@@ -2,6 +2,7 @@ package com.callstack.reactnativebrownfield
 
 import android.app.Application
 import android.os.Bundle
+import android.view.WindowManager
 import android.widget.FrameLayout
 import androidx.activity.OnBackPressedCallback
 import androidx.fragment.app.FragmentActivity
@@ -20,7 +21,7 @@ import java.util.concurrent.CopyOnWriteArrayList
 import java.util.concurrent.atomic.AtomicBoolean
 
 fun interface OnJSBundleLoaded {
-    operator fun invoke(initialized: Boolean)
+    operator fun invoke(timings: JSBundleTimings)
 }
 
 fun interface OnMessageListener {
@@ -34,6 +35,7 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
         private lateinit var instance: ReactNativeBrownfield
         private val initialized = AtomicBoolean()
         private val nativeLibsLoaded = AtomicBoolean()
+        private lateinit var applicationContext: Application
 
         @JvmStatic
         val shared: ReactNativeBrownfield get() = instance
@@ -62,7 +64,9 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             reactHost: ReactHost,
             onJSBundleLoaded: OnJSBundleLoaded? = null
         ) {
+            applicationContext = application
             if (!initialized.getAndSet(true)) {
+                AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 installAndPreload(reactHost, onJSBundleLoaded)
             } else {
@@ -76,14 +80,16 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             onJSBundleLoaded: OnJSBundleLoaded? = null,
             reactHostFactory: () -> ReactHost
         ) {
+            applicationContext = application
             if (!initialized.getAndSet(true)) {
+                AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 installAndPreload(reactHostFactory(), onJSBundleLoaded)
             } else {
                 invokeWhenJSBundleLoaded(onJSBundleLoaded)
             }
         }
-        
+
         @JvmStatic
         @JvmOverloads
         fun initialize(
@@ -91,7 +97,9 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             options: HashMap<String, Any>,
             onJSBundleLoaded: OnJSBundleLoaded? = null
         ) {
+            applicationContext = application
             if (!initialized.getAndSet(true)) {
+                AndroidJSBundleTimingObserver.install()
                 loadNativeLibs(application)
                 val reactHost = getDefaultReactHost(
                     context = application,
@@ -123,11 +131,11 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
             initialize(application, options, onJSBundleLoaded)
         }
 
-        private fun preloadReactNative(callback: ((Boolean) -> Unit)) {
+        private fun preloadReactNative(generation: Int) {
             shared.reactHost.addReactInstanceEventListener(object :
                 ReactInstanceEventListener {
                 override fun onReactContextInitialized(context: ReactContext) {
-                    callback(true)
+                    AndroidJSBundleTimingObserver.contextInitialized(context, generation)
                     shared.reactHost.removeReactInstanceEventListener(this)
                 }
             })
@@ -135,10 +143,12 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
         }
 
         private fun installAndPreload(reactHost: ReactHost, onJSBundleLoaded: OnJSBundleLoaded?) {
+            AndroidJSBundleTimingObserver.install()
+            val generation = AndroidJSBundleTimingObserver.beginGeneration()
             instance = ReactNativeBrownfield(reactHost)
-            preloadReactNative {
-                onJSBundleLoaded?.invoke(true)
-            }
+            reactHost.installBrownfieldPerformanceStop()
+            AndroidJSBundleTimingObserver.subscribe(onJSBundleLoaded)
+            preloadReactNative(generation)
         }
 
         private fun invokeWhenJSBundleLoaded(onJSBundleLoaded: OnJSBundleLoaded?) {
@@ -146,18 +156,21 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
                 return
             }
 
-            val reactHost = instance.reactHost
-            reactHost.currentReactContext?.let {
-                onJSBundleLoaded.invoke(true)
-                return
-            }
+            AndroidJSBundleTimingObserver.subscribe(onJSBundleLoaded)
+        }
 
-            reactHost.addReactInstanceEventListener(object : ReactInstanceEventListener {
-                override fun onReactContextInitialized(context: ReactContext) {
-                    onJSBundleLoaded.invoke(true)
-                    reactHost.removeReactInstanceEventListener(this)
-                }
-            })
+        internal fun currentReactContext(): ReactContext? =
+            if (::instance.isInitialized) instance.reactHost.currentReactContext else null
+
+        internal fun displayFrameIntervalNanos(): Long {
+            if (!::applicationContext.isInitialized) return 1_000_000_000L / 60
+            @Suppress("DEPRECATION")
+            val refreshRate = applicationContext
+                .getSystemService(WindowManager::class.java)
+                ?.defaultDisplay
+                ?.refreshRate
+                ?.takeIf { it > 0f } ?: 60f
+            return (1_000_000_000.0 / refreshRate).toLong()
         }
     }
 
@@ -215,10 +228,47 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
         reactDelegate: ReactDelegateWrapper?,
         launchOptions: Bundle?,
         lifecycleOwner: LifecycleOwner?,
+    ): FrameLayout {
+        return createViewInternal(
+            activity, moduleName, reactDelegate, launchOptions, lifecycleOwner, null, false
+        )
+    }
+
+    @JvmOverloads
+    fun createView(
+        activity: FragmentActivity?,
+        moduleName: String,
+        reactDelegate: ReactDelegateWrapper? = null,
+        launchOptions: Bundle? = null,
+        waitForFullDisplay: Boolean,
+        collectThreadMetrics: Boolean = false,
+        onMetrics: OnDisplayMetrics? = null,
+    ): FrameLayout {
+        val session = BrownfieldDisplaySession(
+            moduleName, waitForFullDisplay, collectThreadMetrics, onMetrics
+        )
+        val props = Bundle(launchOptions ?: Bundle()).apply {
+            putString("brownfieldPresentationID", session.id)
+        }
+        return createViewInternal(activity, moduleName, reactDelegate, props, activity, session, false)
+    }
+
+    internal fun createViewInternal(
+        activity: FragmentActivity?,
+        moduleName: String,
+        reactDelegate: ReactDelegateWrapper?,
+        launchOptions: Bundle?,
+        lifecycleOwner: LifecycleOwner?,
+        session: BrownfieldDisplaySession?,
+        requiresResume: Boolean,
     ): FrameLayout {
         val reactHost = shared.reactHost
-        val resolvedDelegate =
-            reactDelegate ?: ReactDelegateWrapper(activity, reactHost, moduleName, launchOptions)
+        val resolvedDelegate = when {
+            reactDelegate == null -> ReactDelegateWrapper(activity, reactHost, moduleName, launchOptions)
+            session != null && reactDelegate.brownfieldLaunchOptions !== launchOptions ->
+                reactDelegate.withLaunchOptions(launchOptions)
+            else -> reactDelegate
+        }
 
         val backPressedCallback: OnBackPressedCallback = object : OnBackPressedCallback(true) {
             override fun handleOnBackPressed() {
@@ -248,24 +298,29 @@ class ReactNativeBrownfield private constructor(val reactHost: ReactHost) {
          * In such a case, we set the lifeCycle observer.
          */
         if (reactDelegate == null) {
-            lifecycleOwner?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate))
+            lifecycleOwner?.lifecycle?.addObserver(getLifeCycleObserver(resolvedDelegate, session))
         }
 
         resolvedDelegate.loadApp()
-        return resolvedDelegate.reactRootView!!
+        return resolvedDelegate.reactRootView!!.also { session?.bind(it, requiresResume) }
     }
 
-    private fun getLifeCycleObserver(reactDelegate: ReactDelegateWrapper): DefaultLifecycleObserver {
+    private fun getLifeCycleObserver(
+        reactDelegate: ReactDelegateWrapper,
+        session: BrownfieldDisplaySession?
+    ): DefaultLifecycleObserver {
         return object : DefaultLifecycleObserver {
             override fun onResume(owner: LifecycleOwner) {
                 reactDelegate.onReactHostResume()
             }
 
             override fun onPause(owner: LifecycleOwner) {
+                session?.cancel()
                 reactDelegate.onHostPause()
             }
 
             override fun onDestroy(owner: LifecycleOwner) {
+                session?.cancel()
                 reactDelegate.onHostDestroy()
                 owner.lifecycle.removeObserver(this) // Cleanup to avoid leaks
             }

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

@@ -17,6 +17,7 @@ class ReactNativeBrownfieldPackage : ReactPackage {
     override fun createNativeModules(reactContext: ReactApplicationContext): MutableList<NativeModule> {
         val modules = ArrayList<NativeModule>()
         modules.add(ReactNativeBrownfieldModule(reactContext))
+        modules.add(BrownfieldPerformanceModule(reactContext))
         return modules
     }
 }

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

@@ -17,6 +17,10 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
     private lateinit var permissionsCallback: Callback
     private var permissionListener: PermissionListener? = null
     private lateinit var moduleName: String
+    private var displaySession: BrownfieldDisplaySession? = null
+
+    /** Reattach after Fragment restoration; callbacks are intentionally not serialized. */
+    var onMetrics: OnDisplayMetrics? = null
 
     override fun onCreate(savedInstanceState: Bundle?) {
         /**
@@ -51,12 +55,34 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
         container: ViewGroup?,
         savedInstanceState: Bundle?
     ): View {
-        return ReactNativeBrownfield.shared.createView(
+        val args = arguments
+        // Only the measured factories set this argument. Plain fragments keep their props as is.
+        val isMeasured = args?.containsKey(ReactNativeFragmentArgNames.ARG_WAIT_FOR_FULL_DISPLAY) == true
+        val session = if (isMeasured) {
+            BrownfieldDisplaySession(
+                moduleName,
+                args!!.getBoolean(ReactNativeFragmentArgNames.ARG_WAIT_FOR_FULL_DISPLAY, false),
+                args.getBoolean(ReactNativeFragmentArgNames.ARG_COLLECT_THREAD_METRICS, false),
+                onMetrics
+            )
+        } else {
+            null
+        }
+        displaySession = session
+        val launchOptions = Bundle(
+            args?.getBundle(ReactNativeFragmentArgNames.ARG_LAUNCH_OPTIONS) ?: Bundle()
+        ).apply { session?.let { putString("brownfieldPresentationID", it.id) } }
+        this.reactDelegate = ReactDelegateWrapper(
+            activity, this.reactHost, moduleName, launchOptions
+        )
+        return ReactNativeBrownfield.shared.createViewInternal(
             activity,
             moduleName,
             this.reactDelegate as ReactDelegateWrapper,
-            launchOptions = null,
-            lifecycleOwner = viewLifecycleOwner
+            launchOptions,
+            viewLifecycleOwner,
+            session,
+            true
         )
     }
 
@@ -69,9 +95,11 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
         } catch (_: ClassCastException) {
             (this.reactDelegate as ReactDelegateWrapper).onReactHostResume()
         }
+        displaySession?.setResumed(true)
     }
 
     override fun onPause() {
+        displaySession?.cancel()
         try {
             super.onPause()
         } catch (error: AssertionError) {
@@ -91,6 +119,12 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
         }
     }
 
+    override fun onDestroyView() {
+        displaySession?.cancel()
+        displaySession = null
+        super.onDestroyView()
+    }
+
     override fun onRequestPermissionsResult(
         requestCode: Int,
         permissions: Array<String>,
@@ -143,6 +177,26 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
             return fragment
         }
 
+        @JvmStatic
+        @JvmOverloads
+        fun createReactNativeFragment(
+            moduleName: String,
+            initialProps: Bundle?,
+            waitForFullDisplay: Boolean,
+            collectThreadMetrics: Boolean = false,
+            onMetrics: OnDisplayMetrics? = null
+        ): ReactNativeFragment {
+            return createReactNativeFragment(moduleName, initialProps).also { fragment ->
+                fragment.arguments?.putBoolean(
+                    ReactNativeFragmentArgNames.ARG_WAIT_FOR_FULL_DISPLAY, waitForFullDisplay
+                )
+                fragment.arguments?.putBoolean(
+                    ReactNativeFragmentArgNames.ARG_COLLECT_THREAD_METRICS, collectThreadMetrics
+                )
+                fragment.onMetrics = onMetrics
+            }
+        }
+
         @JvmStatic
         fun createReactNativeFragment(
             moduleName: String,
@@ -151,6 +205,22 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
             return createReactNativeFragment(moduleName, PropsBundle.fromHashMap(initialProps))
         }
 
+        @JvmStatic
+        @JvmOverloads
+        fun createReactNativeFragment(
+            moduleName: String,
+            initialProps: HashMap<String, *>,
+            waitForFullDisplay: Boolean,
+            collectThreadMetrics: Boolean = false,
+            onMetrics: OnDisplayMetrics? = null
+        ): ReactNativeFragment = createReactNativeFragment(
+            moduleName,
+            PropsBundle.fromHashMap(initialProps),
+            waitForFullDisplay,
+            collectThreadMetrics,
+            onMetrics
+        )
+
         @JvmStatic
         fun createReactNativeFragment(
             moduleName: String,
@@ -158,5 +228,21 @@ class ReactNativeFragment : ReactFragment(), PermissionAwareActivity {
         ): ReactNativeFragment {
             return createReactNativeFragment(moduleName, initialProps.toHashMap())
         }
+
+        @JvmStatic
+        @JvmOverloads
+        fun createReactNativeFragment(
+            moduleName: String,
+            initialProps: WritableMap,
+            waitForFullDisplay: Boolean,
+            collectThreadMetrics: Boolean = false,
+            onMetrics: OnDisplayMetrics? = null
+        ): ReactNativeFragment = createReactNativeFragment(
+            moduleName,
+            initialProps.toHashMap(),
+            waitForFullDisplay,
+            collectThreadMetrics,
+            onMetrics
+        )
     }
 }

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

@@ -16,5 +16,7 @@ class ReactNativeFragmentArgNames private constructor() :
 
         // re-export constants from ReactFragment to enable access
         const val ARG_LAUNCH_OPTIONS: String = "arg_launch_options"
+        const val ARG_WAIT_FOR_FULL_DISPLAY = "arg_wait_for_full_display"
+        const val ARG_COLLECT_THREAD_METRICS = "arg_collect_thread_metrics"
     }
 }

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

@@ -0,0 +1,54 @@
+package com.callstack.reactnativebrownfield
+
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class PerformanceMetricsTest {
+    @Test fun `pairs markers and sorts overlapping timeline`() {
+        val samples = JSBundleTimingAccumulator()
+        samples.record(BundleMarker.EVALUATION_START, 1, 20)
+        samples.record(BundleMarker.DOWNLOAD_START, 0, 10)
+        samples.record(BundleMarker.EVALUATION_END, 1, 40)
+        samples.record(BundleMarker.DOWNLOAD_END, 0, 30)
+
+        val result = samples.snapshot()
+        assertEquals(20.0, result.jsBundleLoadTime!!, 0.0)
+        assertEquals(20.0, result.jsBundleEvaluationTime!!, 0.0)
+        assertEquals(listOf("DOWNLOAD", "RUN_JS_BUNDLE"), result.timeline.map { it["tag"] })
+    }
+
+    @Test fun `keeps zero duration and rejects missing ambiguous and other instances`() {
+        val zero = JSBundleTimingAccumulator().apply {
+            record(BundleMarker.EVALUATION_START, 1, 5)
+            record(BundleMarker.EVALUATION_END, 1, 5)
+        }.snapshot()
+        assertEquals(0.0, zero.jsBundleEvaluationTime!!, 0.0)
+
+        val missing = JSBundleTimingAccumulator().apply {
+            record(BundleMarker.DOWNLOAD_END, 0, 8)
+            record(BundleMarker.EVALUATION_START, 2, 9)
+            record(BundleMarker.EVALUATION_END, 2, 10)
+        }.snapshot()
+        assertNull(missing.jsBundleLoadTime)
+        assertNull(missing.jsBundleEvaluationTime)
+
+        val ambiguous = JSBundleTimingAccumulator().apply {
+            record(BundleMarker.DOWNLOAD_START, 0, 1)
+            record(BundleMarker.DOWNLOAD_START, 0, 2)
+            record(BundleMarker.DOWNLOAD_END, 0, 3)
+        }.snapshot()
+        assertNull(ambiguous.jsBundleLoadTime)
+    }
+
+    @Test fun `frame accumulator includes unfinished deadline excess`() {
+        val samples = BrownfieldFrameSamples()
+        samples.begin(0)
+        samples.record(20_000_000, 10_000_000)
+        val result = samples.snapshot(50_000_000)
+        assertEquals(20.0, result.fps!!, 0.001)
+        assertEquals(0.6, result.busyRatio!!, 0.001)
+        assertEquals(50.0, result.sampledMs, 0.001)
+        assertEquals(1, result.frameCount)
+    }
+}

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-alpha10
+VERSION=2.0.0-alpha11
 GROUP=com.callstack.react
 IMPLEMENTATION_CLASS=com.callstack.react.brownfield.plugin.RNBrownfieldPlugin
 

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

@@ -3,13 +3,16 @@ package com.callstack.react.brownfield.plugin
 import com.android.build.api.dsl.AndroidSourceSet
 import com.android.build.api.dsl.LibraryExtension
 import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.api.variant.SourceDirectories
 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 org.gradle.api.Project
 import org.gradle.api.Task
+import org.gradle.api.file.DirectoryProperty
 import org.gradle.api.tasks.Copy
 import java.io.File
 
@@ -63,26 +66,67 @@ object RNSourceSets {
             val capitalizedBundledAssetsVariantName = bundledAssetsVariantName.capitalized()
             val appProject = getAppProject()
 
-            val bundlePathSegments =
-                listOf(
-                    // outputs for RN <= 0.81
-                    "createBundle${capitalizedBundledAssetsVariantName}JsAndAssets",
-                    // outputs for RN >= 0.82
-                    "react/$bundledAssetsVariantName",
-                )
+            val jsBundleTaskName = "createBundle${capitalizedBundledAssetsVariantName}JsAndAssets"
 
-            val appBuildDir = getAppBuildDir()
-            bundlePathSegments.forEach { segment ->
-                variant.sources.assets?.addStaticSourceDirectory("$appBuildDir/generated/assets/$segment")
-                variant.sources.res?.addStaticSourceDirectory("$appBuildDir/generated/res/$segment")
-            }
+            /**
+             * Wire the bundle task's own `jsBundleDir`/`resourcesDir` outputs as *generated*
+             * source directories
+             */
+            wireGeneratedSourceDirectory(appProject, jsBundleTaskName, "getJsBundleDir", variant.sources.assets)
+            wireGeneratedSourceDirectory(appProject, jsBundleTaskName, "getResourcesDir", variant.sources.res)
 
             if (Utils.hasExpoUpdates(appProject, variantName)) {
-                val updateResourcesPathSegment = VariantHelper.getExpoUpdatesResourcesTaskName(variant.name)
-                variant.sources.assets?.addStaticSourceDirectory("$appBuildDir/generated/assets/$updateResourcesPathSegment")
-                variant.sources.res?.addStaticSourceDirectory("$appBuildDir/generated/res/$updateResourcesPathSegment")
+                /**
+                 * expo-updates registers `create<Variant>UpdatesResources` as
+                 * `ExpoUpdatesPlugin.CreateUpdatesResourcesTask`, with a single
+                 * `assetDir: DirectoryProperty` output (no `res` output exists for this task).
+                 */
+                val updatesResourcesTaskName = VariantHelper.getExpoUpdatesResourcesTaskName(variant.name)
+                wireGeneratedSourceDirectory(appProject, updatesResourcesTaskName, "getAssetDir", variant.sources.assets)
+            }
+        }
+    }
+
+    /**
+     * 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.
+     */
+    private fun wireGeneratedSourceDirectory(
+        appProject: Project,
+        taskName: String,
+        getterName: String,
+        sources: SourceDirectories?,
+    ) {
+        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 taskProvider = appProject.tasks.named(taskName)
+        sources.addGeneratedSourceDirectory(taskProvider) { t -> getter.invoke(t) as DirectoryProperty }
     }
 
     private fun getLibraryNameSpace(): String {

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

@@ -3,6 +3,7 @@ package com.callstack.react.brownfield.utils
 import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
 import org.gradle.api.Project
 import java.io.File
+import javax.xml.parsers.DocumentBuilderFactory
 
 class AndroidArchiveLibrary(
     private val project: Project,
@@ -46,11 +47,47 @@ class AndroidArchiveLibrary(
         val regex = Regex("""namespace\s*=?\s*["']([^"']+)["']""")
         val match = regex.find(text)
 
-        val namespace =
-            match?.groupValues?.get(1)
-                ?: error("No namespace found in ${buildFile.path}")
+        return match?.groupValues?.get(1)
+            ?: getNameSpaceFromAndroidManifest(subProj)
+            ?: error(
+                "No namespace found in ${buildFile.path}, and no package attribute found in " +
+                    "AndroidManifest.xml for ${artifact.moduleName}",
+            )
+    }
 
-        return namespace
+    /**
+     * Falls back to the `package` attribute of the dependency's `AndroidManifest.xml` when the
+     * module declares no `namespace` in its `build.gradle`. The Android Gradle plugin itself
+     * derives the namespace this way for such libraries, so they build fine as a regular
+     * dependency but trip up [getNameSpaceFromBuildGradle]'s `build.gradle`-only regex.
+     *
+     * The manifest is parsed as XML and only the root `<manifest>` element's `package`
+     * attribute is read, so comments or child attributes such as `android:targetPackage`
+     * cannot be mistaken for the package name.
+     */
+    private fun getNameSpaceFromAndroidManifest(subProj: Project): String? {
+        val candidateManifests =
+            listOf(
+                File(subProj.projectDir, "src/main/AndroidManifest.xml"),
+                File(subProj.projectDir, "AndroidManifest.xml"),
+            )
+
+        return candidateManifests
+            .filter { it.exists() }
+            .firstNotNullOfOrNull { manifestFile ->
+                runCatching {
+                    val document =
+                        DocumentBuilderFactory.newInstance().apply {
+                            isNamespaceAware = true
+                            setFeature("http://apache.org/xml/features/disallow-doctype-decl", true)
+                            setFeature("http://xml.org/sax/features/external-general-entities", false)
+                            setFeature("http://xml.org/sax/features/external-parameter-entities", false)
+                        }.newDocumentBuilder().parse(manifestFile)
+                    document.documentElement
+                        ?.getAttribute("package")
+                        ?.takeIf { it.isNotBlank() }
+                }.getOrNull()
+            }
     }
 
     fun getManifestFile() = File(getExplodedAarRootDir(), "AndroidManifest.xml")

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/plugin/AgpCompatibilityMatrixTest.kt

@@ -102,9 +102,10 @@ class AgpCompatibilityMatrixTest {
         File(projectDir, "local.properties").writeText("sdk.dir=$androidSdk\n")
         // Stands in for the RN app project. It has to be a real `com.android.application` because
         // the brownfield plugin wires into AGP's own app-side tasks; the extra registrations cover
-        // the tasks the React Native Gradle plugin would otherwise contribute. Empty registrations
-        // are enough: this test is about AGP API compatibility, not about what those tasks produce.
-        File(projectDir, "app").mkdirs()
+        // the tasks the React Native Gradle plugin would otherwise contribute. The bundle tasks need
+        // their `jsBundleDir`/`resourcesDir` outputs, which the plugin wires as generated sources;
+        // the rest can stay empty, since this test is about AGP API compatibility.
+        writeRNBundleTaskStubs(File(projectDir, "app").apply { mkdirs() })
         File(projectDir, "app/build.gradle.kts").writeText(
             """
             plugins {
@@ -116,11 +117,8 @@ class AgpCompatibilityMatrixTest {
                 compileSdk = 34
             }
 
-            listOf(
-                "generateAutolinkingPackageList",
-                "createBundleDebugJsAndAssets",
-                "createBundleReleaseJsAndAssets",
-            ).forEach { name -> tasks.register(name) }
+            tasks.register("generateAutolinkingPackageList")
+            apply(from = "$RN_BUNDLE_TASK_STUBS_SCRIPT")
             """.trimIndent(),
         )
 

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/plugin/LegacyConsumerConfigurationTest.kt

@@ -64,10 +64,12 @@ class LegacyConsumerConfigurationTest {
             """.trimIndent(),
         )
         File(projectDir, "local.properties").writeText("sdk.dir=$androidSdk\n")
-        // ArtifactsResolver looks for an `app` project; an empty stub is enough, this test is about
-        // the task container, not discovery.
-        File(projectDir, "app").mkdirs()
-        File(projectDir, "app/build.gradle.kts").writeText("")
+        // ArtifactsResolver looks for an `app` project. It only needs the RN bundle tasks whose
+        // outputs the plugin wires as generated sources; this test is about the task container,
+        // not discovery.
+        val appDir = File(projectDir, "app").apply { mkdirs() }
+        writeRNBundleTaskStubs(appDir)
+        File(appDir, "build.gradle.kts").writeText("apply(from = \"$RN_BUNDLE_TASK_STUBS_SCRIPT\")\n")
 
         // The `tasks.register("removeDependenciesFromModuleFile")` block below is verbatim from
         // the published setup docs. Do not "modernize" it — its whole purpose is to reproduce

package/gradle-plugin/brownfield/src/test/kotlin/com/callstack/react/brownfield/plugin/RNBundleTaskStubs.kt

@@ -0,0 +1,27 @@
+package com.callstack.react.brownfield.plugin
+
+import java.io.File
+
+internal const val RN_BUNDLE_TASK_STUBS_SCRIPT = "rn-bundle-task-stubs.gradle.kts"
+
+/**
+ * Writes a script plugin into [appDir] that stubs RNGP's `createBundle<Variant>JsAndAssets` tasks.
+ * The brownfield plugin wires their `jsBundleDir`/`resourcesDir` outputs as generated sources and
+ * fails fast when they are missing, so plain `tasks.register(name)` stubs are not enough.
+ * Apply it from the app build script with `apply(from = RN_BUNDLE_TASK_STUBS_SCRIPT)`.
+ */
+internal fun writeRNBundleTaskStubs(appDir: File) {
+    File(appDir, RN_BUNDLE_TASK_STUBS_SCRIPT).writeText(
+        """
+        abstract class StubBundleTask : DefaultTask() {
+            @get:OutputDirectory abstract val jsBundleDir: DirectoryProperty
+            @get:OutputDirectory abstract val resourcesDir: DirectoryProperty
+        }
+
+        listOf(
+            "createBundleDebugJsAndAssets",
+            "createBundleReleaseJsAndAssets",
+        ).forEach { name -> tasks.register<StubBundleTask>(name) }
+        """.trimIndent(),
+    )
+}