@callstack/react-native-brownfield 3.11.0 → 3.13.0

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

@@ -0,0 +1,149 @@
+package com.callstack.react.brownfield.plugin
+
+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.utils.Extension
+import com.callstack.react.brownfield.utils.Utils
+import com.callstack.react.brownfield.utils.capitalized
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.Copy
+import java.io.File
+
+object RNSourceSets {
+    private lateinit var project: Project
+    private lateinit var extension: Extension
+    private lateinit var androidExtension: LibraryExtension
+
+    fun configure(
+        project: Project,
+        extension: Extension,
+    ) {
+        this.project = project
+        this.extension = extension
+
+        androidExtension = this.project.extensions.getByType(LibraryExtension::class.java)
+
+        configureSourceSets()
+        configureTasks()
+    }
+
+    private fun getAppProject(): Project = project.rootProject.project(extension.appProjectName)
+
+    private fun getAppBuildDir() = getAppProject().layout.buildDirectory.get()
+
+    private fun getModuleBuildDir() = project.layout.buildDirectory.get()
+
+    private fun configureSourceSets() {
+        // 1. Get the 'androidComponents' extension for the new Variant API
+        val componentsExtension = project.extensions.getByType(LibraryAndroidComponentsExtension::class.java)
+
+        // 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")
+        }
+
+        // 2. Use the onVariants block to configure each variant
+        componentsExtension.onVariants { variant ->
+            val variantName = variant.name
+            val bundledAssetsVariantName =
+                Utils.getBundledAssetsVariantName(
+                    variantName = variantName,
+                    buildTypeName = variant.buildType,
+                    isDebuggable = variant.debuggable,
+                )
+            val capitalizedBundledAssetsVariantName = bundledAssetsVariantName.capitalized()
+
+            // 3. Lazily configure the 'variant-specific' source set using .named()
+            androidExtension.sourceSets.named(variantName) { sourceSet ->
+                // Paths are collected and added, similar to your improved version
+                val bundlePathSegments =
+                    listOf(
+                        // outputs for RN <= 0.81
+                        "createBundle${capitalizedBundledAssetsVariantName}JsAndAssets",
+                        // outputs for RN >= 0.82
+                        "react/$bundledAssetsVariantName",
+                        // expo update resources
+                        "create${capitalizedBundledAssetsVariantName}UpdatesResources",
+                    )
+
+                // Add the variant-specific generated asset and resource directories
+                val appBuildDir = getAppBuildDir()
+                sourceSet.assets.srcDirs(bundlePathSegments.map { "$appBuildDir/generated/assets/$it" })
+                sourceSet.res.srcDirs(bundlePathSegments.map { "$appBuildDir/generated/res/$it" })
+                sourceSet.jniLibs.srcDirs("libs${variantName.capitalized()}")
+            }
+        }
+    }
+
+    private fun getLibraryNameSpace(): String {
+        val nameSpace = androidExtension.namespace
+        return nameSpace
+            ?: throw NameSpaceNotFound("namespace must be defined in your android library build.gradle")
+    }
+
+    private fun patchRNEntryPoint(
+        task: Task,
+        path: String,
+    ) {
+        val rnEntryPointTaskName = "generateReactNativeEntryPoint"
+
+        /**
+         * If `generateReactNativeEntryPoint` task does not exist, we early return. It means
+         * the consumer library is running on RN version < 0.80
+         */
+        val rnEntryPointTask = getAppProject().tasks.findByName(rnEntryPointTaskName) ?: return
+
+        task.dependsOn(rnEntryPointTask)
+        val sourceFile =
+            File(
+                getModuleBuildDir().toString(),
+                "$path/com/facebook/react/ReactNativeApplicationEntryPoint.java",
+            )
+        task.doLast {
+            if (sourceFile.exists()) {
+                var content = sourceFile.readText()
+                val nameSpace = getLibraryNameSpace()
+
+                /**
+                 * We use look-ahead regex to replace any occurrences with Build.Config referenced via the old(app) package
+                 *
+                 * \b[\w.]+ → matches the old package
+                 * (?=\.BuildConfig) → only if it’s immediately followed by that suffix
+                 */
+                val regex = Regex("""\b[\w.]+(?=\.BuildConfig)""")
+                content = content.replace(regex, nameSpace)
+                sourceFile.writeText(content)
+            }
+        }
+    }
+
+    private fun configureTasks() {
+        project.tasks.register("copyAutolinkingSources", Copy::class.java) {
+            val path = "generated/autolinking/src/main/java"
+            val appBuildDir = getAppBuildDir()
+            it.dependsOn(":${getAppProject().name}:generateAutolinkingPackageList")
+            it.from("$appBuildDir/$path")
+            it.into("${getModuleBuildDir()}/$path")
+
+            patchRNEntryPoint(it, path)
+        }
+
+        project.tasks.named("preBuild").configure {
+            /**
+             * Ensure auto-generated sources are available before compilation.
+             *
+             * This hooks into the global `preBuild` task, so the dependency runs
+             * regardless of build variant. Use this only when the generated sources
+             * are identical for all variants (debug/release).
+             *
+             * If variant-specific
+             * files are needed, prefer `preDebugBuild` / `preReleaseBuild` under
+             * `VariantProcessor.processVariant`
+             */
+            it.dependsOn("copyAutolinkingSources")
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+package com.callstack.react.brownfield.processors
+
+import com.android.build.gradle.LibraryExtension
+import com.android.build.gradle.api.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 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() })
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+package com.callstack.react.brownfield.processors
+
+import com.android.build.gradle.api.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.capitalized
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.bundling.Zip
+import java.io.File
+
+object ExplodeTaskProvider {
+    fun getTask(
+        variant: LibraryVariant,
+        project: Project,
+        artifacts: List<UnresolvedArtifactInfo>,
+    ): TaskProvider<ExplodeAarTask> {
+        val variantTaskProvider = VariantTaskProvider(project)
+        val bundleProvider = BundleTaskProvider(variantTaskProvider)
+        val capitalizedVariantName = variant.name.capitalized()
+
+        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
+
+                    dependencyProject.tasks.findByName(taskName)?.let { task.dependsOn(it) }
+                    artifactPath = createArtifactFile(bundleTaskProvider?.get() as Task).absolutePath
+                }
+
+                finalArtifacts.add(
+                    UnresolvedArtifactInfo(
+                        art.moduleGroup,
+                        art.moduleName,
+                        art.moduleVersion,
+                        artifactPath,
+                        isExpoPublishDependency = art.isExpoPublishDependency,
+                    ),
+                )
+            }
+
+            task.inputArtifacts.set(finalArtifacts)
+        }
+    }
+
+    private fun createArtifactFile(bundle: Task): File {
+        val packageLibraryProvider = bundle as Zip
+        return File(packageLibraryProvider.destinationDirectory.get().asFile, packageLibraryProvider.archiveFileName.get())
+    }
+}

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

@@ -0,0 +1,165 @@
+package com.callstack.react.brownfield.processors
+
+import com.android.build.gradle.LibraryExtension
+import com.callstack.react.brownfield.exceptions.TaskNotFound
+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.Project
+import org.gradle.api.tasks.Copy
+import org.gradle.api.tasks.TaskProvider
+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
+        val copyTask = copySoLibsTask(variantName)
+
+        mergeJniLibsTask.configure {
+            it.dependsOn(copyTask)
+
+            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)
+                }
+            }
+        }
+    }
+
+    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") }
+        }
+    }
+
+    private fun copyStrippedSoLibs(
+        variantName: String,
+        existingJNILibs: MutableMap<String, MutableList<String>>,
+    ) {
+        val (fromDir, intoDir) = getStrippedLibsPath(variantName)
+
+        existingJNILibs.forEach { (arch, libNames) ->
+            copyLibsForArchitecture(fromDir, intoDir, arch, libNames)
+        }
+    }
+
+    private fun copyLibsForArchitecture(
+        fromDir: File,
+        intoDir: 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)
+        }
+    }
+
+    private fun copyLibFile(
+        sourceArchDir: 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}")
+            }
+        }
+    }
+
+    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) {
+                    deleteFile(file)
+                } else {
+                    libList.add(file.name)
+                }
+            }
+        }
+    }
+
+    private fun deleteFile(file: File) {
+        if (!file.delete()) {
+            Logging.log("Failed to delete: ${file.name}")
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+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.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,
+        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()
+        }
+    }
+}

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

@@ -0,0 +1,55 @@
+package com.callstack.react.brownfield.processors
+
+import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
+import org.gradle.api.Project
+import java.io.File
+
+object MergeProcessor {
+    fun mergeClassesJarIntoClasses(
+        project: Project,
+        androidLibraries: Collection<AndroidArchiveLibrary>,
+        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 ->
+            project.copy {
+                it.from(project.zipTree(jarFile))
+                it.into(folderOut)
+            }
+        }
+    }
+
+    fun mergeLibsIntoClasses(
+        project: Project,
+        androidLibraries: Collection<AndroidArchiveLibrary>,
+        jarFiles: Collection<File>,
+        outputDir: 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/")
+            }
+        }
+    }
+
+    private fun getFilteredAarLibs(androidLibraries: Collection<AndroidArchiveLibrary>): Collection<AndroidArchiveLibrary> {
+        return androidLibraries.filter { it.getExplodedAarRootDir().exists() }
+    }
+}

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

@@ -0,0 +1,61 @@
+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.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(
+        proguardRules: List<File>,
+        capitalizedVariantName: String,
+    ) {
+        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)
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+package com.callstack.react.brownfield.processors
+
+import com.android.build.gradle.api.LibraryVariant
+import com.callstack.react.brownfield.exceptions.TaskNotFound
+import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
+import com.callstack.react.brownfield.utils.capitalized
+import org.gradle.api.Project
+
+object ResourceTaskProcessor {
+    fun process(
+        variant: LibraryVariant,
+        project: Project,
+        aarLibraries: List<AndroidArchiveLibrary>,
+    ) {
+        val taskPath = "generate${variant.name.capitalized()}Resources"
+        val resourceGenTask = project.tasks.named(taskPath)
+
+        if (!resourceGenTask.isPresent) {
+            throw TaskNotFound("Task $taskPath not found")
+        }
+
+        variant.registerGeneratedResFolders(
+            project.files(aarLibraries.map { it.getResDir() }),
+        )
+    }
+}

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

@@ -0,0 +1,61 @@
+package com.callstack.react.brownfield.processors
+
+import com.callstack.react.brownfield.shared.BaseProject
+import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
+import com.callstack.react.brownfield.utils.DirectoryManager
+import com.callstack.react.brownfield.utils.capitalized
+import org.gradle.api.file.ConfigurableFileCollection
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+
+class VariantHelper : BaseProject() {
+    private fun getClassPathDirFiles(variantName: String): ConfigurableFileCollection {
+        return project.files(
+            "$buildDir/intermediates/javac/$variantName/compile${variantName.capitalized()}JavaWithJavac/classes",
+        )
+    }
+
+    fun classesMergeTaskDoFirst(
+        outputDir: File,
+        variantName: String,
+    ) {
+        val pathsToDelete = mutableListOf<Path>()
+        val javacDir = getClassPathDirFiles(variantName).first()
+        project.fileTree(outputDir).forEach { path ->
+            pathsToDelete.add(
+                Paths.get(outputDir.absolutePath).relativize(Paths.get(path.absolutePath)),
+            )
+        }
+        outputDir.deleteRecursively()
+        pathsToDelete.forEach { path ->
+            Files.deleteIfExists(Paths.get("$javacDir.absolutePath/$path"))
+        }
+    }
+
+    fun classesMergeTaskDoLast(
+        outputDir: File,
+        aarLibraries: Collection<AndroidArchiveLibrary>,
+        jarFiles: MutableList<File>,
+        variantName: String,
+        isMinifyEnabled: Boolean,
+    ) {
+        MergeProcessor.mergeClassesJarIntoClasses(project, aarLibraries, outputDir)
+        if (isMinifyEnabled) {
+            MergeProcessor.mergeLibsIntoClasses(project, aarLibraries, jarFiles, outputDir)
+        }
+        val javacDir = getClassPathDirFiles(variantName).first()
+        project.copy { copyTask ->
+            copyTask.from(outputDir)
+            copyTask.into(javacDir)
+            copyTask.exclude("META-INF/")
+        }
+
+        project.copy { copyTask ->
+            copyTask.from("${outputDir.absolutePath}/META-INF")
+            copyTask.into(DirectoryManager.getKotlinMetaDirectory(variantName))
+            copyTask.include("*.kotlin_module")
+        }
+    }
+}