Feat/revamp plugin

apps/RNApp/android/build.gradle

@@ -16,7 +16,7 @@ buildscript {
         classpath("com.android.tools.build:gradle")
         classpath("com.facebook.react:react-native-gradle-plugin")
         classpath("org.jetbrains.kotlin:kotlin-gradle-plugin")
-        classpath("com.callstack.react:brownfield-gradle-plugin:0.6.3")
+        classpath("com.callstack.react:brownfield-gradle-plugin:0.6.3-local")
     }
 }
 

apps/RNApp/package.json

@@ -7,6 +7,9 @@
     "ios": "react-native run-ios",
     "build:example:android-rn": "react-native build-android",
     "build:example:ios-rn": "react-native build-ios",
+    "build:aar:dryRun": "cd android && ./gradlew :brownfieldlib:assembleRelease --dry-run",
+    "build:aar": "cd android && ./gradlew :brownfieldlib:processArtifacts :brownfieldlib:assembleRelease",
+    "build:scan": "cd android && ./gradlew :brownfieldlib:assembleRelease --scan",
     "lint": "eslint .",
     "start": "react-native start",
     "test": "jest"

apps/TesterIntegrated/package.json

@@ -4,7 +4,7 @@
   "private": true,
   "scripts": {
     "start": "react-native start",
-    "build:tester-integrated:android": "cd kotlin && ./gradlew assembleDebug",
+    "build:tester-integrated:android": "cd kotlin && ./gradlew installDebug",
     "build:tester-integrated:ios": "cd swift && xcodebuild -workspace SwiftExample.xcworkspace -scheme SwiftExample -configuration Release -sdk iphonesimulator build CODE_SIGNING_ALLOWED=NO -derivedDataPath ./build"
   },
   "dependencies": {

gradle-plugins/publish-to-maven-local.sh

@@ -2,7 +2,7 @@
 
 set -e
 
-cd ./gradle-plugins/react
+cd ./react
 ./gradlew clean
 ./gradlew build
 ./gradlew :brownfield:publishMavenLocalPublicationToMavenLocalRepository

gradle-plugins/react/brownfield/build.gradle.kts

@@ -5,6 +5,7 @@ plugins {
     alias(libs.plugins.detekt)
     `maven-publish`
     signing
+    kotlin("plugin.serialization") version "1.9.24"
 }
 
 ktlint {
@@ -64,18 +65,6 @@ publishing {
                         distribution.set("repo")
                     }
                 }
-                developers {
-                    developer {
-                        id.set("callstack")
-                        name.set("Callstack Team")
-                        email.set("it-admin@callstack.com")
-                    }
-                }
-                scm {
-                    connection.set(property("SCM_CONNECTION").toString())
-                    developerConnection.set(property("SCM_DEV_CONNECTION").toString())
-                    url.set(property("GITHUB_URL").toString())
-                }
             }
         }
     }
@@ -85,10 +74,6 @@ publishing {
     }
 }
 
-signing {
-    sign(publishing.publications["mavenLocal"])
-}
-
 repositories {
     mavenCentral()
     google()
@@ -98,6 +83,7 @@ dependencies {
     implementation(libs.agp)
     implementation(libs.common)
     implementation(libs.asm.commons)
+    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.3")
 }
 
 tasks.named("detekt").configure {

gradle-plugins/react/brownfield/gradle.properties

@@ -1,6 +1,6 @@
 PROJECT_ID=com.callstack.react.brownfield
 ARTIFACT_ID=brownfield-gradle-plugin
-VERSION=0.6.3
+VERSION=0.6.3-local
 GROUP=com.callstack.react
 IMPLEMENTATION_CLASS=com.callstack.react.brownfield.plugin.RNBrownfieldPlugin
 

gradle-plugins/react/brownfield/src/main/kotlin/com/callstack/react/brownfield/artifacts/ArtifactsResolver.kt

@@ -14,41 +14,36 @@ import com.android.build.gradle.LibraryExtension
 import com.android.build.gradle.api.LibraryVariant
 import com.callstack.react.brownfield.plugin.ProjectConfigurations.Companion.CONFIG_NAME
 import com.callstack.react.brownfield.plugin.ProjectConfigurations.Companion.CONFIG_SUFFIX
-import com.callstack.react.brownfield.processors.VariantHelper
 import com.callstack.react.brownfield.processors.VariantProcessor
 import com.callstack.react.brownfield.processors.VariantTaskProvider
 import com.callstack.react.brownfield.shared.BaseProject
+import com.callstack.react.brownfield.shared.BundleTaskProvider
 import com.callstack.react.brownfield.shared.GradleProps
+import com.callstack.react.brownfield.shared.UnresolvedArtifactInfo
 import com.callstack.react.brownfield.utils.Extension
 import com.callstack.react.brownfield.utils.Utils
-import org.gradle.api.ProjectConfigurationException
+import org.gradle.api.Project
 import org.gradle.api.artifacts.Configuration
-import org.gradle.api.artifacts.ResolvedArtifact
+import org.gradle.api.artifacts.component.ModuleComponentIdentifier
+import org.gradle.api.artifacts.component.ProjectComponentIdentifier
+import org.gradle.api.artifacts.result.ResolvedDependencyResult
 import org.gradle.api.internal.artifacts.dependencies.DefaultProjectDependency
+import org.gradle.internal.component.local.model.PublishArtifactLocalArtifactMetadata
+import kotlin.collections.mutableListOf
+
 
 class ArtifactsResolver(
     private val configurations: MutableCollection<Configuration>,
     private val baseProject: BaseProject,
     private val extension: Extension,
 ) :
     GradleProps() {
-    companion object {
-        const val ARTIFACT_TYPE_AAR = "aar"
-        const val ARTIFACT_TYPE_JAR = "jar"
-    }
-
-    fun processArtifacts() {
+    fun processDefaultDependencies() {
         embedDefaultDependencies("implementation")
-        setTransitiveToConfigurations()
-        generateArtifacts()
     }
 
-    private fun setTransitiveToConfigurations() {
-        configurations.forEach {
-            if (baseProject.project.extensions.getByType(Extension::class.java).transitive) {
-                it.isTransitive = true
-            }
-        }
+    fun processArtifacts(): MutableList<UnresolvedArtifactInfo> {
+        return generateArtifacts()
     }
 
     private fun embedExpoDependencies() {
@@ -72,19 +67,19 @@ class ArtifactsResolver(
         val expoProject = baseProject.project.rootProject.project("expo")
         val expoConfig = expoProject.configurations.findByName("api")
         expoConfig?.dependencies?.forEach {
-            if (extension.resolveLocalDependencies) {
-                if (it is DefaultProjectDependency) {
-                    baseProject.project.dependencies.add(
-                        CONFIG_NAME,
-                        expoProject.dependencies.project(mapOf("path" to ":${it.name}")),
-                    )
-                } else {
-                    baseProject.project.dependencies.add(
-                        CONFIG_NAME,
-                        it,
-                    )
+                if (extension.resolveLocalDependencies) {
+                    if (it is DefaultProjectDependency) {
+                        baseProject.project.dependencies.add(
+                            CONFIG_NAME,
+                            expoProject.dependencies.project(mapOf("path" to ":${it.name}")),
+                        )
+                    } else {
+                        baseProject.project.dependencies.add(
+                            CONFIG_NAME,
+                            it,
+                        )
+                    }
                 }
-            }
         }
     }
 
@@ -96,33 +91,35 @@ class ArtifactsResolver(
         val config = baseProject.project.configurations.findByName(configName)
         val defaultDependencies = config?.dependencies?.filterIsInstance<DefaultProjectDependency>()
         defaultDependencies?.forEach { dependency ->
-            if (extension.resolveLocalDependencies) {
-                baseProject.project.dependencies.add(
-                    CONFIG_NAME,
-                    baseProject.project.dependencies.project(mapOf("path" to ":${dependency.name}")),
-                )
-            }
+                if (extension.resolveLocalDependencies) {
+                    baseProject.project.dependencies.add(
+                        CONFIG_NAME,
+                        baseProject.project.dependencies.project(mapOf("path" to ":${dependency.name}")),
+                    )
+                }
         }
     }
 
-    private fun generateArtifacts() {
+    private fun generateArtifacts(): MutableList<UnresolvedArtifactInfo> {
+        // store the artifacts which can be variant aware including flavors
+        val artifacts = mutableSetOf<UnresolvedArtifactInfo>()
         baseProject.project.extensions.getByType(LibraryExtension::class.java).libraryVariants.all { variant ->
-            val artifacts: MutableCollection<ResolvedArtifact> = ArrayList()
 
             configurations.forEach { configuration ->
                 if (isEmbedConfig(configuration, variant)) {
-                    val resolvedArtifacts = resolveArtifacts(configuration)
-                    artifacts.addAll(resolvedArtifacts)
-                    artifacts.addAll(handleUnResolvedArtifacts(configuration, variant, resolvedArtifacts))
+                    val res = handleUnResolvedArtifacts(configuration, variant)
+                    artifacts.addAll(res)
                 }
             }
 
             if (artifacts.isNotEmpty()) {
-                val processor = VariantProcessor(variant)
+                val processor = VariantProcessor()
                 processor.project = baseProject.project
-                processor.processVariant(artifacts)
+                processor.processVariant(variant.name)
             }
         }
+
+        return artifacts.toMutableList()
     }
 
     private fun isEmbedConfig(
@@ -134,47 +131,88 @@ class ArtifactsResolver(
             configuration.name == variant.name + CONFIG_SUFFIX
     }
 
-    private fun resolveArtifacts(configuration: Configuration): Collection<ResolvedArtifact> {
-        val artifacts = ArrayList<ResolvedArtifact>()
-        configuration.resolvedConfiguration.resolvedArtifacts.forEach { artifact ->
-            if (artifact.type != ARTIFACT_TYPE_AAR && artifact.type != ARTIFACT_TYPE_JAR) {
-                throw ProjectConfigurationException("Unsupported dependency. Please provide either Aar or Jar dependency", listOf())
-            }
-            artifacts.add(artifact)
-        }
-        return artifacts
-    }
-
     private fun handleUnResolvedArtifacts(
         configuration: Configuration,
         variant: LibraryVariant,
-        artifacts: Collection<ResolvedArtifact>,
-    ): Collection<ResolvedArtifact> {
-        val artifactList = ArrayList<ResolvedArtifact>()
-        val unMatchedArtifacts =
-            configuration.resolvedConfiguration.firstLevelModuleDependencies.filter {
-                !artifacts.any { artifact ->
-                    it.moduleName == artifact.moduleVersion.id.name
+    ): List<UnresolvedArtifactInfo> {
+        val unMatchedArtifacts = mutableListOf<UnresolvedArtifactInfo>()
+        val firstLevelIds = setOf<String>()
+
+        val resolutionResult = configuration.incoming.resolutionResult
+        resolutionResult.root.dependencies.forEach {
+            if (it is ResolvedDependencyResult) {
+                when (val id = it.selected.id) {
+                    is ModuleComponentIdentifier -> {
+//                        println("===----- module ${id.moduleIdentifier.name} ${id.displayName} ")
+                        if (id.displayName !in firstLevelIds) {
+//                            unMatchedArtifacts.add(
+//                                UnresolvedArtifactInfo(
+//                                    id.group,
+//                                    id.module,
+//                                    id.version,
+//                                )
+//                            )
+                        }
+                    }
+                    is ProjectComponentIdentifier -> {
+                        val depProj = baseProject.project.project(id.projectPath)
+                        if (id.displayName !in firstLevelIds) {
+                            unMatchedArtifacts.add(UnresolvedArtifactInfo(
+                                depProj.group.toString(),
+                                depProj.name,
+                                depProj.version.toString(),
+                                baseProject.project.file(id.projectName).absolutePath,
+                                mutableSetOf(),
+                                null,
+                            ))
+                        }
+                    }
                 }
             }
+        }
 
-        val variantHelper = VariantHelper(variant)
-        variantHelper.project = baseProject.project
-        val variantTaskProvider = VariantTaskProvider(variantHelper)
+        val variantTaskProvider = VariantTaskProvider()
         variantTaskProvider.project = baseProject.project
-        val flavorArtifact = FlavorArtifact(variant, variantTaskProvider)
+        val flavorArtifact = FlavorArtifact(configuration)
         flavorArtifact.project = baseProject.project
 
-        unMatchedArtifacts.forEach { dependency ->
+        val bundleTaskProvider = BundleTaskProvider(variantTaskProvider)
+
+        val unMatchedArtifacts1 = mutableListOf<UnresolvedArtifactInfo>()
+        unMatchedArtifacts.forEach { artifact ->
+            val artifactProject = getArtifactProject(artifact)
+            val bundleProvider = artifactProject?.let { bundleTaskProvider.getBundleTask(it, variant) }
+
             val resolvedArtifact =
                 flavorArtifact.createFlavorArtifact(
-                    dependency,
-                    calculatedValueContainerFactory,
                     fileResolver,
                     taskDependencyFactory,
+                    bundleProvider,
+                    variant.name
                 )
-            artifactList.add(resolvedArtifact)
+
+            when (val asd = resolvedArtifact.id) {
+                is PublishArtifactLocalArtifactMetadata -> {
+                    val deps = asd.buildDependencies.getDependencies(null)
+                    unMatchedArtifacts1.add(UnresolvedArtifactInfo(
+                        artifact.moduleGroup,
+                        artifact.moduleName,
+                        artifact.moduleVersion,
+                        resolvedArtifact.file.absolutePath,
+                        deps.map { it.path }.toSet(),
+                        bundleProvider?.name,
+                    ))
+                }
+            }
+        }
+
+        return unMatchedArtifacts1
+    }
+
+
+    private fun getArtifactProject(unResolvedArtifact: UnresolvedArtifactInfo): Project? {
+        return baseProject.project.rootProject.allprojects.find { p ->
+            unResolvedArtifact.moduleName == p.name && unResolvedArtifact.moduleGroup == p.group.toString()
         }
-        return artifactList
     }
 }