@callstack/react-native-brownfield 4.0.0 → 4.1.0

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

@@ -1,20 +1,10 @@
 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(
@@ -22,53 +12,27 @@ object ManifestTaskProcessor {
         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()
-        }
+        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,17 @@
 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.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)
+        val resDirectories = aarLibraries.map { it.getResDir() }.filter { it.exists() }
 
-        if (!resourceGenTask.isPresent) {
-            throw TaskNotFound("Task $taskPath not found")
+        resDirectories.forEach { resDirectory ->
+            variant.sources.res?.addStaticSourceDirectory(resDirectory.path)
         }
-
-        variant.registerGeneratedResFolders(
-            project.files(aarLibraries.map { it.getResDir() }),
-        )
     }
 }

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 =