@callstack/react-native-brownfield 6.0.1 → 6.1.1

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

@@ -1,28 +1,27 @@
 package com.callstack.react.brownfield.processors
 
 import com.android.build.api.variant.LibraryVariant
-import com.callstack.react.brownfield.shared.Logging
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.Extension
 import com.callstack.react.brownfield.utils.capitalized
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
+import org.gradle.api.Task
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.provider.ListProperty
-import org.gradle.api.provider.Property
 import org.gradle.api.tasks.CacheableTask
 import org.gradle.api.tasks.Input
-import org.gradle.api.tasks.InputDirectory
 import org.gradle.api.tasks.InputFiles
 import org.gradle.api.tasks.Optional
 import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.OutputFile
 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 java.io.File
-import kotlin.collections.component1
-import kotlin.collections.component2
 
 /**
  * Below contains a list of dynamic libs which we should not embed
@@ -37,126 +36,246 @@ val IGNORE_EMBEDDED_LIBS =
         "libreactnative.so",
     )
 
+private val ABIS = listOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
+
+private const val APP_MODULES_LIB = "libappmodules.so"
+
+internal enum class SkipReason { IGNORED, NOT_EMBEDDED }
+
+/**
+ * @property copies source file for each `<abi>/<name>` that goes into the AAR
+ * @property unmatchedDynamicLibs dynamicLibs entries that match no file in the app module's output
+ * @property skipped every lib name that no ABI copies, with why
+ * @property ignoredDynamicLibs dynamicLibs entries dropped because an ignore entry matches them
+ * @property excludedAbis ABIs the embedded AARs ship but the app module did not build
+ */
+internal data class JniLibsPlan(
+    val copies: Map<String, File>,
+    val unmatchedDynamicLibs: Set<String>,
+    val skipped: Map<String, SkipReason>,
+    val ignoredDynamicLibs: Set<String> = emptySet(),
+    val excludedAbis: Set<String> = emptySet(),
+)
+
+private fun isAppOwned(name: String) = name == APP_MODULES_LIB || (name.startsWith("libreact_codegen_") && name.endsWith(".so"))
+
+private fun isIgnored(
+    name: String,
+    ignoredLibs: List<String>,
+) = ignoredLibs.any { entry -> name == entry || name.contains(entry) }
+
+private fun libNames(dir: File?): List<String> = dir?.listFiles()?.filter { it.isFile }?.map { it.name }.orEmpty()
+
+/**
+ * Picks the .so files for the AAR: the app module's own libs, the libs the embedded libraries
+ * ship, and [dynamicLibs], minus [ignoredLibs]. Libs that only come from Maven dependencies stay
+ * out, because the host app gets them through the published POM.
+ */
+internal fun planJniLibs(
+    aarJniDirs: List<File>,
+    appNativeLibsDir: File?,
+    ignoredLibs: List<String>,
+    dynamicLibs: List<String>,
+): JniLibsPlan {
+    val copies = linkedMapOf<String, File>()
+    val matchedDynamicLibs = mutableSetOf<String>()
+    val candidates = mutableMapOf<String, SkipReason>()
+    val ignoredDynamicLibs = mutableSetOf<String>()
+
+    // An ABI folder without libappmodules.so crashes on devices that pick it, so follow the app
+    // module's ABIs (it may use abiFilters) and only fall back to all of them when it built none.
+    val appAbis = ABIS.filter { abi -> appNativeLibsDir?.let { File(it, abi).isDirectory } == true }
+    val abis = appAbis.ifEmpty { ABIS }
+    val excludedAbis = ABIS.filter { abi -> abi !in abis && aarJniDirs.any { File(it, abi).isDirectory } }.toSet()
+
+    for (abi in abis) {
+        val appAbiDir = appNativeLibsDir?.let { File(it, abi) }
+        val appNames = libNames(appAbiDir).toSet()
+
+        val embedded = linkedMapOf<String, File>()
+        aarJniDirs.forEach { jniDir ->
+            val abiDir = File(jniDir, abi)
+            libNames(abiDir).forEach { name -> embedded.putIfAbsent(name, File(abiDir, name)) }
+        }
+        val extra = dynamicLibs.filter { it in appNames }
+        matchedDynamicLibs += extra
+        ignoredDynamicLibs += extra.filter { isIgnored(it, ignoredLibs) }
+
+        val wanted = appNames.filter(::isAppOwned) + (embedded.keys + extra).filterNot { isIgnored(it, ignoredLibs) }
+        wanted.forEach { name ->
+            copies["$abi/$name"] = appAbiDir?.let { File(it, name) }?.takeIf { it.isFile } ?: embedded.getValue(name)
+        }
+
+        (appNames + embedded.keys).filterNot { it in wanted }.forEach { name ->
+            val reason = if (isIgnored(name, ignoredLibs)) SkipReason.IGNORED else SkipReason.NOT_EMBEDDED
+            // IGNORED wins: once a name is ignored in one ABI it is ignored everywhere.
+            if (candidates[name] != SkipReason.IGNORED) candidates[name] = reason
+        }
+    }
+
+    val copiedNames = copies.keys.map { it.substringAfter('/') }.toSet()
+    return JniLibsPlan(
+        copies = copies,
+        unmatchedDynamicLibs = dynamicLibs.toSet() - matchedDynamicLibs,
+        skipped = candidates.filterKeys { it !in copiedNames }.toSortedMap(),
+        ignoredDynamicLibs = ignoredDynamicLibs,
+        excludedAbis = excludedAbis,
+    )
+}
+
+internal fun planWarnings(plan: JniLibsPlan): List<String> =
+    plan.unmatchedDynamicLibs.map { entry ->
+        "Brownfield: dynamicLibs entry '$entry' matches no .so file in the app module's native output."
+    } +
+        plan.ignoredDynamicLibs.map { name ->
+            "Brownfield: dynamicLibs entry '$name' is not in the AAR because an ignore entry matches it. " +
+                "Remove that entry from ignoreEmbeddedLibs to embed it."
+        }
+
+/**
+ * One line naming the libs no embedded library ships, or null when there are none. Ignored libs
+ * are left out: they are skipped on purpose and would only add noise on every build.
+ */
+internal fun skippedSummary(
+    plan: JniLibsPlan,
+    reportFile: File?,
+): String? {
+    val names = plan.skipped.filterValues { it == SkipReason.NOT_EMBEDDED }.keys.sorted()
+    if (names.isEmpty()) return null
+    val details = reportFile?.let { " Details: ${it.absolutePath}" }.orEmpty()
+    return "Brownfield: left ${names.size} .so file(s) out of the AAR because no embedded library ships them: " +
+        "${names.joinToString(", ")}. If one comes from a Maven dependency, the host app gets it through the POM. " +
+        "If not (for example, your app module builds or ships it), add it to reactBrownfield.dynamicLibs.$details"
+}
+
+internal data class AppNativeLibsSource(val relativeDir: String, val producerTaskName: String)
+
+internal fun appNativeLibsSource(
+    variantName: String,
+    useStrippedSoFiles: Boolean,
+): AppNativeLibsSource {
+    val capitalized = variantName.capitalized()
+    return if (useStrippedSoFiles) {
+        val task = "strip${capitalized}DebugSymbols"
+        AppNativeLibsSource("intermediates/stripped_native_libs/$variantName/$task/out/lib", task)
+    } else {
+        val task = "merge${capitalized}NativeLibs"
+        AppNativeLibsSource("intermediates/merged_native_libs/$variantName/$task/out/lib", task)
+    }
+}
+
 @CacheableTask
 abstract class ProcessAndCopyJniLibsTask : DefaultTask() {
     @get:InputFiles
     @get:PathSensitive(PathSensitivity.RELATIVE)
     abstract val aarJniDirs: ConfigurableFileCollection
 
-    @get:InputDirectory
+    // @InputFiles rather than @InputDirectory: a variant without native code has no such dir,
+    // and @InputDirectory would fail validation before the task can run.
+    @get:InputFiles
     @get:Optional
     @get:PathSensitive(PathSensitivity.RELATIVE)
-    abstract val strippedLibsDir: DirectoryProperty
+    abstract val appNativeLibsDir: DirectoryProperty
 
     @get:Input
-    abstract val useStrippedSoFiles: Property<Boolean>
+    abstract val extraIgnoredLibs: ListProperty<String>
 
     @get:Input
-    abstract val extraIgnoredLibs: ListProperty<String>
+    abstract val dynamicLibs: ListProperty<String>
 
     @get:OutputDirectory
     abstract val outputDirectory: DirectoryProperty
 
+    // A declared output, so it is restored on cache hits when nothing is logged.
+    @get:OutputFile
+    abstract val skippedReportFile: RegularFileProperty
+
     @TaskAction
     fun execute() {
         val outDir = outputDirectory.get().asFile
-        // Clear out old data to ensure clean, reproducible builds
         outDir.deleteRecursively()
         outDir.mkdirs()
 
-        val existingJNILibs =
-            listOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
-                .associateWith { mutableListOf<String>() }
-                .toMutableMap()
-
-        // 1. Scan and process duplicate libs from AAR paths
-        aarJniDirs.forEach { jniDir ->
-            if (jniDir.exists()) {
-                processNestedLibs(jniDir.listFiles(), existingJNILibs)
-
-                // If not using stripped files, copy the unstripped ones directly to our output
-                if (!useStrippedSoFiles.get()) {
-                    jniDir.copyRecursively(outDir, overwrite = true)
-                }
-            }
+        val appDir = appNativeLibsDir.orNull?.asFile
+        if (appDir != null && !appDir.exists()) {
+            logger.warn(
+                "Brownfield: $appDir does not exist, so libappmodules.so and libreact_codegen_*.so " +
+                    "were not found and are not in the AAR.",
+            )
         }
 
-        // 2. If using stripped files, copy targeted files from the stripped directory
-        if (useStrippedSoFiles.get() && strippedLibsDir.isPresent) {
-            copyStrippedSoLibs(outDir, existingJNILibs)
-        }
-    }
+        val plan =
+            planJniLibs(
+                aarJniDirs.files.toList(),
+                appDir,
+                IGNORE_EMBEDDED_LIBS + extraIgnoredLibs.getOrElse(emptyList()),
+                dynamicLibs.getOrElse(emptyList()),
+            )
 
-    private fun copyStrippedSoLibs(
-        outDir: File,
-        existingJNILibs: MutableMap<String, MutableList<String>>,
-    ) {
-        val fromDir = strippedLibsDir.get().asFile
-        if (!fromDir.exists()) return
+        plan.copies.forEach { (path, source) -> source.copyTo(File(outDir, path), overwrite = true) }
 
-        existingJNILibs.keys.forEach { arch ->
-            copyArchStrippedSoLibs(fromDir, outDir, arch)
+        writeReport(plan)
+        val reportFile = skippedReportFile.get().asFile
+        skippedSummary(plan, reportFile)?.let { logger.lifecycle(it) }
+        plan.skipped.forEach { (name, reason) -> logger.info("Brownfield: skipped $name ($reason)") }
+        planWarnings(plan).forEach { logger.warn(it) }
+        if (plan.excludedAbis.isNotEmpty()) {
+            logger.info("Brownfield: left out ABIs the app module did not build: ${plan.excludedAbis.sorted().joinToString(", ")}")
         }
     }
 
-    private fun copyArchStrippedSoLibs(
-        fromDir: File,
-        outDir: File,
-        arch: String,
-    ) {
-        val sourceArchDir = File(fromDir, arch)
-        if (!sourceArchDir.exists()) return
-
-        val destArchDir = File(outDir, arch).apply { mkdirs() }
-        sourceArchDir.listFiles()?.forEach { file ->
-            copyIfAllowed(file, destArchDir)
-        }
+    private fun writeReport(plan: JniLibsPlan) {
+        val reportFile = skippedReportFile.get().asFile
+        reportFile.parentFile.mkdirs()
+        val lines =
+            if (plan.skipped.isEmpty()) {
+                listOf("No .so files were left out.")
+            } else {
+                listOfNotNull(skippedSummary(plan, null)) + plan.skipped.map { (name, reason) -> "$name: $reason" }
+            }
+        reportFile.writeText(lines.joinToString("\n", postfix = "\n"))
     }
+}
 
-    private fun copyIfAllowed(
-        file: File,
-        destArchDir: File,
-    ) {
-        val name = file.name
-        if (!matchesAllowedLib(name)) return
+internal fun wireAarJniDirs(
+    task: ProcessAndCopyJniLibsTask,
+    jniDirs: List<File>,
+    explodeTask: TaskProvider<out Task>,
+) {
+    // The dirs are plain paths, so Gradle can't infer who fills them; without this the task can
+    // run before the AARs are unpacked and drop every embedded lib.
+    task.aarJniDirs.setFrom(jniDirs)
+    task.aarJniDirs.builtBy(explodeTask)
+}
 
-        try {
-            file.copyTo(File(destArchDir, name), overwrite = true)
-        } catch (e: java.io.IOException) {
-            Logging.error("Failed to copy $name: ${e.message}", e.cause)
-        }
-    }
+internal fun configureProcessJniTask(
+    task: ProcessAndCopyJniLibsTask,
+    project: Project,
+    appProject: Project,
+    projectExt: Extension,
+    variantName: String,
+    jniDirs: List<File>,
+    explodeTask: TaskProvider<out Task>,
+) {
+    val source = appNativeLibsSource(variantName, projectExt.useStrippedSoFiles)
 
-    private fun matchesAllowedLib(name: String): Boolean {
-        val isCodegenLib = name.startsWith("libreact_codegen_") && name.endsWith(".so")
-        val ignoredLibs = IGNORE_EMBEDDED_LIBS + extraIgnoredLibs.getOrElse(emptyList())
-        val isIgnoredLib = ignoredLibs.any { lib -> name == lib || name.contains(lib) }
-        return name == "libappmodules.so" || isCodegenLib || !isIgnoredLib
-    }
+    task.extraIgnoredLibs.set(projectExt.ignoreEmbeddedLibs)
+    task.dynamicLibs.set(projectExt.dynamicLibs)
+    wireAarJniDirs(task, jniDirs, explodeTask)
+    task.appNativeLibsDir.set(appProject.layout.buildDirectory.dir(source.relativeDir))
+    task.skippedReportFile.set(project.layout.buildDirectory.file("reports/brownfield/$variantName/skipped-so.txt"))
 
-    private fun processNestedLibs(
-        files: Array<File>?,
-        existingJNILibs: MutableMap<String, MutableList<String>>,
-    ) {
-        files?.forEach { folder ->
-            val libFiles = folder.listFiles() ?: return@forEach
-            val libList = existingJNILibs[folder.name] ?: return@forEach
-
-            libFiles.forEach { file ->
-                if (file.name in libList) {
-                    file.delete()
-                } else {
-                    libList.add(file.name)
-                }
-            }
-        }
-    }
+    task.dependsOn(
+        "${appProject.path}:${source.producerTaskName}",
+        "${project.path}:generateCodegenSchemaFromJavaScript",
+    )
 }
 
 class JNILibsProcessor(val project: Project) {
     fun processJniLibs(
         aarLibraries: Collection<AndroidArchiveLibrary>,
         variant: LibraryVariant,
+        explodeTask: TaskProvider<out Task>,
     ) {
         val variantName = variant.name
         val capitalizedVariantName = variantName.capitalized()
@@ -165,25 +284,8 @@ class JNILibsProcessor(val project: Project) {
 
         val processJniTask =
             project.tasks.register("processCustomJniLibsFor$capitalizedVariantName", ProcessAndCopyJniLibsTask::class.java) {
-                it.useStrippedSoFiles.set(projectExt.useStrippedSoFiles)
-                it.extraIgnoredLibs.set(projectExt.ignoreEmbeddedLibs)
-
-                val jniDirs =
-                    aarLibraries.map { aarLib ->
-                        aarLib.getJniDir()
-                    }
-
-                it.aarJniDirs.setFrom(jniDirs)
-
-                val fromDirProvider =
-                    appProject.layout.buildDirectory.dir(
-                        "intermediates/stripped_native_libs/$variantName/strip${capitalizedVariantName}DebugSymbols/out/lib",
-                    )
-                it.strippedLibsDir.set(fromDirProvider)
-
-                val stripTaskPath = ":${appProject.name}:strip${capitalizedVariantName}DebugSymbols"
-                val codegenTaskPath = ":${project.name}:generateCodegenSchemaFromJavaScript"
-                it.dependsOn(stripTaskPath, codegenTaskPath)
+                val jniDirs = aarLibraries.map { aarLib -> aarLib.getJniDir() }
+                configureProcessJniTask(it, project, appProject, projectExt, variantName, jniDirs, explodeTask)
             }
 
         variant.sources.jniLibs?.addGeneratedSourceDirectory(

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"
     }