Allow creating and manipulating created trackers via SolarXR

gui/src/components/onboarding/pages/body-proportions/ManualProportions.tsx

@@ -1,5 +1,6 @@
 import { Control, Controller, useForm } from 'react-hook-form';
 import {
+  BodyPart,
   ChangeSkeletonConfigRequestT,
   ResetType,
   RpcMessage,
@@ -318,9 +319,7 @@ function ButtonsControl({ control }: { control: ManualProportionControls }) {
 
   const beneathFloor = useMemo(() => {
     const hmd = computedTrackers.find(
-      (tracker) =>
-        tracker.tracker.trackerId?.trackerNum === 1 &&
-        tracker.tracker.trackerId.deviceId?.id === undefined
+      (tracker) => tracker.tracker.info?.bodyPart === BodyPart.HEAD
     );
     return !(hmd?.tracker.position && hmd.tracker.position.y >= MIN_HEIGHT);
   }, [computedTrackers]);

server/core/src/main/java/dev/slimevr/VRServer.kt

@@ -34,7 +34,7 @@ import dev.slimevr.tracking.trackers.*
 import dev.slimevr.tracking.trackers.udp.TrackersUDPServer
 import dev.slimevr.trackingchecklist.TrackingChecklistManager
 import dev.slimevr.util.ann.VRServerThread
-import dev.slimevr.websocketapi.WebSocketVRBridge
+import dev.slimevr.websocketapi.WebSocketRPCBridge
 import io.eiren.util.ann.ThreadSafe
 import io.eiren.util.ann.ThreadSecure
 import io.eiren.util.collections.FastList
@@ -156,7 +156,8 @@ class VRServer @JvmOverloads constructor(
 		) { tracker: Tracker -> registerTracker(tracker) }
 
 		// Start bridges and WebSocket server
-		for (bridge in bridgeProvider(this, computedTrackers) + sequenceOf(WebSocketVRBridge(computedTrackers, this))) {
+		for (bridge in bridgeProvider(this, computedTrackers) +
+			sequenceOf(WebSocketRPCBridge(this, protocolAPI))) {
 			tasks.add(Runnable { bridge.startBridge() })
 			bridges.add(bridge)
 		}
@@ -186,15 +187,6 @@ class VRServer @JvmOverloads constructor(
 		instance = this
 	}
 
-	fun hasBridge(bridgeClass: Class<out Bridge?>): Boolean {
-		for (bridge in bridges) {
-			if (bridgeClass.isAssignableFrom(bridge.javaClass)) {
-				return true
-			}
-		}
-		return false
-	}
-
 	@ThreadSafe
 	fun getVRBridge(pred: (Bridge) -> Boolean): Bridge? {
 		for (bridge in bridges) {

server/core/src/main/java/dev/slimevr/osc/VMCHandler.kt

@@ -16,6 +16,7 @@ import dev.slimevr.osc.UnityBone.Companion.getByStringVal
 import dev.slimevr.tracking.processor.BoneType
 import dev.slimevr.tracking.processor.HumanPoseManager
 import dev.slimevr.tracking.trackers.Device
+import dev.slimevr.tracking.trackers.DeviceOrigin
 import dev.slimevr.tracking.trackers.Tracker
 import dev.slimevr.tracking.trackers.TrackerPosition
 import dev.slimevr.tracking.trackers.TrackerStatus
@@ -270,7 +271,7 @@ class VMCHandler(
 		// Create device if it doesn't exist
 		var rot = rotation
 		if (trackerDevice == null) {
-			trackerDevice = server.deviceManager.createDevice("VMC receiver", "1.0", "VMC")
+			trackerDevice = server.deviceManager.createDevice(DeviceOrigin.VMC, "VMC receiver", "1.0", "VMC")
 			server.deviceManager.addDevice(trackerDevice!!)
 		}
 

server/core/src/main/java/dev/slimevr/osc/VRCOSCHandler.kt

@@ -13,6 +13,7 @@ import com.jme3.system.NanoTimer
 import dev.slimevr.VRServer
 import dev.slimevr.config.VRCOSCConfig
 import dev.slimevr.tracking.trackers.Device
+import dev.slimevr.tracking.trackers.DeviceOrigin
 import dev.slimevr.tracking.trackers.Tracker
 import dev.slimevr.tracking.trackers.TrackerPosition
 import dev.slimevr.tracking.trackers.TrackerStatus
@@ -328,7 +329,7 @@ class VRCOSCHandler(
 			// Create device if it doesn't exist
 			if (vrsystemTrackersDevice == null) {
 				// Instantiate OSC Trackers device
-				vrsystemTrackersDevice = server.deviceManager.createDevice("VRC VRSystem", null, "VRChat")
+				vrsystemTrackersDevice = server.deviceManager.createDevice(DeviceOrigin.VRCHAT, "VRC VRSystem", null, "VRChat")
 				server.deviceManager.addDevice(vrsystemTrackersDevice!!)
 			}
 
@@ -404,7 +405,7 @@ class VRCOSCHandler(
 			// Receiving OSC Trackers data. This is not from VRChat.
 			if (oscTrackersDevice == null) {
 				// Instantiate OSC Trackers device
-				oscTrackersDevice = server.deviceManager.createDevice("OSC Tracker", null, "OSC Trackers")
+				oscTrackersDevice = server.deviceManager.createDevice(DeviceOrigin.OSC, "OSC Tracker", null, "OSC Trackers")
 				server.deviceManager.addDevice(oscTrackersDevice!!)
 			}
 

server/core/src/main/java/dev/slimevr/protocol/ConnectionContext.kt

@@ -1,8 +1,11 @@
 package dev.slimevr.protocol
 
+import dev.slimevr.tracking.trackers.Tracker
+
 class ConnectionContext {
 	val dataFeedList: MutableList<DataFeed> = mutableListOf()
 	val subscribedTopics: MutableList<Int> = mutableListOf()
+	val createdTrackers: MutableList<Tracker> = mutableListOf()
 
 	var useSerial: Boolean = false
 	var useProvisioning: Boolean = false

server/core/src/main/java/dev/slimevr/protocol/datafeed/DataFeedHandler.kt

@@ -67,6 +67,8 @@ class DataFeedHandler(private val api: ProtocolAPI) : ProtocolHandler<DataFeedMe
 	}
 
 	fun buildDatafeed(fbb: FlatBufferBuilder, config: DataFeedConfigT, index: Int): Int {
+		val humanPoseManager = this.api.server.humanPoseManager
+
 		val devicesOffset = createDevicesData(
 			fbb,
 			config.dataMask,
@@ -77,19 +79,14 @@ class DataFeedHandler(private val api: ProtocolAPI) : ProtocolHandler<DataFeedMe
 		val trackersOffset = createSyntheticTrackersData(
 			fbb,
 			config.syntheticTrackersMask,
-			this.api.server
-				.allTrackers
-				.stream()
-				.filter(Tracker::isComputed)
-				.collect(Collectors.toList()),
+			humanPoseManager.computedTrackers,
 		)
 
-		val h = this.api.server.humanPoseManager
 		val bonesOffset =
 			createBonesData(
 				fbb,
 				config.boneMask,
-				h.allBones.toMutableList(),
+				humanPoseManager.allBones.toMutableList(),
 			)
 
 		var stayAlignedPoseOffset = 0

server/core/src/main/java/dev/slimevr/protocol/rpc/RPCHandler.kt

@@ -20,6 +20,7 @@ import dev.slimevr.protocol.rpc.setup.RPCHandshakeHandler
 import dev.slimevr.protocol.rpc.setup.RPCTapSetupHandler
 import dev.slimevr.protocol.rpc.setup.RPCUtil.getLocalIp
 import dev.slimevr.protocol.rpc.status.RPCStatusHandler
+import dev.slimevr.protocol.rpc.tracker.RPCExternalTrackerHandler
 import dev.slimevr.protocol.rpc.trackingchecklist.RPCTrackingChecklistHandler
 import dev.slimevr.protocol.rpc.trackingpause.RPCTrackingPause
 import dev.slimevr.tracking.processor.config.SkeletonConfigOffsets
@@ -36,6 +37,28 @@ import solarxr_protocol.datatypes.TransactionId
 import solarxr_protocol.rpc.*
 import kotlin.io.path.Path
 
+fun createRPCMessage(fbb: FlatBufferBuilder, messageType: Byte, messageOffset: Int, txId: Long?): Int {
+	val data = IntArray(1)
+
+	RpcMessageHeader.startRpcMessageHeader(fbb)
+	RpcMessageHeader.addMessage(fbb, messageOffset)
+	RpcMessageHeader.addMessageType(fbb, messageType)
+	txId?.let { txId ->
+		RpcMessageHeader.addTxId(fbb, TransactionId.createTransactionId(fbb, txId))
+	}
+	data[0] = RpcMessageHeader.endRpcMessageHeader(fbb)
+
+	val messages = MessageBundle.createRpcMsgsVector(fbb, data)
+
+	MessageBundle.startMessageBundle(fbb)
+	MessageBundle.addRpcMsgs(fbb, messages)
+	return MessageBundle.endMessageBundle(fbb)
+}
+
+fun createRPCMessage(fbb: FlatBufferBuilder, messageType: Byte, messageOffset: Int): Int = createRPCMessage(fbb, messageType, messageOffset, txId = null)
+
+fun createRPCMessage(fbb: FlatBufferBuilder, messageType: Byte, messageOffset: Int, respondTo: RpcMessageHeader?): Int = createRPCMessage(fbb, messageType, messageOffset, respondTo?.txId()?.id())
+
 class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeader>() {
 	private val mainScope = CoroutineScope(SupervisorJob())
 
@@ -54,6 +77,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 		RPCTrackingChecklistHandler(this, api)
 		RPCUserHeightCalibration(this, api)
 		RPCInstallInfoHandler(this, api)
+		RPCExternalTrackerHandler(this, api)
 
 		registerPacketListener(
 			RpcMessage.AssignTrackerRequest,
@@ -162,7 +186,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 		val localIp = getLocalIp() ?: return
 		val response = ServerInfosResponse
 			.createServerInfosResponse(fbb, fbb.createString(localIp))
-		val outbound = this.createRPCMessage(fbb, RpcMessage.ServerInfosResponse, response, messageHeader)
+		val outbound = createRPCMessage(fbb, RpcMessage.ServerInfosResponse, response, messageHeader)
 		fbb.finish(outbound)
 		conn.send(fbb.dataBuffer())
 	}
@@ -175,7 +199,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 		val config = api.server.configManager.vrConfig.overlay
 		val response = OverlayDisplayModeResponse
 			.createOverlayDisplayModeResponse(fbb, config.isVisible, config.isMirrored)
-		val outbound = this.createRPCMessage(fbb, RpcMessage.OverlayDisplayModeResponse, response, messageHeader)
+		val outbound = createRPCMessage(fbb, RpcMessage.OverlayDisplayModeResponse, response, messageHeader)
 		fbb.finish(outbound)
 		conn.send(fbb.dataBuffer())
 	}
@@ -211,7 +235,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 			// might not be a good idea maybe let the client ask again
 			val fbb = FlatBufferBuilder(300)
 			val config = createSkeletonConfig(fbb, api.server.humanPoseManager)
-			val outbound = this.createRPCMessage(fbb, RpcMessage.SkeletonConfigResponse, config, messageHeader)
+			val outbound = createRPCMessage(fbb, RpcMessage.SkeletonConfigResponse, config, messageHeader)
 			fbb.finish(outbound)
 			conn.send(fbb.dataBuffer())
 		}
@@ -226,7 +250,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 
 		val fbb = FlatBufferBuilder(300)
 		val config = createSkeletonConfig(fbb, api.server.humanPoseManager)
-		val outbound = this.createRPCMessage(fbb, RpcMessage.SkeletonConfigResponse, config, messageHeader)
+		val outbound = createRPCMessage(fbb, RpcMessage.SkeletonConfigResponse, config, messageHeader)
 		fbb.finish(outbound)
 		conn.send(fbb.dataBuffer())
 	}
@@ -261,7 +285,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 		val fbb = FlatBufferBuilder(40)
 		val status = RecordBVHStatus
 			.createRecordBVHStatus(fbb, api.server.bvhRecorder.isRecording)
-		val outbound = this.createRPCMessage(fbb, RpcMessage.RecordBVHStatus, status, messageHeader)
+		val outbound = createRPCMessage(fbb, RpcMessage.RecordBVHStatus, status, messageHeader)
 		fbb.finish(outbound)
 		conn.send(fbb.dataBuffer())
 	}
@@ -272,7 +296,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 		val fbb = FlatBufferBuilder(40)
 		val status = RecordBVHStatus
 			.createRecordBVHStatus(fbb, api.server.bvhRecorder.isRecording)
-		val outbound = this.createRPCMessage(fbb, RpcMessage.RecordBVHStatus, status, messageHeader)
+		val outbound = createRPCMessage(fbb, RpcMessage.RecordBVHStatus, status, messageHeader)
 		fbb.finish(outbound)
 		conn.send(fbb.dataBuffer())
 	}
@@ -376,28 +400,6 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 		}
 	}
 
-	fun createRPCMessage(fbb: FlatBufferBuilder, messageType: Byte, messageOffset: Int, txId: Long?): Int {
-		val data = IntArray(1)
-
-		RpcMessageHeader.startRpcMessageHeader(fbb)
-		RpcMessageHeader.addMessage(fbb, messageOffset)
-		RpcMessageHeader.addMessageType(fbb, messageType)
-		txId?.let { txId ->
-			RpcMessageHeader.addTxId(fbb, TransactionId.createTransactionId(fbb, txId))
-		}
-		data[0] = RpcMessageHeader.endRpcMessageHeader(fbb)
-
-		val messages = MessageBundle.createRpcMsgsVector(fbb, data)
-
-		MessageBundle.startMessageBundle(fbb)
-		MessageBundle.addRpcMsgs(fbb, messages)
-		return MessageBundle.endMessageBundle(fbb)
-	}
-
-	fun createRPCMessage(fbb: FlatBufferBuilder, messageType: Byte, messageOffset: Int): Int = createRPCMessage(fbb, messageType, messageOffset, txId = null)
-
-	fun createRPCMessage(fbb: FlatBufferBuilder, messageType: Byte, messageOffset: Int, respondTo: RpcMessageHeader?): Int = createRPCMessage(fbb, messageType, messageOffset, respondTo?.txId()?.id())
-
 	override fun messagesCount(): Int = RpcMessage.names.size
 
 	fun onStatusSystemRequest(conn: GenericConnection, messageHeader: RpcMessageHeader) {
@@ -412,7 +414,7 @@ class RPCHandler(private val api: ProtocolAPI) : ProtocolHandler<RpcMessageHeade
 		val response = StatusSystemResponseT()
 		response.currentStatuses = statuses
 		val offset = StatusSystemResponse.pack(fbb, response)
-		val outbound = this.createRPCMessage(fbb, RpcMessage.StatusSystemResponse, offset, messageHeader)
+		val outbound = createRPCMessage(fbb, RpcMessage.StatusSystemResponse, offset, messageHeader)
 		fbb.finish(outbound)
 		conn.send(fbb.dataBuffer())
 	}

server/core/src/main/java/dev/slimevr/protocol/rpc/RPCUserHeightCalibration.kt

@@ -48,7 +48,7 @@ class RPCUserHeightCalibration(var rpcHandler: RPCHandler, var api: ProtocolAPI)
 
 		val res = UserHeightRecordingStatusResponse.pack(fbb, status)
 
-		val outbound = rpcHandler.createRPCMessage(
+		val outbound = createRPCMessage(
 			fbb,
 			RpcMessage.UserHeightRecordingStatusResponse,
 			res,

server/core/src/main/java/dev/slimevr/protocol/rpc/autobone/RPCAutoBoneHandler.kt

@@ -9,6 +9,7 @@ import dev.slimevr.poseframeformat.PoseFrames
 import dev.slimevr.protocol.GenericConnection
 import dev.slimevr.protocol.ProtocolAPI
 import dev.slimevr.protocol.rpc.RPCHandler
+import dev.slimevr.protocol.rpc.createRPCMessage
 import dev.slimevr.protocol.rpc.createSkeletonConfig
 import dev.slimevr.tracking.processor.config.SkeletonConfigOffsets
 import solarxr_protocol.rpc.AutoBoneEpochResponse
@@ -87,7 +88,7 @@ class RPCAutoBoneHandler(
 
 			val update = AutoBoneProcessStatusResponse
 				.endAutoBoneProcessStatusResponse(fbb)
-			val outbound: Int = rpcHandler.createRPCMessage(
+			val outbound: Int = createRPCMessage(
 				fbb,
 				RpcMessage.AutoBoneProcessStatusResponse,
 				update,
@@ -127,7 +128,7 @@ class RPCAutoBoneHandler(
 					epoch.epochError.mean,
 					skeletonPartsOffset,
 				)
-			val outbound: Int = rpcHandler.createRPCMessage(
+			val outbound: Int = createRPCMessage(
 				fbb,
 				RpcMessage.AutoBoneEpochResponse,
 				update,
@@ -150,7 +151,7 @@ class RPCAutoBoneHandler(
 
 		// Send the new body proportions, this is to update the listener's state
 		val fbb = FlatBufferBuilder(300)
-		val outbound = rpcHandler.createRPCMessage(
+		val outbound = createRPCMessage(
 			fbb,
 			RpcMessage.SkeletonConfigResponse,
 			createSkeletonConfig(fbb, api.server.humanPoseManager),

server/core/src/main/java/dev/slimevr/protocol/rpc/firmware/RPCFirmwareUpdateHandler.kt

@@ -8,6 +8,7 @@ import dev.slimevr.firmware.UpdateStatusEvent
 import dev.slimevr.protocol.GenericConnection
 import dev.slimevr.protocol.ProtocolAPI
 import dev.slimevr.protocol.rpc.RPCHandler
+import dev.slimevr.protocol.rpc.createRPCMessage
 import solarxr_protocol.datatypes.DeviceIdT
 import solarxr_protocol.datatypes.DeviceIdTableT
 import solarxr_protocol.rpc.FirmwareUpdateDeviceId
@@ -73,7 +74,7 @@ class RPCFirmwareUpdateHandler(
 		FirmwareUpdateStatusResponse.addProgress(fbb, event.progress.toByte())
 
 		val update = FirmwareUpdateStatusResponse.endFirmwareUpdateStatusResponse(fbb)
-		val outbound = rpcHandler.createRPCMessage(
+		val outbound = createRPCMessage(
 			fbb,
 			RpcMessage.FirmwareUpdateStatusResponse,
 			update,

server/core/src/main/java/dev/slimevr/protocol/rpc/games/vrchat/RPCVRChatHandler.kt

@@ -8,6 +8,7 @@ import dev.slimevr.games.vrchat.VRCConfigValues
 import dev.slimevr.protocol.GenericConnection
 import dev.slimevr.protocol.ProtocolAPI
 import dev.slimevr.protocol.rpc.RPCHandler
+import dev.slimevr.protocol.rpc.createRPCMessage
 import solarxr_protocol.rpc.*
 
 class RPCVRChatHandler(
@@ -40,7 +41,7 @@ class RPCVRChatHandler(
 			muted = api.server.configManager.vrConfig.vrcConfig.mutedWarnings,
 		)
 
-		val outbound = rpcHandler.createRPCMessage(
+		val outbound = createRPCMessage(
 			fbb,
 			RpcMessage.VRCConfigStateChangeResponse,
 			response,
@@ -67,7 +68,7 @@ class RPCVRChatHandler(
 			muted,
 		)
 
-		val outbound = rpcHandler.createRPCMessage(
+		val outbound = createRPCMessage(
 			fbb,
 			RpcMessage.VRCConfigStateChangeResponse,
 			response,

server/core/src/main/java/dev/slimevr/protocol/rpc/installinfo/RPCInstallInfoHandler.kt

@@ -4,6 +4,7 @@ import com.google.flatbuffers.FlatBufferBuilder
 import dev.slimevr.protocol.GenericConnection
 import dev.slimevr.protocol.ProtocolAPI
 import dev.slimevr.protocol.rpc.RPCHandler
+import dev.slimevr.protocol.rpc.createRPCMessage
 import io.eiren.util.logging.LogManager
 import solarxr_protocol.rpc.InstalledInfoResponse.createInstalledInfoResponse
 import solarxr_protocol.rpc.RpcMessage
@@ -34,7 +35,7 @@ class RPCInstallInfoHandler(var rpcHandler: RPCHandler, var api: ProtocolAPI) {
 		}
 		val response = udevResponse.contains("slime")
 		val fbb = FlatBufferBuilder(1024)
-		val outbound = this.rpcHandler.createRPCMessage(
+		val outbound = createRPCMessage(
 			fbb,
 			RpcMessage.InstalledInfoResponse,
 			createInstalledInfoResponse(fbb, response, false),

server/core/src/main/java/dev/slimevr/protocol/rpc/reset/RPCResetHandler.kt

@@ -6,6 +6,7 @@ import dev.slimevr.protocol.ProtocolAPI
 import dev.slimevr.protocol.ProtocolAPIServer
 import dev.slimevr.protocol.rpc.RPCHandler
 import dev.slimevr.protocol.rpc.TransactionInfo
+import dev.slimevr.protocol.rpc.createRPCMessage
 import dev.slimevr.reset.ResetListener
 import solarxr_protocol.rpc.ClearMountingResetRequest
 import solarxr_protocol.rpc.ResetRequest
@@ -105,7 +106,7 @@ class RPCResetHandler(var rpcHandler: RPCHandler, var api: ProtocolAPI) : ResetL
 			ResetResponse.addDuration(fbb, duration)
 
 			val update = ResetResponse.endResetResponse(fbb)
-			val outbound = rpcHandler.createRPCMessage(fbb, RpcMessage.ResetResponse, update, txId)
+			val outbound = createRPCMessage(fbb, RpcMessage.ResetResponse, update, txId)
 			fbb.finish(outbound)
 
 			return fbb.dataBuffer()