feat(kmp): add a jvm() target to the shared KMP libraries

apps/flipcash/features/messenger/build.gradle.kts

@@ -9,7 +9,7 @@ android {
 dependencies {
     implementation(project(":apps:flipcash:shared:analytics"))
     testImplementation(testFixtures(project(":apps:flipcash:shared:analytics")))
-    testImplementation(testFixtures(project(":libs:coroutines")))
+    testImplementation(project(":libs:coroutines:test-fixtures"))
     implementation(project(":apps:flipcash:shared:blob"))
     implementation(project(":apps:flipcash:shared:bills"))
     implementation(project(":apps:flipcash:shared:blocklist"))

apps/flipcash/shared/appupdates/build.gradle.kts

@@ -20,5 +20,5 @@ dependencies {
     testImplementation(kotlin("test"))
     testImplementation(libs.bundles.unit.testing)
     testImplementation(libs.robolectric)
-    testImplementation(testFixtures(project(":libs:coroutines")))
+    testImplementation(project(":libs:coroutines:test-fixtures"))
 }

apps/flipcash/shared/authentication/build.gradle.kts

@@ -26,5 +26,5 @@ dependencies {
     testImplementation(kotlin("test"))
     testImplementation(libs.bundles.unit.testing)
     testImplementation(libs.robolectric)
-    testImplementation(testFixtures(project(":libs:coroutines")))
+    testImplementation(project(":libs:coroutines:test-fixtures"))
 }

apps/flipcash/shared/funding/build.gradle.kts

@@ -1,16 +1,44 @@
 plugins {
-    alias(libs.plugins.flipcash.android.feature)
+    alias(libs.plugins.flipcash.kmp.library)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.kotlin.ksp)
 }
 
-android {
-    namespace = "${Gradle.flipcashNamespace}.shared.funding"
+kotlin {
+    android {
+        namespace = "${Gradle.flipcashNamespace}.shared.funding"
+        withHostTest {}
+        androidResources { enable = true }
+    }
+    sourceSets {
+        androidMain.dependencies {
+            implementation(project.dependencies.platform(libs.compose.bom))
+            implementation(libs.bundles.compose)
+            implementation(libs.bundles.hilt)
+            implementation(project(":libs:coroutines"))
+            implementation(project(":libs:logging"))
+            implementation(project(":ui:core"))
+            implementation(project(":ui:components"))
+            implementation(project(":ui:navigation"))
+            implementation(project(":ui:resources"))
+            implementation(project(":ui:theme"))
+            implementation(project(":apps:flipcash:core"))
+            implementation(project(":apps:flipcash:core-ui"))
+            implementation(project(":apps:flipcash:shared:analytics"))
+            implementation(project(":apps:flipcash:shared:featureflags"))
+            implementation(project(":apps:flipcash:shared:tokens:core"))
+            implementation(project(":apps:flipcash:shared:userflags"))
+            implementation(project(":libs:messaging"))
+            implementation(project(":services:flipcash"))
+        }
+        getByName("androidHostTest").dependencies {
+            implementation(kotlin("test"))
+            implementation(libs.bundles.unit.testing)
+        }
+    }
 }
 
 dependencies {
-    implementation(project(":apps:flipcash:shared:analytics"))
-    implementation(project(":apps:flipcash:shared:featureflags"))
-    implementation(project(":apps:flipcash:shared:tokens:core"))
-    implementation(project(":apps:flipcash:shared:userflags"))
-    implementation(project(":libs:messaging"))
-    implementation(project(":services:flipcash"))
+    add("kspAndroid", libs.hilt.android.compiler)
+    add("kspAndroid", libs.hilt.compiler)
 }

apps/flipcash/shared/invite/build.gradle.kts

@@ -12,5 +12,5 @@ dependencies {
     testImplementation(kotlin("test"))
     testImplementation(libs.bundles.unit.testing)
     testImplementation(libs.robolectric)
-    testImplementation(testFixtures(project(":libs:coroutines")))
+    testImplementation(project(":libs:coroutines:test-fixtures"))
 }

apps/flipcash/shared/session/build.gradle.kts

@@ -9,7 +9,7 @@ android {
 dependencies {
     testImplementation(kotlin("test"))
     testImplementation(libs.bundles.unit.testing)
-    testImplementation(testFixtures(project(":libs:coroutines")))
+    testImplementation(project(":libs:coroutines:test-fixtures"))
     testImplementation(testFixtures(project(":ui:resources")))
 
     implementation(project(":apps:flipcash:shared:blob"))

build-logic/convention/build.gradle.kts

@@ -49,6 +49,10 @@ gradlePlugin {
             id = "flipcash.kmp.library"
             implementationClass = "KmpLibraryConventionPlugin"
         }
+        register("kmpAppLibrary") {
+            id = "flipcash.kmp.app.library"
+            implementationClass = "KmpAppLibraryConventionPlugin"
+        }
         register("kmpTestFixtures") {
             id = "flipcash.kmp.test.fixtures"
             implementationClass = "KmpTestFixturesConventionPlugin"

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

@@ -0,0 +1,129 @@
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.api.tasks.testing.Test
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.withType
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+/**
+ * Convention plugin for app-layer KMP modules that build for Android and the desktop JVM only.
+ *
+ * Unlike `flipcash.kmp.library` it declares no Kotlin/Native targets: these modules sit on Android
+ * and JVM libraries (gRPC, Room, DataStore, OkHttp) with no native counterpart. Because every target
+ * is a JVM, `commonMain` sees the JDK, so code that only needs `java.*` moves there unchanged and
+ * only `android.*` uses need an `expect`/`actual` or an interface.
+ *
+ * Applies:
+ *   - `org.jetbrains.kotlin.multiplatform`
+ *   - `com.android.kotlin.multiplatform.library`
+ *   - `org.jetbrains.kotlin.plugin.serialization`
+ *
+ * and declares:
+ *   - `android` -- compileSdk and minSdk from the version catalog, host tests enabled with the same
+ *     options `flipcash.android.library` sets on unit tests
+ *   - `jvm` -- the desktop client
+ *
+ * The AGP KMP library target is single-variant: it has no `buildTypes` and no `BuildConfig`, so a
+ * value that differed between debug and release must come from the app at runtime.
+ *
+ * Usage in a module's `build.gradle.kts`:
+ * ```
+ * plugins {
+ *     alias(libs.plugins.flipcash.kmp.app.library)
+ * }
+ *
+ * kotlin {
+ *     android {
+ *         namespace = "com.example"
+ *     }
+ * }
+ * ```
+ */
+class KmpAppLibraryConventionPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("org.jetbrains.kotlin.multiplatform")
+                apply("com.android.kotlin.multiplatform.library")
+                apply("org.jetbrains.kotlin.plugin.serialization")
+            }
+
+            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+            val compileSdkVersion = libs.findVersion("android-compileSdk").get().requiredVersion.toInt()
+            val compileSdkMinorVersion = libs.findVersion("android-compileSdkMinor").get().requiredVersion.toInt()
+            val minSdkVersion = libs.findVersion("android-minSdk").get().requiredVersion.toInt()
+            val javaVersion = libs.findVersion("android-java").get().requiredVersion
+
+            extensions.configure<KotlinMultiplatformExtension> {
+                jvmToolchain {
+                    languageVersion.set(JavaLanguageVersion.of(javaVersion))
+                }
+
+                (this as ExtensionAware).extensions.configure<KotlinMultiplatformAndroidLibraryTarget> {
+                    compileSdk {
+                        version = release(compileSdkVersion) {
+                            minorApiLevel = compileSdkMinorVersion
+                        }
+                    }
+                    minSdk = minSdkVersion
+                    withHostTestBuilder {}.configure {
+                        isReturnDefaultValues = true
+                        isIncludeAndroidResources = true
+                    }
+                    compilerOptions {
+                        jvmTarget.set(JvmTarget.fromTarget(javaVersion))
+                    }
+                }
+
+                jvm {
+                    compilerOptions {
+                        jvmTarget.set(JvmTarget.fromTarget(javaVersion))
+                    }
+                }
+
+                compilerOptions {
+                    optIn.addAll(
+                        "kotlin.time.ExperimentalTime",
+                        "kotlin.ExperimentalUnsignedTypes",
+                        "kotlin.RequiresOptIn"
+                    )
+                    freeCompilerArgs.add("-Xexpect-actual-classes")
+                }
+
+                sourceSets.named("commonMain") {
+                    dependencies {
+                        implementation(libs.findLibrary("kotlinx-coroutines-core").get())
+                    }
+                }
+                sourceSets.named("androidMain") {
+                    dependencies {
+                        implementation(libs.findLibrary("timber").get())
+                    }
+                }
+                sourceSets.named("androidHostTest") {
+                    dependencies {
+                        implementation(libs.findLibrary("kotlin-test-junit").get())
+                        // Provides robolectric.properties, which pins the Robolectric SDK level.
+                        implementation(project(":libs:test-utils"))
+                    }
+                }
+                sourceSets.named("jvmTest") {
+                    dependencies {
+                        implementation(libs.findLibrary("kotlin-test-junit").get())
+                    }
+                }
+            }
+
+            tasks.withType<Test> {
+                failOnNoDiscoveredTests.set(false)
+                maxHeapSize = "2g"
+            }
+        }
+    }
+}

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

@@ -1,5 +1,12 @@
+import com.android.build.api.dsl.KotlinMultiplatformAndroidLibraryTarget
 import org.gradle.api.Plugin
 import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.api.plugins.ExtensionAware
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.getByType
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 /**
  * Convention plugin for KMP library modules.
@@ -8,14 +15,26 @@ import org.gradle.api.Project
  *   - `org.jetbrains.kotlin.multiplatform`
  *   - `com.android.kotlin.multiplatform.library`
  *
- * After applying this plugin the `kotlin {}` DSL block is available for configuring targets,
- * source sets, and dependencies.
+ * and declares the targets every shared library builds for:
+ *   - `android` -- compileSdk and minSdk from the version catalog
+ *   - `iosArm64`, `iosSimulatorArm64`, `iosX64`, `macosArm64`, `macosX64` -- the Kotlin/Native
+ *     slices of the `SharedCore` framework iOS consumes
+ *   - `jvm` -- the desktop client
+ *
+ * A module still sets its own `namespace`, and opts into host/device tests, inside `kotlin { android {} }`.
  *
  * Usage in a module's `build.gradle.kts`:
  * ```
  * plugins {
  *     alias(libs.plugins.flipcash.kmp.library)
  * }
+ *
+ * kotlin {
+ *     android {
+ *         namespace = "com.example"
+ *         withHostTest {}
+ *     }
+ * }
  * ```
  */
 class KmpLibraryConventionPlugin : Plugin<Project> {
@@ -25,6 +44,35 @@ class KmpLibraryConventionPlugin : Plugin<Project> {
                 apply("org.jetbrains.kotlin.multiplatform")
                 apply("com.android.kotlin.multiplatform.library")
             }
+
+            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+            val compileSdkVersion = libs.findVersion("android-compileSdk").get().requiredVersion.toInt()
+            val compileSdkMinorVersion = libs.findVersion("android-compileSdkMinor").get().requiredVersion.toInt()
+            val minSdkVersion = libs.findVersion("android-minSdk").get().requiredVersion.toInt()
+            val javaVersion = libs.findVersion("android-java").get().requiredVersion
+
+            extensions.configure<KotlinMultiplatformExtension> {
+                (this as ExtensionAware).extensions.configure<KotlinMultiplatformAndroidLibraryTarget> {
+                    compileSdk {
+                        version = release(compileSdkVersion) {
+                            minorApiLevel = compileSdkMinorVersion
+                        }
+                    }
+                    minSdk = minSdkVersion
+                }
+
+                iosArm64()
+                iosSimulatorArm64()
+                iosX64()
+                macosArm64()
+                macosX64()
+
+                jvm {
+                    compilerOptions {
+                        jvmTarget.set(JvmTarget.fromTarget(javaVersion))
+                    }
+                }
+            }
         }
     }
 }

gradle/libs.versions.toml

@@ -349,6 +349,7 @@ flipcash-android-library-compose = { id = "flipcash.android.library.compose" }
 flipcash-android-feature = { id = "flipcash.android.feature" }
 flipcash-android-ed25519-shadow = { id = "flipcash.android.ed25519.shadow" }
 flipcash-kmp-library = { id = "flipcash.kmp.library" }
+flipcash-kmp-app-library = { id = "flipcash.kmp.app.library" }
 flipcash-kmp-test-fixtures = { id = "flipcash.kmp.test.fixtures" }
 flipcash-analytics-catalogue = { id = "flipcash.analytics.catalogue" }
 android-application = { id = "com.android.application", version.ref = "agp" }

kmp/shared-core/build.gradle.kts

@@ -1,9 +1,9 @@
 import co.touchlab.kmmbridge.KmmBridgeExtension
 import org.gradle.api.tasks.bundling.Zip
+import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 
 plugins {
-    kotlin("multiplatform")
-    id("com.android.kotlin.multiplatform.library")
+    alias(libs.plugins.flipcash.kmp.library)
     id("co.touchlab.kmmbridge.github") version "1.2.1"
     `maven-publish`
 }
@@ -24,17 +24,11 @@ val spmPackageDir = findProperty("spmRepoDir") as String?
 kotlin {
     android {
         namespace = "com.flipcash.shared"
-        compileSdk {
-            version = release(libs.versions.android.compileSdk.get().toInt()) {
-                minorApiLevel = libs.versions.android.compileSdkMinor.get().toInt()
-            }
-        }
-        minSdk = 29
     }
-    
-    val appleTargets = listOf(iosArm64(), iosSimulatorArm64(), iosX64(), macosArm64(), macosX64())
-    appleTargets.forEach {
-        it.binaries.framework {
+
+    // The Apple targets come from `flipcash.kmp.library`; each one ships a `SharedCore` slice.
+    targets.withType<KotlinNativeTarget>().configureEach {
+        binaries.framework {
             baseName = "SharedCore"
             isStatic = true
             export(project(":libs:codes:kikcode"))

libs/analytics-events/build.gradle.kts

@@ -1,28 +1,15 @@
 plugins {
-    kotlin("multiplatform")
-    id("com.android.kotlin.multiplatform.library")
+    alias(libs.plugins.flipcash.kmp.library)
     // Generates the builders and value enums from events.toml into commonMain.
     alias(libs.plugins.flipcash.analytics.catalogue)
 }
 
 kotlin {
     android {
         namespace = "com.flipcash.analytics"
-        compileSdk {
-            version = release(libs.versions.android.compileSdk.get().toInt()) {
-                minorApiLevel = libs.versions.android.compileSdkMinor.get().toInt()
-            }
-        }
-        minSdk = 29
         withHostTest {}
     }
 
-    iosArm64()
-    iosSimulatorArm64()
-    iosX64()
-    macosArm64()
-    macosX64()
-
     sourceSets {
         commonMain {
             // Pure Kotlin -- no external dependencies needed.