Add jvm target with Hot Reload (beta06)

sellmair · sellmair · commit 606005b432ca · 2025-09-14T20:03:43.000+02:00
diff --git a/app-core/build.gradle.kts b/app-core/build.gradle.kts
@@ -6,6 +6,7 @@ plugins {
 pacemaker {
     ios()
     android()
+    jvm()
 
     features {
         useSqlDelight {
diff --git a/app-core/src/jvmMain/kotlin/io/sellmair/pacemaker/ApplicationBackend.jvm.kt b/app-core/src/jvmMain/kotlin/io/sellmair/pacemaker/ApplicationBackend.jvm.kt
@@ -0,0 +1,67 @@
+package io.sellmair.pacemaker
+
+import app.cash.sqldelight.driver.jdbc.sqlite.JdbcSqliteDriver
+import com.russhwolf.settings.PreferencesSettings
+import com.russhwolf.settings.Settings
+import io.sellmair.evas.Events
+import io.sellmair.evas.States
+import io.sellmair.pacemaker.bluetooth.HeartRateSensor
+import io.sellmair.pacemaker.bluetooth.HeartRateSensorBluetoothService
+import io.sellmair.pacemaker.bluetooth.PacemakerBluetoothService
+import io.sellmair.pacemaker.sql.PacemakerDatabase
+import kotlinx.coroutines.CompletableDeferred
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Deferred
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.update
+import java.util.prefs.Preferences
+
+actual fun ApplicationBackend.launchPlatform(scope: CoroutineScope) {
+    scope.launchHeartRateSensorEmulation()
+}
+
+object JvmApplicationBackend : ApplicationBackend {
+    override val pacemakerBluetoothService: Deferred<PacemakerBluetoothService>
+        get() = CompletableDeferred()
+
+    override val heartRateSensorBluetoothService: Deferred<HeartRateSensorBluetoothService>
+        get() = CompletableDeferred(JvmHeartRateSensorBluetoothService)
+
+    private val database by lazy { createInMemoryDatabase() }
+
+    override val sessionService: SessionService by lazy {
+        SqlSessionService(database)
+    }
+
+    private val meId by lazy {
+        settings.meId
+    }
+
+    override val userService: UserService by lazy {
+        SqlUserService(database, meId)
+    }
+
+    override val states: States = States()
+    override val events: Events = Events()
+    override val settings: Settings = PreferencesSettings(Preferences.userRoot())
+}
+
+
+internal fun createInMemoryDatabase(): SafePacemakerDatabase = SafePacemakerDatabase {
+    val driver = JdbcSqliteDriver(JdbcSqliteDriver.IN_MEMORY)
+    PacemakerDatabase.Schema.create(driver)
+    PacemakerDatabase(driver)
+}
+
+object JvmHeartRateSensorBluetoothService : HeartRateSensorBluetoothService {
+    fun addSensor(sensor: HeartRateSensor) {
+        allSensorsNearby.update { sensors -> sensors + sensor }
+        newSensorsNearby.tryEmit(sensor)
+    }
+
+    override val newSensorsNearby = MutableSharedFlow<HeartRateSensor>(replay = 1)
+
+
+    override val allSensorsNearby = MutableStateFlow<List<HeartRateSensor>>(emptyList())
+}
diff --git a/app-core/src/jvmMain/kotlin/io/sellmair/pacemaker/BluetoothState.jvm.kt b/app-core/src/jvmMain/kotlin/io/sellmair/pacemaker/BluetoothState.jvm.kt
@@ -0,0 +1,9 @@
+package io.sellmair.pacemaker
+
+internal actual suspend fun isBluetoothEnabled(): Boolean {
+    return true
+}
+
+internal actual suspend fun isBluetoothPermissionGranted(): Boolean {
+    return true
+}
diff --git a/app-core/src/jvmMain/kotlin/io/sellmair/pacemaker/heartRateSensorEmulation.kt b/app-core/src/jvmMain/kotlin/io/sellmair/pacemaker/heartRateSensorEmulation.kt
@@ -0,0 +1,82 @@
+package io.sellmair.pacemaker
+
+import io.sellmair.pacemaker.ble.BleConnectable
+import io.sellmair.pacemaker.ble.BleConnection
+import io.sellmair.pacemaker.ble.BleDeviceId
+import io.sellmair.pacemaker.ble.BleServiceDescriptor
+import io.sellmair.pacemaker.bluetooth.HeartRateSensor
+import io.sellmair.pacemaker.bluetooth.HeartRateSensorMeasurement
+import io.sellmair.pacemaker.bluetooth.HeartRateSensorServiceDescriptors
+import io.sellmair.pacemaker.model.HeartRate
+import io.sellmair.pacemaker.model.HeartRateSensorId
+import io.sellmair.pacemaker.model.HeartRateSensorInfo
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+import kotlin.random.Random
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
+
+fun CoroutineScope.launchHeartRateSensorEmulation(): Job = launch {
+    val mySensor = object : HeartRateSensor {
+        override val heartRate = MutableSharedFlow<HeartRateSensorMeasurement>()
+
+        init {
+            launch {
+                var currentHeartRate = HeartRate(Random.nextInt(50, 100))
+                var drift = 0f
+
+                launch {
+                    while (isActive) {
+                        delay(2.seconds)
+                        drift = (Random.nextFloat() - 0.5f) * 0.5f
+                    }
+                }
+
+                while (isActive) {
+                    delay(128.milliseconds)
+                    val delta = (Random.nextFloat() - 0.5f) + drift
+                    currentHeartRate = HeartRate(Math.clamp(currentHeartRate.value + delta, 40f, 160f))
+
+                    heartRate.emit(
+                        HeartRateSensorMeasurement(
+                            heartRate = currentHeartRate,
+                            sensorInfo = HeartRateSensorInfo(HeartRateSensorId(deviceId.value)),
+                            receivedTime = Clock.System.now()
+                        )
+                    )
+                }
+            }
+        }
+
+        override val deviceName: String = "Emulated"
+
+        override val deviceId: BleDeviceId
+            get() = BleDeviceId("Emulated")
+
+        override val service: BleServiceDescriptor
+            get() = HeartRateSensorServiceDescriptors.service
+
+        private val _connection = MutableStateFlow<BleConnection?>(null)
+
+        override val connection: SharedFlow<BleConnection> = _connection
+            .filterNotNull()
+            .shareIn(this@launch, SharingStarted.Eagerly)
+
+        override val connectionState = MutableStateFlow(BleConnectable.ConnectionState.Disconnected)
+
+        override val connectIfPossible = MutableStateFlow(false)
+
+        override fun connectIfPossible(connect: Boolean) {
+            connectIfPossible.value = connect
+
+            connectionState.value = if (connect) BleConnectable.ConnectionState.Connected
+            else BleConnectable.ConnectionState.Disconnected
+        }
+
+        override val rssi = MutableStateFlow<Int?>(24)
+
+    }
+
+    JvmHeartRateSensorBluetoothService.addSensor(mySensor)
+}
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
@@ -7,14 +7,16 @@ import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
 
 plugins {
-    id("pacemaker-application")
-    id("org.jetbrains.compose")
-    kotlin("plugin.compose")
+    `pacemaker-application`
+    org.jetbrains.compose
+    org.jetbrains.kotlin.plugin.compose
+    id("org.jetbrains.compose.hot-reload")
 }
 
 pacemaker {
     ios()
     android()
+    jvm()
 }
 
 extensions.configure(ApplicationExtension::class) {
@@ -48,6 +50,11 @@ kotlin {
 
     }
 
+    sourceSets.jvmMain.dependencies {
+        implementation(compose.desktop.currentOs)
+        implementation(deps.coroutines.swing)
+    }
+
     sourceSets.androidMain.get().dependencies {
         /* androidx */
         implementation("androidx.activity:activity-compose:1.9.3")
diff --git a/app/src/androidMain/kotlin/launchPlatformSpecificFrontendServices.kt b/app/src/androidMain/kotlin/launchPlatformSpecificFrontendServices.kt
diff --git a/app/src/appleMain/kotlin/launchPlatformSpecificFrontendServices.kt b/app/src/appleMain/kotlin/launchPlatformSpecificFrontendServices.kt
diff --git a/app/src/commonMain/kotlin/io/sellmair/pacemaker/launchFrontendServices.kt b/app/src/commonMain/kotlin/io/sellmair/pacemaker/launchFrontendServices.kt
@@ -5,8 +5,4 @@ import kotlinx.coroutines.CoroutineScope
 
 fun CoroutineScope.launchFrontendServices() {
     launchHeartRateUtteranceActor()
-    launchPlatformSpecificFrontendServices()
 }
-
-expect fun CoroutineScope.launchPlatformSpecificFrontendServices()
-
diff --git a/app/src/jvmMain/kotlin/io/sellmair/pacemaker/ui/BackHandlerIfAny.jvm.kt b/app/src/jvmMain/kotlin/io/sellmair/pacemaker/ui/BackHandlerIfAny.jvm.kt
@@ -0,0 +1,5 @@
+package io.sellmair.pacemaker.ui
+
+@androidx.compose.runtime.Composable
+internal actual fun BackHandlerIfAny(enabled: Boolean, onBack: () -> Unit) {
+}
diff --git a/app/src/jvmMain/kotlin/io/sellmair/pacemaker/ui/main.kt b/app/src/jvmMain/kotlin/io/sellmair/pacemaker/ui/main.kt
@@ -0,0 +1,40 @@
+package io.sellmair.pacemaker.ui
+
+import androidx.compose.material.Text
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.unit.DpSize
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.window.WindowPosition
+import androidx.compose.ui.window.WindowState
+import androidx.compose.ui.window.singleWindowApplication
+import io.sellmair.evas.compose.installEvas
+import io.sellmair.evas.eventsOrThrow
+import io.sellmair.evas.statesOrThrow
+import io.sellmair.pacemaker.JvmApplicationBackend
+import io.sellmair.pacemaker.JvmHeartRateSensorBluetoothService
+import io.sellmair.pacemaker.launchApplicationBackend
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+
+ val appScope = CoroutineScope(
+    SupervisorJob() + Dispatchers.Main +
+        JvmApplicationBackend.events + JvmApplicationBackend.states
+)
+
+fun main() {
+
+    JvmApplicationBackend.launchApplicationBackend(appScope)
+
+
+    singleWindowApplication(
+        title = "Pacemaker",
+        alwaysOnTop = true,
+        state = WindowState(position = WindowPosition.Aligned(Alignment.TopEnd), size = DpSize(400.dp, 800.dp)),
+    ) {
+        installEvas(appScope.coroutineContext.eventsOrThrow, appScope.coroutineContext.statesOrThrow) {
+            ApplicationWindow()
+        }
+    }
+}
+
diff --git a/bluetooth-core/build.gradle.kts b/bluetooth-core/build.gradle.kts
@@ -6,6 +6,7 @@ pacemaker {
     android()
     ios()
     macos()
+    jvm()
 }
 
 kotlin {
diff --git a/bluetooth-core/src/jvmMain/kotlin/io/sellmair/pacemaker/ble/BleUUID.jvm.kt b/bluetooth-core/src/jvmMain/kotlin/io/sellmair/pacemaker/ble/BleUUID.jvm.kt
@@ -0,0 +1,5 @@
+package io.sellmair.pacemaker.ble
+
+actual fun BleUUID(value: String): BleUUID = value
+
+actual typealias BleUUID = String
diff --git a/bluetooth/build.gradle.kts b/bluetooth/build.gradle.kts
@@ -6,6 +6,7 @@ pacemaker {
     android()
     ios()
     macos()
+    jvm()
 }
 
 kotlin {
diff --git a/bluetooth/src/commonMain/kotlin/io/sellmair/pacemaker/bluetooth/HeartRateSensorServiceDescriptors.kt b/bluetooth/src/commonMain/kotlin/io/sellmair/pacemaker/bluetooth/HeartRateSensorServiceDescriptors.kt
@@ -4,7 +4,7 @@ import io.sellmair.pacemaker.ble.BleCharacteristicDescriptor
 import io.sellmair.pacemaker.ble.BleServiceDescriptor
 import io.sellmair.pacemaker.ble.BleUUID
 
-internal object HeartRateSensorServiceDescriptors {
+object HeartRateSensorServiceDescriptors {
     val heartRateCharacteristic = BleCharacteristicDescriptor(
         name = "Heart Rate",
         uuid = BleUUID("00002a37-0000-1000-8000-00805f9b34fb"),
@@ -17,4 +17,4 @@ internal object HeartRateSensorServiceDescriptors {
         uuid = BleUUID("0000180D-0000-1000-8000-00805f9b34fb"),
         characteristics = setOf(heartRateCharacteristic)
     )
-}
+}
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
@@ -5,9 +5,10 @@ plugins {
 }
 
 dependencies {
-    implementation(deps.compose.gradlePlugin)
-    implementation(deps.kotlin.composeCompilerPlugin)
     implementation(deps.kotlin.gradlePlugin)
+    implementation(deps.kotlin.composeCompilerPlugin)
+    implementation(deps.compose.gradlePlugin)
+    implementation(deps.compose.hotReload.gradlePlugin)
     implementation(deps.android.gradlePlugin)
     implementation(deps.sqldelight.gradlePlugin)
     implementation(deps.atomicFu.gradlePlugin)
diff --git a/buildSrc/settings.gradle.kts b/buildSrc/settings.gradle.kts
@@ -18,5 +18,7 @@ dependencyResolutionManagement {
                 includeGroupByRegex(".*android.*")
             }
         }
+        maven("https://repo.sellmair.io")
     }
+
 }
diff --git a/buildSrc/src/main/kotlin/Dependencies.kt b/buildSrc/src/main/kotlin/Dependencies.kt
@@ -5,8 +5,10 @@ object Dependencies {
     const val androidx_core_ktx = "androidx.core:core-ktx:1.13.1"
     const val atomicFu_gradlePlugin = "org.jetbrains.kotlinx:atomicfu-gradle-plugin:0.29.0"
     const val compose_gradlePlugin = "org.jetbrains.compose:compose-gradle-plugin:1.8.2"
+    const val compose_hotReload_gradlePlugin = "org.jetbrains.compose.hot-reload:hot-reload-gradle-plugin:1.0.0-beta06"
     const val coroutines_android = "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.10.1"
     const val coroutines_core = "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.1"
+    const val coroutines_swing = "org.jetbrains.kotlinx:kotlinx-coroutines-swing:1.10.1"
     const val coroutines_test = "org.jetbrains.kotlinx:kotlinx-coroutines-test:1.10.1"
     const val evas = "io.sellmair:evas:1.3.0"
     const val evas_compose = "io.sellmair:evas-compose:1.3.0"
@@ -16,5 +18,9 @@ object Dependencies {
     const val kotlinx_datetime = "org.jetbrains.kotlinx:kotlinx-datetime:0.7.1"
     const val multiplatform_settings = "com.russhwolf:multiplatform-settings:1.3.0"
     const val okio = "com.squareup.okio:okio:3.10.2"
+    const val sqldelight_androidDriver = "app.cash.sqldelight:android-driver:2.1.0"
+    const val sqldelight_coroutineExtensions = "app.cash.sqldelight:coroutines-extensions:2.1.0"
     const val sqldelight_gradlePlugin = "app.cash.sqldelight:gradle-plugin:2.1.0"
+    const val sqldelight_nativeDriver = "app.cash.sqldelight:native-driver:2.1.0"
+    const val sqldelight_sqliteDriver = "app.cash.sqldelight:sqlite-driver:2.1.0"
 }
diff --git a/buildSrc/src/main/kotlin/PacemakerExtension.kt b/buildSrc/src/main/kotlin/PacemakerExtension.kt
@@ -1,4 +1,3 @@
-
 import app.cash.sqldelight.gradle.SqlDelightExtension
 import com.android.build.api.dsl.ApplicationExtension
 import com.android.build.gradle.BaseExtension
@@ -103,22 +102,24 @@ class PacemakerExtension(
             project.plugins.apply("app.cash.sqldelight")
             kotlin {
                 sourceSets.commonMain.dependencies {
-                    implementation("app.cash.sqldelight:coroutines-extensions:2.0.2")
+                    implementation(Dependencies.sqldelight_coroutineExtensions)
                 }
 
                 sourceSets.androidMain.dependencies {
-                    implementation("app.cash.sqldelight:android-driver:2.0.2")
+                    implementation(Dependencies.sqldelight_androidDriver)
                 }
 
                 sourceSets.getByName("androidUnitTest").dependencies {
-                    implementation("app.cash.sqldelight:sqlite-driver:2.0.2")
+                    implementation(Dependencies.sqldelight_sqliteDriver)
                 }
 
                 sourceSets.nativeMain.dependencies {
-                    implementation("app.cash.sqldelight:native-driver:2.0.2")
+                    implementation(Dependencies.sqldelight_nativeDriver)
                 }
 
-
+                sourceSets.jvmMain.dependencies {
+                    implementation(Dependencies.sqldelight_sqliteDriver)
+                }
             }
 
             project.extensions.configure(SqlDelightExtension::class.java) {
diff --git a/buildSrc/src/main/kotlin/pacemaker.gradle.kts b/buildSrc/src/main/kotlin/pacemaker.gradle.kts
@@ -1,3 +1,5 @@
+@file:OptIn(ExperimentalKotlinGradlePluginApi::class)
+
 import org.jetbrains.compose.ComposePlugin
 import org.jetbrains.kotlin.gradle.ExperimentalKotlinGradlePluginApi
 
diff --git a/dependencies.toml b/dependencies.toml
diff --git a/settings.gradle.kts b/settings.gradle.kts

Original file line number	Diff line number	Diff line change
`@@ -5,8 +5,4 @@ import kotlinx.coroutines.CoroutineScope`
`5`	`5`
`6`	`6`	`fun CoroutineScope.launchFrontendServices() {`
`7`	`7`	`launchHeartRateUtteranceActor()`
`8`		`- launchPlatformSpecificFrontendServices()`
`9`	`8`	`}`
`10`		`-`
`11`		`-expect fun CoroutineScope.launchPlatformSpecificFrontendServices()`
`12`		`-`