migrate build configuration to build-logic module.

build-logic/convention/build.gradle.kts

@@ -12,17 +12,25 @@ repositories {
 dependencies {
     implementation(libs.kotlin.gradle.plugin)
     implementation(libs.android.gradle.plugin)
+    compileOnly(libs.compose.gradle.plugin)
     implementation(libs.dokka.plugin)
     implementation(libs.org.jacoco.core)
     implementation(libs.gradle.maven.publish.plugin)
-
 }
 
 gradlePlugin {
     plugins {
         register("publishingConventionPlugin") {
-            id = "android.maps.compose.PublishingConventionPlugin"
+            id = "android.maps.compose.publish"
             implementationClass = "PublishingConventionPlugin"
         }
+        register("androidLibraryConventionPlugin") {
+            id = "android.maps.compose.library"
+            implementationClass = "AndroidLibraryConventionPlugin"
+        }
+        register("androidApplicationConventionPlugin") {
+            id = "android.maps.compose.application"
+            implementationClass = "AndroidApplicationConventionPlugin"
+        }
     }
 }

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

@@ -0,0 +1,22 @@
+import com.android.build.api.dsl.ApplicationExtension
+import internal.configureAndroidCompose
+import internal.configureKotlinAndroid
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+
+class AndroidApplicationConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply(plugin = "com.android.application")
+            apply(plugin = "org.jetbrains.kotlin.android")
+
+            extensions.configure<ApplicationExtension> {
+                configureKotlinAndroid(this, isLibrary = false)
+                defaultConfig.targetSdk = 36
+                configureAndroidCompose(this)
+            }
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+import com.android.build.api.dsl.LibraryExtension
+import internal.configureAndroidCompose
+import internal.configureKotlinAndroid
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+
+class AndroidLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            apply(plugin = "com.android.library")
+            apply(plugin = "org.jetbrains.kotlin.android")
+
+            extensions.configure<LibraryExtension> {
+                configureKotlinAndroid(this)
+                defaultConfig.targetSdk = 36
+                configureAndroidCompose(this)
+            }
+        }
+    }
+}

build-logic/convention/src/main/kotlin/PublishingConventionPlugin.kt

@@ -28,7 +28,6 @@ class PublishingConventionPlugin : Plugin<Project> {
     private fun Project.configureJacoco() {
         configure<JacocoPluginExtension> {
             toolVersion = "0.8.7"
-
         }
 
         tasks.withType<Test>().configureEach {

build-logic/convention/src/main/kotlin/internal/AndroidCompose.kt

@@ -0,0 +1,52 @@
+package internal
+
+import com.android.build.api.dsl.CommonExtension
+import org.gradle.api.Project
+import org.gradle.api.provider.Provider
+import org.gradle.kotlin.dsl.apply
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.dependencies
+import org.jetbrains.kotlin.compose.compiler.gradle.ComposeCompilerGradlePluginExtension
+
+/**
+ * Configure Compose-specific options
+ */
+internal fun Project.configureAndroidCompose(
+    commonExtension: CommonExtension<*, *, *, *, *, *>,
+) {
+    apply(plugin = "org.jetbrains.kotlin.plugin.compose")
+
+    commonExtension.apply {
+        buildFeatures {
+            compose = true
+        }
+
+        dependencies {
+            val bom = libs.findLibrary("androidx-compose-bom").get()
+            "implementation"(platform(bom))
+            "androidTestImplementation"(platform(bom))
+            "implementation"(libs.findLibrary("androidx-compose-ui-preview-tooling").get())
+            "debugImplementation"(libs.findLibrary("androidx-compose-ui-tooling").get())
+        }
+    }
+
+//    extensions.configure<ComposeCompilerGradlePluginExtension> {
+//        fun Provider<String>.onlyIfTrue() = flatMap { provider { it.takeIf(String::toBoolean) } }
+//        fun Provider<*>.relativeToRootProject(dir: String) = map {
+//            isolated.rootProject.projectDirectory
+//                .dir("build")
+//                .dir(projectDir.toRelativeString(rootDir))
+//        }.map { it.dir(dir) }
+//
+//        project.providers.gradleProperty("composeCompilerMetrics").onlyIfTrue()
+//            .relativeToRootProject("compose-metrics")
+//            .let(metricsDestination::set)
+//
+//        project.providers.gradleProperty("composeCompilerReports").onlyIfTrue()
+//            .relativeToRootProject("compose-reports")
+//            .let(reportsDestination::set)
+//
+//        stabilityConfigurationFiles
+//            .add(isolated.rootProject.projectDirectory.file("compose_compiler_config.conf"))
+//    }
+}

build-logic/convention/src/main/kotlin/internal/KotlinAndroid.kt

@@ -0,0 +1,93 @@
+package internal
+
+import com.android.build.api.dsl.CommonExtension
+import org.gradle.api.JavaVersion
+import org.gradle.api.Project
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.kotlin.dsl.assign
+import org.gradle.kotlin.dsl.configure
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinAndroidProjectExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinBaseExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
+
+/**
+ * Configure base Kotlin with Android options
+ */
+internal fun Project.configureKotlinAndroid(
+    commonExtension: CommonExtension<*, *, *, *, *, *>,
+    isLibrary: Boolean = true
+) {
+    commonExtension.apply {
+        lint {
+            targetSdk = 36
+            sarifOutput = layout.buildDirectory.file("reports/lint-results.sarif").get().asFile
+        }
+
+        compileSdk = 36
+
+        defaultConfig {
+            minSdk = 21
+
+            testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        }
+
+        testOptions {
+            targetSdk = 36
+            animationsDisabled = true
+        }
+
+        compileOptions {
+            sourceCompatibility = JavaVersion.VERSION_1_8
+            targetCompatibility = JavaVersion.VERSION_1_8
+        }
+
+        buildFeatures {
+            buildConfig = false
+        }
+    }
+
+    configureKotlin<KotlinAndroidProjectExtension>(isLibrary)
+}
+
+/**
+ * Configure base Kotlin options for JVM (non-Android)
+ */
+internal fun Project.configureKotlinJvm() {
+    extensions.configure<JavaPluginExtension> {
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    configureKotlin<KotlinJvmProjectExtension>()
+}
+
+/**
+ * Configure base Kotlin options
+ */
+private inline fun <reified T : KotlinBaseExtension> Project.configureKotlin(isLibrary: Boolean = true) = configure<T> {
+    // Treat all Kotlin warnings as errors (disabled by default)
+    // Override by setting warningsAsErrors=true in your ~/.gradle/gradle.properties
+    val warningsAsErrors = providers.gradleProperty("warningsAsErrors").map {
+        it.toBoolean()
+    }.orElse(false)
+    when (this) {
+        is KotlinAndroidProjectExtension -> compilerOptions
+        is KotlinJvmProjectExtension -> compilerOptions
+        else -> TODO("Unsupported project extension $this ${T::class}")
+    }.apply {
+        jvmTarget = JvmTarget.JVM_1_8
+        allWarningsAsErrors = warningsAsErrors
+        freeCompilerArgs.add(
+            "-Xopt-in=kotlin.RequiresOptIn"
+        )
+        if (isLibrary) {
+            freeCompilerArgs.add(
+                "-Xexplicit-api=strict"
+            )
+        }
+        freeCompilerArgs.add(
+            // Enable experimental coroutines APIs, including Flow
+            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+        )
+    }
+}

build-logic/convention/src/main/kotlin/internal/ProjectExtensions.kt

@@ -0,0 +1,9 @@
+package internal
+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalog
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.getByType
+
+val Project.libs
+    get(): VersionCatalog = extensions.getByType<VersionCatalogsExtension>().named("libs")

build.gradle.kts

@@ -1,27 +1,12 @@
-// Top-level build file where you can add configuration options common to all sub-projects/modules.
-buildscript {
-    val kotlinVersion by extra(libs.versions.kotlin.get())
-    val androidxTestVersion by extra(libs.versions.androidxtest.get())
-    repositories {
-        google()
-        mavenCentral()
-    }
-    dependencies {
-        classpath(libs.android.gradle.plugin)
-        classpath(libs.maps.secrets.plugin)
-        classpath(libs.kotlin.gradle.plugin)
-        classpath(libs.dokka.plugin)
-        classpath(libs.jacoco.android.plugin)
-    }
-}
-
 plugins {
     alias(libs.plugins.dokka) apply true
     alias(libs.plugins.compose.compiler) apply false
     id("com.autonomousapps.dependency-analysis") version "2.0.0"
     alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.android.library) apply false
     alias(libs.plugins.kotlin.android) apply false
-
+    alias(libs.plugins.maps.secrets.gradle.plugin) apply false
+    alias(libs.plugins.jacoco.android) apply false
 }
 
 val projectArtifactId by extra { project: Project ->

gradle/libs.versions.toml

@@ -43,15 +43,14 @@ androidx-test-rules = { module = "androidx.test:rules", version.ref = "androidCo
 androidx-test-runner = { module = "androidx.test:runner", version.ref = "androidxtest" }
 dokka-plugin = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
 gradle-maven-publish-plugin = { module = "com.vanniktech:gradle-maven-publish-plugin", version.ref = "gradleMavenPublishPlugin" }
-jacoco-android-plugin = { module = "com.mxalbert.gradle:jacoco-android", version.ref = "jacoco-plugin", version.require = "0.2.1" }
+compose-gradle-plugin = { module = "org.jetbrains.kotlin:compose-compiler-gradle-plugin", version.ref = "kotlin" }
 kotlin = { module = "org.jetbrains.kotlin:kotlin-stdlib-jdk7", version.ref = "kotlin" }
-kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
+kotlin-gradle-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version = "2.2.0" }
 kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref = "kotlinxCoroutines" }
 kotlinx-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlinxCoroutines" }
 leakcanary-android = { module = "com.squareup.leakcanary:leakcanary-android", version.ref = "leakcanaryAndroid" }
 maps-ktx-std = { module = "com.google.maps.android:maps-ktx", version.ref = "mapsktx" }
 maps-ktx-utils = { module = "com.google.maps.android:maps-utils-ktx", version.ref = "mapsktx" }
-maps-secrets-plugin = { module = "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin", version.ref = "mapsecrets" }
 org-jacoco-core = { module = "org.jacoco:org.jacoco.core", version.ref = "org-jacoco-core" }
 test-junit = { module = "junit:junit", version.ref = "junit" }
 androidx-constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintlayout" }
@@ -62,7 +61,10 @@ truth = { module = "com.google.truth:truth", version.ref = "truth" }
 
 [plugins]
 android-application = { id = "com.android.application", version.ref = "agp" }
+android-library = { id = "com.android.library", version.ref = "agp" }
 compose-compiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
 dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
 kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
 screenshot = { id = "com.android.compose.screenshot", version.ref = "screenshot"}
+maps-secrets-gradle-plugin = { id = "com.google.android.libraries.mapsplatform.secrets-gradle-plugin", version.ref = "mapsecrets" }
+jacoco-android = { id = "com.mxalbert.gradle.jacoco-android", version.ref = "jacoco-plugin" }

maps-app/build.gradle.kts

@@ -1,18 +1,12 @@
 import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
-    id("com.android.application")
-    id("kotlin-android")
-    id("com.google.android.libraries.mapsplatform.secrets-gradle-plugin")
-    alias(libs.plugins.compose.compiler)
+    id("android.maps.compose.application")
+    alias(libs.plugins.maps.secrets.gradle.plugin)
     alias(libs.plugins.screenshot)
 }
 
 android {
-    lint {
-        sarifOutput = layout.buildDirectory.file("reports/lint-results.sarif").get().asFile
-    }
-
     buildTypes {
         getByName("debug") {
             enableUnitTestCoverage = true
@@ -25,34 +19,15 @@ android {
     }
 
     namespace = "com.google.maps.android.compose"
-    compileSdk = 36
 
     defaultConfig {
-        minSdk = 21
-        targetSdk = 36
         versionCode = 1
         versionName = "1.0"
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
-    compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
 
     buildFeatures {
         buildConfig = true
-        compose = true
-    }
-
-
-    kotlin {
-        compilerOptions {
-            jvmTarget.set(JvmTarget.JVM_1_8)
-            freeCompilerArgs.addAll(
-                "-opt-in=kotlin.RequiresOptIn"
-            )
-        }
     }
 
     experimentalProperties["android.experimental.enableScreenshotTest"] = true
@@ -65,7 +40,6 @@ android {
 }
 
 dependencies {
-    implementation(platform(libs.androidx.compose.bom))
     implementation(libs.androidx.compose.activity)
     implementation(libs.androidx.compose.foundation)
     implementation(libs.androidx.compose.material)
@@ -79,7 +53,6 @@ dependencies {
     debugImplementation(libs.androidx.compose.ui.tooling)
     debugImplementation(libs.leakcanary.android)
 
-    androidTestImplementation(platform(libs.androidx.compose.bom))
     androidTestImplementation(libs.androidx.test.core)
     androidTestImplementation(libs.androidx.test.rules)
     androidTestImplementation(libs.androidx.test.runner)

maps-app/src/androidTest/java/com/google/maps/android/compose/MapsInLazyColumnTest.kt

@@ -108,6 +108,6 @@ class MapsInLazyColumnTests {
         initMaps()
         composeTestRule.onRoot().performTouchInput { swipeUp(durationMillis = 1000) }
         composeTestRule.waitForIdle()
-        //We do not need to check anything on the test, just to make sure the scroll down doesnt crash
+        //We do not need to check anything on the test, just to make sure the scroll down doesn't crash
     }
 }