@callstack/react-native-brownfield 4.0.0 → 4.1.0

package/gradle-plugin/brownfield/config/detekt/detekt.yml

@@ -844,7 +844,7 @@ style:
     ignoredCharacters: []
   ThrowsCount:
     active: true
-    max: 2
+    max: 3
     excludeGuardClauses: false
   TrailingWhitespace:
     active: false

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

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

@@ -1,6 +1,6 @@
 package com.callstack.react.brownfield.expo.utils
 
-import com.android.build.gradle.LibraryExtension
+import com.android.build.api.dsl.LibraryExtension
 import org.gradle.api.Project
 import java.io.File
 
@@ -68,10 +68,7 @@ object LocalMavenUtils {
                 BrownfieldPublishingInfo(
                     groupId = groupId,
                     artifactId = artifactId,
-                    version = (
-                        targetProjectAndroidLibExt.defaultConfig.versionName
-                            ?: targetProject.version.toString()
-                    ),
+                    version = targetProject.version.toString(),
                 )
             )
         }

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

@@ -1,7 +1,7 @@
 package com.callstack.react.brownfield.plugin
 
+import com.android.build.api.dsl.LibraryExtension
 import com.android.build.api.variant.LibraryAndroidComponentsExtension
-import com.android.build.gradle.LibraryExtension
 import com.callstack.react.brownfield.shared.Logging
 import com.callstack.react.brownfield.utils.capitalized
 import org.gradle.api.Project
@@ -70,7 +70,6 @@ class ProjectConfigurations(private val project: Project) {
         val configuration = project.configurations.create(configName)
 
         configuration.extendsFrom(project.configurations.getByName("implementation"))
-        configuration.isVisible = false
         configuration.isTransitive = false
 
         val androidComponents = project.extensions.getByType(LibraryAndroidComponentsExtension::class.java)
@@ -96,9 +95,8 @@ class ProjectConfigurations(private val project: Project) {
         from: AttributeContainer,
         into: AttributeContainer,
     ) {
-        val value: T? = from.getAttribute(key)
-        if (value != null) {
-            into.attribute(key, value)
+        from.getAttribute(key)?.let {
+            into.attribute(key, it)
         }
     }
 

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

@@ -1,7 +1,7 @@
 package com.callstack.react.brownfield.plugin
 
-import com.android.build.gradle.LibraryExtension
-import com.android.build.gradle.api.LibraryVariant
+import com.android.build.api.variant.LibraryAndroidComponentsExtension
+import com.android.build.api.variant.LibraryVariant
 import com.callstack.react.brownfield.artifacts.ArtifactsResolver
 import com.callstack.react.brownfield.expo.ExpoPublishingHelper
 import com.callstack.react.brownfield.expo.utils.ExpoGradleProjectProjection
@@ -11,6 +11,7 @@ import com.callstack.react.brownfield.processors.JNILibsProcessor
 import com.callstack.react.brownfield.processors.ManifestTaskProcessor
 import com.callstack.react.brownfield.processors.ProguardProcessor
 import com.callstack.react.brownfield.processors.ResourceTaskProcessor
+import com.callstack.react.brownfield.processors.VariantHelper
 import com.callstack.react.brownfield.processors.VariantPackagesProperty
 import com.callstack.react.brownfield.processors.VariantTaskProvider
 import com.callstack.react.brownfield.shared.BaseProject
@@ -21,6 +22,7 @@ import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.DirectoryManager
 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.Plugin
 import org.gradle.api.Project
 import org.gradle.api.ProjectConfigurationException
@@ -65,11 +67,14 @@ class RNBrownfieldPlugin : Plugin<Project> {
 
         val variantTaskProvider = VariantTaskProvider(project)
 
-        /**
-         * Configure Tasks
-         */
-        project.extensions.getByType(LibraryExtension::class.java).libraryVariants.all { variant ->
+        val androidComponents = project.extensions.getByType(LibraryAndroidComponentsExtension::class.java)
+        androidComponents.onVariants { variant ->
             configureTasks(variant, artifacts, variantTaskProvider)
+
+            val aarLibraries = getAarLibraries(artifacts, variant.name)
+            ManifestTaskProcessor.process(variant, project, aarLibraries)
+            AssetTaskProcessor.process(variant, aarLibraries)
+            ResourceTaskProcessor.process(variant, aarLibraries)
         }
     }
 
@@ -124,48 +129,38 @@ class RNBrownfieldPlugin : Plugin<Project> {
         variantTaskProvider: VariantTaskProvider,
     ) {
         val variantName = variant.name
-        val capitalizedVariantName = variantName.replaceFirstChar(Char::titlecase)
+        val capitalizedVariantName = variantName.capitalized()
 
         /** =======  EXPLODE AAR  =========*/
         val explodeTask = ExplodeTaskProvider.getTask(variant, project, artifacts)
 
         /** =======  Pre<Variant>Build  =========*/
         variantTaskProvider.preBuildTaskByVariant(
-            variantName,
-            variant.buildType.name,
-            variant.buildType.isDebuggable,
+            variant,
             explodeTask,
         )
 
         val aarLibraries = getAarLibraries(artifacts, variantName)
 
+        /** =======  MERGE CLASSES  =========*/
+        val mergeClassesTask = variantTaskProvider.mergeClasses(aarLibraries, explodeTask, variantName)
+        VariantHelper.getAsmTransformTask(project, capitalizedVariantName).configureEach {
+            it.dependsOn(mergeClassesTask)
+        }
+
         /**
          * Flat IDs to be put into the variant property, required for RClass Transformer
          */
         val packageIDs = aarLibraries.map { it.getPackageName() }
         VariantPackagesProperty.getVariantPackagesProperty().put(variantName, packageIDs)
 
-        /** =======  MANIFEST MERGER  =========*/
-        ManifestTaskProcessor.process(variant, project, aarLibraries)
-
-        /** =======  GENERATE RESOURCES =========*/
-        ResourceTaskProcessor.process(variant, project, aarLibraries)
-
-        /** =======  GENERATE ASSETS ========= */
-        AssetTaskProcessor.process(variant, project, aarLibraries)
-
         /** ===== jniLibsProcessor ===== */
         val jniLibsProcessor = JNILibsProcessor(project)
-        jniLibsProcessor.processJniLibs(aarLibraries, variantName)
+        jniLibsProcessor.processJniLibs(aarLibraries, variant)
 
         /** ===== proguardProcessor ===== */
         val proguardProcessor = ProguardProcessor(project)
         val proguardRules = aarLibraries.map { it.getProguardRules() }
-        proguardProcessor.processConsumerFiles(proguardRules, capitalizedVariantName)
-        proguardProcessor.processGeneratedFiles(proguardRules, capitalizedVariantName)
-
-        /** ===== processDataBinding ===== */
-        val bundleTask = variantTaskProvider.bundleTaskProvider(project, variantName)
-        variantTaskProvider.processDataBinding(bundleTask, aarLibraries, variantName)
+        proguardProcessor.processFiles(proguardRules, variantName.capitalized(), explodeTask)
     }
 }

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

@@ -1,8 +1,9 @@
 package com.callstack.react.brownfield.plugin
 
+import com.android.build.api.dsl.LibraryExtension
 import com.android.build.api.variant.LibraryAndroidComponentsExtension
-import com.android.build.gradle.LibraryExtension
 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
@@ -42,14 +43,14 @@ object RNSourceSets {
         // Move the non-variant-specific configuration out of the loop
         androidExtension.sourceSets.named("main") { sourceSet ->
             // This path is not variant-specific, so it's added once here.
-            sourceSet.java.srcDir("${getModuleBuildDir()}/generated/autolinking/src/main/java")
+            sourceSet.java.directories.add("${getModuleBuildDir()}/generated/autolinking/src/main/java")
         }
 
-        // 2. Use the onVariants block to configure each variant
+        // 2. Use the onVariants block to wire RN bundle outputs via the Variant Sources API
         componentsExtension.onVariants { variant ->
             val variantName = variant.name
             val bundledAssetsVariantName =
-                Utils.getBundledAssetsVariantName(
+                VariantHelper.getBundledAssetsVariantName(
                     variantName = variantName,
                     buildTypeName = variant.buildType,
                     isDebuggable = variant.debuggable,
@@ -57,37 +58,24 @@ object RNSourceSets {
             val capitalizedBundledAssetsVariantName = bundledAssetsVariantName.capitalized()
             val appProject = getAppProject()
 
-            // 3. Lazily configure the 'variant-specific' source set using .named()
-            androidExtension.sourceSets.named(variantName) { sourceSet ->
-                val bundlePathSegments =
-                    listOf(
-                        // outputs for RN <= 0.81
-                        "createBundle${capitalizedBundledAssetsVariantName}JsAndAssets",
-                        // outputs for RN >= 0.82
-                        "react/$bundledAssetsVariantName",
-                    )
-                val updateResourcesPathSegment = Utils.getExpoUpdatesResourcesTaskName(variant.name)
-
-                val appBuildDir = getAppBuildDir()
-                sourceSet.assets.srcDirs(bundlePathSegments.map { "$appBuildDir/generated/assets/$it" })
-                sourceSet.res.srcDirs(bundlePathSegments.map { "$appBuildDir/generated/res/$it" })
-                if (extension.useStrippedSoFiles) {
-                    val capitalizedVariantName = variantName.capitalized()
-                    val libsDir = project.layout.projectDirectory.dir("libs$capitalizedVariantName")
-                    val copyTaskName = "copy${capitalizedVariantName}LibSources"
-                    sourceSet.jniLibs.srcDir(
-                        project.files(libsDir).builtBy(copyTaskName),
-                    )
-                }
-                if (Utils.hasExpoUpdates(appProject, variant.name)) {
-                    val updateResourcesTask = appProject.tasks.named(updateResourcesPathSegment)
-                    sourceSet.assets.srcDir(
-                        project.files("$appBuildDir/generated/assets/$updateResourcesPathSegment").builtBy(updateResourcesTask),
-                    )
-                    sourceSet.res.srcDir(
-                        project.files("$appBuildDir/generated/res/$updateResourcesPathSegment").builtBy(updateResourcesTask),
-                    )
-                }
+            val bundlePathSegments =
+                listOf(
+                    // outputs for RN <= 0.81
+                    "createBundle${capitalizedBundledAssetsVariantName}JsAndAssets",
+                    // outputs for RN >= 0.82
+                    "react/$bundledAssetsVariantName",
+                )
+
+            val appBuildDir = getAppBuildDir()
+            bundlePathSegments.forEach { segment ->
+                variant.sources.assets?.addStaticSourceDirectory("$appBuildDir/generated/assets/$segment")
+                variant.sources.res?.addStaticSourceDirectory("$appBuildDir/generated/res/$segment")
+            }
+
+            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")
             }
         }
     }

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

@@ -1,29 +1,17 @@
 package com.callstack.react.brownfield.processors
 
-import com.android.build.gradle.LibraryExtension
-import com.android.build.gradle.api.LibraryVariant
+import com.android.build.api.variant.LibraryVariant
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
-import org.gradle.api.Project
 
 object AssetTaskProcessor {
     fun process(
         variant: LibraryVariant,
-        project: Project,
         aarLibraries: List<AndroidArchiveLibrary>,
     ) {
-        val assetsTask = variant.mergeAssetsProvider.get()
+        val assetDirectories = aarLibraries.map { it.getAssetsDir() }.filter { it.exists() }
 
-        val androidExtension = project.extensions.getByName("android") as LibraryExtension
-        assetsTask.doFirst {
-            val filteredSourceSets =
-                androidExtension.sourceSets.filter { it.name == variant.name }
-
-            filteredSourceSets.forEach { sourceSet ->
-                val filteredAarLibs = aarLibraries.filter { it.getAssetsDir().exists() }
-                if (!filteredAarLibs.isEmpty()) {
-                    sourceSet.assets.srcDirs(filteredAarLibs.map { it.getAssetsDir() })
-                }
-            }
+        assetDirectories.forEach { assetDirectory ->
+            variant.sources.assets?.addStaticSourceDirectory(assetDirectory.path)
         }
     }
 }

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

@@ -1,9 +1,10 @@
 package com.callstack.react.brownfield.processors
 
-import com.android.build.gradle.api.LibraryVariant
+import com.android.build.api.variant.LibraryVariant
 import com.callstack.react.brownfield.shared.BundleTaskProvider
 import com.callstack.react.brownfield.shared.ExplodeAarTask
 import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+import com.callstack.react.brownfield.utils.Extension
 import com.callstack.react.brownfield.utils.capitalized
 import org.gradle.api.Project
 import org.gradle.api.Task
@@ -20,25 +21,23 @@ object ExplodeTaskProvider {
         val variantTaskProvider = VariantTaskProvider(project)
         val bundleProvider = BundleTaskProvider(variantTaskProvider)
         val capitalizedVariantName = variant.name.capitalized()
+        val projectExt = project.extensions.getByType(Extension::class.java)
 
         return project.tasks.register(
             "explode${capitalizedVariantName}Aar",
             ExplodeAarTask::class.java,
         ) { task ->
             task.variantName.set(variant.name)
-            task.minifyEnabled.set(variant.buildType.isMinifyEnabled)
 
             val finalArtifacts = mutableListOf<UnresolvedArtifactInfo>()
             artifacts.forEach { art ->
                 var artifactPath = art.file
                 if (art.isExpoPublishDependency != true) {
-                    val defaultTaskName = "bundle${capitalizedVariantName}Aar"
                     val dependencyProject = project.project(":${art.moduleName}")
-                    val bundleTaskProvider = bundleProvider.getBundleTask(dependencyProject, variant)
-                    val taskName = bundleTaskProvider?.name ?: defaultTaskName
-
+                    val bundleTaskProvider = bundleProvider.getBundleTask(dependencyProject, variant, projectExt.missingDimensionStrategies)
+                    val taskName = bundleTaskProvider.name
                     dependencyProject.tasks.findByName(taskName)?.let { task.dependsOn(it) }
-                    artifactPath = createArtifactFile(bundleTaskProvider?.get() as Task).absolutePath
+                    artifactPath = createArtifactFile(bundleTaskProvider.get()).absolutePath
                 }
 
                 finalArtifacts.add(

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 },
+        )
     }
 }