Better event-dispatcher with liteners that die with scope

This commit is contained in:
lucas lelievre committed 2026-07-23 22:04:49 +02:00
1 parent 8e19542c82
commit 05fbf64ac3
35 files changed
+174 -174

No files matched your search

@@ -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 {
@@ -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<DriverBridgeInbound.Version> { event ->
receiver.context.dispatch(DriverBridgeActions.UpdateProtocolVersion(event.protocolVersion))
}
}.launchIn(receiver.context.scope)
receiver.inbound.on<DriverBridgeInbound.TrackerAdded> { event ->
handleTrackerAdded(
@@ -109,7 +107,7 @@ class DriverIncomingTrackersBehaviour : DriverBridgeBehaviour {
event.manufacturer,
event.serial,
)
}
}.launchIn(receiver.context.scope)
receiver.inbound.on<DriverBridgeInbound.TrackerPosition> { 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<DriverBridgeInbound.TrackerBattery> { 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(
@@ -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<T : Any>(private val keyOf: (T) -> KClass<*> = { it::class }) {
@Volatile var listeners: Map<KClass<*>, List<suspend (T) -> Unit>> = emptyMap()
// For now, it blocks all the time, no queue. Maybe it is a bad idea IDK. Future us problem
class EventDispatcher<T : Any>(
extraBufferCapacity: Int = 0,
onBufferOverflow: BufferOverflow = BufferOverflow.SUSPEND,
) {
private val flow = MutableSharedFlow<T>(extraBufferCapacity = extraBufferCapacity, onBufferOverflow = onBufferOverflow)
val events: SharedFlow<T> = flow.asSharedFlow()
@Volatile private var globalListeners: List<suspend (T) -> 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 <reified P : T> 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 <reified P : Any> on(crossinline action: suspend (P) -> Unit): Flow<P> =
events.filterIsInstance<P>().onEach { action(it) }
}
@@ -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<HIDDeviceRegister> { packet ->
receiver.packetEvents.on<HIDDeviceRegister> { 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<HIDDeviceInfo> { packet ->
val device = receiver.getDevice(packet.hidId) ?: return@onPacket
receiver.packetEvents.on<HIDDeviceInfo> { 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<HIDRotation> { packet ->
val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket
receiver.packetEvents.on<HIDRotation> { 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<HIDRotationBattery> { packet ->
val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket
receiver.packetEvents.on<HIDRotationBattery> { 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<HIDRotationMag> { packet ->
val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket
receiver.packetEvents.on<HIDRotationMag> { 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<HIDRotationButton> { packet ->
val tracker = receiver.getTracker(packet.hidId) ?: return@onPacket
receiver.packetEvents.on<HIDRotationButton> { 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<HIDRotationBattery> { packet ->
receiver.packetEvents.on<HIDRotationBattery> { 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<HIDRotationButton> { packet ->
receiver.packetEvents.on<HIDRotationButton> { packet ->
receiver.getDevice(packet.hidId)?.context?.dispatch(
DeviceActions.Update { copy(signalStrength = packet.rssi) },
)
}
}.launchIn(receiver.context.scope)
receiver.packetEvents.onPacket<HIDData> { packet ->
receiver.packetEvents.on<HIDData> { packet ->
receiver.getDevice(packet.hidId)?.context?.dispatch(
DeviceActions.Update { copy(signalStrength = packet.rssi) },
)
}
}.launchIn(receiver.context.scope)
receiver.packetEvents.onPacket<HIDRuntime> { packet ->
receiver.packetEvents.on<HIDRuntime> { 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<HIDRotationButton> { packet ->
receiver.packetEvents.on<HIDRotationButton> { packet ->
onPacket(packet.hidId)
scheduleSleep(packet.hidId, packet.timeout)
}
}.launchIn(receiver.context.scope)
receiver.packetEvents.onPacket<HIDData> { packet ->
receiver.packetEvents.on<HIDData> { packet ->
onPacket(packet.hidId)
scheduleSleep(packet.hidId, packet.timeout)
}
}.launchIn(receiver.context.scope)
receiver.packetEvents.onPacket<HIDRotation> { packet -> onPacket(packet.hidId) }
receiver.packetEvents.onPacket<HIDRotationBattery> { packet -> onPacket(packet.hidId) }
receiver.packetEvents.onPacket<HIDRotationMag> { packet -> onPacket(packet.hidId) }
receiver.packetEvents.onPacket<HIDStatus> { packet -> onPacket(packet.hidId) }
receiver.packetEvents.onPacket<HIDRuntime> { packet -> onPacket(packet.hidId) }
receiver.packetEvents.on<HIDRotation> { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope)
receiver.packetEvents.on<HIDRotationBattery> { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope)
receiver.packetEvents.on<HIDRotationMag> { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope)
receiver.packetEvents.on<HIDStatus> { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope)
receiver.packetEvents.on<HIDRuntime> { packet -> onPacket(packet.hidId) }.launchIn(receiver.context.scope)
}
}
class HIDStatusBehaviour : HIDReceiverBehaviour {
override fun observe(receiver: HIDReceiver) {
receiver.packetEvents.onPacket<HIDStatus> { packet ->
if (receiver.getTracker(packet.hidId) == null) return@onPacket
receiver.packetEvents.on<HIDStatus> { 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<HIDStatus> { packet ->
receiver.packetEvents.on<HIDStatus> { packet ->
receiver.getDevice(packet.hidId)?.context?.dispatch(
DeviceActions.PacketStats(packetsReceived = packet.packetsReceived.toLong(), packetsLost = packet.packetsLost.toLong()),
)
}
}.launchIn(receiver.context.scope)
}
}
@@ -29,11 +29,6 @@ typealias HIDReceiverContext = Context<HIDReceiverState, HIDReceiverActions>
typealias HIDReceiverBehaviour = Behaviour<HIDReceiverState, HIDReceiverActions, HIDReceiver>
typealias HIDPacketDispatcher = EventDispatcher<HIDPacket>
@Suppress("UNCHECKED_CAST")
inline fun <reified T : HIDPacket> HIDPacketDispatcher.onPacket(crossinline callback: suspend (T) -> Unit) {
register(T::class) { callback(it as T) }
}
class HIDReceiver(
val context: HIDReceiverContext,
val appContext: AppContextProvider,
@@ -89,7 +89,7 @@ class KeybindTriggerBehaviour(
KeybindId.NONE -> Unit
}
}
}.launchIn(receiver.context.scope)
}
}
@@ -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<RecordBVHStatusRequest> {
receiver.sendRpc(RecordBVHStatus(recording = bvhManager.isRecording))
}
}.launchIn(receiver.context.scope)
bvhManager.context.state.drop(1)
.onEach { state -> receiver.sendRpc(RecordBVHStatus(recording = state.recording)) }
@@ -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<PollDataFeed> { 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)
}
}
@@ -64,10 +64,10 @@ class FirmwareBehaviour(private val server: VRServer, private val firmwareManage
else -> return@on
}
}
}.launchIn(scope)
receiver.rpcDispatcher.on<FirmwareUpdateStopQueuesRequest> {
firmwareManager.cancelAll()
}
}.launchIn(scope)
}
}
@@ -14,11 +14,11 @@ class HeightCalibrationBehaviour(
override fun observe(receiver: SolarXRBridge) {
receiver.rpcDispatcher.on<StartUserHeightCalibration> {
heightCalibrationManager.start()
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<CancelUserHeightCalibration> {
heightCalibrationManager.cancel()
}
}.launchIn(receiver.context.scope)
heightCalibrationManager.context.state.drop(1).onEach { state ->
receiver.sendRpc(
@@ -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<InstalledInfoRequest> {
val udevRulesInstalled = receiver.appContext.featureFlags.udevRulesInstalled ?: return@on
receiver.sendRpc(InstalledInfoResponse(isUdevInstalled = udevRulesInstalled))
}
}.launchIn(receiver.context.scope)
}
}
@@ -50,7 +50,7 @@ class KeybindsBehaviour(
override fun observe(receiver: SolarXRBridge) {
receiver.rpcDispatcher.on<SetKeybindRecordingRequest> { req ->
keybindManager.context.dispatch(KeybindActions.SetRecording(req.recording ?: false))
}
}.launchIn(receiver.context.scope)
fun buildResponse(keybinds: List<KeybindConfig>) = KeybindResponse(
keybind = keybinds.map { keybindConfigToProto(it) },
@@ -60,7 +60,7 @@ class KeybindsBehaviour(
receiver.rpcDispatcher.on<KeybindRequest> {
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)
}
}
@@ -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<AddUnknownDeviceRequest> { req ->
val mac = req.macAddress ?: return@on
settings.context.dispatch(SettingsActions.AddAllowedUdpDevice(mac))
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<ForgetDeviceRequest> { req ->
val mac = req.macAddress ?: return@on
settings.context.dispatch(SettingsActions.RemoveAllowedUdpDevice(mac))
}
}.launchIn(receiver.context.scope)
}
}
@@ -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<MagToggleRequest> { req ->
val trackerId = req.trackerId
@@ -102,6 +103,6 @@ class MagBehaviour(
enable = trackerState.magStatus == MagnetometerStatus.ENABLED,
),
)
}
}.launchIn(receiver.context.scope)
}
}
@@ -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<ChangeOutputTrackersSettingsRequest> { req ->
@@ -38,6 +39,6 @@ class OutputTrackersBehaviour(
)
},
)
}
}.launchIn(receiver.context.scope)
}
}
@@ -23,11 +23,11 @@ class ProvisioningBehaviour(
event.password,
event.port,
)
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<StopWifiProvisioningRequest> {
provisioningManager.stopProvisioning()
}
}.launchIn(receiver.context.scope)
provisioningManager.context.state.drop(1).onEach { state ->
receiver.sendRpc(
@@ -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<ChangeResetsSettingsRequest> { req ->
@@ -41,6 +42,6 @@ class ResetsBehaviour(
)
},
)
}
}.launchIn(receiver.context.scope)
}
}
@@ -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<OpenSerialRequest> { 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<CloseSerialRequest> {
logSubscription?.cancel()
logSubscription = null
activePortLocation = null
}
}.launchIn(scope)
receiver.rpcDispatcher.on<SerialTrackerRebootRequest> {
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<SerialTrackerGetInfoRequest> {
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<SerialTrackerFactoryResetRequest> {
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<SerialTrackerGetWifiScanRequest> {
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<SerialTrackerCustomCommandRequest> { 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)
}
}
@@ -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<ResetRequest> { req ->
resetsManager.scheduleReset("SolarXRBridge", req.resetType ?: ResetType.YAW, req.delay ?: 0f, req.bodyParts)
}
}.launchIn(receiver.context.scope)
}
}
@@ -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<SkeletonProportionsRequest> {
receiver.sendRpc(buildConfigResponse())
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<ChangeUserHeightRequest> { req ->
val hmdHeight = req.hmdHeight ?: return@on
@@ -51,7 +52,7 @@ class SkeletonProportionsBehaviour(
},
)
}
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<SkeletonProportionsResetAllRequest> {
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<ChangeSkeletonProportionsRequest> { 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)
}
}
@@ -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<ChangeSkeletonSettingsRequest> { req ->
@@ -91,7 +92,7 @@ class SkeletonSettingsBehaviour(
)
},
)
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<SetPauseTrackingRequest> {
receiver.appContext.skeleton.context.dispatch(
@@ -105,7 +106,7 @@ class SkeletonSettingsBehaviour(
trackingPaused = it.pauseTracking,
),
)
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<TrackingPauseStateRequest> {
receiver.sendRpc(
@@ -113,6 +114,6 @@ class SkeletonSettingsBehaviour(
trackingPaused = receiver.appContext.skeleton.context.state.value.paused,
),
)
}
}.launchIn(receiver.context.scope)
}
}
@@ -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<ChangeTapDetectionSettingsRequest> { req ->
@@ -60,11 +61,11 @@ class TapDetectionBehaviour(
)
},
)
}
}.launchIn(receiver.context.scope)
// Setup Mode (tap to assign)
receiver.rpcDispatcher.on<TapDetectionSetupModeRequest> { req ->
tapDetectionManager.context.dispatch(TapDetectionActions.SetSetupMode(req.setupMode == true))
}
}.launchIn(receiver.context.scope)
}
}
@@ -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)
}
}
@@ -39,7 +39,7 @@ class TrackingChecklistBehaviour(
receiver.rpcDispatcher.on<TrackingChecklistRequest> {
receiver.sendRpc(buildResponse())
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<IgnoreTrackingChecklistStepRequest> { 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)
}
}
@@ -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<VRMSettingsRequest> {
@@ -37,7 +37,7 @@ class VmcBehaviour(
vrmJson = config.vrmJson,
),
)
}
}.launchIn(receiver.context.scope)
// Receive VMC config
receiver.rpcDispatcher.on<ChangeVMCOSCSettingsRequest> { req ->
@@ -55,7 +55,7 @@ class VmcBehaviour(
)
},
)
}
}.launchIn(receiver.context.scope)
// Receive VRM json
receiver.rpcDispatcher.on<ChangeVRMSettingsRequest> { req ->
@@ -66,6 +66,6 @@ class VmcBehaviour(
)
},
)
}
}.launchIn(receiver.context.scope)
}
}
@@ -39,11 +39,11 @@ class VrcBehaviour(
receiver.rpcDispatcher.on<VRCConfigStateRequest> {
receiver.sendRpc(buildCurrentResponse())
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<VRCConfigSettingToggleMute> { req ->
val key = req.key ?: return@on
vrcManager.context.dispatch(VRCConfigActions.ToggleMutedWarning(key))
}
}.launchIn(receiver.context.scope)
}
}
@@ -48,13 +48,13 @@ internal class VrcOscBehaviour(
address = config.address,
),
)
}
}.launchIn(receiver.context.scope)
receiver.rpcDispatcher.on<VRCOSCStatusRequest> {
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<ChangeVRCOSCSettingsRequest> { req ->
settings.context.dispatch(
@@ -70,7 +70,7 @@ internal class VrcOscBehaviour(
)
},
)
}
}.launchIn(receiver.context.scope)
}
private fun buildStatusResponse(status: VRCOSCStatus, enabled: Boolean) = VRCOSCStatusChangeResponse(
@@ -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<SignalStrength> { 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<RotationData> { 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<RotationAndAccel> { 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<Accel> { 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<Rotation2> { 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<PacketBundleCompact> { 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<Temperature> { 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)
}
}
@@ -124,7 +124,7 @@ class UDPConnection(
name = "UDPConnection[$address]",
)
val dispatcher = EventDispatcher<PacketEvent<UDPPacket>> { it.data::class }
val dispatcher = EventDispatcher<PacketEvent<UDPPacket>>()
val packetChannel = Channel<PacketEvent<UDPPacket>>(capacity = 256)
val conn = UDPConnection(
@@ -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<out T : UDPPacket>(
typealias UDPPacketDispatcher = EventDispatcher<PacketEvent<UDPPacket>>
@Suppress("UNCHECKED_CAST")
inline fun <reified T : UDPPacket> UDPPacketDispatcher.onPacket(crossinline callback: suspend (PacketEvent<T>) -> Unit) {
register(T::class) { callback(it as PacketEvent<T>) }
}
inline fun <reified T : UDPPacket> UDPPacketDispatcher.onPacket(): Flow<PacketEvent<T>> = events
.mapNotNull { event -> (event.takeIf { it.data is T }) as PacketEvent<T>? }
inline fun <reified T : UDPPacket> UDPPacketDispatcher.onPacket(crossinline action: suspend (PacketEvent<T>) -> Unit): Flow<PacketEvent<T>> =
onPacket<T>().onEach { action(it) }
@@ -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<VRCOSCEvent.YawAlign> { event ->
sendYawAlign(receiver, runtime, event.headRotation)
}
}.launchIn(receiver.context.scope)
}
private suspend fun applyTarget(
@@ -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<MessageBundle> { _ -> onSend(ByteArray(0)) }
bridge.outbound.on<MessageBundle> { onSend(ByteArray(0)) }.launchIn(backgroundScope)
return bridge
}
@@ -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<DriverBridgeOutbound.TrackerPosition> { event ->
sendMsg(
ProtobufMessage(
@@ -167,7 +169,7 @@ suspend fun handleDriverConnection(
),
),
)
}
}.launchIn(this)
bridge.outbound.on<DriverBridgeOutbound.TrackerStatus> { event ->
sendMsg(
@@ -190,7 +192,7 @@ suspend fun handleDriverConnection(
),
),
)
}
}.launchIn(this)
sendMsg(ProtobufMessage(version = Version(protocol_version = PROTOCOL_VERSION)))
@@ -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 ->
@@ -75,7 +75,7 @@ private suspend fun setupWindowsKeybinds(appContext: AppContextProvider, scope:
}
apply(appContext.config.settings.context.state.value.data.keybinds)
appContext.keybindManager.events.on<KeybindEvent.Rebind> { apply(it.keybinds) }
appContext.keybindManager.events.on<KeybindEvent.Rebind> { apply(it.keybinds) }.launchIn(scope)
appContext.keybindManager.context.state
.map { it.recording }