sync all values from nestdrop OSC on startup

- improve OSC class structure to reduce duplicated code
- improve XML watching and loading code

Author: NikkyAI

src/desktopMain/kotlin/Main.kt

@@ -30,9 +30,15 @@ import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.FlowPreview
 import kotlinx.coroutines.channels.consumeEach
 import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.consumeAsFlow
 import kotlinx.coroutines.flow.debounce
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.filterNotNull
+import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.flowOn
 import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.flow.mapNotNull
 import kotlinx.coroutines.flow.merge
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.launch
@@ -45,11 +51,11 @@ import nestdrop.deck.Deck
 import nestdrop.deck.PresetQueues
 import nestdrop.deck.loadDeckSettings
 import nestdrop.loadNestdropConfig
+import nestdrop.parseNestdropXml
 import nestdrop.setupSpriteFX
 import org.jetbrains.compose.resources.painterResource
-import osc.initializeSyncedValues
 import osc.runNestDropSend
-import osc.startNestdropListener
+import osc.startNestdropOSC
 import tags.startTagsFileWatcher
 import ui.App
 import ui.components.verticalScroll
@@ -153,14 +159,30 @@ object Main {
 
 //        OSCMessage("thiswillfail", "string", 'c', "" to "")
 
-        flowScope.launch(Dispatchers.IO) {
+        run {
             logger.info { "loading nestdrop XML" }
-            loadNestdropConfig(presetQueues, decks)
-            nestdropConfig.asWatchChannel(KWatchChannel.Mode.SingleFile).consumeEach {
-                if (it.kind == KWatchEvent.Kind.Modified) {
-                    loadNestdropConfig(presetQueues, decks)
+            loadNestdropConfig(parseNestdropXml(), presetQueues, decks)
+
+            nestdropConfig
+                .asWatchChannel(KWatchChannel.Mode.SingleFile)
+                .consumeAsFlow().mapNotNull {
+                    if (it.kind == KWatchEvent.Kind.Modified) {
+                        try {
+                            parseNestdropXml()
+                        } catch (e: Exception) {
+                            logger.error(e) { "failed to load XML after file modification was detected" }
+                            null
+                        }
+                    } else {
+                        null
+                    }
                 }
-            }
+                .distinctUntilChanged()
+                .onEach {
+                    logger.info { "parsed (changed) xml from $nestdropConfig" }
+                    loadNestdropConfig(it, presetQueues, decks)
+                }
+                .launchIn(flowScope)
         }
 
 
@@ -207,10 +229,8 @@ object Main {
 //        deck2.imgSprite.index.value--
 
         logger.info { "starting OSC listener" }
-        startNestdropListener()
+        startNestdropOSC()
 
-        logger.info { "initializing OSC synced values" }
-        initializeSyncedValues()
         delay(200)
 //        logger.info { "re-emitting all values" }
     }
@@ -345,7 +365,7 @@ object Main {
                         //                    transparent = true,
                         focusable = false,
                         alwaysOnTop = true,
-                        icon = painterResource (resource =  Res.drawable.blobhai_trans)
+                        icon = painterResource(resource = Res.drawable.blobhai_trans)
                     ) {
                         splashScreen()
                     }
@@ -354,7 +374,7 @@ object Main {
                         onCloseRequest = ::exitApplication,
                         title = "Nest Ctrl",
                         state = rememberWindowState(width = 1600.dp, height = 1200.dp),
-                        icon = painterResource (resource =  Res.drawable.blobhai_trans)
+                        icon = painterResource(resource = Res.drawable.blobhai_trans)
                     ) {
                         App()
                     }

src/desktopMain/kotlin/beatCounter.kt

@@ -44,6 +44,8 @@ val bpmSynced = OscSynced.ValueSingle<Float>(
 //    it.logReceived = false
 //}
 
+val beatCounter = MutableStateFlow(0.0)
+
 suspend fun startBeatCounter(
 //    vararg decks: Deck
 ) {
@@ -89,7 +91,7 @@ suspend fun startBeatCounter(
 
 
     run {
-        val beatCounter = MutableStateFlow(0.0)
+//        val beatCounter = MutableStateFlow(0.0)
 
         beatCounter.combine(beatFrame) { beats, beatFrame ->
             beats to beatFrame
@@ -102,9 +104,9 @@ suspend fun startBeatCounter(
 //                    var newBeatCounter = beatCounter.value
                 beatCounter.value %= totalBeats
 
-                decks.forEach {
-                    it.presetSwitching.resetLatch()
-                }
+//                decks.forEach {
+//                    it.presetSwitching.resetLatch()
+//                }
             }
         }
             .launchIn(flowScope)
@@ -129,10 +131,11 @@ suspend fun startBeatCounter(
 //        }
 //            .launchIn(flowScope)
 
-        decks.forEach { deck ->
-            deck.presetSwitching.beatFlow(beatCounter.runningHistoryNotNull())
-                .launchIn(flowScope)
-        }
+//        decks.forEach { deck ->
+//            deck.presetSwitching.beatFlow(beatCounter.runningHistoryNotNull())
+//                .launchIn(flowScope)
+//        }
+
 //        decks.forEach { deck ->
 //            deck.presetSwitching
 //                .beatFlow(

src/desktopMain/kotlin/nestdrop/NestdropControl.kt

@@ -101,11 +101,18 @@ sealed interface NestdropControl {
 
         private val valueLabel = MutableStateFlow("")
 
-        private val syncedFlow = OscSynced.ValueSingle(
+        private val syncedFlow = object : OscSynced.ValueSingle<Float>(
             address = sliderAddress,
             initialValue = initialValue,
             target = OscSynced.Target.Nestdrop,
-        )
+        ) {
+            override fun convertArg(input: Any): Float =
+                when (input) {
+                    is Float -> input
+                    is Number -> input.toFloat()
+                    else -> error("input should be a number")
+                }
+        }
 
         suspend fun doReset() {
             stateFlow.value = defaultValue

src/desktopMain/kotlin/nestdrop/deck/Deck.kt

@@ -3,7 +3,9 @@ package nestdrop.deck
 import androidx.compose.runtime.Immutable
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.compositeOver
+import beatCounter
 import beatFrame
+import com.illposed.osc.OSCMessage
 import configFolder
 import decks
 import flowScope
@@ -92,7 +94,7 @@ class Deck(
         val horizontalMotion = NestdropControl.SliderWithResetButton(id, "HorizonMotion", -0.5f..0.5f, 0.0f)
         val verticalMotion = NestdropControl.SliderWithResetButton(id, "VerticalMotion", -0.5f..0.5f, 0.0f)
         val stretchSpeed = NestdropControl.SliderWithResetButton(id, "StretchSpeed", 0.5f..1.5f, 1.0f)
-        val waveMode = NestdropControl.SliderWithResetButton(id, "WaveMode", -15f..15f, 0.0f)
+        val waveMode = NestdropControl.SliderWithResetButton(id, "WaveMode", -15f..15f, 0f)
 
         suspend fun startFlows() {
             transitionTime.startFlows()
@@ -258,47 +260,6 @@ class Deck(
         private val hasSwitchedNew = MutableStateFlow(false)
         val hasSwitched = hasSwitchedNew.asStateFlow()
 
-        suspend fun resetLatch() {
-//            hasSwitched.value = false
-        }
-
-        //        suspend fun beatFlowOldOld(
-//            flow: Flow<HistoryNotNull<Double>>
-//        ) = flow
-//            .combine(
-//                triggerTime.combine(beatFrame) { triggerTime, b ->
-//                    logger.info { "$deckName triggerTime: ${triggerTime * b} ($triggerTime * $b)" }
-//                    triggerTime * b
-//                }
-//            ) { (currentBeat, lastBeat), triggerAt ->
-//                Triple(currentBeat, lastBeat, triggerAt)
-//            }.onEach { (currentBeat, lastBeat, triggerAt) ->
-//
-////                logger.info { "currentBeat: $currentBeat" }
-////                logger.info { "triggerAt: $triggerAt" }
-//                if (!hasSwitched.value && lastBeat < triggerAt && currentBeat >= triggerAt) {
-//                    logger.info { "$deckName triggered at ${(currentBeat * 1000).roundToInt() / 1000f} ${(triggerAt * 1000).roundToInt() / 1000f}" }
-//                    hasSwitched.value = true
-//                    doSwitch()
-//                }
-//            }
-        suspend fun beatFlowOld(
-            flow: Flow<HistoryNotNull<Double>>
-        ) = combine(
-                flow,
-                triggerTime.combine(beatFrame) { triggerTime, b ->
-                    logger.info { "$deckName triggerTime: ${triggerTime * b} ($triggerTime * $b)" }
-                    triggerTime * b
-                },
-                isEnabled
-            ) { (currentBeat, lastBeat), triggerAt, isEnabled ->
-                if (isEnabled && !hasSwitched.value && lastBeat < triggerAt && currentBeat >= triggerAt) {
-                    logger.info { "$deckName triggered at ${(currentBeat * 1000).roundToInt() / 1000f} ${(triggerAt * 1000).roundToInt() / 1000f}" }
-//                    hasSwitched.value = true
-                    doSwitch()
-                }
-            }
-
         suspend fun beatFlow(
             flow: Flow<HistoryNotNull<Double>>
         ) = combine(
@@ -316,7 +277,9 @@ class Deck(
                 val shouldTrigger = (lastBeat < triggerAt && currentBeat >= triggerAt) || (lastBeat > beatFrame && currentBeat >= triggerAt)
 
                 if(shouldTrigger) {
-                    logger.info { "$deckName triggered at $currentBeat ($triggerAt)" }
+                    flowScope.launch {
+                        logger.info { "$deckName triggered at $currentBeat ($triggerAt)" }
+                    }
                     hasSwitchedNew.value = true
                     flowScope.launch {
                         val transitionTime = ndTime.transitionTime.value.toDouble().seconds
@@ -358,6 +321,36 @@ class Deck(
                 .joinToString(", ", "{", "}") { (k, v) -> "$k: \"$v\"" }
             appendWarn("SKIPPED $deckName preset: \"${preset.currentPreset.value.name}\" all decks: $otherDecks")
         }
+
+        suspend fun startFlows() {
+            combine(
+                beatCounter.runningHistoryNotNull(),
+                beatFrame,
+                triggerTime,
+                isEnabled,
+            ) { (currentBeat, lastBeat), beatFrame, triggerTime, isEnabled ->
+                val triggerAt = triggerTime * beatFrame
+                if (isEnabled && !hasSwitchedNew.value) {
+                    val shouldTrigger =
+                        (lastBeat < triggerAt && currentBeat >= triggerAt) || (lastBeat > beatFrame && currentBeat >= triggerAt)
+
+                    if (shouldTrigger) {
+                        logger.info { "$deckName triggered at $currentBeat $triggerAt" }
+                        hasSwitchedNew.emit(true)
+                        flowScope.launch {
+                            val transitionTime = ndTime.transitionTime.value.toDouble().seconds
+                            delay(transitionTime)
+                            hasSwitchedNew.emit(false)
+                        }
+                        flowScope.launch {
+                            doSwitch()
+                        }
+                    }
+                }
+                currentBeat
+            }
+                .launchIn(flowScope)
+        }
     }
 
     val presetSwitching = PresetSwitching()
@@ -371,6 +364,7 @@ class Deck(
         ndStrobe.startFlows()
         ndAudio.startFlows()
         ndOutput.startFlows()
+        presetSwitching.startFlows()
 
 //        transitionTime
 //            //TODO: combine with trigger flow
@@ -450,12 +444,15 @@ class Deck(
 
     @Immutable
     inner class Preset {
-        val currentPreset = OscSynced.FlowCustom(
+        val currentPreset = object: OscSynced.FlowBase<PresetData>(
             "/Deck$id/Preset",
 //            initialValue = PresetData(-1, "unitialized"),
             target = OscSynced.Target.Nestdrop
-        ) { address, arguments ->
-            PresetData(arguments[0] as Int, arguments[1] as String)
+        ) {
+            override fun convertMessage(message: OSCMessage): PresetData {
+                val input = message.arguments
+                return PresetData(input[0] as Int, input[1] as String)
+            }
         }
             .stateIn(flowScope, SharingStarted.Eagerly, initialValue = PresetData(-1, "unitialized"))
 
@@ -517,19 +514,22 @@ class Deck(
 
         val spoutTarget = MutableStateFlow(emptySet<SpriteKey>())
         val spoutStates = MutableStateFlow<Map<String, SpriteKey>>(mapOf())
-        private val spriteStateFlow = OscSynced.FlowCustom(
+        private val spriteStateFlow = object : OscSynced.FlowBase<SpriteData>(
             "/Deck$id/Sprite",
 //            SpriteData(),
             target = OscSynced.Target.Nestdrop
-        ) { _, args ->
-            SpriteData(
-                id = args[0] as Int,
-                name = args[1] as String,
-                mode = ImgMode.valueOf(args[2] as String),
-                fx = args[3] as Int,
-                mystery = args[4] as Int,
-                enabled = (args[5] as Int) == 1,
-            )
+        ) {
+            override fun convertMessage(message: OSCMessage): SpriteData {
+                val args = message.arguments
+                return SpriteData(
+                    id = args[0] as Int,
+                    name = args[1] as String,
+                    mode = ImgMode.valueOf(args[2] as String),
+                    fx = args[3] as Int,
+                    mystery = args[4] as Int,
+                    enabled = (args[5] as Int) == 1,
+                )
+            }
         }
 
 //        suspend fun enabledSprites() = imgStates.value.values
@@ -544,12 +544,11 @@ class Deck(
 //                .launchIn(flowScope)
 //            val imgSpriteIds = imgSpritesMap.map { it.values.map { it.id }.toSet() } //.stateIn(flowScope)
             spriteStateFlow
-                .onEach {
-                    logger.info { "$deckName sprite: $it" }
-                }
-
+//                .onEach {
+//                    logger.info { "$deckName sprite: $it" }
+//                }
                 .combine(
-                    imgSpritesMap.map { it.values.map { it.id }.toSet() }
+                    imgSpritesMap.map { map -> map.values.map { img -> img.id }.toSet() }
                 ) { spriteData, imgSpriteIds ->
                     spriteData.copy(isImg = spriteData.id in imgSpriteIds)
                 }

src/desktopMain/kotlin/nestdrop/loadQueues.kt

@@ -18,7 +18,7 @@ private val logger = KotlinLogging.logger { }
 //    ).trim().toInt()
 //}
 
-private suspend fun parseNestdropXml(
+suspend fun parseNestdropXml(
     retries: Int = 0
 ): NestdropSettings {
     val nestdropSettings: NestdropSettings = try {
@@ -33,7 +33,7 @@ private suspend fun parseNestdropXml(
         logger.error(e) { "failed to parse XML" }
         delay(100)
         if (retries < 5) {
-            return parseNestdropXml( retries + 1)
+            return parseNestdropXml(retries + 1)
         } else {
             throw e
         }
@@ -42,11 +42,12 @@ private suspend fun parseNestdropXml(
 }
 
 suspend fun loadNestdropConfig(
+    nestdropSettings: NestdropSettings,
     presetQueues: PresetQueues,
     decks: List<Deck>
 ) {
-    val nestdropSettings = parseNestdropXml()
-    logger.info { "loaded xml from $nestdropConfig" }
+//    val nestdropSettings = parseNestdropXml()
+//    logger.info { "loaded xml from $nestdropConfig" }
 
 //    val numberOfDecks = loadNumberOfDecks()
     val numberOfDecks = nestdropSettings.mainWindow.settingsGeneral.nbDecks