@callstack/react-native-brownfield 4.0.0 → 4.2.0

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

@@ -1,61 +1,66 @@
 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",
-        )
+import org.gradle.api.Project
+import org.gradle.api.Task
+import org.gradle.api.tasks.TaskCollection
+
+object VariantHelper {
+    fun getAsmTransformTaskName(capitalizedVariantName: String): String {
+        return "transform${capitalizedVariantName}ClassesWithAsm"
     }
 
-    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)),
-            )
+    fun getBundledAssetsVariantName(
+        variantName: String?,
+        buildTypeName: String?,
+        isDebuggable: Boolean,
+    ): String {
+        require(!variantName.isNullOrEmpty()) {
+            "getBundledAssetsVariantName: Variant name cannot be empty"
         }
-        outputDir.deleteRecursively()
-        pathsToDelete.forEach { path ->
-            Files.deleteIfExists(Paths.get("$javacDir.absolutePath/$path"))
+
+        require(!buildTypeName.isNullOrEmpty()) {
+            "getBundledAssetsVariantName: Build Type cannot be empty"
         }
-    }
 
-    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)
+        if (!isDebuggable) {
+            return variantName
         }
-        val javacDir = getClassPathDirFiles(variantName).first()
-        project.copy { copyTask ->
-            copyTask.from(outputDir)
-            copyTask.into(javacDir)
-            copyTask.exclude("META-INF/")
+
+        if (variantName == buildTypeName) {
+            return "release"
         }
 
-        project.copy { copyTask ->
-            copyTask.from("${outputDir.absolutePath}/META-INF")
-            copyTask.into(DirectoryManager.getKotlinMetaDirectory(variantName))
-            copyTask.include("*.kotlin_module")
+        val capitalizedBuildTypeName = buildTypeName.capitalized()
+        return if (variantName.endsWith(capitalizedBuildTypeName)) {
+            "${variantName.removeSuffix(capitalizedBuildTypeName)}Release"
+        } else {
+            "release"
         }
     }
+
+    fun getExpoUpdatesResourcesTaskName(variantName: String): String {
+        return "create${variantName.capitalized()}UpdatesResources"
+    }
+
+    fun getKotlinCompileTask(
+        project: Project,
+        capitalizedVariantName: String,
+    ): TaskCollection<Task> {
+        return project.tasks.matching { it.name == "compile${capitalizedVariantName}Kotlin" }
+    }
+
+    fun getJavaCompileTask(
+        project: Project,
+        capitalizedVariantName: String,
+    ): TaskCollection<Task> {
+        return project.tasks.matching { it.name == "compile${capitalizedVariantName}JavaWithJavac" }
+    }
+
+    fun getAsmTransformTask(
+        project: Project,
+        capitalizedVariantName: String,
+    ): TaskCollection<Task> {
+        return project.tasks.matching { it.name == getAsmTransformTaskName(capitalizedVariantName) }
+    }
 }

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

@@ -1,8 +1,8 @@
 package com.callstack.react.brownfield.processors
 
-import com.android.build.gradle.internal.tasks.factory.dependsOn
-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.shared.MergeClassesTask
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
 import com.callstack.react.brownfield.utils.DirectoryManager
 import com.callstack.react.brownfield.utils.Extension
@@ -12,7 +12,6 @@ import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.UnknownTaskException
 import org.gradle.api.tasks.TaskProvider
-import java.io.File
 
 class VariantTaskProvider(val project: Project) {
     fun bundleTaskProvider(
@@ -28,77 +27,46 @@ class VariantTaskProvider(val project: Project) {
         }
     }
 
-    fun processDataBinding(
-        bundleTask: TaskProvider<Task>,
-        aarLibraries: Collection<AndroidArchiveLibrary>,
-        variantName: String,
-    ) {
-        bundleTask.configure { task ->
-            task.doLast {
-                aarLibraries.forEach {
-                    val dataBindingFolder = it.getDataBindingFolder()
-                    if (dataBindingFolder.exists()) {
-                        val filePath = getReBundleFilePath(dataBindingFolder.name, variantName)
-                        File(filePath).mkdirs()
-                        project.copy { copyTask ->
-                            copyTask.from(dataBindingFolder)
-                            copyTask.into(filePath)
-                        }
-                    }
-
-                    val dataBindingLogFolder = it.getDataBindingLogFolder()
-                    if (dataBindingLogFolder.exists()) {
-                        val filePath = getReBundleFilePath(dataBindingLogFolder.name, variantName)
-                        File(filePath).mkdirs()
-                        project.copy { copyTask ->
-                            copyTask.from(dataBindingLogFolder)
-                            copyTask.into(filePath)
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    private fun getReBundleFilePath(
-        folderName: String,
-        variantName: String,
-    ) = "${DirectoryManager.getReBundleDirectory(
-        variantName,
-    ).path}/$folderName"
-
     fun preBuildTaskByVariant(
-        variantName: String,
-        buildTypeName: String,
-        isVariantDebuggable: Boolean,
+        variant: LibraryVariant,
         explodeAarTask: TaskProvider<ExplodeAarTask>,
     ) {
-        val preBuildTaskPath = "pre${variantName.capitalized()}Build"
-        val preBuildTask = project.tasks.named(preBuildTaskPath)
-
-        if (!preBuildTask.isPresent) {
-            throw TaskNotFound("Can not find $preBuildTaskPath task")
-        }
-
-        preBuildTask.dependsOn(explodeAarTask)
-
+        val variantName = variant.name
         val bundledAssetsVariantName =
-            Utils.getBundledAssetsVariantName(
+            VariantHelper.getBundledAssetsVariantName(
                 variantName = variantName,
-                buildTypeName = buildTypeName,
-                isDebuggable = isVariantDebuggable,
+                buildTypeName = variant.buildType,
+                isDebuggable = variant.debuggable,
             )
         val capitalizedBundledAssetsVariantName = bundledAssetsVariantName.capitalized()
 
         val projectExt = project.extensions.getByType(Extension::class.java)
         val appProject = project.rootProject.project(projectExt.appProjectName)
-        preBuildTask.dependsOn("${appProject.path}:createBundle${capitalizedBundledAssetsVariantName}JsAndAssets")
 
-        if (Utils.isExpoProject(project)) {
-            val updatesResourcesTaskName = Utils.getExpoUpdatesResourcesTaskName(variantName)
-            if (Utils.hasExpoUpdates(appProject, variantName)) {
-                preBuildTask.dependsOn("${appProject.path}:$updatesResourcesTaskName")
-            }
+        val jsBundleTaskName = "${appProject.path}:createBundle${capitalizedBundledAssetsVariantName}JsAndAssets"
+
+        variant.lifecycleTasks.registerPreBuild(explodeAarTask, jsBundleTaskName)
+        if (Utils.isExpoProject(project) && Utils.hasExpoUpdates(appProject, variantName)) {
+            val updatesResourcesTaskName = VariantHelper.getExpoUpdatesResourcesTaskName(variantName)
+            variant.lifecycleTasks.registerPreBuild("${appProject.path}:$updatesResourcesTaskName")
+        }
+    }
+
+    fun mergeClasses(
+        aarLibraries: Collection<AndroidArchiveLibrary>,
+        explodeTasks: TaskProvider<ExplodeAarTask>,
+        variantName: String,
+    ): TaskProvider<MergeClassesTask> {
+        val capitalizedVariantName = variantName.capitalized()
+        val mergeClassesTaskName = "mergeClasses$capitalizedVariantName"
+
+        return project.tasks.register(mergeClassesTaskName, MergeClassesTask::class.java) {
+            it.dependsOn(explodeTasks)
+            it.dependsOn(VariantHelper.getKotlinCompileTask(project, capitalizedVariantName))
+            it.dependsOn(VariantHelper.getJavaCompileTask(project, capitalizedVariantName))
+            it.variantName.set(variantName)
+            it.inputClassesJars.from(aarLibraries.map { aarLibrary -> aarLibrary.getClassesJarFile() })
+            it.outputDir.set(DirectoryManager.getMergeClassDirectory(variantName))
         }
     }
 }

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

@@ -1,10 +1,10 @@
-@file:Suppress("DEPRECATION")
-
 package com.callstack.react.brownfield.shared
 
-import com.android.build.gradle.LibraryExtension
-import com.android.build.gradle.api.LibraryVariant
+import com.android.build.api.dsl.LibraryExtension
+import com.android.build.api.dsl.LibraryProductFlavor
+import com.android.build.api.variant.LibraryVariant
 import com.callstack.react.brownfield.processors.VariantTaskProvider
+import com.callstack.react.brownfield.utils.capitalized
 import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.tasks.TaskProvider
@@ -13,34 +13,79 @@ class BundleTaskProvider(private val variantTaskProvider: VariantTaskProvider) {
     fun getBundleTask(
         project: Project,
         variant: LibraryVariant,
-    ): TaskProvider<Task>? {
-        val androidExtension = project.extensions.getByType(LibraryExtension::class.java)
-
-        // Find the first variant in the library that matches our criteria
-        val matchedVariant =
-            androidExtension.libraryVariants.find { libraryVariant ->
-                // 1. Try Simple Match
-                if (libraryVariant.name == variant.name || libraryVariant.name == variant.buildType.name) {
-                    return@find true
-                }
+        missingDimensionStrategies: List<String>,
+    ): TaskProvider<Task> {
+        val taskName = resolveTaskName(project, variant, missingDimensionStrategies)
+        return variantTaskProvider.bundleTaskProvider(project, taskName)
+    }
+
+    private fun resolveTaskName(
+        project: Project,
+        variant: LibraryVariant,
+        missingDimensionStrategies: List<String>,
+    ): String {
+        val androidComponent = project.extensions.findByType(LibraryExtension::class.java) ?: return variant.name
 
-                // 2. Try Dimension Strategy Match
-                val flavor = variant.productFlavors.firstOrNull() ?: variant.mergedFlavor
-                val strategies =
-                    runCatching {
-                        androidExtension.productFlavors.getByName(flavor.name).missingDimensionStrategies
-                    }.getOrNull() ?: return@find false
+        for (buildType in androidComponent.buildTypes) {
+            if (buildType.name != variant.name && buildType.name != variant.buildType) {
+                continue
+            }
 
-                strategies.any { (dimension, strategy) ->
-                    val fallbacks = listOf(strategy.requested) + strategy.fallbacks
-                    val libFlavor = libraryVariant.productFlavors.firstOrNull() ?: libraryVariant.mergedFlavor
+            if (androidComponent.productFlavors.isEmpty()) {
+                return buildType.name.capitalized()
+            }
 
-                    dimension == libFlavor.dimension &&
-                        fallbacks.contains(libFlavor.name) &&
-                        variant.buildType.name == libraryVariant.buildType.name
+            val flavorNames = androidComponent.productFlavors.map { fl -> fl.name }
+            for (productFlavor in androidComponent.productFlavors) {
+                handleMissingDimensionStrategies(missingDimensionStrategies, project, flavorNames, productFlavor)
+                val flavorName = missingDimensionStrategies[1]
+                if (productFlavor.name != flavorName) {
+                    continue
                 }
+
+                return "${productFlavor.name.capitalized()}${buildType.name.capitalized()}"
             }
+        }
 
-        return matchedVariant?.let { variantTaskProvider.bundleTaskProvider(project, it.name) }
+        return variant.name
+    }
+
+    private fun handleMissingDimensionStrategies(
+        missingDimensionStrategies: List<String>,
+        project: Project,
+        flavorNames: List<String>,
+        productFlavor: LibraryProductFlavor,
+    ) {
+        if (missingDimensionStrategies.isEmpty()) {
+            throw MissingDimensionStrategiesException(getErrorMessage(project.name))
+        }
+
+        val dimension = missingDimensionStrategies[0]
+        if (productFlavor.dimension != dimension) {
+            throw DimensionMismatchException(
+                "Ensure the provided dimension matches the ${project.name}'s dimension. Required dimension: $dimension",
+            )
+        }
+
+        val flavorName = missingDimensionStrategies[1]
+        if (!flavorNames.contains(flavorName)) {
+            throw FlavorMismatchException(
+                "Ensure the provided flavor matches the ${project.name}'s flavor. Required flavor(s): $flavorNames",
+            )
+        }
+    }
+
+    private fun getErrorMessage(projectName: String): String {
+        return """
+            Provide `missingDimensionStrategies` for $projectName:
+            If using Expo, provide the `android.expo.missingDimensionStrategies` property from Brownfield Config.
+            If using Bare React Native, provide the `reactBrownfield.missingDimensionStrategies` property.
+            """.trimIndent()
     }
 }
+
+class MissingDimensionStrategiesException(message: String) : IllegalStateException(message)
+
+class DimensionMismatchException(message: String) : IllegalArgumentException(message)
+
+class FlavorMismatchException(message: String) : IllegalArgumentException(message)

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

@@ -38,7 +38,6 @@ object Constants {
     const val PROJECT_ID = "com.callstack.react.brownfield"
     const val PLUGIN_NAME = "react-brownfield"
 
-    const val RE_BUNDLE_FOLDER = "aar_rebundle"
     const val INTERMEDIATES_TEMP_DIR = PLUGIN_NAME
 
     val BROWNFIELD_EXPO_TRANSITIVE_DEPS_WHITELISTED_MODULES_FOR_DISCOVERY =

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

@@ -1,15 +1,15 @@
 package com.callstack.react.brownfield.shared
 
-import com.callstack.react.brownfield.processors.VariantHelper
 import com.callstack.react.brownfield.utils.AndroidArchiveLibrary
-import com.callstack.react.brownfield.utils.DirectoryManager
 import org.gradle.api.DefaultTask
 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.Internal
 import org.gradle.api.tasks.TaskAction
 
+@CacheableTask
 abstract class ExplodeAarTask : DefaultTask() {
     @get:Internal
     abstract val inputArtifacts: ListProperty<UnresolvedArtifactInfo>
@@ -17,25 +17,11 @@ abstract class ExplodeAarTask : DefaultTask() {
     @get:Input
     abstract val variantName: Property<String>
 
-    @get:Input
-    abstract val minifyEnabled: Property<Boolean>
-
     @TaskAction
     fun run() {
         val artifacts = inputArtifacts.get()
         val resolvedVariantName = variantName.get()
 
-        val variantHelper = VariantHelper()
-        variantHelper.project = project
-
-        // classes-merge
-        variantHelper.classesMergeTaskDoFirst(
-            DirectoryManager.getMergeClassDirectory(
-                resolvedVariantName,
-            ),
-            resolvedVariantName,
-        )
-
         val aarLibraries = mutableListOf<AndroidArchiveLibrary>()
         artifacts.forEach { art ->
             val artifactFile =
@@ -64,9 +50,5 @@ abstract class ExplodeAarTask : DefaultTask() {
                 it.into(zipFolder)
             }
         }
-
-        // classes-merge
-        val mergeClassesOutputDir = DirectoryManager.getMergeClassDirectory(resolvedVariantName)
-        variantHelper.classesMergeTaskDoLast(mergeClassesOutputDir, aarLibraries, mutableListOf(), resolvedVariantName, minifyEnabled.get())
     }
 }

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

@@ -5,7 +5,7 @@ import com.callstack.react.brownfield.shared.Constants.PLUGIN_NAME
 object Logging : BaseProject() {
     fun error(
         message: Any,
-        error: Throwable,
+        error: Throwable?,
     ) {
         project.logger.error(getFormattedMessage(message), error)
     }

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

@@ -0,0 +1,70 @@
+package com.callstack.react.brownfield.shared
+
+import com.callstack.react.brownfield.processors.MergeProcessor
+import com.callstack.react.brownfield.utils.DirectoryManager
+import com.callstack.react.brownfield.utils.capitalized
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.file.DirectoryProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.OutputDirectory
+import org.gradle.api.tasks.TaskAction
+import java.io.File
+import java.nio.file.Files
+import java.nio.file.Path
+import java.nio.file.Paths
+
+abstract class MergeClassesTask : DefaultTask() {
+    @get:Classpath
+    abstract val inputClassesJars: ConfigurableFileCollection
+
+    @get:Input
+    abstract val variantName: Property<String>
+
+    @get:OutputDirectory
+    abstract val outputDir: DirectoryProperty
+
+    @TaskAction
+    fun run() {
+        val resolvedVariantName = variantName.get()
+        val mergedOutputDir = outputDir.get().asFile
+        val javacDir = getClassPathDir(resolvedVariantName)
+        val pathsToDelete = mutableListOf<Path>()
+
+        if (mergedOutputDir.exists()) {
+            project.fileTree(mergedOutputDir).forEach { path ->
+                pathsToDelete.add(
+                    Paths.get(mergedOutputDir.absolutePath).relativize(Paths.get(path.absolutePath)),
+                )
+            }
+        }
+
+        mergedOutputDir.deleteRecursively()
+        pathsToDelete.forEach { path ->
+            Files.deleteIfExists(javacDir.toPath().resolve(path))
+        }
+
+        MergeProcessor.mergeClassesJarFilesIntoClasses(project, inputClassesJars.files, mergedOutputDir)
+
+        project.copy { copyTask ->
+            copyTask.from(mergedOutputDir)
+            copyTask.into(javacDir)
+            copyTask.exclude("META-INF/")
+        }
+
+        project.copy { copyTask ->
+            copyTask.from(File(mergedOutputDir, "META-INF"))
+            copyTask.into(DirectoryManager.getKotlinMetaDirectory(resolvedVariantName))
+            copyTask.include("*.kotlin_module")
+        }
+    }
+
+    private fun getClassPathDir(variantName: String): File {
+        val buildDirectory = project.layout.buildDirectory.get().asFile
+        return project.file(
+            "$buildDirectory/intermediates/javac/$variantName/compile${variantName.capitalized()}JavaWithJavac/classes",
+        )
+    }
+}