@callstack/react-native-brownfield 4.0.0 → 4.2.0

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

@@ -1,142 +1,134 @@
 package com.callstack.react.brownfield.processors
 
-import com.android.build.gradle.LibraryExtension
-import com.callstack.react.brownfield.exceptions.TaskNotFound
+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.tasks.Copy
-import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.DirectoryProperty
+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.PathSensitive
+import org.gradle.api.tasks.PathSensitivity
+import org.gradle.api.tasks.TaskAction
 import java.io.File
-
-class JNILibsProcessor(val project: Project) {
-    fun processJniLibs(
-        aarLibraries: Collection<AndroidArchiveLibrary>,
-        variantName: String,
-    ) {
-        val capitalizedVariantName = variantName.capitalized()
-        val taskName = "merge${capitalizedVariantName}JniLibFolders"
-        val mergeJniLibsTask = project.tasks.named(taskName)
-
-        if (!mergeJniLibsTask.isPresent) {
-            throw TaskNotFound("Task $taskName not found")
-        }
-
-        val androidExtension = project.extensions.getByName("android") as LibraryExtension
-        copySoLibsTask(variantName)
-
-        mergeJniLibsTask.configure {
-            it.doFirst {
-                val projectExt = project.extensions.getByType(Extension::class.java)
-                val existingJNILibs =
-                    listOf("arm64-v8a", "armeabi-v7a", "x86_64", "x86")
-                        .associateWith { mutableListOf<String>() }
-                        .toMutableMap()
-                for (archiveLibrary in aarLibraries) {
-                    val jniDir = archiveLibrary.getJniDir()
-                    processNestedLibs(jniDir.listFiles(), existingJNILibs)
-                    if (!projectExt.useStrippedSoFiles) {
-                        if (jniDir.exists()) {
-                            val filteredSourceSets =
-                                androidExtension.sourceSets.filter { sourceSet -> sourceSet.name == variantName }
-                            filteredSourceSets.forEach { sourceSet ->
-                                sourceSet.jniLibs.srcDir(
-                                    jniDir,
-                                )
-                            }
-                        }
-                    }
-                }
-                if (projectExt.useStrippedSoFiles) {
-                    copyStrippedSoLibs(variantName, existingJNILibs)
+import kotlin.collections.component1
+import kotlin.collections.component2
+
+/**
+ * Below contains a list of dynamic libs which we should not embed
+ * with the AAR as they are provided by the Gradle when AAR is
+ * consumed by the host App.
+ */
+val IGNORE_EMBEDDED_LIBS =
+    listOf(
+        "libc++_shared.so", "libfbjni.so", "libhermestooling.so",
+        "libhermesvm.so", "libimagepipeline.so", "libjsi.so",
+        "libnative-filters.so", "libnative-imagetranscoder.so",
+        "libreactnative.so",
+    )
+
+@CacheableTask
+abstract class ProcessAndCopyJniLibsTask : DefaultTask() {
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val aarJniDirs: ConfigurableFileCollection
+
+    @get:InputDirectory
+    @get:Optional
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val strippedLibsDir: DirectoryProperty
+
+    @get:Input
+    abstract val useStrippedSoFiles: Property<Boolean>
+
+    @get:OutputDirectory
+    abstract val outputDirectory: DirectoryProperty
+
+    @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)
                 }
             }
         }
-    }
-
-    private fun getStrippedLibsPath(variantName: String): Pair<File, File> {
-        val projectExt = project.extensions.getByType(Extension::class.java)
-        val appProject = project.rootProject.project(projectExt.appProjectName)
-        val appBuildDir = appProject.layout.buildDirectory.get()
-
-        val capitalizedVariant = variantName.capitalized()
-
-        val fromDir =
-            appBuildDir
-                .dir("intermediates/stripped_native_libs/$variantName/strip${capitalizedVariant}DebugSymbols/out/lib")
-                .asFile
-
-        val intoDir = project.rootProject.file("${project.name}/libs$capitalizedVariant")
-
-        return Pair(fromDir, intoDir)
-    }
-
-    private fun copySoLibsTask(variantName: String): TaskProvider<Copy> {
-        val capitalizedVariant = variantName.capitalized()
-        val projectExt = project.extensions.getByType(Extension::class.java)
-        val appProject = project.rootProject.project(projectExt.appProjectName)
-
-        val stripTask = ":${appProject.name}:strip${capitalizedVariant}DebugSymbols"
-        val codegenTask = ":${project.name}:generateCodegenSchemaFromJavaScript"
 
-        val (fromDir, intoDir) = getStrippedLibsPath(variantName)
-
-        return project.tasks.register("copy${capitalizedVariant}LibSources", Copy::class.java) {
-            it.dependsOn(stripTask, codegenTask)
-            it.from(fromDir)
-            it.into(intoDir)
-
-            it.include("**/libappmodules.so", "**/libreact_codegen_*.so")
-            projectExt.dynamicLibs.forEach { lib -> it.include("**/$lib") }
+        // 2. If using stripped files, copy targeted files from the stripped directory
+        if (useStrippedSoFiles.get() && strippedLibsDir.isPresent) {
+            copyStrippedSoLibs(outDir, existingJNILibs)
         }
     }
 
     private fun copyStrippedSoLibs(
-        variantName: String,
+        outDir: File,
         existingJNILibs: MutableMap<String, MutableList<String>>,
     ) {
-        val (fromDir, intoDir) = getStrippedLibsPath(variantName)
+        val fromDir = strippedLibsDir.get().asFile
+        if (!fromDir.exists()) return
 
-        existingJNILibs.forEach { (arch, libNames) ->
-            copyLibsForArchitecture(fromDir, intoDir, arch, libNames)
+        existingJNILibs.keys.forEach { arch ->
+            copyArchStrippedSoLibs(fromDir, outDir, arch)
         }
     }
 
-    private fun copyLibsForArchitecture(
+    private fun copyArchStrippedSoLibs(
         fromDir: File,
-        intoDir: File,
+        outDir: File,
         arch: String,
-        libNames: List<String>,
     ) {
         val sourceArchDir = File(fromDir, arch)
         if (!sourceArchDir.exists()) return
 
-        val destArchDir = File(intoDir, arch).apply { mkdirs() }
-
-        libNames.forEach { libName ->
-            copyLibFile(sourceArchDir, destArchDir, libName)
+        val destArchDir = File(outDir, arch).apply { mkdirs() }
+        sourceArchDir.listFiles()?.forEach { file ->
+            copyIfAllowed(file, destArchDir)
         }
     }
 
-    private fun copyLibFile(
-        sourceArchDir: File,
+    private fun copyIfAllowed(
+        file: File,
         destArchDir: File,
-        libName: String,
     ) {
-        val sourceFile = File(sourceArchDir, libName)
-        val destFile = File(destArchDir, libName)
-
-        if (sourceFile.exists()) {
-            try {
-                sourceFile.copyTo(destFile, overwrite = true)
-            } catch (e: java.io.IOException) {
-                Logging.log("Failed to copy $libName: ${e.message}")
-            }
+        val name = file.name
+        if (!matchesAllowedLib(name)) return
+
+        try {
+            file.copyTo(File(destArchDir, name), overwrite = true)
+        } catch (e: java.io.IOException) {
+            Logging.error("Failed to copy $name: ${e.message}", e.cause)
         }
     }
 
+    private fun matchesAllowedLib(name: String): Boolean {
+        val isCodegenLib = name.startsWith("libreact_codegen_") && name.endsWith(".so")
+        val isIgnoredLib = IGNORE_EMBEDDED_LIBS.any { lib -> name == lib || name.contains(lib) }
+        return name == "libappmodules.so" || isCodegenLib || !isIgnoredLib
+    }
+
     private fun processNestedLibs(
         files: Array<File>?,
         existingJNILibs: MutableMap<String, MutableList<String>>,
@@ -147,17 +139,50 @@ class JNILibsProcessor(val project: Project) {
 
             libFiles.forEach { file ->
                 if (file.name in libList) {
-                    deleteFile(file)
+                    file.delete()
                 } else {
                     libList.add(file.name)
                 }
             }
         }
     }
+}
 
-    private fun deleteFile(file: File) {
-        if (!file.delete()) {
-            Logging.log("Failed to delete: ${file.name}")
-        }
+class JNILibsProcessor(val project: Project) {
+    fun processJniLibs(
+        aarLibraries: Collection<AndroidArchiveLibrary>,
+        variant: LibraryVariant,
+    ) {
+        val variantName = variant.name
+        val capitalizedVariantName = variantName.capitalized()
+        val projectExt = project.extensions.getByType(Extension::class.java)
+        val appProject = project.rootProject.project(projectExt.appProjectName)
+
+        val processJniTask =
+            project.tasks.register("processCustomJniLibsFor$capitalizedVariantName", ProcessAndCopyJniLibsTask::class.java) {
+                it.useStrippedSoFiles.set(projectExt.useStrippedSoFiles)
+
+                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)
+            }
+
+        variant.sources.jniLibs?.addGeneratedSourceDirectory(
+            taskProvider = processJniTask,
+            wiredWith = { it.outputDirectory },
+        )
     }
 }

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

@@ -1,74 +1,38 @@
 package com.callstack.react.brownfield.processors
 
-import com.android.build.gradle.api.LibraryVariant
-import com.android.manifmerger.ManifestMerger2
-import com.android.manifmerger.ManifestProvider
-import com.android.manifmerger.MergingReport
-import com.android.utils.ILogger
-import com.callstack.react.brownfield.shared.GradleILogger
+import com.android.build.api.artifact.SingleArtifact
+import com.android.build.api.variant.LibraryVariant
+import com.callstack.react.brownfield.shared.MergeLibraryManifestTask
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
-import com.callstack.react.brownfield.utils.capitalized
-import org.apache.tools.ant.BuildException
 import org.gradle.api.Project
-import org.gradle.api.logging.Logger
-import java.io.BufferedWriter
-import java.io.File
-import java.io.FileOutputStream
-import java.io.OutputStreamWriter
 
 object ManifestTaskProcessor {
     fun process(
-        variant: LibraryVariant,
         project: Project,
+        variant: LibraryVariant,
         aarLibraries: List<AndroidArchiveLibrary>,
     ) {
-        val processManifestTask = variant.outputs.first().processManifestProvider.get()
-        val variantName = variant.name
-        processManifestTask.doLast {
-            val buildDir = project.layout.buildDirectory.get()
-            val manifestOutput =
-                project.file(
-                    "$buildDir/intermediates/merged_manifest/$variantName/process${variantName.capitalized()}Manifest/AndroidManifest.xml",
-                )
-
-            val inputManifests = aarLibraries.map { it.getManifestFile() }
-            mergeManifests(manifestOutput, inputManifests, manifestOutput, project.logger)
-        }
-    }
-
-    private fun mergeManifests(
-        mainManifestFile: File,
-        secondaryManifestFiles: List<File>,
-        outputFile: File,
-        logger: Logger,
-    ) {
-        val iLogger: ILogger = GradleILogger(logger)
-        val mergerInvoker = ManifestMerger2.newMerger(mainManifestFile, iLogger, ManifestMerger2.MergeType.LIBRARY)
-        val manifestProviders = mutableListOf<ManifestProvider>()
-
-        val filteredSecondaryManifests = secondaryManifestFiles.filter { it.exists() }
-        filteredSecondaryManifests.forEach { file ->
-            manifestProviders.add(
-                object : ManifestProvider {
-                    override fun getManifest(): File = file.absoluteFile
-
-                    override fun getName(): String = file.name
-                },
-            )
-        }
-
-        mergerInvoker.addManifestProviders(manifestProviders)
-        val mergingReport: MergingReport = mergerInvoker.merge()
-
-        if (mergingReport.result.isError) {
-            logger.error(mergingReport.reportString)
-            mergingReport.log(iLogger)
-            throw BuildException(mergingReport.reportString)
-        }
-
-        BufferedWriter(OutputStreamWriter(FileOutputStream(outputFile), "UTF-8")).use { writer ->
-            writer.append(mergingReport.getMergedDocument(MergingReport.MergedManifestKind.MERGED))
-            writer.flush()
-        }
+        val capitalizedVariantName = variant.name.replaceFirstChar(Char::titlecase)
+        val taskProvider =
+            project.tasks.register(
+                "transform${capitalizedVariantName}BrownfieldMergedManifest",
+                MergeLibraryManifestTask::class.java,
+            ) { task ->
+                task.variantName.set(variant.name)
+                task.namespace.set(variant.namespace)
+                task.manifestPlaceholders.set(variant.manifestPlaceholders)
+                task.aarManifestFiles.from(aarLibraries.map { it.getManifestFile() })
+
+                // The exploded AAR manifests are generated out of band, so keep the transform
+                // ordered after the variant-specific explode task without reaching for old APIs.
+                task.dependsOn("explode${capitalizedVariantName}Aar")
+            }
+
+        variant.artifacts
+            .use(taskProvider)
+            .wiredWithFiles(
+                MergeLibraryManifestTask::inputManifest,
+                MergeLibraryManifestTask::outputManifest,
+            ).toTransform(SingleArtifact.MERGED_MANIFEST)
     }
 }

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

@@ -5,19 +5,12 @@ import org.gradle.api.Project
 import java.io.File
 
 object MergeProcessor {
-    fun mergeClassesJarIntoClasses(
+    fun mergeClassesJarFilesIntoClasses(
         project: Project,
-        androidLibraries: Collection<AndroidArchiveLibrary>,
+        classJarFiles: Collection<File>,
         folderOut: File,
     ) {
-        val allJarFiles: MutableCollection<File> = ArrayList()
-        val filteredLibs = getFilteredAarLibs(androidLibraries)
-        filteredLibs.forEach {
-            allJarFiles.add(it.getClassesJarFile())
-        }
-
-        val filteredAllJarFiles = allJarFiles.filter { it.exists() }
-        filteredAllJarFiles.forEach { jarFile ->
+        classJarFiles.filter { it.exists() }.forEach { jarFile ->
             project.copy {
                 it.from(project.zipTree(jarFile))
                 it.into(folderOut)
@@ -25,28 +18,13 @@ object MergeProcessor {
         }
     }
 
-    fun mergeLibsIntoClasses(
+    fun mergeClassesJarIntoClasses(
         project: Project,
         androidLibraries: Collection<AndroidArchiveLibrary>,
-        jarFiles: Collection<File>,
-        outputDir: File,
+        folderOut: File,
     ) {
-        val allJarFiles: MutableCollection<File> = ArrayList()
-        val filteredLibs = getFilteredAarLibs(androidLibraries)
-        filteredLibs.forEach {
-            allJarFiles.addAll(it.getLocalJars())
-        }
-
-        val filteredJarFiles = jarFiles.filter { it.exists() }
-        filteredJarFiles.forEach { allJarFiles.add(it) }
-
-        allJarFiles.forEach { jarFile ->
-            project.copy {
-                it.from(project.zipTree(jarFile))
-                it.into(outputDir)
-                it.exclude("META-INF/")
-            }
-        }
+        val classesJarFiles = getFilteredAarLibs(androidLibraries).map { it.getClassesJarFile() }
+        mergeClassesJarFilesIntoClasses(project, classesJarFiles, folderOut)
     }
 
     private fun getFilteredAarLibs(androidLibraries: Collection<AndroidArchiveLibrary>): Collection<AndroidArchiveLibrary> {

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

@@ -1,61 +1,24 @@
 package com.callstack.react.brownfield.processors
 
-import com.callstack.react.brownfield.exceptions.TaskNotFound
-import com.callstack.react.brownfield.shared.Logging
+import com.callstack.react.brownfield.shared.ExplodeAarTask
 import com.callstack.react.brownfield.utils.Utils
 import org.gradle.api.Project
-import org.gradle.api.file.RegularFileProperty
 import org.gradle.api.tasks.TaskProvider
 import java.io.File
 
 class ProguardProcessor(val project: Project) {
-    fun processConsumerFiles(
+    fun processFiles(
         proguardRules: List<File>,
         capitalizedVariantName: String,
+        explodeTask: TaskProvider<ExplodeAarTask>,
     ) {
         val mergeTaskName = "merge${capitalizedVariantName}ConsumerProguardFiles"
-        val mergeFileTask = project.tasks.named(mergeTaskName)
-
-        if (!mergeFileTask.isPresent) {
-            throw TaskNotFound("Task $mergeTaskName not found")
-        }
-
-        mergeFileTask.get().doLast {
-            val outputFile = it.outputs.files.singleFile
-            doLast(proguardRules, outputFile)
-        }
-    }
-
-    fun processGeneratedFiles(
-        proguardRules: List<File>,
-        capitalizedVariantName: String,
-    ) {
-        val mergeGenerateProguardTask: TaskProvider<*>?
-        val mergeName = "merge${capitalizedVariantName}GeneratedProguardFiles"
-        mergeGenerateProguardTask = project.tasks.named(mergeName)
-
-        mergeGenerateProguardTask.get().doLast {
-            val outputFile = it.outputs.files.singleFile
-            doLast(proguardRules, outputFile)
-        }
-    }
-
-    private fun doLast(
-        files: List<File>,
-        outputFile: File,
-    ) {
-        try {
-            val outputFileToMerge =
-                @Suppress("USELESS_IS_CHECK")
-                if (outputFile is File) {
-                    outputFile
-                } else {
-                    (outputFile as? RegularFileProperty)?.get()?.asFile
-                        ?: error("Invalid output file")
-                }
-            Utils.mergeFiles(files, outputFileToMerge)
-        } catch (e: NoSuchFileException) {
-            Logging.log(e)
+        project.tasks.matching { it.name == mergeTaskName }.configureEach { task ->
+            task.dependsOn(explodeTask)
+            task.doLast {
+                val outputFile = task.outputs.files.singleFile
+                Utils.mergeFiles(proguardRules, outputFile)
+            }
         }
     }
 }

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

@@ -1,26 +1,64 @@
 package com.callstack.react.brownfield.processors
 
-import com.android.build.gradle.api.LibraryVariant
-import com.callstack.react.brownfield.exceptions.TaskNotFound
+import com.android.build.api.variant.LibraryVariant
+import com.callstack.react.brownfield.shared.ExplodeAarTask
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.capitalized
+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.tasks.CacheableTask
+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
+
+@CacheableTask
+abstract class CopyExplodedResTask : DefaultTask() {
+    @get:InputFiles
+    @get:PathSensitive(PathSensitivity.RELATIVE)
+    abstract val inputResDirs: ConfigurableFileCollection
+
+    @get:OutputDirectory
+    abstract val outputDirectory: DirectoryProperty
+
+    @TaskAction
+    fun run() {
+        val out = outputDirectory.get().asFile
+        out.deleteRecursively()
+        out.mkdirs()
+        inputResDirs.forEach { resDir ->
+            if (resDir.exists()) {
+                resDir.copyRecursively(out, overwrite = true)
+            }
+        }
+    }
+}
 
 object ResourceTaskProcessor {
     fun process(
-        variant: LibraryVariant,
         project: Project,
+        variant: LibraryVariant,
         aarLibraries: List<AndroidArchiveLibrary>,
+        explodeTask: TaskProvider<ExplodeAarTask>,
     ) {
-        val taskPath = "generate${variant.name.capitalized()}Resources"
-        val resourceGenTask = project.tasks.named(taskPath)
-
-        if (!resourceGenTask.isPresent) {
-            throw TaskNotFound("Task $taskPath not found")
-        }
+        val capitalized = variant.name.capitalized()
+        val resDirs = aarLibraries.map { it.getResDir() }
+        val copyResTask =
+            project.tasks.register(
+                "copyExplodedResFor$capitalized",
+                CopyExplodedResTask::class.java,
+            ) { task ->
+                task.inputResDirs.setFrom(resDirs)
+                task.dependsOn(explodeTask)
+            }
 
-        variant.registerGeneratedResFolders(
-            project.files(aarLibraries.map { it.getResDir() }),
+        variant.sources.res?.addGeneratedSourceDirectory(
+            copyResTask,
+            CopyExplodedResTask::outputDirectory,
         )
     }
 }