Files
Incido/composeApp/build.gradle.kts
T
Incido Developer 9ad7c60537 feat(phase-1/m4.2): :core:domain → multiplatform (androidTarget + jvm); NoteColors to commonMain
Phase-0 recommendation #1 ("core:domain is already JVM-clean —
convert it first; zero code changes"), now unlocked by M4.1: common
source sets cannot see plain kotlin("jvm") projects, so the domain
deploy was the gate for making composeApp's commonMain depend on
Note/NoteColor/NoteRepository. Sources move untouched (pure renames);
Flow moves implementation → api (it is in the public repository
interfaces — was already leaking, now stated).

androidTarget() drags in the AGP plugin + a namespace — the module is
now a library-for-Android too, but emits no Android-specific code and
needed no manifest (AGP 8 + namespace). Plain-JVM consumers
(:core:data-jvm, :core:backup, :core:settings, :desktopApp) and AGP
consumers (:core:data, :app) resolve through variant metadata with
ZERO import or build-line changes — verified below.

Then composeApp: api(project(":core:domain")) in commonMain (up from
androidMain), NoteColors.kt moves to commonMain — first real shared
UI-layer file with a domain dependency.

Verified: ./gradlew assembleDebug + :composeApp:compileKotlinJvm +
:core:data-jvm:smoke (M1a PASS) in one run, and
:desktopApp:run --args="--data-dir /tmp/incido-desktop-smoke3
--self-test --exit-after 6" (SELFTEST wrote note id=1).
2026-10-06 12:20:05 +13:00

141 lines
6.0 KiB
Kotlin

// composeApp — Incido's UI module: all screens, ViewModels, theme,
// navigation, and the manual DI container.
//
// Phase 1 (M4.1): converted in place from `kotlin("android")` to
// `kotlin("multiplatform")` with `androidTarget()` + `jvm()`, per the
// order of attack in tools/DESKTOP_PHASE_PLAN.md §6.1. The split is
// deliberately conservative — the goal of THIS step is the build shape:
//
// * commonMain — every file that compiles for both targets today
// (theme Color/Type, PasswordPolicy, ReleaseNotes,
// LinkedShareComposer) plus two expect/actual seams:
// `platformDynamicColorScheme` and `relativeTimestamp`.
// The Android actuals keep the pre-M4 code verbatim.
// * androidMain — everything still touching `android.*` (screens,
// ViewModels, AppContainer, security, backup IO, …),
// moved UNMODIFIED. Zero behaviour change; the seams
// for these move file-by-file in M4.2/M4.3.
// * jvmMain — the JVM actuals. Nothing else yet: :desktopApp keeps
// its own stand-in UI until M4.5 consumes this target.
//
// Note: :core:domain is still a plain kotlin("jvm") module, so
// commonMain cannot reference it yet — that is why NoteColors.kt stays
// in androidMain until :core:domain is converted in M4.2.
plugins {
alias(libs.plugins.androidLibrary)
alias(libs.plugins.kotlinMultiplatform)
// org.jetbrains.compose provides the `compose.*` dependency accessors
// that resolve to the right artifact per target (androidx.compose.*
// on androidTarget, *-desktop jars on jvm).
alias(libs.plugins.compose)
alias(libs.plugins.kotlinCompose)
// v0.3.2.0 — Kotlin Serialization for the Backup JSON codec (used by
// CarnetImporter today; the plugin stays target-agnostic).
alias(libs.plugins.kotlinSerialization)
}
kotlin {
jvmToolchain(17)
androidTarget()
jvm()
sourceSets {
commonMain.dependencies {
implementation(compose.runtime)
implementation(compose.ui)
implementation(compose.foundation)
implementation(compose.material3)
implementation(libs.kotlinx.coroutines.core)
// Phase 1 (M4.2): :core:domain is multiplatform now (M4.2's own
// conversion), so commonMain can see it — this is what let
// NoteColors.kt move up. api: screens/ViewModels across all
// targets consume Note/NoteColor/NoteRepository from it.
api(project(":core:domain"))
}
androidMain.dependencies {
implementation(project(":core:data"))
// Phase 1 (M2 task 1): backup codecs + bridge now live here; the
// org.incido.compose.data.backup package name was kept, so no imports
// changed — only this dependency line.
implementation(project(":core:backup"))
// Phase 1 (M3 task 1): settings repository, same treatment — package
// kept, the Context-based construction moved to AndroidSettingsStore.kt.
implementation(project(":core:settings"))
// Core / lifecycle
implementation(libs.androidx.core.ktx)
implementation(libs.androidx.lifecycle.viewmodel)
implementation(libs.androidx.lifecycle.viewmodel.compose)
implementation(libs.androidx.lifecycle.runtime)
implementation(libs.androidx.lifecycle.process)
implementation(libs.kotlinx.coroutines.android)
// Compose BOM keeps all Compose artefact versions aligned.
// (Called inline — the KMP source-set dependency handler's
// platform() returns a raw notation, not a Dependency, so the
// old `val composeBom = platform(…)` idiom fails here.)
implementation(project.dependencies.platform(libs.composeBom))
implementation(libs.androidx.activity.compose)
implementation(libs.androidx.navigation.compose)
// Compose (same org.jetbrains.compose artifacts as before the
// M4.1 conversion — they resolve to the androidx variants on
// this target; version alignment unchanged).
implementation(libs.compose.ui)
implementation(libs.compose.ui.tooling.preview)
implementation(libs.compose.foundation)
implementation(libs.compose.material3)
implementation(libs.compose.material.icons.extended)
// v0.3.2.0 — Settings (DataStore Preferences), Security (Biometric),
// and Backup (Kotlin Serialization JSON) support.
implementation(libs.androidx.datastore.preferences)
implementation(libs.androidx.biometric)
implementation(libs.kotlinx.serialization.json)
}
jvmMain.dependencies {
// Nothing yet — the compose artifacts arrive via commonMain;
// :core:data-jvm / :core:settings wiring lands with M4.3's
// container seam when :desktopApp starts consuming this target.
}
}
}
android {
namespace = "org.incido.compose"
compileSdk = 35
defaultConfig {
minSdk = 26
}
// M4.1: `buildFeatures.compose` is NOT set — the org.jetbrains.compose
// plugin owns Compose wiring on this target (setting it here alongside
// the KMP plugin is the classic double-wire; see §3 trap 6's sibling).
compileOptions {
sourceCompatibility = JavaVersion.VERSION_17
targetCompatibility = JavaVersion.VERSION_17
}
packaging {
resources {
excludes += "/META-INF/{AL2.0,LGPL2.1}"
}
}
}
// AGP's debug-only configurations are project-level, so the Compose
// tooling dependency that was `debugImplementation` before the M4.1
// conversion keeps that exact scope here (the KMP `sourceSets { … }`
// dependency handlers only expose implementation/api/compileOnly).
dependencies {
debugImplementation(libs.compose.ui.tooling)
}