diff --git a/server/android/src/main/java/dev/slimevr/android/ipc/ws-server.kt b/server/android/src/main/java/dev/slimevr/android/ipc/ws-server.kt index 081b4f4de..72b1768e2 100644 --- a/server/android/src/main/java/dev/slimevr/android/ipc/ws-server.kt +++ b/server/android/src/main/java/dev/slimevr/android/ipc/ws-server.kt @@ -19,6 +19,7 @@ import io.ktor.websocket.Frame import kotlinx.coroutines.awaitCancellation import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.flow.flow +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.MessageBundle import java.nio.ByteBuffer @@ -44,7 +45,7 @@ suspend fun createAndroidSolarXRWebsocketServer(appContext: AppContextProvider) val fbb = FlatBufferBuilder(256) fbb.finish(bundle.encode(JvmFlatBufferWriter(fbb))) send(Frame.Binary(fin = true, data = fbb.dataBuffer().moveToByteArray())) - } + }.launchIn(this) try { flow { diff --git a/server/core/src/main/java/dev/slimevr/driver/behaviours.kt b/server/core/src/main/java/dev/slimevr/driver/behaviours.kt index b95613e39..c62773d76 100644 --- a/server/core/src/main/java/dev/slimevr/driver/behaviours.kt +++ b/server/core/src/main/java/dev/slimevr/driver/behaviours.kt @@ -6,8 +6,6 @@ import dev.slimevr.device.DeviceActions import dev.slimevr.device.DeviceOrigin import dev.slimevr.tracker.Tracker import dev.slimevr.tracker.TrackerActions -import io.github.axisangles.ktmath.Quaternion -import io.github.axisangles.ktmath.Vector3 import kotlinx.coroutines.flow.launchIn import kotlinx.coroutines.flow.onEach import solarxr_protocol.datatypes.BodyPart @@ -99,7 +97,7 @@ class DriverIncomingTrackersBehaviour : DriverBridgeBehaviour { override fun observe(receiver: DriverBridge) { receiver.inbound.on { event -> receiver.context.dispatch(DriverBridgeActions.UpdateProtocolVersion(event.protocolVersion)) - } + }.launchIn(receiver.context.scope) receiver.inbound.on { event -> handleTrackerAdded( @@ -109,7 +107,7 @@ class DriverIncomingTrackersBehaviour : DriverBridgeBehaviour { event.manufacturer, event.serial, ) - } + }.launchIn(receiver.context.scope) receiver.inbound.on { event -> val trackerId = receiver.context.state.value.trackers[event.id] ?: return@on @@ -120,7 +118,7 @@ class DriverIncomingTrackersBehaviour : DriverBridgeBehaviour { }, ) } - } + }.launchIn(receiver.context.scope) receiver.inbound.on { event -> val trackerId = receiver.context.state.value.trackers[event.id] ?: return@on @@ -137,7 +135,7 @@ class DriverIncomingTrackersBehaviour : DriverBridgeBehaviour { }, ) } - } + }.launchIn(receiver.context.scope) } private fun handleTrackerAdded( diff --git a/server/core/src/main/java/dev/slimevr/event-dispatcher.kt b/server/core/src/main/java/dev/slimevr/event-dispatcher.kt index 97b7e587f..4e378721a 100644 --- a/server/core/src/main/java/dev/slimevr/event-dispatcher.kt +++ b/server/core/src/main/java/dev/slimevr/event-dispatcher.kt @@ -1,33 +1,23 @@ package dev.slimevr -import kotlin.reflect.KClass +import kotlinx.coroutines.channels.BufferOverflow +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.MutableSharedFlow +import kotlinx.coroutines.flow.SharedFlow +import kotlinx.coroutines.flow.asSharedFlow +import kotlinx.coroutines.flow.filterIsInstance +import kotlinx.coroutines.flow.onEach -class EventDispatcher(private val keyOf: (T) -> KClass<*> = { it::class }) { - @Volatile var listeners: Map, List Unit>> = emptyMap() +// For now, it blocks all the time, no queue. Maybe it is a bad idea IDK. Future us problem +class EventDispatcher( + extraBufferCapacity: Int = 0, + onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND, +) { + private val flow = MutableSharedFlow(extraBufferCapacity = extraBufferCapacity, onBufferOverflow = onBufferOverflow) + val events: SharedFlow = flow.asSharedFlow() - @Volatile private var globalListeners: List Unit> = emptyList() + suspend fun emit(event: T) = flow.emit(event) - fun register(key: KClass<*>, callback: suspend (T) -> Unit) { - synchronized(this) { - val updated = listeners.toMutableMap() - updated[key] = (updated[key] ?: emptyList()) + callback - listeners = updated - } - } - - @Suppress("UNCHECKED_CAST") - inline fun on(crossinline callback: suspend (P) -> Unit) { - register(P::class) { callback(it as P) } - } - - fun onAny(callback: suspend (T) -> Unit) { - synchronized(this) { - globalListeners = globalListeners + callback - } - } - - suspend fun emit(event: T) { - globalListeners.forEach { it(event) } - listeners[keyOf(event)]?.forEach { it(event) } - } + inline fun on(crossinline action: suspend (P) -> Unit): Flow

= + events.filterIsInstance

().onEach { action(it) } } diff --git a/server/core/src/main/java/dev/slimevr/hid/behaviours.kt b/server/core/src/main/java/dev/slimevr/hid/behaviours.kt index abadfe27b..1ed74c4f5 100644 --- a/server/core/src/main/java/dev/slimevr/hid/behaviours.kt +++ b/server/core/src/main/java/dev/slimevr/hid/behaviours.kt @@ -10,7 +10,7 @@ import dev.slimevr.tracker.TrackerActions import dev.slimevr.util.safeLaunch import kotlinx.coroutines.Job import kotlinx.coroutines.delay -import kotlinx.coroutines.isActive +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.datatypes.TrackerStatus class HIDRegistrationBehaviour : HIDReceiverBehaviour { @@ -31,10 +31,10 @@ class HIDRegistrationBehaviour : HIDReceiverBehaviour { } override fun observe(receiver: HIDReceiver) { - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> val state = receiver.context.state.value val existing = state.trackers[packet.hidId] - if (existing != null) return@onPacket + if (existing != null) return@on val existingDevice = receiver.appContext.server.context.state.value.devices.values .find { it.context.state.value.macAddress == packet.address && it.context.state.value.origin == DeviceOrigin.HID } @@ -42,7 +42,7 @@ class HIDRegistrationBehaviour : HIDReceiverBehaviour { if (existingDevice != null) { receiver.context.dispatch(HIDReceiverActions.DeviceRegistered(packet.hidId, packet.address, existingDevice.context.state.value.id)) AppLogger.hid.info("Reconnected HID device ${packet.address} (hidId=${packet.hidId})") - return@onPacket + return@on } val deviceId = receiver.appContext.server.nextHandle() @@ -58,7 +58,7 @@ class HIDRegistrationBehaviour : HIDReceiverBehaviour { receiver.appContext.server.context.dispatch(VRServerActions.NewDevice(deviceId, device)) receiver.context.dispatch(HIDReceiverActions.DeviceRegistered(packet.hidId, packet.address, deviceId)) AppLogger.hid.info("Registered HID device ${packet.address} (hidId=${packet.hidId})") - } + }.launchIn(receiver.context.scope) } } @@ -73,8 +73,8 @@ class HIDDeviceInfoBehaviour : HIDReceiverBehaviour { } override fun observe(receiver: HIDReceiver) { - receiver.packetEvents.onPacket { packet -> - val device = receiver.getDevice(packet.hidId) ?: return@onPacket + receiver.packetEvents.on { packet -> + val device = receiver.getDevice(packet.hidId) ?: return@on val deviceState = device.context.state.value device.context.dispatch( @@ -111,64 +111,64 @@ class HIDDeviceInfoBehaviour : HIDReceiverBehaviour { // HID does not have a rest calibration signal tracker.context.dispatch(TrackerActions.Update { copy(sensorType = packet.imuType, completedRestCalibration = true, magStatus = packet.magStatus) }) tracker.context.dispatch(TrackerActions.SetStatus(TrackerStatus.OK)) - } + }.launchIn(receiver.context.scope) } } class HIDRotationBehaviour : HIDReceiverBehaviour { override fun observe(receiver: HIDReceiver) { - receiver.packetEvents.onPacket { packet -> - val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket + receiver.packetEvents.on { packet -> + val tracker = receiver.getTracker(packet.hidId) ?: return@on tracker.context.dispatch(TrackerActions.SetRotation(rotation = packet.rotation, acceleration = packet.acceleration)) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> - val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket + receiver.packetEvents.on { packet -> + val tracker = receiver.getTracker(packet.hidId) ?: return@on tracker.context.dispatch(TrackerActions.SetRotation(rotation = packet.rotation, acceleration = packet.acceleration)) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> - val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket + receiver.packetEvents.on { packet -> + val tracker = receiver.getTracker(packet.hidId) ?: return@on tracker.context.dispatch(TrackerActions.SetRotation(rotation = packet.rotation, magnetometer = packet.magnetometer)) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> - val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket + receiver.packetEvents.on { packet -> + val tracker = receiver.getTracker(packet.hidId) ?: return@on tracker.context.dispatch(TrackerActions.SetRotation(rotation = packet.rotation, acceleration = packet.acceleration)) - } + }.launchIn(receiver.context.scope) } } class HIDBatteryBehaviour : HIDReceiverBehaviour { override fun observe(receiver: HIDReceiver) { - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> receiver.getDevice(packet.hidId)?.context?.dispatch( DeviceActions.Update { copy(batteryLevel = packet.batteryLevel, batteryVoltage = packet.batteryVoltage, signalStrength = packet.rssi) }, ) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> receiver.getDevice(packet.hidId)?.context?.dispatch( DeviceActions.Update { copy(signalStrength = packet.rssi) }, ) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> receiver.getDevice(packet.hidId)?.context?.dispatch( DeviceActions.Update { copy(signalStrength = packet.rssi) }, ) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> // -1: not yet known (keep existing value); 0: N/A (e.g. charging) if (packet.runtime >= 0) { receiver.getDevice(packet.hidId)?.context?.dispatch( DeviceActions.Update { copy(batteryRemainingRuntime = packet.runtime) }, ) } - } + }.launchIn(receiver.context.scope) } } @@ -210,41 +210,41 @@ class HIDSleepBehaviour : HIDReceiverBehaviour { armIdleTimeout(hidId) } - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> onPacket(packet.hidId) scheduleSleep(packet.hidId, packet.timeout) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> onPacket(packet.hidId) scheduleSleep(packet.hidId, packet.timeout) - } + }.launchIn(receiver.context.scope) - receiver.packetEvents.onPacket { packet -> onPacket(packet.hidId) } - receiver.packetEvents.onPacket { packet -> onPacket(packet.hidId) } - receiver.packetEvents.onPacket { packet -> onPacket(packet.hidId) } - receiver.packetEvents.onPacket { packet -> onPacket(packet.hidId) } - receiver.packetEvents.onPacket { packet -> onPacket(packet.hidId) } + receiver.packetEvents.on { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope) + receiver.packetEvents.on { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope) + receiver.packetEvents.on { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope) + receiver.packetEvents.on { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope) + receiver.packetEvents.on { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope) } } class HIDStatusBehaviour : HIDReceiverBehaviour { override fun observe(receiver: HIDReceiver) { - receiver.packetEvents.onPacket { packet -> - if (receiver.getTracker(packet.hidId) == null) return@onPacket + receiver.packetEvents.on { packet -> + if (receiver.getTracker(packet.hidId) == null) return@on receiver.getDevice(packet.hidId)?.context?.dispatch( DeviceActions.Update { copy(status = packet.status, signalStrength = packet.rssi) }, ) - } + }.launchIn(receiver.context.scope) } } class HIDPacketLossBehaviour : HIDReceiverBehaviour { override fun observe(receiver: HIDReceiver) { - receiver.packetEvents.onPacket { packet -> + receiver.packetEvents.on { packet -> receiver.getDevice(packet.hidId)?.context?.dispatch( DeviceActions.PacketStats(packetsReceived = packet.packetsReceived.toLong(), packetsLost = packet.packetsLost.toLong()), ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/hid/module.kt b/server/core/src/main/java/dev/slimevr/hid/module.kt index 58d2280db..33a8ff28b 100644 --- a/server/core/src/main/java/dev/slimevr/hid/module.kt +++ b/server/core/src/main/java/dev/slimevr/hid/module.kt @@ -29,11 +29,6 @@ typealias HIDReceiverContext = Context typealias HIDReceiverBehaviour = Behaviour typealias HIDPacketDispatcher = EventDispatcher -@Suppress("UNCHECKED_CAST") -inline fun HIDPacketDispatcher.onPacket(crossinline callback: suspend (T) -> Unit) { - register(T::class) { callback(it as T) } -} - class HIDReceiver( val context: HIDReceiverContext, val appContext: AppContextProvider, diff --git a/server/core/src/main/java/dev/slimevr/keybind/module.kt b/server/core/src/main/java/dev/slimevr/keybind/module.kt index 5cc110be4..387329f60 100644 --- a/server/core/src/main/java/dev/slimevr/keybind/module.kt +++ b/server/core/src/main/java/dev/slimevr/keybind/module.kt @@ -89,7 +89,7 @@ class KeybindTriggerBehaviour( KeybindId.NONE -> Unit } - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/bvh.kt b/server/core/src/main/java/dev/slimevr/solarxr/bvh.kt index cad9543ea..8f89666f4 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/bvh.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/bvh.kt @@ -17,11 +17,11 @@ class BvhBehaviour(private val bvhManager: BVHManager) : SolarXRBridgeBehaviour req.path?.let { path -> bvhManager.startRecording(path) } } receiver.sendRpc(RecordBVHStatus(recording = bvhManager.isRecording)) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { receiver.sendRpc(RecordBVHStatus(recording = bvhManager.isRecording)) - } + }.launchIn(receiver.context.scope) bvhManager.context.state.drop(1) .onEach { state -> receiver.sendRpc(RecordBVHStatus(recording = state.recording)) } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/datafeed.kt b/server/core/src/main/java/dev/slimevr/solarxr/datafeed.kt index 20f16cdd0..dfb3b82b2 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/datafeed.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/datafeed.kt @@ -11,6 +11,7 @@ import dev.slimevr.tracker.TrackerState import dev.slimevr.util.safeLaunch import kotlinx.coroutines.cancelAndJoin import kotlinx.coroutines.delay +import kotlinx.coroutines.flow.launchIn import kotlinx.coroutines.isActive import solarxr_protocol.data_feed.BoneMask import solarxr_protocol.data_feed.DataFeedConfig @@ -191,7 +192,7 @@ class DataFeedInitBehaviour(val server: VRServer, val skeleton: Skeleton) : Sola receiver.datafeedTimers = timers receiver.context.dispatch(SolarXRBridgeActions.SetConfig(dataFeeds)) - } + }.launchIn(receiver.context.scope) receiver.dataFeedDispatcher.on { event -> val config = event.config ?: return@on @@ -204,6 +205,6 @@ class DataFeedInitBehaviour(val server: VRServer, val skeleton: Skeleton) : Sola heightCalibrationManager = receiver.appContext.heightCalibrationManager, ), ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/firmware.kt b/server/core/src/main/java/dev/slimevr/solarxr/firmware.kt index 1744e186c..90675c34a 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/firmware.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/firmware.kt @@ -64,10 +64,10 @@ class FirmwareBehaviour(private val server: VRServer, private val firmwareManage else -> return@on } - } + }.launchIn(scope) receiver.rpcDispatcher.on { firmwareManager.cancelAll() - } + }.launchIn(scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/height-calibration.kt b/server/core/src/main/java/dev/slimevr/solarxr/height-calibration.kt index 025fda15a..719372ed8 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/height-calibration.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/height-calibration.kt @@ -14,11 +14,11 @@ class HeightCalibrationBehaviour( override fun observe(receiver: SolarXRBridge) { receiver.rpcDispatcher.on { heightCalibrationManager.start() - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { heightCalibrationManager.cancel() - } + }.launchIn(receiver.context.scope) heightCalibrationManager.context.state.drop(1).onEach { state -> receiver.sendRpc( diff --git a/server/core/src/main/java/dev/slimevr/solarxr/installed-info.kt b/server/core/src/main/java/dev/slimevr/solarxr/installed-info.kt index 69eba579c..be3b49fbc 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/installed-info.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/installed-info.kt @@ -1,5 +1,6 @@ package dev.slimevr.solarxr +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.InstalledInfoRequest import solarxr_protocol.rpc.InstalledInfoResponse @@ -8,6 +9,6 @@ class InstalledInfoBehaviour : SolarXRBridgeBehaviour { receiver.rpcDispatcher.on { val udevRulesInstalled = receiver.appContext.featureFlags.udevRulesInstalled ?: return@on receiver.sendRpc(InstalledInfoResponse(isUdevInstalled = udevRulesInstalled)) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/keybinds.kt b/server/core/src/main/java/dev/slimevr/solarxr/keybinds.kt index 0a8853340..27b07e551 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/keybinds.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/keybinds.kt @@ -50,7 +50,7 @@ class KeybindsBehaviour( override fun observe(receiver: SolarXRBridge) { receiver.rpcDispatcher.on { req -> keybindManager.context.dispatch(KeybindActions.SetRecording(req.recording ?: false)) - } + }.launchIn(receiver.context.scope) fun buildResponse(keybinds: List) = KeybindResponse( keybind = keybinds.map { keybindConfigToProto(it) }, @@ -60,7 +60,7 @@ class KeybindsBehaviour( receiver.rpcDispatcher.on { receiver.sendRpc(buildResponse(settings.context.state.value.data.keybinds)) - } + }.launchIn(receiver.context.scope) settings.context.state .map { it.data.keybinds } @@ -90,6 +90,6 @@ class KeybindsBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/known-trackers.kt b/server/core/src/main/java/dev/slimevr/solarxr/known-trackers.kt index ffbc13e0a..a240b5039 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/known-trackers.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/known-trackers.kt @@ -2,6 +2,7 @@ package dev.slimevr.solarxr import dev.slimevr.config.Settings import dev.slimevr.config.SettingsActions +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.AddUnknownDeviceRequest import solarxr_protocol.rpc.ForgetDeviceRequest @@ -12,11 +13,11 @@ class KnownTrackersBehaviour( receiver.rpcDispatcher.on { req -> val mac = req.macAddress ?: return@on settings.context.dispatch(SettingsActions.AddAllowedUdpDevice(mac)) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { req -> val mac = req.macAddress ?: return@on settings.context.dispatch(SettingsActions.RemoveAllowedUdpDevice(mac)) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/mag.kt b/server/core/src/main/java/dev/slimevr/solarxr/mag.kt index 0bb075183..87b0cd6b3 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/mag.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/mag.kt @@ -8,6 +8,7 @@ import dev.slimevr.udp.UDPConnectionActions import dev.slimevr.util.safeLaunch import kotlinx.coroutines.flow.distinctUntilChangedBy import kotlinx.coroutines.flow.first +import kotlinx.coroutines.flow.launchIn import kotlinx.coroutines.withTimeout import solarxr_protocol.datatypes.MagnetometerStatus import solarxr_protocol.rpc.ChangeMagToggleRequest @@ -80,7 +81,7 @@ class MagBehaviour( else -> return@on } - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { req -> val trackerId = req.trackerId @@ -102,6 +103,6 @@ class MagBehaviour( enable = trackerState.magStatus == MagnetometerStatus.ENABLED, ), ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/output-trackers.kt b/server/core/src/main/java/dev/slimevr/solarxr/output-trackers.kt index db6623531..59c27c6a5 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/output-trackers.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/output-trackers.kt @@ -4,6 +4,7 @@ import dev.slimevr.config.OutputTrackersConfig import dev.slimevr.config.Settings import dev.slimevr.config.SettingsActions import dev.slimevr.outputtrackertoggle.OutputTrackerToggleManager +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.ChangeOutputTrackersSettingsRequest import solarxr_protocol.rpc.OutputTrackersSettingsRequest import solarxr_protocol.rpc.OutputTrackersSettingsResponse @@ -23,7 +24,7 @@ class OutputTrackersBehaviour( sendDerivedVelocity = config.sendDerivedVelocity, ), ) - } + }.launchIn(receiver.context.scope) // Receive config receiver.rpcDispatcher.on { req -> @@ -38,6 +39,6 @@ class OutputTrackersBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/provisioning.kt b/server/core/src/main/java/dev/slimevr/solarxr/provisioning.kt index 5d60ecc79..25b331b47 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/provisioning.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/provisioning.kt @@ -23,11 +23,11 @@ class ProvisioningBehaviour( event.password, event.port, ) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { provisioningManager.stopProvisioning() - } + }.launchIn(receiver.context.scope) provisioningManager.context.state.drop(1).onEach { state -> receiver.sendRpc( diff --git a/server/core/src/main/java/dev/slimevr/solarxr/resets.kt b/server/core/src/main/java/dev/slimevr/solarxr/resets.kt index 81334e26b..20db9c27f 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/resets.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/resets.kt @@ -3,6 +3,7 @@ package dev.slimevr.solarxr import dev.slimevr.config.ResetsConfig import dev.slimevr.config.Settings import dev.slimevr.config.SettingsActions +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.ArmsResetMode import solarxr_protocol.rpc.ChangeResetsSettingsRequest import solarxr_protocol.rpc.ResetsSettingsRequest @@ -24,7 +25,7 @@ class ResetsBehaviour( resetHmdPitch = config.resetHmdPitch, ), ) - } + }.launchIn(receiver.context.scope) // Receive config receiver.rpcDispatcher.on { req -> @@ -41,6 +42,6 @@ class ResetsBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/serial.kt b/server/core/src/main/java/dev/slimevr/solarxr/serial.kt index dc3ae975b..ff41b0018 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/serial.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/serial.kt @@ -1,7 +1,6 @@ package dev.slimevr.solarxr import dev.slimevr.serial.SerialConnection -import dev.slimevr.serial.SerialPortInfo import dev.slimevr.serial.SerialServer import dev.slimevr.util.safeLaunch import kotlinx.coroutines.Job @@ -12,7 +11,6 @@ import kotlinx.coroutines.flow.onEach import solarxr_protocol.rpc.CloseSerialRequest import solarxr_protocol.rpc.NewSerialDeviceResponse import solarxr_protocol.rpc.OpenSerialRequest -import solarxr_protocol.rpc.SerialDevice import solarxr_protocol.rpc.SerialDevicesRequest import solarxr_protocol.rpc.SerialDevicesResponse import solarxr_protocol.rpc.SerialTrackerCustomCommandRequest @@ -52,7 +50,7 @@ class SerialBehaviour(private val serialServer: SerialServer) : SolarXRBridgeBeh .map { it.toSerialDevice() }, ), ) - } + }.launchIn(scope) receiver.rpcDispatcher.on { req -> val portLocation = if (req.auto == true) { @@ -95,43 +93,43 @@ class SerialBehaviour(private val serialServer: SerialServer) : SolarXRBridgeBeh dev.slimevr.AppLogger.solarxr.error(e, "Error streaming serial log") } } - } + }.launchIn(scope) receiver.rpcDispatcher.on { logSubscription?.cancel() logSubscription = null activePortLocation = null - } + }.launchIn(scope) receiver.rpcDispatcher.on { val portLocation = activePortLocation ?: return@on val c = serialServer.context.state.value.connections[portLocation] if (c is SerialConnection.Console) c.handle.writeCommand("REBOOT") - } + }.launchIn(scope) receiver.rpcDispatcher.on { val portLocation = activePortLocation ?: return@on val c = serialServer.context.state.value.connections[portLocation] if (c is SerialConnection.Console) c.handle.writeCommand("GET INFO") - } + }.launchIn(scope) receiver.rpcDispatcher.on { val portLocation = activePortLocation ?: return@on val c = serialServer.context.state.value.connections[portLocation] if (c is SerialConnection.Console) c.handle.writeCommand("FRST") - } + }.launchIn(scope) receiver.rpcDispatcher.on { val portLocation = activePortLocation ?: return@on val c = serialServer.context.state.value.connections[portLocation] if (c is SerialConnection.Console) c.handle.writeCommand("GET WIFISCAN") - } + }.launchIn(scope) receiver.rpcDispatcher.on { req -> val portLocation = activePortLocation ?: return@on val command = req.command ?: return@on val c = serialServer.context.state.value.connections[portLocation] if (c is SerialConnection.Console) c.handle.writeCommand(command) - } + }.launchIn(scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/session-calibration.kt b/server/core/src/main/java/dev/slimevr/solarxr/session-calibration.kt index c6e22ed87..b9ca70964 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/session-calibration.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/session-calibration.kt @@ -1,6 +1,7 @@ package dev.slimevr.solarxr import dev.slimevr.resets.ResetsManager +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.ResetRequest import solarxr_protocol.rpc.ResetType @@ -10,6 +11,6 @@ class SessionCalibrationBehaviour( override fun observe(receiver: SolarXRBridge) { receiver.rpcDispatcher.on { req -> resetsManager.scheduleReset("SolarXRBridge", req.resetType ?: ResetType.YAW, req.delay ?: 0f, req.bodyParts) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/skeleton-proportions.kt b/server/core/src/main/java/dev/slimevr/solarxr/skeleton-proportions.kt index 9a8e52ef5..500d4d9cf 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/skeleton-proportions.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/skeleton-proportions.kt @@ -8,6 +8,7 @@ import dev.slimevr.skeleton.computeDefaultProportionsByBone import dev.slimevr.skeleton.configToBoneValues import dev.slimevr.skeleton.height import dev.slimevr.skeleton.toBoneValues +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.ChangeSkeletonProportionsRequest import solarxr_protocol.rpc.ChangeUserHeightRequest import solarxr_protocol.rpc.SkeletonPart @@ -38,7 +39,7 @@ class SkeletonProportionsBehaviour( override fun observe(receiver: SolarXRBridge) { receiver.rpcDispatcher.on { receiver.sendRpc(buildConfigResponse()) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { req -> val hmdHeight = req.hmdHeight ?: return@on @@ -51,7 +52,7 @@ class SkeletonProportionsBehaviour( }, ) } - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { val height = userConfig.context.state.value.data.userHeight @@ -60,7 +61,7 @@ class SkeletonProportionsBehaviour( userConfig.context.dispatch(UserConfigActions.Update { copy(proportions = defaults) }) } receiver.sendRpc(buildConfigResponse()) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { req -> val bone = req.bone ?: return@on @@ -70,6 +71,6 @@ class SkeletonProportionsBehaviour( UserConfigActions.Update { copy(proportions = proportions + (bone.name to value)) }, ) receiver.sendRpc(buildConfigResponse()) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/skeleton-settings.kt b/server/core/src/main/java/dev/slimevr/solarxr/skeleton-settings.kt index 047fb8e4e..140668fd3 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/skeleton-settings.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/skeleton-settings.kt @@ -7,6 +7,7 @@ import dev.slimevr.config.SkeletonFilteringConfig import dev.slimevr.config.SkeletonRatiosConfig import dev.slimevr.config.SkeletonTogglesConfig import dev.slimevr.skeleton.SkeletonActions +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.ChangeSkeletonSettingsRequest import solarxr_protocol.rpc.FilteringType import solarxr_protocol.rpc.SetPauseTrackingRequest @@ -51,7 +52,7 @@ class SkeletonSettingsBehaviour( ), ), ) - } + }.launchIn(receiver.context.scope) // Receive config receiver.rpcDispatcher.on { req -> @@ -91,7 +92,7 @@ class SkeletonSettingsBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { receiver.appContext.skeleton.context.dispatch( @@ -105,7 +106,7 @@ class SkeletonSettingsBehaviour( trackingPaused = it.pauseTracking, ), ) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { receiver.sendRpc( @@ -113,6 +114,6 @@ class SkeletonSettingsBehaviour( trackingPaused = receiver.appContext.skeleton.context.state.value.paused, ), ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/tap-detection.kt b/server/core/src/main/java/dev/slimevr/solarxr/tap-detection.kt index 8f2db1b6b..0fbe2a01d 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/tap-detection.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/tap-detection.kt @@ -5,6 +5,7 @@ import dev.slimevr.config.SettingsActions import dev.slimevr.config.TapDetectionConfig import dev.slimevr.tapdetection.TapDetectionActions import dev.slimevr.tapdetection.TapDetectionManager +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.ChangeTapDetectionSettingsRequest import solarxr_protocol.rpc.TapDetectionSettingsRequest import solarxr_protocol.rpc.TapDetectionSettingsResponse @@ -35,7 +36,7 @@ class TapDetectionBehaviour( numberTrackersOverThreshold = config.numberTrackersOverThreshold.toUByte(), ), ) - } + }.launchIn(receiver.context.scope) // Receive config receiver.rpcDispatcher.on { req -> @@ -60,11 +61,11 @@ class TapDetectionBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) // Setup Mode (tap to assign) receiver.rpcDispatcher.on { req -> tapDetectionManager.context.dispatch(TapDetectionActions.SetSetupMode(req.setupMode == true)) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/tracker-assignment.kt b/server/core/src/main/java/dev/slimevr/solarxr/tracker-assignment.kt index 2dad01c50..ff2095ea0 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/tracker-assignment.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/tracker-assignment.kt @@ -3,6 +3,7 @@ package dev.slimevr.solarxr import dev.slimevr.VRServer import dev.slimevr.tracker.TrackerActions import io.github.axisangles.ktmath.Quaternion +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.datatypes.BodyPart import solarxr_protocol.rpc.AssignTrackerRequest @@ -32,6 +33,6 @@ class AssignTrackerBehaviour( TrackerActions.SetMountingOrientation(mountingOrientation), ) } - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/tracking-checklist.kt b/server/core/src/main/java/dev/slimevr/solarxr/tracking-checklist.kt index 66e0b9884..de8f1307d 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/tracking-checklist.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/tracking-checklist.kt @@ -39,7 +39,7 @@ class TrackingChecklistBehaviour( receiver.rpcDispatcher.on { receiver.sendRpc(buildResponse()) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { req -> val stepId = req.stepId ?: return@on @@ -49,6 +49,6 @@ class TrackingChecklistBehaviour( copy(mutedChecklistSteps = if (req.ignore == true) mutedChecklistSteps + name else mutedChecklistSteps - name) }, ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/vmc.kt b/server/core/src/main/java/dev/slimevr/solarxr/vmc.kt index 059350bbf..84e67deb1 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/vmc.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/vmc.kt @@ -2,7 +2,7 @@ package dev.slimevr.solarxr import dev.slimevr.config.Settings import dev.slimevr.config.SettingsActions -import dev.slimevr.config.VMCConfig +import kotlinx.coroutines.flow.launchIn import solarxr_protocol.rpc.ChangeVMCOSCSettingsRequest import solarxr_protocol.rpc.ChangeVRMSettingsRequest import solarxr_protocol.rpc.VMCOSCSettingsRequest @@ -27,7 +27,7 @@ class VmcBehaviour( mirrorTracking = config.mirrorTracking, ), ) - } + }.launchIn(receiver.context.scope) // Send VRM json receiver.rpcDispatcher.on { @@ -37,7 +37,7 @@ class VmcBehaviour( vrmJson = config.vrmJson, ), ) - } + }.launchIn(receiver.context.scope) // Receive VMC config receiver.rpcDispatcher.on { req -> @@ -55,7 +55,7 @@ class VmcBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) // Receive VRM json receiver.rpcDispatcher.on { req -> @@ -66,6 +66,6 @@ class VmcBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/vrchat.kt b/server/core/src/main/java/dev/slimevr/solarxr/vrchat.kt index b50dc98b0..89d165e35 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/vrchat.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/vrchat.kt @@ -39,11 +39,11 @@ class VrcBehaviour( receiver.rpcDispatcher.on { receiver.sendRpc(buildCurrentResponse()) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { req -> val key = req.key ?: return@on vrcManager.context.dispatch(VRCConfigActions.ToggleMutedWarning(key)) - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/solarxr/vrcosc.kt b/server/core/src/main/java/dev/slimevr/solarxr/vrcosc.kt index 4c68fb31f..833c69658 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/vrcosc.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/vrcosc.kt @@ -48,13 +48,13 @@ internal class VrcOscBehaviour( address = config.address, ), ) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { val state = vrcOscManager.context.state.value val config = settings.context.state.value.data.vrcOscConfig receiver.sendRpc(buildStatusResponse(state.status, config.enabled)) - } + }.launchIn(receiver.context.scope) receiver.rpcDispatcher.on { req -> settings.context.dispatch( @@ -70,7 +70,7 @@ internal class VrcOscBehaviour( ) }, ) - } + }.launchIn(receiver.context.scope) } private fun buildStatusResponse(status: VRCOSCStatus, enabled: Boolean) = VRCOSCStatusChangeResponse( diff --git a/server/core/src/main/java/dev/slimevr/udp/behaviours.kt b/server/core/src/main/java/dev/slimevr/udp/behaviours.kt index 3f8c4d63b..ec11eb6ea 100644 --- a/server/core/src/main/java/dev/slimevr/udp/behaviours.kt +++ b/server/core/src/main/java/dev/slimevr/udp/behaviours.kt @@ -41,7 +41,7 @@ class PacketBehaviour : UDPConnectionBehaviour { } override fun observe(receiver: UDPConnection) { - receiver.packetEvents.onAny { packet -> + receiver.packetEvents.events.onEach { packet -> val state = receiver.context.state.value val now = System.currentTimeMillis() val num = packet.packetNumber @@ -49,10 +49,10 @@ class PacketBehaviour : UDPConnectionBehaviour { AppLogger.udp.info("[${state.address}] Reconnecting") } else if (num != null && num != 0L && num <= state.lastPacketNum) { AppLogger.udp.warn("[${state.address}] Received packet with wrong packet number") - return@onAny + return@onEach } receiver.context.dispatch(UDPConnectionActions.LastPacket(packetNum = num, time = now)) - } + }.launchIn(receiver.context.scope) } } @@ -63,8 +63,8 @@ class PacketLossBehaviour : UDPConnectionBehaviour { var lastPacketCounterReset = System.currentTimeMillis() var lastPacketNumber = 0L - receiver.packetEvents.onAny { packet -> - val num = packet.packetNumber ?: return@onAny + receiver.packetEvents.events.onEach { packet -> + val num = packet.packetNumber ?: return@onEach val now = System.currentTimeMillis() if (now - lastPacketCounterReset >= 10_000L) { @@ -83,7 +83,7 @@ class PacketLossBehaviour : UDPConnectionBehaviour { receiver.getDevice()?.context?.dispatch( DeviceActions.PacketStats(packetsReceived = totalPacketsReceived, packetsLost = totalPacketsReceived - acceptedPackets), ) - } + }.launchIn(receiver.context.scope) } } @@ -120,7 +120,7 @@ class PingBehaviour : UDPConnectionBehaviour { val ping = (System.currentTimeMillis() - state.lastPing.startTime) / 2 val device = receiver.appContext.server.getDevice(deviceId) ?: return@onPacket device.context.dispatch(DeviceActions.Update { copy(ping = ping) }) - } + }.launchIn(receiver.context.scope) } } @@ -202,7 +202,7 @@ class HandshakeBehaviour : UDPConnectionBehaviour { ) receiver.send(Handshake()) - } + }.launchIn(receiver.context.scope) } } @@ -276,12 +276,12 @@ class DeviceStatsBehaviour : UDPConnectionBehaviour { device.context.dispatch( DeviceActions.Update { copy(batteryLevel = batteryLevel, batteryVoltage = voltage) }, ) - } + }.launchIn(receiver.context.scope) receiver.packetEvents.onPacket { event -> val device = receiver.getDevice() ?: return@onPacket device.context.dispatch(DeviceActions.Update { copy(signalStrength = event.data.signal) }) - } + }.launchIn(receiver.context.scope) } } @@ -376,7 +376,7 @@ class SensorInfoBehaviour : UDPConnectionBehaviour { UDPConnectionActions.SetSensorConfig(sensorId = event.data.sensorId, flags = SensorConfigFlags(magStatus = desiredMagStatus)), ) } - } + }.launchIn(receiver.context.scope) } } @@ -385,22 +385,22 @@ class SensorRotationBehaviour : UDPConnectionBehaviour { receiver.packetEvents.onPacket { event -> val tracker = receiver.getTracker(event.data.sensorId) ?: return@onPacket tracker.context.dispatch(TrackerActions.SetRotation(rotation = AXES_OFFSET * event.data.rotation)) - } + }.launchIn(receiver.context.scope) receiver.packetEvents.onPacket { event -> val tracker = receiver.getTracker(event.data.sensorId) ?: return@onPacket tracker.context.dispatch(TrackerActions.SetRotation(rotation = AXES_OFFSET * event.data.rotation, acceleration = event.data.acceleration)) - } + }.launchIn(receiver.context.scope) receiver.packetEvents.onPacket { event -> val tracker = receiver.getTracker(event.data.sensorId) ?: return@onPacket tracker.context.dispatch(TrackerActions.SetRotation(acceleration = event.data.acceleration)) - } + }.launchIn(receiver.context.scope) receiver.packetEvents.onPacket { event -> val tracker = receiver.getTracker(event.data.sensorId) ?: return@onPacket tracker.context.dispatch(TrackerActions.SetRotation(rotation = AXES_OFFSET * event.data.rotation)) - } + }.launchIn(receiver.context.scope) } } @@ -413,7 +413,7 @@ class BundledPacketBehaviour : UDPConnectionBehaviour { // it should be done by the parent packet receiver.packetEvents.emit(PacketEvent(packet, packetNumber = null)) } - } + }.launchIn(receiver.context.scope) receiver.packetEvents.onPacket { event -> for (packet in event.data.packets) { @@ -422,7 +422,7 @@ class BundledPacketBehaviour : UDPConnectionBehaviour { // it should be done by the parent packet receiver.packetEvents.emit(PacketEvent(packet, packetNumber = null)) } - } + }.launchIn(receiver.context.scope) } } @@ -440,7 +440,7 @@ class FlagsBehaviour : UDPConnectionBehaviour { receiver.context.dispatch(UDPConnectionActions.FirmwareFeatures(event.data.firmwareFeatures)) // send back the server features receiver.send(FeatureFlags()) - } + }.launchIn(receiver.context.scope) } } @@ -449,7 +449,7 @@ class TemperatureBehaviour : UDPConnectionBehaviour { receiver.packetEvents.onPacket { event -> val tracker = receiver.getTracker(event.data.sensorId) ?: return@onPacket tracker.context.dispatch(TrackerActions.Update { copy(imuTemp = event.data.temp) }) - } + }.launchIn(receiver.context.scope) } } @@ -490,6 +490,6 @@ class AckConfigBehaviour : UDPConnectionBehaviour { if (configType == SensorConfigType.MAGNETOMETER) { tracker.context.dispatch(TrackerActions.SetMagStatus(flags.magStatus)) } - } + }.launchIn(receiver.context.scope) } } diff --git a/server/core/src/main/java/dev/slimevr/udp/connection.kt b/server/core/src/main/java/dev/slimevr/udp/connection.kt index 7925d2c58..3aefe678b 100644 --- a/server/core/src/main/java/dev/slimevr/udp/connection.kt +++ b/server/core/src/main/java/dev/slimevr/udp/connection.kt @@ -124,7 +124,7 @@ class UDPConnection( name = "UDPConnection[$address]", ) - val dispatcher = EventDispatcher> { it.data::class } + val dispatcher = EventDispatcher>() val packetChannel = Channel>(capacity = 256) val conn = UDPConnection( diff --git a/server/core/src/main/java/dev/slimevr/udp/packets.kt b/server/core/src/main/java/dev/slimevr/udp/packets.kt index 8f15246d0..7a35dafc8 100644 --- a/server/core/src/main/java/dev/slimevr/udp/packets.kt +++ b/server/core/src/main/java/dev/slimevr/udp/packets.kt @@ -4,6 +4,9 @@ import dev.slimevr.EventDispatcher import io.github.axisangles.ktmath.Quaternion import io.github.axisangles.ktmath.Vector3 import io.ktor.utils.io.core.remaining +import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.mapNotNull +import kotlinx.coroutines.flow.onEach import kotlinx.io.Buffer import kotlinx.io.Sink import kotlinx.io.Source @@ -537,7 +540,8 @@ data class PacketEvent( typealias UDPPacketDispatcher = EventDispatcher> -@Suppress("UNCHECKED_CAST") -inline fun UDPPacketDispatcher.onPacket(crossinline callback: suspend (PacketEvent) -> Unit) { - register(T::class) { callback(it as PacketEvent) } -} +inline fun UDPPacketDispatcher.onPacket(): Flow> = events + .mapNotNull { event -> (event.takeIf { it.data is T }) as PacketEvent? } + +inline fun UDPPacketDispatcher.onPacket(crossinline action: suspend (PacketEvent) -> Unit): Flow> = + onPacket().onEach { action(it) } diff --git a/server/core/src/main/java/dev/slimevr/vrcosc/output.kt b/server/core/src/main/java/dev/slimevr/vrcosc/output.kt index 730387236..e5d3abbc5 100644 --- a/server/core/src/main/java/dev/slimevr/vrcosc/output.kt +++ b/server/core/src/main/java/dev/slimevr/vrcosc/output.kt @@ -3,7 +3,6 @@ package dev.slimevr.vrcosc import dev.slimevr.AppLogger import dev.slimevr.config.VRCOSCConfig import dev.slimevr.osc.OscSender -import dev.slimevr.outputtrackertoggle.OutputTrackerToggleManager import dev.slimevr.skeleton.BoneState import dev.slimevr.skeleton.Skeleton import io.github.axisangles.ktmath.Quaternion @@ -80,7 +79,7 @@ class VRCOSCOutputBehaviour( private fun observeYawAlign(receiver: VRCOSCManager, runtime: OutputRuntime) { receiver.events.on { event -> sendYawAlign(receiver, runtime, event.headRotation) - } + }.launchIn(receiver.context.scope) } private suspend fun applyTarget( diff --git a/server/core/src/test/java/dev/slimevr/solarxr/DataFeedTest.kt b/server/core/src/test/java/dev/slimevr/solarxr/DataFeedTest.kt index 4fe19ac81..79b772d43 100644 --- a/server/core/src/test/java/dev/slimevr/solarxr/DataFeedTest.kt +++ b/server/core/src/test/java/dev/slimevr/solarxr/DataFeedTest.kt @@ -10,6 +10,7 @@ import dev.slimevr.buildTestUserConfig import dev.slimevr.buildTestVrServer import dev.slimevr.context.Context import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.launchIn import kotlinx.coroutines.test.advanceTimeBy import kotlinx.coroutines.test.runTest import solarxr_protocol.MessageBundle @@ -46,7 +47,7 @@ private fun testConn(backgroundScope: kotlinx.coroutines.CoroutineScope, onSend: rpcDispatcher = EventDispatcher(), ) bridge.startObserving() - bridge.outbound.on { _ -> onSend(ByteArray(0)) } + bridge.outbound.on { onSend(ByteArray(0)) }.launchIn(backgroundScope) return bridge } diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/ipc/protocol.kt b/server/desktop/src/main/java/dev/slimevr/desktop/ipc/protocol.kt index 871a99aaf..834dfcda4 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/ipc/protocol.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/ipc/protocol.kt @@ -19,6 +19,7 @@ import io.github.axisangles.ktmath.Vector3 import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.launchIn import kotlinx.coroutines.sync.Mutex import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.withContext @@ -151,7 +152,8 @@ suspend fun handleDriverConnection( ), ), ) - } + }.launchIn(this) + bridge.outbound.on { event -> sendMsg( ProtobufMessage( @@ -167,7 +169,7 @@ suspend fun handleDriverConnection( ), ), ) - } + }.launchIn(this) bridge.outbound.on { event -> sendMsg( @@ -190,7 +192,7 @@ suspend fun handleDriverConnection( ), ), ) - } + }.launchIn(this) sendMsg(ProtobufMessage(version = Version(protocol_version = PROTOCOL_VERSION))) diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/ipc/solarxr.kt b/server/desktop/src/main/java/dev/slimevr/desktop/ipc/solarxr.kt index b04b8329a..f42b36705 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/ipc/solarxr.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/ipc/solarxr.kt @@ -21,6 +21,7 @@ import io.ktor.util.moveToByteArray import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.coroutineScope import kotlinx.coroutines.flow.Flow +import kotlinx.coroutines.flow.launchIn import kotlinx.coroutines.withContext import solarxr_protocol.MessageBundle import solarxr_protocol.rpc.EnableSteamVRDriverRequest @@ -35,7 +36,7 @@ class EnableSteamVRDriverBehaviour : SolarXRBridgeBehaviour { unblockSteamVRDriver(client, "slimevr") client.close() } - } + }.launchIn(receiver.context.scope) } } @@ -50,7 +51,7 @@ class OpenKeybindSettingsBehaviour : SolarXRBridgeBehaviour { }.onFailure { AppLogger.keybind.error(it, "Failed to open global shortcuts settings") } } } - } + }.launchIn(receiver.context.scope) } } @@ -77,7 +78,7 @@ suspend fun handleSolarXRBridge( val fbb = FlatBufferBuilder(256) fbb.finish(bundle.encode(JvmFlatBufferWriter(fbb))) send(fbb.dataBuffer().moveToByteArray()) - } + }.launchIn(this) try { messages.collect { bytes -> diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/keybind/keybinds.kt b/server/desktop/src/main/java/dev/slimevr/desktop/keybind/keybinds.kt index 64f39b4b5..ed5385c0a 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/keybind/keybinds.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/keybind/keybinds.kt @@ -75,7 +75,7 @@ private suspend fun setupWindowsKeybinds(appContext: AppContextProvider, scope: } apply(appContext.config.settings.context.state.value.data.keybinds) - appContext.keybindManager.events.on { apply(it.keybinds) } + appContext.keybindManager.events.on { apply(it.keybinds) }.launchIn(scope) appContext.keybindManager.context.state .map { it.recording }