Wire convention plugins into Toolkit and Microapp modules

bom/build.gradle.kts

@@ -17,8 +17,8 @@
  */
 
 plugins {
-    id("maven-publish")
-    id("java-platform")
+    `maven-publish`
+    `java-platform`
 }
 
 // Find these in properties passed through command line or read from GRADLE_HOME/gradle.properties
@@ -91,5 +91,3 @@ afterEvaluate {
         }
     }
 }
-
-

build-logic/.gitignore

@@ -0,0 +1,2 @@
+/build
+/.gradle

build-logic/convention/.gitignore

@@ -0,0 +1 @@
+/build

build-logic/convention/build.gradle.kts

@@ -0,0 +1,66 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    `kotlin-dsl`
+}
+
+group = "com.esri.arcgismaps.kotlin.build_logic.convention"
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+    compilerOptions {
+        jvmTarget.set(JvmTarget.JVM_17)
+    }
+}
+
+dependencies {
+    compileOnly(libs.android.gradlePlugin)
+    compileOnly(libs.android.tools.common)
+    compileOnly(libs.kotlin.gradlePlugin)
+    compileOnly(libs.ksp.gradlePlugin)
+}
+
+tasks {
+    validatePlugins {
+        enableStricterValidation = true
+        failOnWarning = true
+    }
+}
+
+gradlePlugin {
+    plugins {
+        register("androidApplicationComposing") {
+            id = "arcgismaps.android.application.compose"
+            implementationClass = "AndroidApplicationComposeConventionPlugin"
+        }
+        register("androidApplication") {
+            id = "arcgismaps.android.application"
+            implementationClass = "AndroidApplicationConventionPlugin"
+        }
+        register("androidLibraryCompose") {
+            id = "arcgismaps.android.library.compose"
+            implementationClass = "AndroidLibraryComposeConventionPlugin"
+        }
+        register("androidLibrary") {
+            id = "arcgismaps.android.library"
+            implementationClass = "AndroidLibraryConventionPlugin"
+        }
+        register("arcgismapsKotlinToolkit") {
+            id = "arcgismaps.kotlin.toolkit"
+            implementationClass = "ArcGISMapsKotlinToolkitConventionPlugin"
+        }
+        register("arcgismapsKotlinMicroapp") {
+            id = "arcgismaps.kotlin.microapp"
+            implementationClass = "ArcGISMapsKotlinMicroappConventionPlugin"
+        }
+        register("arcGISMapsKotlinSDK") {
+            id = "arcgismaps.kotlin.sdk"
+            implementationClass = "ArcGISMapsKotlinSDKConventionPlugin"
+        }
+    }
+}

build-logic/convention/src/main/java/AndroidApplicationComposeConventionPlugin.kt

@@ -0,0 +1,35 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.esri.arcgismaps.kotlin.build_logic.convention.configureAndroidCompose
+import com.esri.arcgismaps.kotlin.build_logic.convention.configureKotlinAndroid
+import com.esri.arcgismaps.kotlin.build_logic.convention.debugImplementation
+import com.esri.arcgismaps.kotlin.build_logic.convention.implementation
+import com.esri.arcgismaps.kotlin.build_logic.convention.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
+
+class AndroidApplicationComposeConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.findPlugin("android-application").get().get().pluginId)
+                apply(libs.findPlugin("kotlin-android").get().get().pluginId)
+                apply(libs.findPlugin("compose-compiler").get().get().pluginId)
+            }
+            val extension = extensions.getByType<ApplicationExtension>()
+            configureKotlinAndroid(extension)
+            configureAndroidCompose(extension)
+
+            // Add common Compose dependencies for application modules
+            dependencies {
+                implementation(platform(libs.findLibrary("androidx-compose-bom").get()))
+                implementation(libs.findBundle("composeCore").get())
+                implementation(libs.findBundle("core").get())
+                implementation(libs.findLibrary("androidx-activity-compose").get())
+                implementation(libs.findLibrary("androidx-lifecycle-viewmodel-compose").get())
+                debugImplementation(libs.findBundle("debug").get())
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/AndroidApplicationConventionPlugin.kt

@@ -0,0 +1,55 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.esri.arcgismaps.kotlin.build_logic.convention.configureKotlinAndroid
+import com.esri.arcgismaps.kotlin.build_logic.convention.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.get
+
+class AndroidApplicationConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.findPlugin("android-application").get().get().pluginId)
+                apply(libs.findPlugin("kotlin-android").get().get().pluginId)
+            }
+
+            extensions.configure<ApplicationExtension> {
+                configureKotlinAndroid(this)
+                defaultConfig {
+                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                    vectorDrawables {
+                        useSupportLibrary = true
+                    }
+                    minSdk = libs.findVersion("minSdk").get().toString().toInt()
+                    targetSdk = libs.findVersion("compileSdk").get().toString().toInt()
+                    versionCode = 1
+                    versionName = "1.0"
+                }
+
+                buildFeatures {
+                    buildConfig = true
+                }
+
+                buildTypes {
+                    release {
+                        isMinifyEnabled = false
+                        proguardFiles(
+                            getDefaultProguardFile("proguard-android-optimize.txt"),
+                            "proguard-rules.pro"
+                        )
+                    }
+                }
+
+                packaging {
+                    resources {
+                        excludes += "/META-INF/{AL2.0,LGPL2.1}"
+                    }
+                }
+
+                // Add the custom assets directory to the app module's assets build.
+                sourceSets["main"].assets.srcDirs(layout.buildDirectory.dir("sampleAssets/"))
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/AndroidLibraryComposeConventionPlugin.kt

@@ -0,0 +1,44 @@
+import com.android.build.api.dsl.LibraryExtension
+import com.esri.arcgismaps.kotlin.build_logic.convention.configureAndroidCompose
+import com.esri.arcgismaps.kotlin.build_logic.convention.configureKotlinAndroid
+import com.esri.arcgismaps.kotlin.build_logic.convention.implementation
+import com.esri.arcgismaps.kotlin.build_logic.convention.libs
+import com.esri.arcgismaps.kotlin.build_logic.convention.testImplementation
+import com.esri.arcgismaps.kotlin.build_logic.convention.androidTestImplementation
+import com.esri.arcgismaps.kotlin.build_logic.convention.debugImplementation
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.getByType
+
+class AndroidLibraryComposeConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.findPlugin("android-library").get().get().pluginId)
+                apply(libs.findPlugin("kotlin-android").get().get().pluginId)
+                apply(libs.findPlugin("compose-compiler").get().get().pluginId)
+                apply(libs.findPlugin("kotlin-parcelize").get().get().pluginId)
+                apply(libs.findPlugin("kotlin-serialization").get().get().pluginId)
+            }
+            val extension = extensions.getByType<LibraryExtension>()
+            configureKotlinAndroid(extension)
+            configureAndroidCompose(extension)
+
+            // Add common Compose dependencies for library modules
+            dependencies {
+                implementation(platform(libs.findLibrary("androidx-compose-bom").get()))
+                implementation(libs.findBundle("composeCore").get())
+                implementation(libs.findBundle("core").get())
+                implementation(libs.findLibrary("androidx-lifecycle-runtime-compose").get())
+                implementation(libs.findLibrary("androidx-activity-compose").get())
+                implementation(libs.findLibrary("androidx-material-icons").get())
+                implementation(libs.findLibrary("kotlinx-serialization-json").get())
+                testImplementation(libs.findBundle("unitTest").get())
+                androidTestImplementation(libs.findBundle("composeTest").get())
+                androidTestImplementation(libs.findBundle("androidXTest").get())
+                debugImplementation(libs.findBundle("debug").get())
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/AndroidLibraryConventionPlugin.kt

@@ -0,0 +1,54 @@
+import com.android.build.gradle.LibraryExtension
+import com.esri.arcgismaps.kotlin.build_logic.convention.configureKotlinAndroid
+import com.esri.arcgismaps.kotlin.build_logic.convention.implementation
+import com.esri.arcgismaps.kotlin.build_logic.convention.libs
+import com.esri.arcgismaps.kotlin.build_logic.convention.testImplementation
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.kotlin
+
+class AndroidLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.findPlugin("android-library").get().get().pluginId)
+                apply(libs.findPlugin("kotlin-android").get().get().pluginId)
+            }
+
+            extensions.configure<LibraryExtension> {
+                configureKotlinAndroid(this)
+                defaultConfig {
+                    testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+                    vectorDrawables {
+                        useSupportLibrary = true
+                    }
+                    minSdk = libs.findVersion("minSdk").get().toString().toInt()
+                    lint.targetSdk = libs.findVersion("compileSdk").get().toString().toInt()
+                    consumerProguardFiles("consumer-rules.pro")
+                }
+
+                buildTypes {
+                    release {
+                        isMinifyEnabled = false
+                        proguardFiles(
+                            getDefaultProguardFile("proguard-android-optimize.txt"),
+                            "proguard-rules.pro"
+                        )
+                    }
+                }
+
+                packaging {
+                    resources {
+                        excludes += "/META-INF/{AL2.0,LGPL2.1}"
+                    }
+                }
+            }
+
+            dependencies {
+                testImplementation(kotlin("test"))
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/ArcGISMapsKotlinMicroappConventionPlugin.kt

@@ -0,0 +1,54 @@
+import com.android.build.api.dsl.ApplicationExtension
+import com.esri.arcgismaps.kotlin.build_logic.convention.ArcGISMapsKotlinSDKDependency
+import com.esri.arcgismaps.kotlin.build_logic.convention.implementation
+import com.esri.arcgismaps.kotlin.build_logic.convention.libs
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.tasks.testing.Test
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.project
+import org.gradle.kotlin.dsl.withType
+
+class ArcGISMapsKotlinMicroappConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply(libs.findPlugin("arcgismaps-android-application").get().get().pluginId)
+                apply(libs.findPlugin("arcgismaps-android-application-compose").get().get().pluginId)
+                apply(libs.findPlugin("gradle-secrets").get().get().pluginId)
+            }
+
+
+            // Configure secrets plugin defaults and custom BuildConfig fields
+            extensions.configure<ApplicationExtension> {
+                val defaultPropertiesFile = rootProject.file("secrets.defaults.properties")
+                if (defaultPropertiesFile.exists()) {
+                    val properties = java.util.Properties()
+                    defaultPropertiesFile.inputStream().use { properties.load(it) }
+                    defaultConfig {
+                        // Add each property as a BuildConfig field
+                        properties.forEach { (key, value) ->
+                            val escapedValue = value.toString().replace("\"", "\\\"")
+                            buildConfigField("String", key.toString(), "\"${escapedValue}\"")
+                        }
+                    }
+                }
+            }
+
+            // Avoids an empty test report showing up in the CI integration test report.
+            // Remove this if tests will be added.
+            tasks.withType<Test> {
+                enabled = false
+            }
+
+            dependencies {
+                // Configure the ArcGIS Maps SDK dependency
+                ArcGISMapsKotlinSDKDependency.configureArcGISMapsDependencies(target)
+
+                // Local project common microapps library
+                implementation(project(":microapps-lib"))
+            }
+        }
+    }
+}

build-logic/convention/src/main/java/ArcGISMapsKotlinSDKConventionPlugin.kt

@@ -0,0 +1,12 @@
+import com.esri.arcgismaps.kotlin.build_logic.convention.ArcGISMapsKotlinSDKDependency
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+
+class ArcGISMapsKotlinSDKConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            // Configure the ArcGIS Maps SDK dependency
+            ArcGISMapsKotlinSDKDependency.configureArcGISMapsDependencies(target)
+        }
+    }
+}