@callstack/react-native-brownfield 3.12.0 → 3.13.1

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

@@ -0,0 +1,100 @@
+package com.callstack.react.brownfield.expo.utils
+
+import io.github.g00fy2.versioncompare.Version
+
+/**
+ * A set that stores DependencyInfo objects based only on their groupId and artifactId.
+ * When adding a new dependency with the same groupId and artifactId,
+ * it compares the versions and keeps the one with the higher version.
+ */
+open class VersionMediatingDependencySet : Iterable<DependencyInfo> {
+    private var backingMap =
+        mutableMapOf<Pair<String, String>, DependencyInfo>()
+
+    val size: Int get() = backingMap.size
+
+    fun contains(element: DependencyInfo): Boolean {
+        return backingMap.containsKey(element.groupId to element.artifactId)
+    }
+
+    fun add(element: DependencyInfo): Boolean {
+        val key = element.groupId to element.artifactId
+        val existing = backingMap[key]
+
+        if (existing == null) {
+            backingMap[key] = element
+            return true
+        }
+
+        // compare versions - replace if new version is greater (behavior of Gradle itself)
+        val existingVersion = existing.version
+        val newVersion = element.version
+
+        if (newVersion != null && (
+                existingVersion == null || compareVersions(
+                    newVersion,
+                    existingVersion,
+                ) > 0
+            )
+        ) {
+            backingMap[key] = element
+            return true
+        }
+
+        return false
+    }
+
+    fun forEach(action: (DependencyInfo) -> Unit) {
+        backingMap.values.forEach(action)
+    }
+
+    fun filter(predicate: (DependencyInfo) -> Boolean): VersionMediatingDependencySet {
+        backingMap =
+            backingMap.filter {
+                predicate(it.value)
+            }.toMutableMap()
+
+        return this
+    }
+
+    fun addAll(elements: Iterable<DependencyInfo>): Boolean {
+        var modified = false
+        elements.forEach { if (add(it)) modified = true }
+        return modified
+    }
+
+    fun removeAll(predicate: (it: DependencyInfo) -> Boolean): List<DependencyInfo?> {
+        val keysToBeRemoved = mutableSetOf<Pair<String, String>>()
+
+        forEach {
+            if (predicate(it)) {
+                keysToBeRemoved.add(it.groupId to it.artifactId)
+            }
+        }
+
+        return keysToBeRemoved.map {
+            backingMap.remove(it)
+        }
+    }
+
+    private fun compareVersions(
+        version1: String,
+        version2: String,
+    ): Int {
+        return Version(version1).compareTo(Version(version2))
+    }
+
+    override fun iterator(): Iterator<DependencyInfo> {
+        return backingMap.values.iterator()
+    }
+
+    companion object {
+        fun from(source: Iterable<DependencyInfo>): VersionMediatingDependencySet {
+            val instance = VersionMediatingDependencySet()
+
+            instance.addAll(source)
+
+            return instance
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+package com.callstack.react.brownfield.plugin
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.artifacts.DependencyResolutionListener
+import org.gradle.api.artifacts.ResolvableDependencies
+import org.gradle.api.internal.artifacts.dependencies.DefaultProjectDependency
+
+/**
+ * The goal of this class is to find the project dependencies
+ * either local or remote and link to the Aar for code hints and supports.
+ *
+ * It does not embed anything to the Aar.
+ */
+class CustomDependencyResolver(
+    private val project: Project,
+    private val configuration: Configuration,
+) : DependencyResolutionListener {
+    private fun getCompileOnlyConfigName(configurationName: String): String {
+        val configSuffix = ProjectConfigurations.CONFIG_SUFFIX
+        if (configurationName.endsWith(configSuffix)) {
+            val configName = configurationName.dropLast(configSuffix.length)
+            return "${configName}CompileOnly"
+        } else {
+            return "compileOnly"
+        }
+    }
+
+    override fun beforeResolve(dependencies: ResolvableDependencies) {
+        val configName = getCompileOnlyConfigName(configuration.name)
+        configuration.dependencies.forEach { dependency ->
+            if (dependency is DefaultProjectDependency) {
+                if (dependency.targetConfiguration == null) {
+                    dependency.targetConfiguration = "default"
+                }
+
+                val dependencyClone = dependency.copy()
+                dependencyClone.targetConfiguration = null
+
+                project.dependencies.add(configName, dependencyClone)
+            } else {
+                project.dependencies.add(configName, dependency)
+            }
+        }
+    }
+
+    override fun afterResolve(dependencies: ResolvableDependencies) {
+        project.gradle.removeListener(this)
+    }
+}

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

@@ -0,0 +1,107 @@
+package com.callstack.react.brownfield.plugin
+
+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
+import org.gradle.api.artifacts.Configuration
+import org.gradle.api.attributes.Attribute
+import org.gradle.api.attributes.AttributeContainer
+
+class ProjectConfigurations(private val project: Project) {
+    private val configurations: MutableCollection<Configuration> = mutableListOf()
+
+    companion object {
+        const val CONFIG_NAME = "embed"
+        const val CONFIG_SUFFIX = "Embed"
+    }
+
+    fun getConfigurations(): MutableCollection<Configuration> {
+        return configurations
+    }
+
+    /**
+     * Handles setting up the configuration for the project.
+     * It operates in the following manner:
+     *
+     * 1. creates main config
+     * 2. creates configs for buildTypes
+     * 3. creates configs for flavours
+     * 4. creates configs for flavours with buildTypes
+     */
+    fun configure() {
+        // create main configuration
+        createConfiguration(CONFIG_NAME)
+        val androidExtension = project.extensions.getByName("android") as LibraryExtension
+        createBuildTypesConfiguration(androidExtension)
+        createFlavorConfigurations(androidExtension)
+    }
+
+    /**
+     * creates configs for buildTypes
+     */
+    private fun createBuildTypesConfiguration(androidExtension: LibraryExtension) {
+        androidExtension.buildTypes.all { buildType ->
+            createConfiguration(getConfigName(buildType.name))
+        }
+    }
+
+    /**
+     * 1. creates configs for flavours
+     * 2. creates configs for flavours with buildTypes
+     */
+    private fun createFlavorConfigurations(androidExtension: LibraryExtension) {
+        androidExtension.productFlavors.all { flavor ->
+            createConfiguration(getConfigName(flavor.name))
+
+            androidExtension.buildTypes.all { buildType ->
+                val variantName = "${flavor.name}${buildType.name.capitalized()}"
+                createConfiguration(getConfigName(variantName))
+            }
+        }
+    }
+
+    /**
+     * creates configuration based on `configName`. Also attaches a resolution listener.
+     */
+    private fun createConfiguration(configName: String) {
+        Logging.log("creating configuration $configName ⌛️")
+        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)
+        androidComponents.onVariants { variant ->
+
+            val runtimeAttributes = variant.runtimeConfiguration.attributes
+            runtimeAttributes.keySet().forEach { key ->
+                copyAttribute(
+                    key,
+                    runtimeAttributes,
+                    configuration.attributes,
+                )
+            }
+        }
+
+        project.gradle.addListener(CustomDependencyResolver(project, configuration))
+        configurations.add(configuration)
+        Logging.log("created configuration $configName ✅")
+    }
+
+    private fun <T : Any> copyAttribute(
+        key: Attribute<T>,
+        from: AttributeContainer,
+        into: AttributeContainer,
+    ) {
+        from.getAttribute(key)?.let {
+            into.attribute(key, it)
+        }
+    }
+
+    private fun getConfigName(prefix: String): String {
+        return "${prefix}$CONFIG_SUFFIX"
+    }
+}

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

@@ -0,0 +1,131 @@
+package com.callstack.react.brownfield.plugin
+
+import com.android.build.api.instrumentation.AsmClassVisitorFactory
+import com.android.build.api.instrumentation.ClassContext
+import com.android.build.api.instrumentation.ClassData
+import com.android.build.api.instrumentation.FramesComputationMode
+import com.android.build.api.instrumentation.InstrumentationParameters
+import com.android.build.api.instrumentation.InstrumentationScope
+import com.android.build.api.variant.AndroidComponentsExtension
+import com.callstack.react.brownfield.processors.VariantPackagesProperty
+import com.callstack.react.brownfield.shared.BaseProject
+import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.Optional
+import org.objectweb.asm.ClassVisitor
+import org.objectweb.asm.commons.ClassRemapper
+import org.objectweb.asm.commons.Remapper
+import java.util.Collections
+import java.util.stream.Collectors
+
+/**
+ * Transforms R classes of all modules into a single
+ * R class. This avoid duplicates issues as each module
+ * can have it's own R class, so this redirects all
+ * references to a single R class.
+ */
+object RClassTransformer : BaseProject() {
+    fun registerASMTransformation() {
+        val components = project.extensions.getByType(AndroidComponentsExtension::class.java)
+        val variantPackagesProperty = VariantPackagesProperty.getVariantPackagesProperty()
+
+        components.onVariants(components.selector().all()) { variant ->
+            variant.instrumentation.transformClassesWith(
+                RClassAsmTransformerFactory::class.java,
+                InstrumentationScope.PROJECT,
+            ) { params ->
+                params.namespace.set(variant.namespace)
+                params.libraryNamespaces.set(
+                    variantPackagesProperty.getting(variant.name)
+                        .map { list -> list.toList() },
+                )
+            }
+
+            variant.instrumentation.setAsmFramesComputationMode(FramesComputationMode.COPY_FRAMES)
+        }
+    }
+
+    /**
+     * transforms R class into bytecode
+     */
+    abstract class RClassAsmTransformerFactory :
+        AsmClassVisitorFactory<RClassAsmTransformerFactory.Params> {
+        interface Params : InstrumentationParameters {
+            @get:Input
+            val namespace: Property<String>
+
+            @get:Input
+            @get:Optional
+            val libraryNamespaces: ListProperty<String>
+        }
+
+        /**
+         * Creates a class that remaps R class and its subclasses.
+         */
+        override fun createClassVisitor(
+            classContext: ClassContext,
+            nextClassVisitor: ClassVisitor,
+        ): ClassVisitor {
+            val params = parameters.get()
+            val namespace = params.namespace.get()
+            val libraryNamespaces = params.libraryNamespaces.orElse(Collections.emptyList()).get()
+
+            if (libraryNamespaces.isEmpty()) {
+                return nextClassVisitor
+            }
+
+            return ClassRemapper(nextClassVisitor, getRemapper(libraryNamespaces, namespace))
+        }
+
+        private fun getRemapper(
+            libraryNamespaces: List<String>,
+            namespace: String,
+        ): Remapper {
+            val formattedNameSpace = namespace.replace(".", "/")
+            val targetRClass = "$formattedNameSpace/R"
+            val targetRSubclass = "$formattedNameSpace/R$"
+
+            val libraryRClasses = getLibraryRClasses(libraryNamespaces)
+            val libraryRSubclasses = getLibraryRSubclasses(libraryNamespaces)
+
+            val remapper =
+                object : Remapper() {
+                    override fun map(internalName: String?): String? {
+                        if (internalName == null) {
+                            return null
+                        }
+                        if (libraryRClasses.contains(internalName)) {
+                            return targetRClass
+                        }
+                        for (libraryRSubclass in libraryRSubclasses) {
+                            if (internalName.startsWith(libraryRSubclass)) {
+                                return internalName.replaceFirst(libraryRSubclass, targetRSubclass, false)
+                            }
+                        }
+                        return super.map(internalName)
+                    }
+                }
+            return remapper
+        }
+
+        private fun getLibraryRClasses(libraryNamespaces: List<String>): Set<String> {
+            return libraryNamespaces.stream()
+                .map { it.replace(".", "/") + "/R" }
+                .collect(Collectors.toSet())
+        }
+
+        private fun getLibraryRSubclasses(libraryNamespaces: List<String>): List<String> {
+            return libraryNamespaces.stream()
+                .map { it.replace(".", "/") + "/R$" }
+                .collect(Collectors.toList())
+        }
+
+        /**
+         * Determines if the class can be checked for transformation.
+         */
+        override fun isInstrumentable(classData: ClassData): Boolean {
+            return true
+        }
+    }
+}

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

@@ -0,0 +1,171 @@
+package com.callstack.react.brownfield.plugin
+
+import com.android.build.gradle.LibraryExtension
+import com.android.build.gradle.api.LibraryVariant
+import com.callstack.react.brownfield.artifacts.ArtifactsResolver
+import com.callstack.react.brownfield.expo.ExpoPublishingHelper
+import com.callstack.react.brownfield.expo.utils.ExpoGradleProjectProjection
+import com.callstack.react.brownfield.processors.AssetTaskProcessor
+import com.callstack.react.brownfield.processors.ExplodeTaskProvider
+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.VariantPackagesProperty
+import com.callstack.react.brownfield.processors.VariantTaskProvider
+import com.callstack.react.brownfield.shared.BaseProject
+import com.callstack.react.brownfield.shared.Constants.PROJECT_ID
+import com.callstack.react.brownfield.shared.Logging
+import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
+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 org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.ProjectConfigurationException
+
+class RNBrownfieldPlugin : Plugin<Project> {
+    private lateinit var extension: Extension
+    private lateinit var project: Project
+
+    private val isExpoProject: Boolean
+        get() = Utils.isExpoProject(project)
+
+    override fun apply(project: Project) {
+        verifyAndroidPluginApplied(project)
+
+        this.project = project
+        initializers()
+
+        val projectConfigurations = ProjectConfigurations(project)
+        projectConfigurations.configure()
+        RNSourceSets.configure(project, extension)
+        RClassTransformer.registerASMTransformation()
+
+        /**
+         * Must run before processDefaultDependencies: ArtifactsResolver reads :expo's api configuration,
+         * which is only populated after the expo project is evaluated.
+         */
+        if (this.isExpoProject) {
+            project.evaluationDependsOn(EXPO_PROJECT_LOCATOR)
+        }
+
+        var expoProjects = listOf<ExpoGradleProjectProjection>()
+        if (this.isExpoProject) {
+            val expoPublishingHelper = ExpoPublishingHelper(brownfieldAppProject = project)
+            expoProjects = expoPublishingHelper.configure()
+        }
+
+        /**
+         * curates a list of artifacts that we need to bundle with the Aar
+         */
+        val artifactsResolver = ArtifactsResolver(project, isExpoProject)
+        val artifacts = artifactsResolver.processDefaultDependencies(expoProjects)
+
+        val variantTaskProvider = VariantTaskProvider(project)
+
+        /**
+         * Configure Tasks
+         */
+        project.extensions.getByType(LibraryExtension::class.java).libraryVariants.all { variant ->
+            configureTasks(variant, artifacts, variantTaskProvider)
+        }
+    }
+
+    companion object {
+        const val EXPO_PROJECT_LOCATOR = ":expo"
+    }
+
+    private fun initializers() {
+        RClassTransformer.project = project
+        Logging.project = project
+        val baseProject = BaseProject()
+        baseProject.project = project
+        DirectoryManager.project = project
+
+        this.extension = project.extensions.create(Extension.NAME, Extension::class.java)
+        VariantPackagesProperty.setVariantPackagesProperty(project)
+    }
+
+    /**
+     * Verifies and throws error if `com.android.library` plugin is not applied
+     */
+    private fun verifyAndroidPluginApplied(project: Project) {
+        if (!project.plugins.hasPlugin("com.android.library")) {
+            throw ProjectConfigurationException(
+                "$PROJECT_ID must be applied to an android library project",
+                Throwable("Apply $PROJECT_ID"),
+            )
+        }
+    }
+
+    private fun getAarLibraries(
+        artifacts: List<UnresolvedArtifactInfo>,
+        variantName: String,
+    ): List<AndroidArchiveLibrary> {
+        val aarLibraries = mutableListOf<AndroidArchiveLibrary>()
+        artifacts.forEach { art ->
+            val archiveLibrary =
+                AndroidArchiveLibrary(
+                    this.project,
+                    art,
+                    variantName,
+                )
+            aarLibraries.add(archiveLibrary)
+        }
+
+        return aarLibraries
+    }
+
+    private fun configureTasks(
+        variant: LibraryVariant,
+        artifacts: List<UnresolvedArtifactInfo>,
+        variantTaskProvider: VariantTaskProvider,
+    ) {
+        val variantName = variant.name
+        val capitalizedVariantName = variantName.replaceFirstChar(Char::titlecase)
+
+        /** =======  EXPLODE AAR  =========*/
+        val explodeTask = ExplodeTaskProvider.getTask(variant, project, artifacts)
+
+        /** =======  Pre<Variant>Build  =========*/
+        variantTaskProvider.preBuildTaskByVariant(
+            variantName,
+            variant.buildType.name,
+            variant.buildType.isDebuggable,
+            explodeTask,
+        )
+
+        val aarLibraries = getAarLibraries(artifacts, variantName)
+
+        /**
+         * 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)
+
+        /** ===== 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)
+    }
+}