feat(app): add jvm target.

.github/workflows/build.yaml

@@ -10,7 +10,7 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  android:
+  composeApp:
     runs-on: ubuntu-latest
     timeout-minutes: 60
     steps:
@@ -32,20 +32,20 @@ jobs:
         run: mkdir -p ~/.gradle ; cp .github/ci-gradle.properties ~/.gradle/gradle.properties
 
       - name: Check Kotlin lint
-        run: ./gradlew :androidApp:ktlintCheck :androidApp:detekt
+        run: ./gradlew :composeApp:ktlintCheck :composeApp:detekt
 
       - name: Check lint
-        run: ./gradlew :androidApp:lintDebug
+        run: ./gradlew :composeApp:lintDebug
 
       - name: Check and build android project
-        run: ./gradlew :androidApp:assembleDebug :androidApp:bundleDebug
+        run: ./gradlew :composeApp:assembleDebug :composeApp:bundleDebug
 
       - name: Upload build outputs
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: android-build-outputs
-          path: androidApp/build/outputs
+          path: composeApp/build/outputs
 
       - name: Upload reports
         if: always()

android-core/core-sample/build.gradle.kts

@@ -9,7 +9,7 @@ plugins {
 android {
     namespace = "com.paligot.confily.core.sample"
 
-    val appProps = rootProject.file("androidApp/app.properties").toProperties()
+    val appProps = rootProject.file("composeApp/app.properties").toProperties()
     buildTypes {
         getByName("release") {
             stringBuildConfigField("BASE_URL", appProps)

baselineprofile/build.gradle.kts

@@ -27,7 +27,7 @@ android {
         testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
     }
 
-    targetProjectPath = ":androidApp"
+    targetProjectPath = ":composeApp"
 
     testOptions.managedDevices.devices {
         create<ManagedVirtualDevice>("pixel8Api34") {

baselineprofile/src/main/java/com/paligot/confily/baselineprofile/BaselineProfileGenerator.kt

@@ -24,7 +24,7 @@ import org.junit.runner.RunWith
  * You can run the generator with the "Generate Baseline Profile" run configuration in Android Studio or
  * the equivalent `generateBaselineProfile` gradle task:
  * ```
- * ./gradlew :androidApp:generateReleaseBaselineProfile
+ * ./gradlew :composeApp:generateReleaseBaselineProfile
  * ```
  * The run configuration runs the Gradle task and applies filtering to run only the generators.
  *

build-logic/plugins/build.gradle.kts

@@ -24,6 +24,10 @@ gradlePlugin {
             id = "confily.android.application"
             implementationClass = "AndroidApplicationPlugin"
         }
+        register("application") {
+            id = "confily.application"
+            implementationClass = "ApplicationPlugin"
+        }
         register("sampleApplication") {
             id = "confily.sample"
             implementationClass = "conventions.SampleApplicationPlugin"

build-logic/plugins/src/main/kotlin/AndroidApplicationPlugin.kt

@@ -2,19 +2,23 @@
 import com.android.build.gradle.internal.dsl.BaseAppModuleExtension
 import extensions.configureDesugaring
 import extensions.configureKotlinAndroid
+import extensions.configureKotlinCompiler
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.apply
 import org.gradle.kotlin.dsl.configure
 import org.gradle.kotlin.dsl.dependencies
+import org.gradle.kotlin.dsl.get
 import org.gradle.kotlin.dsl.getByType
+import org.jetbrains.compose.ComposeExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
 
 class AndroidApplicationPlugin: Plugin<Project> {
     override fun apply(target: Project) {
         with(target) {
             with(pluginManager) {
                 apply("com.android.application")
-                apply("org.jetbrains.kotlin.android")
                 apply("org.jetbrains.compose")
                 apply("org.jetbrains.kotlin.plugin.compose")
                 apply("kotlin-parcelize")
@@ -23,6 +27,7 @@ class AndroidApplicationPlugin: Plugin<Project> {
             }
             extensions.configure<BaseAppModuleExtension> {
                 configureKotlinAndroid(this)
+                configureKotlinCompiler(jvmVersion = 21)
                 configureDesugaring(this)
                 defaultConfig.targetSdk = 35
             }

build-logic/plugins/src/main/kotlin/ApplicationPlugin.kt

@@ -0,0 +1,29 @@
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.artifacts.VersionCatalogsExtension
+import org.gradle.kotlin.dsl.configure
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.getByType
+import org.jetbrains.compose.ComposeExtension
+import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
+
+class ApplicationPlugin : Plugin<Project> {
+    override fun apply(target: Project) {
+        with(target) {
+            with(pluginManager) {
+                apply("confily.android.application")
+                apply("org.jetbrains.kotlin.multiplatform")
+            }
+            val libs = extensions.getByType<VersionCatalogsExtension>().named("libs")
+            val compose = extensions.getByType<ComposeExtension>()
+            extensions.configure<KotlinMultiplatformExtension> {
+                androidTarget()
+                jvm("desktop")
+                sourceSets["desktopMain"].dependencies {
+                    implementation(compose.dependencies.desktop.currentOs)
+                    implementation(libs.findLibrary("jetbrains-kotlinx-coroutines-swing").get())
+                }
+            }
+        }
+    }
+}

build-logic/plugins/src/main/kotlin/conventions/SampleApplicationPlugin.kt

@@ -41,7 +41,7 @@ class SampleApplicationPlugin : Plugin<Project> {
                     getByName("debug") {
                         keyAlias = "debug"
                         keyPassword = "android"
-                        storeFile = rootProject.file("androidApp/keystore.debug")
+                        storeFile = rootProject.file("composeApp/keystore.debug")
                         storePassword = "android"
                     }
                 }

androidApp/build.gradle.kts → composeApp/build.gradle.kts

@@ -2,9 +2,8 @@ import extensions.stringBuildConfigField
 import extensions.toProperties
 
 plugins {
-    id("confily.android.application")
+    id("confily.application")
     id("confily.quality")
-    id("com.android.application")
     id("androidx.baselineprofile")
 }
 
@@ -68,48 +67,55 @@ android {
     buildFeatures {
         buildConfig = true
     }
-}
-
-dependencies {
-    implementation(projects.features.main.main)
-    implementation(projects.features.main.mainDi)
-    implementation(projects.features.navigation)
-    implementation(projects.features.schedules.schedulesRoutes)
-    implementation(projects.features.networking.networkingRoutes)
-    implementation(projects.widgets.widgetsPresentation)
-    implementation(projects.widgets.widgetsStyle)
-    implementation(projects.shared.core)
-    implementation(projects.shared.coreDi)
-    implementation(projects.shared.resources)
-    implementation(libs.settings)
 
-    implementation(libs.google.material)
+    dependencies {
+        baselineProfile(projects.baselineprofile)
+    }
+}
 
-    implementation(libs.androidx.appcompat)
-    implementation(libs.androidx.browser)
+baselineProfile {
+    automaticGenerationDuringBuild = true
+}
 
-    implementation(libs.jetbrains.navigation.compose)
-    implementation(libs.bundles.jetbrains.compose.adaptive)
-    implementation(libs.jetbrains.kotlinx.datetime)
+kotlin {
+    sourceSets {
+        commonMain.dependencies {
+            implementation(projects.features.main.main)
+            implementation(projects.features.main.mainDi)
+            implementation(projects.features.navigation)
+            implementation(projects.features.schedules.schedulesRoutes)
+            implementation(projects.features.networking.networkingRoutes)
+            implementation(projects.shared.core)
+            implementation(projects.shared.coreDi)
+            implementation(projects.shared.resources)
 
-    implementation(compose.ui)
-    implementation(compose.components.resources)
-    implementation(platform(libs.androidx.compose.bom))
-    implementation(libs.androidx.activity.compose)
-    implementation(libs.androidx.profile)
-    implementation(libs.androidx.workmanager.ktx)
-    implementation(libs.bundles.androidx.glance)
+            implementation(compose.ui)
+            implementation(compose.components.resources)
+            implementation(libs.jetbrains.navigation.compose)
+            implementation(libs.bundles.jetbrains.compose.adaptive)
+            implementation(libs.jetbrains.kotlinx.datetime)
 
-    implementation(libs.koin.core)
-    implementation(libs.koin.android)
-    implementation(libs.koin.androidx.workmanager)
+            implementation(libs.settings)
+            implementation(libs.coil3.compose)
+            implementation(libs.coil3.network.ktor)
+            implementation(libs.coil3.svg)
+            implementation(libs.bundles.koin)
+        }
+        androidMain.dependencies {
+            implementation(projects.widgets.widgetsPresentation)
+            implementation(projects.widgets.widgetsStyle)
 
-    implementation(libs.coil3.compose)
-    implementation(libs.coil3.network.ktor)
-    implementation(libs.coil3.svg)
-    baselineProfile(projects.baselineprofile)
-}
+            implementation(libs.androidx.appcompat)
+            implementation(libs.androidx.browser)
+            implementation(project.dependencies.platform(libs.androidx.compose.bom))
+            implementation(libs.androidx.activity.compose)
+            implementation(libs.androidx.profile)
+            implementation(libs.androidx.workmanager.ktx)
+            implementation(libs.bundles.androidx.glance)
+            implementation(libs.google.material)
 
-baselineProfile {
-    automaticGenerationDuringBuild = true
+            implementation(libs.koin.android)
+            implementation(libs.koin.androidx.workmanager)
+        }
+    }
 }

androidApp/src/main/java/com/paligot/confily/android/MainActivity.kt → composeApp/src/androidMain/kotlin/com/paligot/confily/android/MainActivity.kt

@@ -9,17 +9,12 @@ import androidx.activity.SystemBarStyle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
 import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.material3.adaptive.currentWindowSize
-import androidx.compose.material3.windowsizeclass.ExperimentalMaterial3WindowSizeClassApi
-import androidx.compose.material3.windowsizeclass.WindowSizeClass
 import androidx.compose.runtime.DisposableEffect
 import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalConfiguration
-import androidx.compose.ui.platform.LocalDensity
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.semantics.testTagsAsResourceId
-import androidx.compose.ui.unit.toSize
 import androidx.core.app.ShareCompat
 import androidx.core.content.FileProvider
 import androidx.glance.appwidget.updateAll
@@ -54,7 +49,6 @@ class MainActivity : ComponentActivity() {
         navController.handleDeepLink(intent)
     }
 
-    @OptIn(ExperimentalMaterial3WindowSizeClassApi::class)
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
@@ -74,15 +68,12 @@ class MainActivity : ComponentActivity() {
             navController = rememberNavController()
             val scope = rememberCoroutineScope()
             val config = LocalConfiguration.current
-            val windowSize = with(LocalDensity.current) { currentWindowSize().toSize().toDpSize() }
-            val adaptiveInfo = WindowSizeClass.calculateFromSize(windowSize)
             val exportSubject = stringResource(Resource.string.text_export_subject)
             val reportSubject = stringResource(Resource.string.text_report_subject)
             val reportAppTarget = stringResource(Resource.string.text_report_app_target)
             Main(
                 defaultEvent = BuildConfig.DEFAULT_EVENT,
                 isPortrait = config.isPortrait,
-                adaptiveInfo = adaptiveInfo,
                 launchUrl = { launchUrl(it) },
                 onContactExportClicked = { export ->
                     val uri: Uri = FileProvider.getUriForFile(
@@ -139,10 +130,10 @@ class MainActivity : ComponentActivity() {
                 onProfileCreated = {
                     scope.launch { NetworkingAppWidget().updateAll(context = this@MainActivity) }
                 },
-                navController = navController,
                 modifier = Modifier.semantics {
                     testTagsAsResourceId = true
-                }
+                },
+                navController = navController
             )
         }
     }