@callstack/react-native-brownfield 6.0.0 → 6.1.0

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

@@ -1,20 +1,39 @@
 package com.callstack.react.brownfield.processors
 
+import com.android.build.api.dsl.LibraryExtension
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
 import com.android.build.api.variant.LibraryVariant
+import com.android.ide.common.rendering.api.ResourceNamespace
+import com.android.ide.common.resources.MergeConsumer
+import com.android.ide.common.resources.ResourceMerger
+import com.android.ide.common.resources.ResourceMergerItem
+import com.android.ide.common.resources.ResourceSet
 import com.callstack.react.brownfield.shared.ExplodeAarTask
+import com.callstack.react.brownfield.shared.GradleILogger
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
+import com.callstack.react.brownfield.utils.Extension
 import com.callstack.react.brownfield.utils.capitalized
+import com.callstack.react.brownfield.utils.directoryGetter
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.ListProperty
 import org.gradle.api.tasks.CacheableTask
+import org.gradle.api.tasks.Input
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.OutputDirectory
 import org.gradle.api.tasks.PathSensitive
 import org.gradle.api.tasks.PathSensitivity
 import org.gradle.api.tasks.TaskAction
 import org.gradle.api.tasks.TaskProvider
+import org.w3c.dom.Element
+import org.w3c.dom.Node
+import java.io.File
+import javax.xml.parsers.DocumentBuilderFactory
+import javax.xml.transform.TransformerFactory
+import javax.xml.transform.dom.DOMSource
+import javax.xml.transform.stream.StreamResult
 
 @CacheableTask
 abstract class CopyExplodedResTask : DefaultTask() {
@@ -22,23 +41,183 @@ abstract class CopyExplodedResTask : DefaultTask() {
     @get:PathSensitive(PathSensitivity.RELATIVE)
     abstract val inputResDirs: ConfigurableFileCollection
 
+    /** The module's own resources, which win over every library's, as an app's do over its dependencies. */
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val moduleResDirs: ConfigurableFileCollection
+
+    /** `type/name` of the module's `resValue`s, which also win over every library's. */
+    @get:Input
+    abstract val moduleResValues: ListProperty<String>
+
+    /** The first library wins on a duplicate, so the order is part of the input. */
+    @get:Input
+    abstract val libraryOrder: ListProperty<String>
+
     @get:OutputDirectory
     abstract val outputDirectory: DirectoryProperty
 
+    /**
+     * Every exploded AAR keeps its values in `res/values/values.xml`, so libraries can't simply be
+     * copied over each other (#490), and keeping a resource twice in one dir fails the build (#125).
+     * AGP's own merger picks the winners, with the precedence it uses in an app: the module's own
+     * resources, then the first library.
+     */
     @TaskAction
     fun run() {
         val out = outputDirectory.get().asFile
         out.deleteRecursively()
         out.mkdirs()
-        inputResDirs.forEach { resDir ->
-            if (resDir.exists()) {
-                resDir.copyRecursively(out, overwrite = true)
-            }
+        val iLogger = GradleILogger(logger)
+        val moduleDirs = moduleResDirs.filter { it.exists() }.toList()
+        // 0 keeps every versioned resource. AGP applies the module's minSdk when it merges this dir.
+        val merger = ResourceMerger(0)
+        // Lowest priority first.
+        inputResDirs.filter { it.exists() }.reversed().forEachIndexed { index, resDir ->
+            merger.addDataSet(resourceSet("library$index", resDir, isLibrary = true, iLogger))
+        }
+        // One set per dir: two module dirs may override each other, like main and a flavor.
+        moduleDirs.forEachIndexed { index, resDir ->
+            merger.addDataSet(resourceSet("module$index", resDir, isLibrary = false, iLogger))
+        }
+        val writer = LibraryResWriter(moduleDirs, moduleResValues.get().toSet())
+        merger.mergeData(writer, false)
+        writer.messages.forEach { logger.warn("Brownfield: $it") }
+        writer.writeTo(out)
+    }
+
+    private fun resourceSet(
+        name: String,
+        resDir: File,
+        isLibrary: Boolean,
+        iLogger: GradleILogger,
+    ) = ResourceSet(name, ResourceNamespace.RES_AUTO, if (isLibrary) name else null, false, null).apply {
+        addSource(resDir)
+        loadFromFiles(iLogger)
+    }
+}
+
+/**
+ * Writes the merged library resources that the module doesn't define itself. AGP ranks this generated
+ * dir above the module's own res, so a library copy of a module resource would win there.
+ */
+private class LibraryResWriter(
+    private val moduleDirs: List<File>,
+    private val moduleResValues: Set<String>,
+) : MergeConsumer<ResourceMergerItem> {
+    private val files = mutableListOf<Pair<String, File>>()
+    private val values = sortedMapOf<String, MutableList<Node>>()
+    private val moduleAttrs = mutableMapOf<String, MutableSet<String>>()
+    private val styleableAttrWinners = mutableMapOf<String, MutableList<Node>>()
+    val messages = mutableListOf<String>()
+
+    override fun start(factory: DocumentBuilderFactory) = Unit
+
+    override fun end() = Unit
+
+    override fun removeItem(
+        removedItem: ResourceMergerItem,
+        replacedBy: ResourceMergerItem?,
+    ) = Unit
+
+    override fun ignoreItemInMerge(item: ResourceMergerItem) = false
+
+    override fun addItem(item: ResourceMergerItem) {
+        val folder = valuesFolder(item.qualifiers)
+        val source = item.sourceFile?.file
+        if (source != null && moduleDirs.any { source.startsWith(it) }) {
+            if (item.type.getName() == "attr") moduleAttrs.getOrPut(folder) { mutableSetOf() }.add(item.name)
+            return
         }
+        if (item.qualifiers.isEmpty() && "${item.type.getName()}/${item.name}" in moduleResValues) return
+        // An attr declared inside a styleable. The merger picked this one, so it becomes the definition.
+        if (item.ignoredFromDiskMerge) {
+            styleableAttrWinners.getOrPut(folder) { mutableListOf() }.add(item.value)
+            return
+        }
+        if (item.isFileBased && source != null) {
+            files.add("${source.parentFile.name}/${source.name}" to source)
+        } else {
+            values.getOrPut(folder) { mutableListOf() }.add(item.value)
+        }
+    }
+
+    fun writeTo(out: File) {
+        files.forEach { (path, file) -> file.copyTo(File(out, path)) }
+        val transformer = TransformerFactory.newInstance().newTransformer()
+        (values.keys + styleableAttrWinners.keys).toSortedSet().forEach { folder ->
+            val nodes = values[folder].orEmpty()
+            val document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument()
+            val root = document.createElement("resources")
+            document.appendChild(root)
+            nodes.forEach { root.appendChild(document.importNode(it, true)) }
+            styleableAttrWinners[folder].orEmpty().forEach { root.appendChild(document.importNode(it, true)) }
+            keepOneAttrDefinition(root, folder, moduleAttrs[folder].orEmpty())
+            val target = File(out, "$folder/$folder.xml")
+            target.parentFile.mkdirs()
+            transformer.transform(DOMSource(document), StreamResult(target))
+        }
+    }
+
+    /**
+     * AGP also registers an attr with a `format` (or enum/flag values) inside a styleable as its own
+     * `attr/<name>`, so one dir may define it only once. The merger's winner is written as a top-level
+     * attr, and every styleable copy, or one of an attr the module defines, becomes a plain reference.
+     */
+    private fun keepOneAttrDefinition(
+        root: Element,
+        folder: String,
+        moduleAttrs: Set<String>,
+    ) {
+        val defined = root.childElements().filter { it.tagName == "attr" }.associateBy { it.getAttribute("name") }
+        root.childElements()
+            .filter { it.tagName == "declare-styleable" }
+            .flatMap { it.childElements() }
+            .filter { it.tagName == "attr" && !it.getAttribute("name").startsWith("android:") }
+            .filter { definition(it).isNotEmpty() }
+            .forEach { attr ->
+                val name = attr.getAttribute("name")
+                val winner = defined[name]
+                if (winner == null && name !in moduleAttrs) return@forEach
+                if (winner != null && definition(winner) != definition(attr)) {
+                    messages.add("$folder: attr/$name is defined differently by two libraries, keeping the first")
+                }
+                attr.removeAttribute("format")
+                attr.childElements().forEach { attr.removeChild(it) }
+            }
+    }
+
+    /** Format and enum/flag values of an attr; empty for a plain reference. */
+    private fun definition(attr: Element): String =
+        attr.getAttribute("format") +
+            attr.childElements().joinToString { "${it.tagName}:${it.getAttribute("name")}=${it.getAttribute("value")}" }
+
+    private fun valuesFolder(qualifiers: String) = if (qualifiers.isEmpty()) "values" else "values-$qualifiers"
+
+    private fun Element.childElements(): List<Element> {
+        val children = childNodes
+        return (0 until children.length).map { children.item(it) }.filterIsInstance<Element>()
     }
 }
 
+/**
+ * Some libraries commit the drawables Metro generates for their JS assets to their own `res`, and
+ * the app's bundle writes the same files to `generated/res/react`. Both end up as generated res of
+ * this module, where AGP fails on the duplicates, so Metro's copy is treated as the module's own and
+ * wins. Reading the bundle task's output also orders the copy after it, and keys the cache on it.
+ */
+internal fun wireMetroResDir(
+    task: CopyExplodedResTask,
+    appProject: Project,
+    bundleTaskName: String,
+) {
+    val getter = directoryGetter(appProject, bundleTaskName, "getResourcesDir")
+    task.moduleResDirs.from(appProject.tasks.named(bundleTaskName).flatMap { getter.invoke(it) as DirectoryProperty })
+}
+
 object ResourceTaskProcessor {
+    private const val RES_VALUES_OFF_BY_DEFAULT_SINCE_AGP = 9
+
     fun process(
         project: Project,
         variant: LibraryVariant,
@@ -47,12 +226,22 @@ object ResourceTaskProcessor {
     ) {
         val capitalized = variant.name.capitalized()
         val resDirs = aarLibraries.map { it.getResDir() }
+        val buildDir = project.layout.buildDirectory.get().asFile
+        val appProject = project.rootProject.project(project.extensions.getByType(Extension::class.java).appProjectName)
         val copyResTask =
             project.tasks.register(
                 "copyExplodedResFor$capitalized",
                 CopyExplodedResTask::class.java,
             ) { task ->
                 task.inputResDirs.setFrom(resDirs)
+                if (resValuesEnabled(project)) {
+                    task.moduleResValues.set(variant.resValues.map { values -> values.keys.map { "${it.type}/${it.name}" } })
+                } else {
+                    task.moduleResValues.set(emptyList())
+                }
+                variant.sources.res?.static?.let { static -> task.moduleResDirs.from(static.map { layers -> layers.flatten() }) }
+                task.libraryOrder.set(aarLibraries.map { it.getExplodedAarRootDir().relativeTo(buildDir).invariantSeparatorsPath })
+                wireMetroResDir(task, appProject, VariantHelper.getMetroBundleTaskName(variant))
                 task.dependsOn(explodeTask)
             }
 
@@ -61,4 +250,12 @@ object ResourceTaskProcessor {
             CopyExplodedResTask::outputDirectory,
         )
     }
+
+    /** AGP warns on every read of `variant.resValues` while the feature is off, the default from AGP 9 on. */
+    private fun resValuesEnabled(project: Project): Boolean {
+        val explicit = project.extensions.getByType(LibraryExtension::class.java).buildFeatures.resValues
+        val default = project.providers.gradleProperty("android.defaults.buildfeatures.resvalues").orNull?.toBooleanStrictOrNull()
+        val agpMajor = project.extensions.getByType(LibraryAndroidComponentsExtension::class.java).pluginVersion.major
+        return explicit ?: default ?: (agpMajor < RES_VALUES_OFF_BY_DEFAULT_SINCE_AGP)
+    }
 }

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

@@ -1,5 +1,6 @@
 package com.callstack.react.brownfield.processors
 
+import com.android.build.api.variant.LibraryVariant
 import com.callstack.react.brownfield.utils.capitalized
 import org.gradle.api.Project
 import org.gradle.api.Task
@@ -39,6 +40,12 @@ object VariantHelper {
         }
     }
 
+    /** RNGP's `createBundle<Variant>JsAndAssets` task in the app project for [variant]. */
+    fun getMetroBundleTaskName(variant: LibraryVariant): String {
+        val bundledAssetsVariantName = getBundledAssetsVariantName(variant.name, variant.buildType, variant.debuggable)
+        return "createBundle${bundledAssetsVariantName.capitalized()}JsAndAssets"
+    }
+
     fun getExpoUpdatesResourcesTaskName(variantName: String): String {
         return "create${variantName.capitalized()}UpdatesResources"
     }

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

@@ -66,6 +66,10 @@ class VariantTaskProvider(val project: Project) {
             it.dependsOn(VariantHelper.getJavaCompileTask(project, capitalizedVariantName))
             it.variantName.set(variantName)
             it.inputClassesJars.from(aarLibraries.map { aarLibrary -> aarLibrary.getClassesJarFile() })
+            // libs/*.jar of each library (#489)
+            it.inputClassesJars.from(
+                aarLibraries.map { aarLibrary -> project.fileTree(aarLibrary.getLibsDir()) { tree -> tree.include("*.jar") } },
+            )
             it.outputDir.set(DirectoryManager.getMergeClassDirectory(variantName))
         }
     }

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

@@ -0,0 +1,31 @@
+package com.callstack.react.brownfield.shared
+
+import org.gradle.api.Project
+
+/**
+ * The variant-independent configurations that feed what the host app gets. A variant's own
+ * (`debugRuntimeClasspath`) would leak into every variant, since the published list is shared, and a
+ * tool's (lint, detekt) may exclude things the app still needs.
+ */
+private val PUBLISHED_CONFIG_NAMES = TRANSITIVE_DEPENDENCY_CONFIG_NAMES + "embed"
+
+/**
+ * The configuration-level excludes that keep a dependency out of the brownfield module's build.
+ * The plugin reads what embedded libraries declare, not what Gradle resolves, so without these an
+ * excluded dependency would still be published and the host app would resolve it. `:app`'s rules
+ * are not read: they describe the standalone RN app, which may drop things the host needs.
+ */
+internal fun gradleExcludes(project: Project): List<GradleExclude> =
+    project.configurations
+        .filter { it.name in PUBLISHED_CONFIG_NAMES }
+        .flatMap { it.excludeRules }
+        .map { GradleExclude(it.group, it.module) }
+        .distinct()
+
+/** One exclude rule. Gradle types both parts as non-null, but a rule without one leaves it null. */
+internal data class GradleExclude(val group: String?, val module: String?) {
+    fun matches(
+        groupId: String,
+        artifactId: String,
+    ) = (group == null || group == groupId) && (module == null || module == artifactId)
+}

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

@@ -54,6 +54,8 @@ abstract class MergeClassesTask : DefaultTask() {
             copyTask.from(mergedOutputDir)
             copyTask.into(javacDir)
             copyTask.exclude("META-INF/")
+            // Root module descriptor of a library's local jar, not a class of the AAR.
+            copyTask.exclude("module-info.class")
         }
 
         project.copy { copyTask ->

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

@@ -19,6 +19,7 @@ import org.gradle.api.publish.tasks.GenerateModuleMetadata
 internal fun mutatePomDependenciesNode(
     dependenciesNode: Node,
     dependencies: VersionMediatingDependencySet,
+    excludes: List<GradleExclude> = emptyList(),
     shouldExclude: (groupId: String, artifactId: String) -> Boolean,
 ) {
     dependenciesNode.children()
@@ -49,6 +50,21 @@ internal fun mutatePomDependenciesNode(
             childTags.forEach { (tagName, tagValue) ->
                 newDepNode.appendNode(tagName, tagValue)
             }
+            appendExclusions(newDepNode, excludes)
+        }
+    }
+}
+
+private fun appendExclusions(
+    dependencyNode: Node,
+    excludes: List<GradleExclude>,
+) {
+    if (excludes.isEmpty()) return
+    val exclusionsNode = dependencyNode.appendNode("exclusions")
+    excludes.forEach { exclude ->
+        exclusionsNode.appendNode("exclusion").apply {
+            appendNode("groupId", exclude.group ?: "*")
+            appendNode("artifactId", exclude.module ?: "*")
         }
     }
 }
@@ -69,6 +85,7 @@ internal fun resolveOrCreateDependenciesNode(root: Node): Node =
 internal fun mutateModuleJsonVariants(
     json: Map<*, *>,
     dependencies: VersionMediatingDependencySet,
+    excludes: List<GradleExclude> = emptyList(),
     shouldExclude: (groupId: String, artifactId: String) -> Boolean,
 ) {
     @Suppress("UNCHECKED_CAST")
@@ -98,6 +115,9 @@ internal fun mutateModuleJsonVariants(
                     dependencyToAdd.version?.let { version ->
                         put("version", mapOf("requires" to version))
                     }
+                    if (excludes.isNotEmpty()) {
+                        put("excludes", excludes.map { mapOf("group" to (it.group ?: "*"), "module" to (it.module ?: "*")) })
+                    }
                 },
             )
         }
@@ -116,6 +136,7 @@ internal fun mutateModuleJsonVariants(
 class PublishingMetadataInjector(private val project: Project) {
     private var dependencies = VersionMediatingDependencySet()
     private var shouldExclude: (groupId: String, artifactId: String) -> Boolean = { _, _ -> false }
+    private var excludes: List<GradleExclude> = emptyList()
     private var enabled = false
 
     init {
@@ -124,12 +145,16 @@ class PublishingMetadataInjector(private val project: Project) {
     }
 
     /** Supplies the dependencies to inject and enables injection on the hooks registered in [init]. */
-    fun configure(
+    internal fun configure(
         dependencies: VersionMediatingDependencySet,
         shouldExclude: (groupId: String, artifactId: String) -> Boolean,
+        excludes: List<GradleExclude>,
     ) {
         this.dependencies = dependencies
         this.shouldExclude = shouldExclude
+        // Gradle writes the module's excludes onto the dependencies it declares; these are injected
+        // later, so they need them too, or an excluded library could still arrive through one.
+        this.excludes = excludes
         this.enabled = true
     }
 
@@ -148,7 +173,7 @@ class PublishingMetadataInjector(private val project: Project) {
                     if (!moduleFile.exists()) return@forEach
 
                     val json = moduleFile.inputStream().use { JsonSlurper().parse(it) as Map<*, *> }
-                    mutateModuleJsonVariants(json, dependencies, shouldExclude)
+                    mutateModuleJsonVariants(json, dependencies, excludes, shouldExclude)
                     moduleFile.writer().use {
                         it.write(JsonOutput.prettyPrint(JsonOutput.toJson(json)))
                     }
@@ -172,7 +197,7 @@ class PublishingMetadataInjector(private val project: Project) {
 
                             val root = it.asNode()
                             val dependenciesNode = resolveOrCreateDependenciesNode(root)
-                            mutatePomDependenciesNode(dependenciesNode, dependencies, shouldExclude)
+                            mutatePomDependenciesNode(dependenciesNode, dependencies, excludes, shouldExclude)
                         }
                     }
             }

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/main/kotlin/com/callstack/react/brownfield/utils/Extension.kt

@@ -14,7 +14,9 @@ open class Extension {
     var appProjectName = "app"
 
     /**
-     * Whether to use stripped .so files.
+     * Whether to take the .so files from the app module's stripped or unstripped native output. It
+     * does not change which .so files are embedded. AGP still strips the AAR's native libs when it
+     * packages the library.
      *
      * Default is `true`.
      */
@@ -54,6 +56,17 @@ open class Extension {
      */
     var ignoreEmbeddedLibs = listOf<String>()
 
+    /**
+     * Exact .so file names, taken from the app module's native output, to embed in the AAR on top
+     * of the app's own libs and the embedded libraries' libs. Use it for a .so the host app cannot
+     * get any other way: one the app module builds or ships itself, or one from a dependency the
+     * published AAR does not declare.
+     *
+     * Provide in this format:
+     * listOf("libmmkv.so")
+     */
+    var dynamicLibs = listOf<String>()
+
     /**
      * Whether to publish embedded native modules' third-party dependencies into the generated POM
      * and Gradle Module Metadata, so consuming apps resolve them instead of declaring them by hand.

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

@@ -0,0 +1,40 @@
+package com.callstack.react.brownfield.utils
+
+import org.gradle.api.GradleException
+import org.gradle.api.Project
+import org.gradle.api.file.DirectoryProperty
+import java.lang.reflect.Method
+
+/**
+ * Finds `taskName`'s `getterName()` that returns a `DirectoryProperty`. 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 the property, isn't there, this fails the build with a
+ * clear message instead of silently producing an empty or stale directory.
+ */
+internal fun directoryGetter(
+    appProject: Project,
+    taskName: String,
+    getterName: String,
+): Method {
+    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."
+    }
+    return getter
+}

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

@@ -7,6 +7,7 @@ import org.junit.jupiter.api.io.TempDir
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.MethodSource
 import java.io.File
+import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 
 /**
@@ -39,12 +40,19 @@ class AgpCompatibilityMatrixTest {
         // `--dry-run` still runs configuration in full — variant callbacks, source set wiring, task
         // graph construction — which is where every AGP API the plugin touches is exercised. It just
         // skips the task actions, which would need a real RN app to produce anything meaningful.
-        GradleRunner.create()
-            .withProjectDir(projectDir)
-            .withPluginClasspath(pluginClasspathFor(agpVersion))
-            .withArguments("assembleDebug", "--dry-run", "--stacktrace")
-            .forwardOutput()
-            .build()
+        val result =
+            GradleRunner.create()
+                .withProjectDir(projectDir)
+                .withPluginClasspath(pluginClasspathFor(agpVersion))
+                .withArguments("assembleDebug", "--dry-run", "--stacktrace")
+                .forwardOutput()
+                .build()
+
+        // AGP 9 turns resValues off by default and warns on every read of variant.resValues.
+        assertFalse(
+            result.output.contains("Accessing value resValues"),
+            "the plugin reads variant.resValues although the feature is disabled",
+        )
     }
 
     @Test

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

@@ -0,0 +1,28 @@
+package com.callstack.react.brownfield.plugin
+
+import com.callstack.react.brownfield.shared.gradleExcludes
+import org.gradle.testfixtures.ProjectBuilder
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.io.TempDir
+import java.io.File
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class HardExcludePredicateTest {
+    @TempDir
+    lateinit var tempDir: File
+
+    @Test
+    fun `never publishes what the brownfield module excludes, or its own subprojects`() {
+        val root = ProjectBuilder.builder().withName("MyApp").withProjectDir(tempDir).build()
+        val lib = ProjectBuilder.builder().withName("brownfieldlib").withParent(root).build()
+        lib.configurations.create("implementation")
+        lib.configurations.all { it.exclude(mapOf("group" to "com.caverock", "module" to "androidsvg")) }
+
+        val excluded = hardExcludePredicate(lib, null, emptyList(), emptyList(), gradleExcludes(lib))
+
+        assertTrue(excluded("com.caverock", "androidsvg"))
+        assertTrue(excluded("MyApp", "react-native-screens"))
+        assertFalse(excluded("androidx.core", "core-ktx"))
+    }
+}