diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h index e0ded2e2..8666d937 100644 --- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h +++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h @@ -488,6 +488,15 @@ struct CancelUserHeightCalibrationBuilder; struct UserHeightRecordingStatusResponse; struct UserHeightRecordingStatusResponseBuilder; +struct UnknownHIDDeviceHandshakeNotification; +struct UnknownHIDDeviceHandshakeNotificationBuilder; + +struct HIDAllReceiversCommandRequest; +struct HIDAllReceiversCommandRequestBuilder; + +struct HIDTrackerCommandRequest; +struct HIDTrackerCommandRequestBuilder; + } // namespace rpc namespace pub_sub { @@ -1374,11 +1383,14 @@ enum class RpcMessage : uint8_t { StartUserHeightCalibration = 76, CancelUserHeightCalibration = 77, UserHeightRecordingStatusResponse = 78, + UnknownHIDDeviceHandshakeNotification = 79, + HIDAllReceiversCommandRequest = 80, + HIDTrackerCommandRequest = 81, MIN = NONE, - MAX = UserHeightRecordingStatusResponse + MAX = HIDTrackerCommandRequest }; -inline const RpcMessage (&EnumValuesRpcMessage())[79] { +inline const RpcMessage (&EnumValuesRpcMessage())[82] { static const RpcMessage values[] = { RpcMessage::NONE, RpcMessage::HeartbeatRequest, @@ -1458,13 +1470,16 @@ inline const RpcMessage (&EnumValuesRpcMessage())[79] { RpcMessage::IgnoreTrackingChecklistStepRequest, RpcMessage::StartUserHeightCalibration, RpcMessage::CancelUserHeightCalibration, - RpcMessage::UserHeightRecordingStatusResponse + RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::UnknownHIDDeviceHandshakeNotification, + RpcMessage::HIDAllReceiversCommandRequest, + RpcMessage::HIDTrackerCommandRequest }; return values; } inline const char * const *EnumNamesRpcMessage() { - static const char * const names[80] = { + static const char * const names[83] = { "NONE", "HeartbeatRequest", "HeartbeatResponse", @@ -1544,13 +1559,16 @@ inline const char * const *EnumNamesRpcMessage() { "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", + "UnknownHIDDeviceHandshakeNotification", + "HIDAllReceiversCommandRequest", + "HIDTrackerCommandRequest", nullptr }; return names; } inline const char *EnumNameRpcMessage(RpcMessage e) { - if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::UserHeightRecordingStatusResponse)) return ""; + if (flatbuffers::IsOutRange(e, RpcMessage::NONE, RpcMessage::HIDTrackerCommandRequest)) return ""; const size_t index = static_cast(e); return EnumNamesRpcMessage()[index]; } @@ -1871,6 +1889,18 @@ template<> struct RpcMessageTraits struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::UnknownHIDDeviceHandshakeNotification; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::HIDAllReceiversCommandRequest; +}; + +template<> struct RpcMessageTraits { + static const RpcMessage enum_value = RpcMessage::HIDTrackerCommandRequest; +}; + bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, RpcMessage type); bool VerifyRpcMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); @@ -6063,6 +6093,15 @@ struct RpcMessageHeader FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { const solarxr_protocol::rpc::UserHeightRecordingStatusResponse *message_as_UserHeightRecordingStatusResponse() const { return message_type() == solarxr_protocol::rpc::RpcMessage::UserHeightRecordingStatusResponse ? static_cast(message()) : nullptr; } + const solarxr_protocol::rpc::UnknownHIDDeviceHandshakeNotification *message_as_UnknownHIDDeviceHandshakeNotification() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::UnknownHIDDeviceHandshakeNotification ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::HIDAllReceiversCommandRequest *message_as_HIDAllReceiversCommandRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::HIDAllReceiversCommandRequest ? static_cast(message()) : nullptr; + } + const solarxr_protocol::rpc::HIDTrackerCommandRequest *message_as_HIDTrackerCommandRequest() const { + return message_type() == solarxr_protocol::rpc::RpcMessage::HIDTrackerCommandRequest ? static_cast(message()) : nullptr; + } bool Verify(flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_TX_ID, 4) && @@ -6385,6 +6424,18 @@ template<> inline const solarxr_protocol::rpc::UserHeightRecordingStatusResponse return message_as_UserHeightRecordingStatusResponse(); } +template<> inline const solarxr_protocol::rpc::UnknownHIDDeviceHandshakeNotification *RpcMessageHeader::message_as() const { + return message_as_UnknownHIDDeviceHandshakeNotification(); +} + +template<> inline const solarxr_protocol::rpc::HIDAllReceiversCommandRequest *RpcMessageHeader::message_as() const { + return message_as_HIDAllReceiversCommandRequest(); +} + +template<> inline const solarxr_protocol::rpc::HIDTrackerCommandRequest *RpcMessageHeader::message_as() const { + return message_as_HIDTrackerCommandRequest(); +} + struct RpcMessageHeaderBuilder { typedef RpcMessageHeader Table; flatbuffers::FlatBufferBuilder &fbb_; @@ -13417,6 +13468,188 @@ inline flatbuffers::Offset CreateUserHeightRe return builder_.Finish(); } +/// Same as normal unknown device, but for HID tracker. +struct UnknownHIDDeviceHandshakeNotification FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UnknownHIDDeviceHandshakeNotificationBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DEVICE_ADDRESS = 4, + VT_RECEIVER_ADDRESS = 6 + }; + const flatbuffers::String *device_address() const { + return GetPointer(VT_DEVICE_ADDRESS); + } + const flatbuffers::String *receiver_address() const { + return GetPointer(VT_RECEIVER_ADDRESS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DEVICE_ADDRESS) && + verifier.VerifyString(device_address()) && + VerifyOffset(verifier, VT_RECEIVER_ADDRESS) && + verifier.VerifyString(receiver_address()) && + verifier.EndTable(); + } +}; + +struct UnknownHIDDeviceHandshakeNotificationBuilder { + typedef UnknownHIDDeviceHandshakeNotification Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_device_address(flatbuffers::Offset device_address) { + fbb_.AddOffset(UnknownHIDDeviceHandshakeNotification::VT_DEVICE_ADDRESS, device_address); + } + void add_receiver_address(flatbuffers::Offset receiver_address) { + fbb_.AddOffset(UnknownHIDDeviceHandshakeNotification::VT_RECEIVER_ADDRESS, receiver_address); + } + explicit UnknownHIDDeviceHandshakeNotificationBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateUnknownHIDDeviceHandshakeNotification( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset device_address = 0, + flatbuffers::Offset receiver_address = 0) { + UnknownHIDDeviceHandshakeNotificationBuilder builder_(_fbb); + builder_.add_receiver_address(receiver_address); + builder_.add_device_address(device_address); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateUnknownHIDDeviceHandshakeNotificationDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *device_address = nullptr, + const char *receiver_address = nullptr) { + auto device_address__ = device_address ? _fbb.CreateString(device_address) : 0; + auto receiver_address__ = receiver_address ? _fbb.CreateString(receiver_address) : 0; + return solarxr_protocol::rpc::CreateUnknownHIDDeviceHandshakeNotification( + _fbb, + device_address__, + receiver_address__); +} + +struct HIDAllReceiversCommandRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HIDAllReceiversCommandRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_COMMAND = 4 + }; + const flatbuffers::String *command() const { + return GetPointer(VT_COMMAND); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_COMMAND) && + verifier.VerifyString(command()) && + verifier.EndTable(); + } +}; + +struct HIDAllReceiversCommandRequestBuilder { + typedef HIDAllReceiversCommandRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_command(flatbuffers::Offset command) { + fbb_.AddOffset(HIDAllReceiversCommandRequest::VT_COMMAND, command); + } + explicit HIDAllReceiversCommandRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHIDAllReceiversCommandRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset command = 0) { + HIDAllReceiversCommandRequestBuilder builder_(_fbb); + builder_.add_command(command); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHIDAllReceiversCommandRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *command = nullptr) { + auto command__ = command ? _fbb.CreateString(command) : 0; + return solarxr_protocol::rpc::CreateHIDAllReceiversCommandRequest( + _fbb, + command__); +} + +struct HIDTrackerCommandRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HIDTrackerCommandRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_DEVICE_ADDRESS = 4, + VT_COMMAND = 6 + }; + const flatbuffers::String *device_address() const { + return GetPointer(VT_DEVICE_ADDRESS); + } + const flatbuffers::String *command() const { + return GetPointer(VT_COMMAND); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_DEVICE_ADDRESS) && + verifier.VerifyString(device_address()) && + VerifyOffset(verifier, VT_COMMAND) && + verifier.VerifyString(command()) && + verifier.EndTable(); + } +}; + +struct HIDTrackerCommandRequestBuilder { + typedef HIDTrackerCommandRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_device_address(flatbuffers::Offset device_address) { + fbb_.AddOffset(HIDTrackerCommandRequest::VT_DEVICE_ADDRESS, device_address); + } + void add_command(flatbuffers::Offset command) { + fbb_.AddOffset(HIDTrackerCommandRequest::VT_COMMAND, command); + } + explicit HIDTrackerCommandRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateHIDTrackerCommandRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset device_address = 0, + flatbuffers::Offset command = 0) { + HIDTrackerCommandRequestBuilder builder_(_fbb); + builder_.add_command(command); + builder_.add_device_address(device_address); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateHIDTrackerCommandRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *device_address = nullptr, + const char *command = nullptr) { + auto device_address__ = device_address ? _fbb.CreateString(device_address) : 0; + auto command__ = command ? _fbb.CreateString(command) : 0; + return solarxr_protocol::rpc::CreateHIDTrackerCommandRequest( + _fbb, + device_address__, + command__); +} + } // namespace rpc namespace pub_sub { @@ -14462,6 +14695,18 @@ inline bool VerifyRpcMessage(flatbuffers::Verifier &verifier, const void *obj, R auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case RpcMessage::UnknownHIDDeviceHandshakeNotification: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::HIDAllReceiversCommandRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case RpcMessage::HIDTrackerCommandRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequest.java b/protocol/java/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequest.java new file mode 100644 index 00000000..5e2067c6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequest.java @@ -0,0 +1,59 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class HIDAllReceiversCommandRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static HIDAllReceiversCommandRequest getRootAsHIDAllReceiversCommandRequest(ByteBuffer _bb) { return getRootAsHIDAllReceiversCommandRequest(_bb, new HIDAllReceiversCommandRequest()); } + public static HIDAllReceiversCommandRequest getRootAsHIDAllReceiversCommandRequest(ByteBuffer _bb, HIDAllReceiversCommandRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public HIDAllReceiversCommandRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String command() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer commandAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer commandInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + + public static int createHIDAllReceiversCommandRequest(FlatBufferBuilder builder, + int commandOffset) { + builder.startTable(1); + HIDAllReceiversCommandRequest.addCommand(builder, commandOffset); + return HIDAllReceiversCommandRequest.endHIDAllReceiversCommandRequest(builder); + } + + public static void startHIDAllReceiversCommandRequest(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addCommand(FlatBufferBuilder builder, int commandOffset) { builder.addOffset(0, commandOffset, 0); } + public static int endHIDAllReceiversCommandRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public HIDAllReceiversCommandRequest get(int j) { return get(new HIDAllReceiversCommandRequest(), j); } + public HIDAllReceiversCommandRequest get(HIDAllReceiversCommandRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public HIDAllReceiversCommandRequestT unpack() { + HIDAllReceiversCommandRequestT _o = new HIDAllReceiversCommandRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(HIDAllReceiversCommandRequestT _o) { + String _oCommand = command(); + _o.setCommand(_oCommand); + } + public static int pack(FlatBufferBuilder builder, HIDAllReceiversCommandRequestT _o) { + if (_o == null) return 0; + int _command = _o.getCommand() == null ? 0 : builder.createString(_o.getCommand()); + return createHIDAllReceiversCommandRequest( + builder, + _command); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequestT.java b/protocol/java/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequestT.java new file mode 100644 index 00000000..70b361d6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequestT.java @@ -0,0 +1,22 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class HIDAllReceiversCommandRequestT { + private String command; + + public String getCommand() { return command; } + + public void setCommand(String command) { this.command = command; } + + + public HIDAllReceiversCommandRequestT() { + this.command = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDTrackerCommandRequest.java b/protocol/java/src/solarxr_protocol/rpc/HIDTrackerCommandRequest.java new file mode 100644 index 00000000..bb3fd845 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/HIDTrackerCommandRequest.java @@ -0,0 +1,69 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class HIDTrackerCommandRequest extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static HIDTrackerCommandRequest getRootAsHIDTrackerCommandRequest(ByteBuffer _bb) { return getRootAsHIDTrackerCommandRequest(_bb, new HIDTrackerCommandRequest()); } + public static HIDTrackerCommandRequest getRootAsHIDTrackerCommandRequest(ByteBuffer _bb, HIDTrackerCommandRequest obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public HIDTrackerCommandRequest __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String deviceAddress() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer deviceAddressAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer deviceAddressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + public String command() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer commandAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer commandInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + + public static int createHIDTrackerCommandRequest(FlatBufferBuilder builder, + int deviceAddressOffset, + int commandOffset) { + builder.startTable(2); + HIDTrackerCommandRequest.addCommand(builder, commandOffset); + HIDTrackerCommandRequest.addDeviceAddress(builder, deviceAddressOffset); + return HIDTrackerCommandRequest.endHIDTrackerCommandRequest(builder); + } + + public static void startHIDTrackerCommandRequest(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addDeviceAddress(FlatBufferBuilder builder, int deviceAddressOffset) { builder.addOffset(0, deviceAddressOffset, 0); } + public static void addCommand(FlatBufferBuilder builder, int commandOffset) { builder.addOffset(1, commandOffset, 0); } + public static int endHIDTrackerCommandRequest(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public HIDTrackerCommandRequest get(int j) { return get(new HIDTrackerCommandRequest(), j); } + public HIDTrackerCommandRequest get(HIDTrackerCommandRequest obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public HIDTrackerCommandRequestT unpack() { + HIDTrackerCommandRequestT _o = new HIDTrackerCommandRequestT(); + unpackTo(_o); + return _o; + } + public void unpackTo(HIDTrackerCommandRequestT _o) { + String _oDeviceAddress = deviceAddress(); + _o.setDeviceAddress(_oDeviceAddress); + String _oCommand = command(); + _o.setCommand(_oCommand); + } + public static int pack(FlatBufferBuilder builder, HIDTrackerCommandRequestT _o) { + if (_o == null) return 0; + int _deviceAddress = _o.getDeviceAddress() == null ? 0 : builder.createString(_o.getDeviceAddress()); + int _command = _o.getCommand() == null ? 0 : builder.createString(_o.getCommand()); + return createHIDTrackerCommandRequest( + builder, + _deviceAddress, + _command); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/HIDTrackerCommandRequestT.java b/protocol/java/src/solarxr_protocol/rpc/HIDTrackerCommandRequestT.java new file mode 100644 index 00000000..db2153e6 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/HIDTrackerCommandRequestT.java @@ -0,0 +1,28 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class HIDTrackerCommandRequestT { + private String deviceAddress; + private String command; + + public String getDeviceAddress() { return deviceAddress; } + + public void setDeviceAddress(String deviceAddress) { this.deviceAddress = deviceAddress; } + + public String getCommand() { return command; } + + public void setCommand(String command) { this.command = command; } + + + public HIDTrackerCommandRequestT() { + this.deviceAddress = null; + this.command = null; + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java index 5435c77b..fdd2bd17 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessage.java @@ -84,8 +84,11 @@ private RpcMessage() { } public static final byte StartUserHeightCalibration = 76; public static final byte CancelUserHeightCalibration = 77; public static final byte UserHeightRecordingStatusResponse = 78; + public static final byte UnknownHIDDeviceHandshakeNotification = 79; + public static final byte HIDAllReceiversCommandRequest = 80; + public static final byte HIDTrackerCommandRequest = 81; - public static final String[] names = { "NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", }; + public static final String[] names = { "NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", "UnknownHIDDeviceHandshakeNotification", "HIDAllReceiversCommandRequest", "HIDTrackerCommandRequest", }; public static String name(int e) { return names[e]; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java index f8ec9923..2b7d37b6 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageHeader.java @@ -364,6 +364,18 @@ public void unpackTo(RpcMessageHeaderT _o) { _oMessageValue = message(new solarxr_protocol.rpc.UserHeightRecordingStatusResponse()); _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.UserHeightRecordingStatusResponse) _oMessageValue).unpack() : null); break; + case solarxr_protocol.rpc.RpcMessage.UnknownHIDDeviceHandshakeNotification: + _oMessageValue = message(new solarxr_protocol.rpc.UnknownHIDDeviceHandshakeNotification()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.UnknownHIDDeviceHandshakeNotification) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.HIDAllReceiversCommandRequest: + _oMessageValue = message(new solarxr_protocol.rpc.HIDAllReceiversCommandRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.HIDAllReceiversCommandRequest) _oMessageValue).unpack() : null); + break; + case solarxr_protocol.rpc.RpcMessage.HIDTrackerCommandRequest: + _oMessageValue = message(new solarxr_protocol.rpc.HIDTrackerCommandRequest()); + _oMessage.setValue(_oMessageValue != null ? ((solarxr_protocol.rpc.HIDTrackerCommandRequest) _oMessageValue).unpack() : null); + break; default: break; } _o.setMessage(_oMessage); diff --git a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java index 0fb9afb4..027363bd 100644 --- a/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java +++ b/protocol/java/src/solarxr_protocol/rpc/RpcMessageUnion.java @@ -99,6 +99,9 @@ public RpcMessageUnion() { public solarxr_protocol.rpc.StartUserHeightCalibrationT asStartUserHeightCalibration() { return (solarxr_protocol.rpc.StartUserHeightCalibrationT) value; } public solarxr_protocol.rpc.CancelUserHeightCalibrationT asCancelUserHeightCalibration() { return (solarxr_protocol.rpc.CancelUserHeightCalibrationT) value; } public solarxr_protocol.rpc.UserHeightRecordingStatusResponseT asUserHeightRecordingStatusResponse() { return (solarxr_protocol.rpc.UserHeightRecordingStatusResponseT) value; } + public solarxr_protocol.rpc.UnknownHIDDeviceHandshakeNotificationT asUnknownHIDDeviceHandshakeNotification() { return (solarxr_protocol.rpc.UnknownHIDDeviceHandshakeNotificationT) value; } + public solarxr_protocol.rpc.HIDAllReceiversCommandRequestT asHIDAllReceiversCommandRequest() { return (solarxr_protocol.rpc.HIDAllReceiversCommandRequestT) value; } + public solarxr_protocol.rpc.HIDTrackerCommandRequestT asHIDTrackerCommandRequest() { return (solarxr_protocol.rpc.HIDTrackerCommandRequestT) value; } public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { switch (_o.type) { @@ -180,6 +183,9 @@ public static int pack(FlatBufferBuilder builder, RpcMessageUnion _o) { case RpcMessage.StartUserHeightCalibration: return solarxr_protocol.rpc.StartUserHeightCalibration.pack(builder, _o.asStartUserHeightCalibration()); case RpcMessage.CancelUserHeightCalibration: return solarxr_protocol.rpc.CancelUserHeightCalibration.pack(builder, _o.asCancelUserHeightCalibration()); case RpcMessage.UserHeightRecordingStatusResponse: return solarxr_protocol.rpc.UserHeightRecordingStatusResponse.pack(builder, _o.asUserHeightRecordingStatusResponse()); + case RpcMessage.UnknownHIDDeviceHandshakeNotification: return solarxr_protocol.rpc.UnknownHIDDeviceHandshakeNotification.pack(builder, _o.asUnknownHIDDeviceHandshakeNotification()); + case RpcMessage.HIDAllReceiversCommandRequest: return solarxr_protocol.rpc.HIDAllReceiversCommandRequest.pack(builder, _o.asHIDAllReceiversCommandRequest()); + case RpcMessage.HIDTrackerCommandRequest: return solarxr_protocol.rpc.HIDTrackerCommandRequest.pack(builder, _o.asHIDTrackerCommandRequest()); default: return 0; } } diff --git a/protocol/java/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotification.java b/protocol/java/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotification.java new file mode 100644 index 00000000..819d3426 --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotification.java @@ -0,0 +1,72 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +/** + * Same as normal unknown device, but for HID tracker. + */ +@SuppressWarnings("unused") +public final class UnknownHIDDeviceHandshakeNotification extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); } + public static UnknownHIDDeviceHandshakeNotification getRootAsUnknownHIDDeviceHandshakeNotification(ByteBuffer _bb) { return getRootAsUnknownHIDDeviceHandshakeNotification(_bb, new UnknownHIDDeviceHandshakeNotification()); } + public static UnknownHIDDeviceHandshakeNotification getRootAsUnknownHIDDeviceHandshakeNotification(ByteBuffer _bb, UnknownHIDDeviceHandshakeNotification obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public UnknownHIDDeviceHandshakeNotification __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public String deviceAddress() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer deviceAddressAsByteBuffer() { return __vector_as_bytebuffer(4, 1); } + public ByteBuffer deviceAddressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); } + public String receiverAddress() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; } + public ByteBuffer receiverAddressAsByteBuffer() { return __vector_as_bytebuffer(6, 1); } + public ByteBuffer receiverAddressInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); } + + public static int createUnknownHIDDeviceHandshakeNotification(FlatBufferBuilder builder, + int deviceAddressOffset, + int receiverAddressOffset) { + builder.startTable(2); + UnknownHIDDeviceHandshakeNotification.addReceiverAddress(builder, receiverAddressOffset); + UnknownHIDDeviceHandshakeNotification.addDeviceAddress(builder, deviceAddressOffset); + return UnknownHIDDeviceHandshakeNotification.endUnknownHIDDeviceHandshakeNotification(builder); + } + + public static void startUnknownHIDDeviceHandshakeNotification(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addDeviceAddress(FlatBufferBuilder builder, int deviceAddressOffset) { builder.addOffset(0, deviceAddressOffset, 0); } + public static void addReceiverAddress(FlatBufferBuilder builder, int receiverAddressOffset) { builder.addOffset(1, receiverAddressOffset, 0); } + public static int endUnknownHIDDeviceHandshakeNotification(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + public static final class Vector extends BaseVector { + public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; } + + public UnknownHIDDeviceHandshakeNotification get(int j) { return get(new UnknownHIDDeviceHandshakeNotification(), j); } + public UnknownHIDDeviceHandshakeNotification get(UnknownHIDDeviceHandshakeNotification obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } + public UnknownHIDDeviceHandshakeNotificationT unpack() { + UnknownHIDDeviceHandshakeNotificationT _o = new UnknownHIDDeviceHandshakeNotificationT(); + unpackTo(_o); + return _o; + } + public void unpackTo(UnknownHIDDeviceHandshakeNotificationT _o) { + String _oDeviceAddress = deviceAddress(); + _o.setDeviceAddress(_oDeviceAddress); + String _oReceiverAddress = receiverAddress(); + _o.setReceiverAddress(_oReceiverAddress); + } + public static int pack(FlatBufferBuilder builder, UnknownHIDDeviceHandshakeNotificationT _o) { + if (_o == null) return 0; + int _deviceAddress = _o.getDeviceAddress() == null ? 0 : builder.createString(_o.getDeviceAddress()); + int _receiverAddress = _o.getReceiverAddress() == null ? 0 : builder.createString(_o.getReceiverAddress()); + return createUnknownHIDDeviceHandshakeNotification( + builder, + _deviceAddress, + _receiverAddress); + } +} + diff --git a/protocol/java/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotificationT.java b/protocol/java/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotificationT.java new file mode 100644 index 00000000..1ed6cb6e --- /dev/null +++ b/protocol/java/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotificationT.java @@ -0,0 +1,28 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +public class UnknownHIDDeviceHandshakeNotificationT { + private String deviceAddress; + private String receiverAddress; + + public String getDeviceAddress() { return deviceAddress; } + + public void setDeviceAddress(String deviceAddress) { this.deviceAddress = deviceAddress; } + + public String getReceiverAddress() { return receiverAddress; } + + public void setReceiverAddress(String receiverAddress) { this.receiverAddress = receiverAddress; } + + + public UnknownHIDDeviceHandshakeNotificationT() { + this.deviceAddress = null; + this.receiverAddress = null; + } +} + diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequest.kt new file mode 100644 index 00000000..18486639 --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/HIDAllReceiversCommandRequest.kt @@ -0,0 +1,52 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class HIDAllReceiversCommandRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : HIDAllReceiversCommandRequest { + __init(_i, _bb) + return this + } + val command : String? + get() { + val o = __offset(4) + return if (o != 0) __string(o + bb_pos) else null + } + val commandAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) + fun commandInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsHIDAllReceiversCommandRequest(_bb: ByteBuffer): HIDAllReceiversCommandRequest = getRootAsHIDAllReceiversCommandRequest(_bb, HIDAllReceiversCommandRequest()) + @JvmStatic + fun getRootAsHIDAllReceiversCommandRequest(_bb: ByteBuffer, obj: HIDAllReceiversCommandRequest): HIDAllReceiversCommandRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createHIDAllReceiversCommandRequest(builder: FlatBufferBuilder, commandOffset: Int) : Int { + builder.startTable(1) + addCommand(builder, commandOffset) + return endHIDAllReceiversCommandRequest(builder) + } + @JvmStatic + fun startHIDAllReceiversCommandRequest(builder: FlatBufferBuilder) = builder.startTable(1) + @JvmStatic + fun addCommand(builder: FlatBufferBuilder, command: Int) = builder.addOffset(0, command, 0) + @JvmStatic + fun endHIDAllReceiversCommandRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/HIDTrackerCommandRequest.kt b/protocol/kotlin/src/solarxr_protocol/rpc/HIDTrackerCommandRequest.kt new file mode 100644 index 00000000..11fa777f --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/HIDTrackerCommandRequest.kt @@ -0,0 +1,62 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +@Suppress("unused") +class HIDTrackerCommandRequest : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : HIDTrackerCommandRequest { + __init(_i, _bb) + return this + } + val deviceAddress : String? + get() { + val o = __offset(4) + return if (o != 0) __string(o + bb_pos) else null + } + val deviceAddressAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) + fun deviceAddressInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) + val command : String? + get() { + val o = __offset(6) + return if (o != 0) __string(o + bb_pos) else null + } + val commandAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) + fun commandInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsHIDTrackerCommandRequest(_bb: ByteBuffer): HIDTrackerCommandRequest = getRootAsHIDTrackerCommandRequest(_bb, HIDTrackerCommandRequest()) + @JvmStatic + fun getRootAsHIDTrackerCommandRequest(_bb: ByteBuffer, obj: HIDTrackerCommandRequest): HIDTrackerCommandRequest { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createHIDTrackerCommandRequest(builder: FlatBufferBuilder, deviceAddressOffset: Int, commandOffset: Int) : Int { + builder.startTable(2) + addCommand(builder, commandOffset) + addDeviceAddress(builder, deviceAddressOffset) + return endHIDTrackerCommandRequest(builder) + } + @JvmStatic + fun startHIDTrackerCommandRequest(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addDeviceAddress(builder: FlatBufferBuilder, deviceAddress: Int) = builder.addOffset(0, deviceAddress, 0) + @JvmStatic + fun addCommand(builder: FlatBufferBuilder, command: Int) = builder.addOffset(1, command, 0) + @JvmStatic + fun endHIDTrackerCommandRequest(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt index 0aba32ed..9841dee4 100644 --- a/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt +++ b/protocol/kotlin/src/solarxr_protocol/rpc/RpcMessage.kt @@ -84,7 +84,10 @@ class RpcMessage private constructor() { const val StartUserHeightCalibration: UByte = 76u const val CancelUserHeightCalibration: UByte = 77u const val UserHeightRecordingStatusResponse: UByte = 78u - val names : Array = arrayOf("NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse") + const val UnknownHIDDeviceHandshakeNotification: UByte = 79u + const val HIDAllReceiversCommandRequest: UByte = 80u + const val HIDTrackerCommandRequest: UByte = 81u + val names : Array = arrayOf("NONE", "HeartbeatRequest", "HeartbeatResponse", "ResetRequest", "ResetResponse", "AssignTrackerRequest", "SettingsRequest", "SettingsResponse", "ChangeSettingsRequest", "ClearDriftCompensationRequest", "RecordBVHRequest", "RecordBVHStatus", "SkeletonConfigRequest", "ChangeSkeletonConfigRequest", "SkeletonResetAllRequest", "SkeletonConfigResponse", "OpenSerialRequest", "CloseSerialRequest", "SetWifiRequest", "SerialUpdateResponse", "AutoBoneProcessRequest", "AutoBoneProcessStatusResponse", "AutoBoneEpochResponse", "OverlayDisplayModeRequest", "OverlayDisplayModeChangeRequest", "OverlayDisplayModeResponse", "SerialTrackerRebootRequest", "SerialTrackerGetInfoRequest", "SerialTrackerFactoryResetRequest", "SerialDevicesRequest", "SerialDevicesResponse", "NewSerialDeviceResponse", "StartWifiProvisioningRequest", "StopWifiProvisioningRequest", "WifiProvisioningStatusResponse", "ServerInfosRequest", "ServerInfosResponse", "LegTweaksTmpChange", "LegTweaksTmpClear", "TapDetectionSetupNotification", "SetPauseTrackingRequest", "StatusSystemRequest", "StatusSystemResponse", "StatusSystemUpdate", "StatusSystemFixed", "ClearMountingResetRequest", "HeightRequest", "HeightResponse", "AutoBoneApplyRequest", "AutoBoneStopRecordingRequest", "AutoBoneCancelRecordingRequest", "SaveFileNotification", "TrackingPauseStateRequest", "TrackingPauseStateResponse", "SerialTrackerGetWifiScanRequest", "UnknownDeviceHandshakeNotification", "AddUnknownDeviceRequest", "ForgetDeviceRequest", "FirmwareUpdateRequest", "FirmwareUpdateStatusResponse", "FirmwareUpdateStopQueuesRequest", "SettingsResetRequest", "MagToggleRequest", "MagToggleResponse", "ChangeMagToggleRequest", "RecordBVHStatusRequest", "VRCConfigStateRequest", "VRCConfigStateChangeResponse", "EnableStayAlignedRequest", "DetectStayAlignedRelaxedPoseRequest", "ResetStayAlignedRelaxedPoseRequest", "SerialTrackerCustomCommandRequest", "VRCConfigSettingToggleMute", "TrackingChecklistRequest", "TrackingChecklistResponse", "IgnoreTrackingChecklistStepRequest", "StartUserHeightCalibration", "CancelUserHeightCalibration", "UserHeightRecordingStatusResponse", "UnknownHIDDeviceHandshakeNotification", "HIDAllReceiversCommandRequest", "HIDTrackerCommandRequest") @JvmStatic fun name(e: Int) : String = names[e] } diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotification.kt b/protocol/kotlin/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotification.kt new file mode 100644 index 00000000..5a4348fc --- /dev/null +++ b/protocol/kotlin/src/solarxr_protocol/rpc/UnknownHIDDeviceHandshakeNotification.kt @@ -0,0 +1,65 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package solarxr_protocol.rpc + +import java.nio.* +import kotlin.math.sign +import com.google.flatbuffers.* + +/** + * Same as normal unknown device, but for HID tracker. + */ +@Suppress("unused") +class UnknownHIDDeviceHandshakeNotification : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : UnknownHIDDeviceHandshakeNotification { + __init(_i, _bb) + return this + } + val deviceAddress : String? + get() { + val o = __offset(4) + return if (o != 0) __string(o + bb_pos) else null + } + val deviceAddressAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(4, 1) + fun deviceAddressInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 4, 1) + val receiverAddress : String? + get() { + val o = __offset(6) + return if (o != 0) __string(o + bb_pos) else null + } + val receiverAddressAsByteBuffer : ByteBuffer get() = __vector_as_bytebuffer(6, 1) + fun receiverAddressInByteBuffer(_bb: ByteBuffer) : ByteBuffer = __vector_in_bytebuffer(_bb, 6, 1) + companion object { + @JvmStatic + fun validateVersion() = Constants.FLATBUFFERS_22_10_26() + @JvmStatic + fun getRootAsUnknownHIDDeviceHandshakeNotification(_bb: ByteBuffer): UnknownHIDDeviceHandshakeNotification = getRootAsUnknownHIDDeviceHandshakeNotification(_bb, UnknownHIDDeviceHandshakeNotification()) + @JvmStatic + fun getRootAsUnknownHIDDeviceHandshakeNotification(_bb: ByteBuffer, obj: UnknownHIDDeviceHandshakeNotification): UnknownHIDDeviceHandshakeNotification { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + @JvmStatic + fun createUnknownHIDDeviceHandshakeNotification(builder: FlatBufferBuilder, deviceAddressOffset: Int, receiverAddressOffset: Int) : Int { + builder.startTable(2) + addReceiverAddress(builder, receiverAddressOffset) + addDeviceAddress(builder, deviceAddressOffset) + return endUnknownHIDDeviceHandshakeNotification(builder) + } + @JvmStatic + fun startUnknownHIDDeviceHandshakeNotification(builder: FlatBufferBuilder) = builder.startTable(2) + @JvmStatic + fun addDeviceAddress(builder: FlatBufferBuilder, deviceAddress: Int) = builder.addOffset(0, deviceAddress, 0) + @JvmStatic + fun addReceiverAddress(builder: FlatBufferBuilder, receiverAddress: Int) = builder.addOffset(1, receiverAddress, 0) + @JvmStatic + fun endUnknownHIDDeviceHandshakeNotification(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/protocol/rust/src/generated/mod.rs b/protocol/rust/src/generated/mod.rs index a3a27b23..c19cf5c9 100644 --- a/protocol/rust/src/generated/mod.rs +++ b/protocol/rust/src/generated/mod.rs @@ -416,6 +416,12 @@ pub mod solarxr_protocol { pub use self::cancel_user_height_calibration_generated::*; mod user_height_recording_status_response_generated; pub use self::user_height_recording_status_response_generated::*; + mod unknown_hiddevice_handshake_notification_generated; + pub use self::unknown_hiddevice_handshake_notification_generated::*; + mod hidall_receivers_command_request_generated; + pub use self::hidall_receivers_command_request_generated::*; + mod hidtracker_command_request_generated; + pub use self::hidtracker_command_request_generated::*; } // rpc mod message_bundle_generated; pub use self::message_bundle_generated::*; diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/hidall_receivers_command_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/hidall_receivers_command_request_generated.rs new file mode 100644 index 00000000..c6ebdb51 --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/hidall_receivers_command_request_generated.rs @@ -0,0 +1,108 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum HIDAllReceiversCommandRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct HIDAllReceiversCommandRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for HIDAllReceiversCommandRequest<'a> { + type Inner = HIDAllReceiversCommandRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> HIDAllReceiversCommandRequest<'a> { + pub const VT_COMMAND: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + HIDAllReceiversCommandRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args HIDAllReceiversCommandRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = HIDAllReceiversCommandRequestBuilder::new(_fbb); + if let Some(x) = args.command { builder.add_command(x); } + builder.finish() + } + + + #[inline] + pub fn command(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(HIDAllReceiversCommandRequest::VT_COMMAND, None)} + } +} + +impl flatbuffers::Verifiable for HIDAllReceiversCommandRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("command", Self::VT_COMMAND, false)? + .finish(); + Ok(()) + } +} +pub struct HIDAllReceiversCommandRequestArgs<'a> { + pub command: Option>, +} +impl<'a> Default for HIDAllReceiversCommandRequestArgs<'a> { + #[inline] + fn default() -> Self { + HIDAllReceiversCommandRequestArgs { + command: None, + } + } +} + +pub struct HIDAllReceiversCommandRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> HIDAllReceiversCommandRequestBuilder<'a, 'b> { + #[inline] + pub fn add_command(&mut self, command: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(HIDAllReceiversCommandRequest::VT_COMMAND, command); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HIDAllReceiversCommandRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + HIDAllReceiversCommandRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for HIDAllReceiversCommandRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("HIDAllReceiversCommandRequest"); + ds.field("command", &self.command()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/hidtracker_command_request_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/hidtracker_command_request_generated.rs new file mode 100644 index 00000000..92ab4d2e --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/hidtracker_command_request_generated.rs @@ -0,0 +1,125 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum HIDTrackerCommandRequestOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct HIDTrackerCommandRequest<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for HIDTrackerCommandRequest<'a> { + type Inner = HIDTrackerCommandRequest<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> HIDTrackerCommandRequest<'a> { + pub const VT_DEVICE_ADDRESS: flatbuffers::VOffsetT = 4; + pub const VT_COMMAND: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + HIDTrackerCommandRequest { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args HIDTrackerCommandRequestArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = HIDTrackerCommandRequestBuilder::new(_fbb); + if let Some(x) = args.command { builder.add_command(x); } + if let Some(x) = args.device_address { builder.add_device_address(x); } + builder.finish() + } + + + #[inline] + pub fn device_address(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(HIDTrackerCommandRequest::VT_DEVICE_ADDRESS, None)} + } + #[inline] + pub fn command(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(HIDTrackerCommandRequest::VT_COMMAND, None)} + } +} + +impl flatbuffers::Verifiable for HIDTrackerCommandRequest<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("device_address", Self::VT_DEVICE_ADDRESS, false)? + .visit_field::>("command", Self::VT_COMMAND, false)? + .finish(); + Ok(()) + } +} +pub struct HIDTrackerCommandRequestArgs<'a> { + pub device_address: Option>, + pub command: Option>, +} +impl<'a> Default for HIDTrackerCommandRequestArgs<'a> { + #[inline] + fn default() -> Self { + HIDTrackerCommandRequestArgs { + device_address: None, + command: None, + } + } +} + +pub struct HIDTrackerCommandRequestBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> HIDTrackerCommandRequestBuilder<'a, 'b> { + #[inline] + pub fn add_device_address(&mut self, device_address: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(HIDTrackerCommandRequest::VT_DEVICE_ADDRESS, device_address); + } + #[inline] + pub fn add_command(&mut self, command: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(HIDTrackerCommandRequest::VT_COMMAND, command); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> HIDTrackerCommandRequestBuilder<'a, 'b> { + let start = _fbb.start_table(); + HIDTrackerCommandRequestBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for HIDTrackerCommandRequest<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("HIDTrackerCommandRequest"); + ds.field("device_address", &self.device_address()); + ds.field("command", &self.command()); + ds.finish() + } +} diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs index f056f10c..23070f8c 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_generated.rs @@ -12,10 +12,10 @@ use super::*; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] pub const ENUM_MIN_RPC_MESSAGE: u8 = 0; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] -pub const ENUM_MAX_RPC_MESSAGE: u8 = 78; +pub const ENUM_MAX_RPC_MESSAGE: u8 = 81; #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")] #[allow(non_camel_case_types)] -pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 79] = [ +pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 82] = [ RpcMessage::NONE, RpcMessage::HeartbeatRequest, RpcMessage::HeartbeatResponse, @@ -95,6 +95,9 @@ pub const ENUM_VALUES_RPC_MESSAGE: [RpcMessage; 79] = [ RpcMessage::StartUserHeightCalibration, RpcMessage::CancelUserHeightCalibration, RpcMessage::UserHeightRecordingStatusResponse, + RpcMessage::UnknownHIDDeviceHandshakeNotification, + RpcMessage::HIDAllReceiversCommandRequest, + RpcMessage::HIDTrackerCommandRequest, ]; #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)] @@ -181,9 +184,12 @@ impl RpcMessage { pub const StartUserHeightCalibration: Self = Self(76); pub const CancelUserHeightCalibration: Self = Self(77); pub const UserHeightRecordingStatusResponse: Self = Self(78); + pub const UnknownHIDDeviceHandshakeNotification: Self = Self(79); + pub const HIDAllReceiversCommandRequest: Self = Self(80); + pub const HIDTrackerCommandRequest: Self = Self(81); pub const ENUM_MIN: u8 = 0; - pub const ENUM_MAX: u8 = 78; + pub const ENUM_MAX: u8 = 81; pub const ENUM_VALUES: &'static [Self] = &[ Self::NONE, Self::HeartbeatRequest, @@ -264,6 +270,9 @@ impl RpcMessage { Self::StartUserHeightCalibration, Self::CancelUserHeightCalibration, Self::UserHeightRecordingStatusResponse, + Self::UnknownHIDDeviceHandshakeNotification, + Self::HIDAllReceiversCommandRequest, + Self::HIDTrackerCommandRequest, ]; /// Returns the variant's name or "" if unknown. pub fn variant_name(self) -> Option<&'static str> { @@ -347,6 +356,9 @@ impl RpcMessage { Self::StartUserHeightCalibration => Some("StartUserHeightCalibration"), Self::CancelUserHeightCalibration => Some("CancelUserHeightCalibration"), Self::UserHeightRecordingStatusResponse => Some("UserHeightRecordingStatusResponse"), + Self::UnknownHIDDeviceHandshakeNotification => Some("UnknownHIDDeviceHandshakeNotification"), + Self::HIDAllReceiversCommandRequest => Some("HIDAllReceiversCommandRequest"), + Self::HIDTrackerCommandRequest => Some("HIDTrackerCommandRequest"), _ => None, } } diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs index 5302176d..811d689e 100644 --- a/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/rpc_message_header_generated.rs @@ -1239,6 +1239,51 @@ impl<'a> RpcMessageHeader<'a> { } } + #[inline] + #[allow(non_snake_case)] + pub fn message_as_unknown_hiddevice_handshake_notification(&self) -> Option> { + if self.message_type() == RpcMessage::UnknownHIDDeviceHandshakeNotification { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { UnknownHIDDeviceHandshakeNotification::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_hidall_receivers_command_request(&self) -> Option> { + if self.message_type() == RpcMessage::HIDAllReceiversCommandRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { HIDAllReceiversCommandRequest::init_from_table(t) } + }) + } else { + None + } + } + + #[inline] + #[allow(non_snake_case)] + pub fn message_as_hidtracker_command_request(&self) -> Option> { + if self.message_type() == RpcMessage::HIDTrackerCommandRequest { + self.message().map(|t| { + // Safety: + // Created from a valid Table for this object + // Which contains a valid union in this slot + unsafe { HIDTrackerCommandRequest::init_from_table(t) } + }) + } else { + None + } + } + } impl flatbuffers::Verifiable for RpcMessageHeader<'_> { @@ -1329,6 +1374,9 @@ impl flatbuffers::Verifiable for RpcMessageHeader<'_> { RpcMessage::StartUserHeightCalibration => v.verify_union_variant::>("RpcMessage::StartUserHeightCalibration", pos), RpcMessage::CancelUserHeightCalibration => v.verify_union_variant::>("RpcMessage::CancelUserHeightCalibration", pos), RpcMessage::UserHeightRecordingStatusResponse => v.verify_union_variant::>("RpcMessage::UserHeightRecordingStatusResponse", pos), + RpcMessage::UnknownHIDDeviceHandshakeNotification => v.verify_union_variant::>("RpcMessage::UnknownHIDDeviceHandshakeNotification", pos), + RpcMessage::HIDAllReceiversCommandRequest => v.verify_union_variant::>("RpcMessage::HIDAllReceiversCommandRequest", pos), + RpcMessage::HIDTrackerCommandRequest => v.verify_union_variant::>("RpcMessage::HIDTrackerCommandRequest", pos), _ => Ok(()), } })? @@ -1936,6 +1984,27 @@ impl core::fmt::Debug for RpcMessageHeader<'_> { ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") } }, + RpcMessage::UnknownHIDDeviceHandshakeNotification => { + if let Some(x) = self.message_as_unknown_hiddevice_handshake_notification() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::HIDAllReceiversCommandRequest => { + if let Some(x) = self.message_as_hidall_receivers_command_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, + RpcMessage::HIDTrackerCommandRequest => { + if let Some(x) = self.message_as_hidtracker_command_request() { + ds.field("message", &x) + } else { + ds.field("message", &"InvalidFlatbuffer: Union discriminant does not match value.") + } + }, _ => { let x: Option<()> = None; ds.field("message", &x) diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/unknown_hiddevice_handshake_notification_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/unknown_hiddevice_handshake_notification_generated.rs new file mode 100644 index 00000000..f07812fa --- /dev/null +++ b/protocol/rust/src/generated/solarxr_protocol/rpc/unknown_hiddevice_handshake_notification_generated.rs @@ -0,0 +1,126 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// @generated +extern crate alloc; +extern crate flatbuffers; +use alloc::boxed::Box; +use alloc::string::{String, ToString}; +use alloc::vec::Vec; +use core::mem; +use core::cmp::Ordering; +use self::flatbuffers::{EndianScalar, Follow}; +use super::*; +pub enum UnknownHIDDeviceHandshakeNotificationOffset {} +#[derive(Copy, Clone, PartialEq)] + +/// Same as normal unknown device, but for HID tracker. +pub struct UnknownHIDDeviceHandshakeNotification<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for UnknownHIDDeviceHandshakeNotification<'a> { + type Inner = UnknownHIDDeviceHandshakeNotification<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> UnknownHIDDeviceHandshakeNotification<'a> { + pub const VT_DEVICE_ADDRESS: flatbuffers::VOffsetT = 4; + pub const VT_RECEIVER_ADDRESS: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + UnknownHIDDeviceHandshakeNotification { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args UnknownHIDDeviceHandshakeNotificationArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = UnknownHIDDeviceHandshakeNotificationBuilder::new(_fbb); + if let Some(x) = args.receiver_address { builder.add_receiver_address(x); } + if let Some(x) = args.device_address { builder.add_device_address(x); } + builder.finish() + } + + + #[inline] + pub fn device_address(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(UnknownHIDDeviceHandshakeNotification::VT_DEVICE_ADDRESS, None)} + } + #[inline] + pub fn receiver_address(&self) -> Option<&'a str> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>(UnknownHIDDeviceHandshakeNotification::VT_RECEIVER_ADDRESS, None)} + } +} + +impl flatbuffers::Verifiable for UnknownHIDDeviceHandshakeNotification<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::>("device_address", Self::VT_DEVICE_ADDRESS, false)? + .visit_field::>("receiver_address", Self::VT_RECEIVER_ADDRESS, false)? + .finish(); + Ok(()) + } +} +pub struct UnknownHIDDeviceHandshakeNotificationArgs<'a> { + pub device_address: Option>, + pub receiver_address: Option>, +} +impl<'a> Default for UnknownHIDDeviceHandshakeNotificationArgs<'a> { + #[inline] + fn default() -> Self { + UnknownHIDDeviceHandshakeNotificationArgs { + device_address: None, + receiver_address: None, + } + } +} + +pub struct UnknownHIDDeviceHandshakeNotificationBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> UnknownHIDDeviceHandshakeNotificationBuilder<'a, 'b> { + #[inline] + pub fn add_device_address(&mut self, device_address: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(UnknownHIDDeviceHandshakeNotification::VT_DEVICE_ADDRESS, device_address); + } + #[inline] + pub fn add_receiver_address(&mut self, receiver_address: flatbuffers::WIPOffset<&'b str>) { + self.fbb_.push_slot_always::>(UnknownHIDDeviceHandshakeNotification::VT_RECEIVER_ADDRESS, receiver_address); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> UnknownHIDDeviceHandshakeNotificationBuilder<'a, 'b> { + let start = _fbb.start_table(); + UnknownHIDDeviceHandshakeNotificationBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for UnknownHIDDeviceHandshakeNotification<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("UnknownHIDDeviceHandshakeNotification"); + ds.field("device_address", &self.device_address()); + ds.field("receiver_address", &self.receiver_address()); + ds.finish() + } +} diff --git a/protocol/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts index 1535b09d..067e1f90 100644 --- a/protocol/typescript/src/all_generated.ts +++ b/protocol/typescript/src/all_generated.ts @@ -83,7 +83,9 @@ export { FirmwareUpdateStatus } from './solarxr-protocol/rpc/firmware-update-sta export { FirmwareUpdateStatusResponse, FirmwareUpdateStatusResponseT } from './solarxr-protocol/rpc/firmware-update-status-response.js'; export { FirmwareUpdateStopQueuesRequest, FirmwareUpdateStopQueuesRequestT } from './solarxr-protocol/rpc/firmware-update-stop-queues-request.js'; export { ForgetDeviceRequest, ForgetDeviceRequestT } from './solarxr-protocol/rpc/forget-device-request.js'; +export { HIDAllReceiversCommandRequest, HIDAllReceiversCommandRequestT } from './solarxr-protocol/rpc/hidall-receivers-command-request.js'; export { HIDSettings, HIDSettingsT } from './solarxr-protocol/rpc/hidsettings.js'; +export { HIDTrackerCommandRequest, HIDTrackerCommandRequestT } from './solarxr-protocol/rpc/hidtracker-command-request.js'; export { HeartbeatRequest, HeartbeatRequestT } from './solarxr-protocol/rpc/heartbeat-request.js'; export { HeartbeatResponse, HeartbeatResponseT } from './solarxr-protocol/rpc/heartbeat-response.js'; export { HeightRequest, HeightRequestT } from './solarxr-protocol/rpc/height-request.js'; @@ -171,6 +173,7 @@ export { TrackingChecklistUnassignedHMD, TrackingChecklistUnassignedHMDT } from export { TrackingPauseStateRequest, TrackingPauseStateRequestT } from './solarxr-protocol/rpc/tracking-pause-state-request.js'; export { TrackingPauseStateResponse, TrackingPauseStateResponseT } from './solarxr-protocol/rpc/tracking-pause-state-response.js'; export { UnknownDeviceHandshakeNotification, UnknownDeviceHandshakeNotificationT } from './solarxr-protocol/rpc/unknown-device-handshake-notification.js'; +export { UnknownHIDDeviceHandshakeNotification, UnknownHIDDeviceHandshakeNotificationT } from './solarxr-protocol/rpc/unknown-hiddevice-handshake-notification.js'; export { UserHeightCalibrationStatus } from './solarxr-protocol/rpc/user-height-calibration-status.js'; export { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from './solarxr-protocol/rpc/user-height-recording-status-response.js'; export { VMCOSCSettings, VMCOSCSettingsT } from './solarxr-protocol/rpc/vmcoscsettings.js'; diff --git a/protocol/typescript/src/solarxr-protocol/rpc/hidall-receivers-command-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/hidall-receivers-command-request.ts new file mode 100644 index 00000000..edc7fc1e --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/hidall-receivers-command-request.ts @@ -0,0 +1,76 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class HIDAllReceiversCommandRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):HIDAllReceiversCommandRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsHIDAllReceiversCommandRequest(bb:flatbuffers.ByteBuffer, obj?:HIDAllReceiversCommandRequest):HIDAllReceiversCommandRequest { + return (obj || new HIDAllReceiversCommandRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsHIDAllReceiversCommandRequest(bb:flatbuffers.ByteBuffer, obj?:HIDAllReceiversCommandRequest):HIDAllReceiversCommandRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new HIDAllReceiversCommandRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +command():string|null +command(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +command(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startHIDAllReceiversCommandRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addCommand(builder:flatbuffers.Builder, commandOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, commandOffset, 0); +} + +static endHIDAllReceiversCommandRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createHIDAllReceiversCommandRequest(builder:flatbuffers.Builder, commandOffset:flatbuffers.Offset):flatbuffers.Offset { + HIDAllReceiversCommandRequest.startHIDAllReceiversCommandRequest(builder); + HIDAllReceiversCommandRequest.addCommand(builder, commandOffset); + return HIDAllReceiversCommandRequest.endHIDAllReceiversCommandRequest(builder); +} + +unpack(): HIDAllReceiversCommandRequestT { + return new HIDAllReceiversCommandRequestT( + this.command() + ); +} + + +unpackTo(_o: HIDAllReceiversCommandRequestT): void { + _o.command = this.command(); +} +} + +export class HIDAllReceiversCommandRequestT implements flatbuffers.IGeneratedObject { +constructor( + public command: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const command = (this.command !== null ? builder.createString(this.command!) : 0); + + return HIDAllReceiversCommandRequest.createHIDAllReceiversCommandRequest(builder, + command + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/hidtracker-command-request.ts b/protocol/typescript/src/solarxr-protocol/rpc/hidtracker-command-request.ts new file mode 100644 index 00000000..268ee00d --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/hidtracker-command-request.ts @@ -0,0 +1,93 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +export class HIDTrackerCommandRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):HIDTrackerCommandRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsHIDTrackerCommandRequest(bb:flatbuffers.ByteBuffer, obj?:HIDTrackerCommandRequest):HIDTrackerCommandRequest { + return (obj || new HIDTrackerCommandRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsHIDTrackerCommandRequest(bb:flatbuffers.ByteBuffer, obj?:HIDTrackerCommandRequest):HIDTrackerCommandRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new HIDTrackerCommandRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +deviceAddress():string|null +deviceAddress(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +deviceAddress(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +command():string|null +command(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +command(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startHIDTrackerCommandRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addDeviceAddress(builder:flatbuffers.Builder, deviceAddressOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, deviceAddressOffset, 0); +} + +static addCommand(builder:flatbuffers.Builder, commandOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, commandOffset, 0); +} + +static endHIDTrackerCommandRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createHIDTrackerCommandRequest(builder:flatbuffers.Builder, deviceAddressOffset:flatbuffers.Offset, commandOffset:flatbuffers.Offset):flatbuffers.Offset { + HIDTrackerCommandRequest.startHIDTrackerCommandRequest(builder); + HIDTrackerCommandRequest.addDeviceAddress(builder, deviceAddressOffset); + HIDTrackerCommandRequest.addCommand(builder, commandOffset); + return HIDTrackerCommandRequest.endHIDTrackerCommandRequest(builder); +} + +unpack(): HIDTrackerCommandRequestT { + return new HIDTrackerCommandRequestT( + this.deviceAddress(), + this.command() + ); +} + + +unpackTo(_o: HIDTrackerCommandRequestT): void { + _o.deviceAddress = this.deviceAddress(); + _o.command = this.command(); +} +} + +export class HIDTrackerCommandRequestT implements flatbuffers.IGeneratedObject { +constructor( + public deviceAddress: string|Uint8Array|null = null, + public command: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const deviceAddress = (this.deviceAddress !== null ? builder.createString(this.deviceAddress!) : 0); + const command = (this.command !== null ? builder.createString(this.command!) : 0); + + return HIDTrackerCommandRequest.createHIDTrackerCommandRequest(builder, + deviceAddress, + command + ); +} +} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts index 45268429..301dee55 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message-header.ts @@ -24,6 +24,8 @@ import { FirmwareUpdateRequest, FirmwareUpdateRequestT } from '../../solarxr-pro import { FirmwareUpdateStatusResponse, FirmwareUpdateStatusResponseT } from '../../solarxr-protocol/rpc/firmware-update-status-response.js'; import { FirmwareUpdateStopQueuesRequest, FirmwareUpdateStopQueuesRequestT } from '../../solarxr-protocol/rpc/firmware-update-stop-queues-request.js'; import { ForgetDeviceRequest, ForgetDeviceRequestT } from '../../solarxr-protocol/rpc/forget-device-request.js'; +import { HIDAllReceiversCommandRequest, HIDAllReceiversCommandRequestT } from '../../solarxr-protocol/rpc/hidall-receivers-command-request.js'; +import { HIDTrackerCommandRequest, HIDTrackerCommandRequestT } from '../../solarxr-protocol/rpc/hidtracker-command-request.js'; import { HeartbeatRequest, HeartbeatRequestT } from '../../solarxr-protocol/rpc/heartbeat-request.js'; import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rpc/heartbeat-response.js'; import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; @@ -77,6 +79,7 @@ import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../sol import { TrackingPauseStateRequest, TrackingPauseStateRequestT } from '../../solarxr-protocol/rpc/tracking-pause-state-request.js'; import { TrackingPauseStateResponse, TrackingPauseStateResponseT } from '../../solarxr-protocol/rpc/tracking-pause-state-response.js'; import { UnknownDeviceHandshakeNotification, UnknownDeviceHandshakeNotificationT } from '../../solarxr-protocol/rpc/unknown-device-handshake-notification.js'; +import { UnknownHIDDeviceHandshakeNotification, UnknownHIDDeviceHandshakeNotificationT } from '../../solarxr-protocol/rpc/unknown-hiddevice-handshake-notification.js'; import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from '../../solarxr-protocol/rpc/user-height-recording-status-response.js'; import { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from '../../solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; import { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from '../../solarxr-protocol/rpc/vrcconfig-state-change-response.js'; @@ -178,7 +181,7 @@ export class RpcMessageHeaderT implements flatbuffers.IGeneratedObject { constructor( public txId: TransactionIdT|null = null, public messageType: RpcMessage = RpcMessage.NONE, - public message: AddUnknownDeviceRequestT|AssignTrackerRequestT|AutoBoneApplyRequestT|AutoBoneCancelRecordingRequestT|AutoBoneEpochResponseT|AutoBoneProcessRequestT|AutoBoneProcessStatusResponseT|AutoBoneStopRecordingRequestT|CancelUserHeightCalibrationT|ChangeMagToggleRequestT|ChangeSettingsRequestT|ChangeSkeletonConfigRequestT|ClearDriftCompensationRequestT|ClearMountingResetRequestT|CloseSerialRequestT|DetectStayAlignedRelaxedPoseRequestT|EnableStayAlignedRequestT|FirmwareUpdateRequestT|FirmwareUpdateStatusResponseT|FirmwareUpdateStopQueuesRequestT|ForgetDeviceRequestT|HeartbeatRequestT|HeartbeatResponseT|HeightRequestT|HeightResponseT|IgnoreTrackingChecklistStepRequestT|LegTweaksTmpChangeT|LegTweaksTmpClearT|MagToggleRequestT|MagToggleResponseT|NewSerialDeviceResponseT|OpenSerialRequestT|OverlayDisplayModeChangeRequestT|OverlayDisplayModeRequestT|OverlayDisplayModeResponseT|RecordBVHRequestT|RecordBVHStatusRequestT|RecordBVHStatusT|ResetRequestT|ResetResponseT|ResetStayAlignedRelaxedPoseRequestT|SaveFileNotificationT|SerialDevicesRequestT|SerialDevicesResponseT|SerialTrackerCustomCommandRequestT|SerialTrackerFactoryResetRequestT|SerialTrackerGetInfoRequestT|SerialTrackerGetWifiScanRequestT|SerialTrackerRebootRequestT|SerialUpdateResponseT|ServerInfosRequestT|ServerInfosResponseT|SetPauseTrackingRequestT|SetWifiRequestT|SettingsRequestT|SettingsResetRequestT|SettingsResponseT|SkeletonConfigRequestT|SkeletonConfigResponseT|SkeletonResetAllRequestT|StartUserHeightCalibrationT|StartWifiProvisioningRequestT|StatusSystemFixedT|StatusSystemRequestT|StatusSystemResponseT|StatusSystemUpdateT|StopWifiProvisioningRequestT|TapDetectionSetupNotificationT|TrackingChecklistRequestT|TrackingChecklistResponseT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|UserHeightRecordingStatusResponseT|VRCConfigSettingToggleMuteT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|WifiProvisioningStatusResponseT|null = null + public message: AddUnknownDeviceRequestT|AssignTrackerRequestT|AutoBoneApplyRequestT|AutoBoneCancelRecordingRequestT|AutoBoneEpochResponseT|AutoBoneProcessRequestT|AutoBoneProcessStatusResponseT|AutoBoneStopRecordingRequestT|CancelUserHeightCalibrationT|ChangeMagToggleRequestT|ChangeSettingsRequestT|ChangeSkeletonConfigRequestT|ClearDriftCompensationRequestT|ClearMountingResetRequestT|CloseSerialRequestT|DetectStayAlignedRelaxedPoseRequestT|EnableStayAlignedRequestT|FirmwareUpdateRequestT|FirmwareUpdateStatusResponseT|FirmwareUpdateStopQueuesRequestT|ForgetDeviceRequestT|HIDAllReceiversCommandRequestT|HIDTrackerCommandRequestT|HeartbeatRequestT|HeartbeatResponseT|HeightRequestT|HeightResponseT|IgnoreTrackingChecklistStepRequestT|LegTweaksTmpChangeT|LegTweaksTmpClearT|MagToggleRequestT|MagToggleResponseT|NewSerialDeviceResponseT|OpenSerialRequestT|OverlayDisplayModeChangeRequestT|OverlayDisplayModeRequestT|OverlayDisplayModeResponseT|RecordBVHRequestT|RecordBVHStatusRequestT|RecordBVHStatusT|ResetRequestT|ResetResponseT|ResetStayAlignedRelaxedPoseRequestT|SaveFileNotificationT|SerialDevicesRequestT|SerialDevicesResponseT|SerialTrackerCustomCommandRequestT|SerialTrackerFactoryResetRequestT|SerialTrackerGetInfoRequestT|SerialTrackerGetWifiScanRequestT|SerialTrackerRebootRequestT|SerialUpdateResponseT|ServerInfosRequestT|ServerInfosResponseT|SetPauseTrackingRequestT|SetWifiRequestT|SettingsRequestT|SettingsResetRequestT|SettingsResponseT|SkeletonConfigRequestT|SkeletonConfigResponseT|SkeletonResetAllRequestT|StartUserHeightCalibrationT|StartWifiProvisioningRequestT|StatusSystemFixedT|StatusSystemRequestT|StatusSystemResponseT|StatusSystemUpdateT|StopWifiProvisioningRequestT|TapDetectionSetupNotificationT|TrackingChecklistRequestT|TrackingChecklistResponseT|TrackingPauseStateRequestT|TrackingPauseStateResponseT|UnknownDeviceHandshakeNotificationT|UnknownHIDDeviceHandshakeNotificationT|UserHeightRecordingStatusResponseT|VRCConfigSettingToggleMuteT|VRCConfigStateChangeResponseT|VRCConfigStateRequestT|WifiProvisioningStatusResponseT|null = null ){} diff --git a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts index 76d9891b..a50c2ff7 100644 --- a/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts +++ b/protocol/typescript/src/solarxr-protocol/rpc/rpc-message.ts @@ -21,6 +21,8 @@ import { FirmwareUpdateRequest, FirmwareUpdateRequestT } from '../../solarxr-pro import { FirmwareUpdateStatusResponse, FirmwareUpdateStatusResponseT } from '../../solarxr-protocol/rpc/firmware-update-status-response.js'; import { FirmwareUpdateStopQueuesRequest, FirmwareUpdateStopQueuesRequestT } from '../../solarxr-protocol/rpc/firmware-update-stop-queues-request.js'; import { ForgetDeviceRequest, ForgetDeviceRequestT } from '../../solarxr-protocol/rpc/forget-device-request.js'; +import { HIDAllReceiversCommandRequest, HIDAllReceiversCommandRequestT } from '../../solarxr-protocol/rpc/hidall-receivers-command-request.js'; +import { HIDTrackerCommandRequest, HIDTrackerCommandRequestT } from '../../solarxr-protocol/rpc/hidtracker-command-request.js'; import { HeartbeatRequest, HeartbeatRequestT } from '../../solarxr-protocol/rpc/heartbeat-request.js'; import { HeartbeatResponse, HeartbeatResponseT } from '../../solarxr-protocol/rpc/heartbeat-response.js'; import { HeightRequest, HeightRequestT } from '../../solarxr-protocol/rpc/height-request.js'; @@ -73,6 +75,7 @@ import { TrackingChecklistResponse, TrackingChecklistResponseT } from '../../sol import { TrackingPauseStateRequest, TrackingPauseStateRequestT } from '../../solarxr-protocol/rpc/tracking-pause-state-request.js'; import { TrackingPauseStateResponse, TrackingPauseStateResponseT } from '../../solarxr-protocol/rpc/tracking-pause-state-response.js'; import { UnknownDeviceHandshakeNotification, UnknownDeviceHandshakeNotificationT } from '../../solarxr-protocol/rpc/unknown-device-handshake-notification.js'; +import { UnknownHIDDeviceHandshakeNotification, UnknownHIDDeviceHandshakeNotificationT } from '../../solarxr-protocol/rpc/unknown-hiddevice-handshake-notification.js'; import { UserHeightRecordingStatusResponse, UserHeightRecordingStatusResponseT } from '../../solarxr-protocol/rpc/user-height-recording-status-response.js'; import { VRCConfigSettingToggleMute, VRCConfigSettingToggleMuteT } from '../../solarxr-protocol/rpc/vrcconfig-setting-toggle-mute.js'; import { VRCConfigStateChangeResponse, VRCConfigStateChangeResponseT } from '../../solarxr-protocol/rpc/vrcconfig-state-change-response.js'; @@ -159,13 +162,16 @@ export enum RpcMessage { IgnoreTrackingChecklistStepRequest = 75, StartUserHeightCalibration = 76, CancelUserHeightCalibration = 77, - UserHeightRecordingStatusResponse = 78 + UserHeightRecordingStatusResponse = 78, + UnknownHIDDeviceHandshakeNotification = 79, + HIDAllReceiversCommandRequest = 80, + HIDTrackerCommandRequest = 81 } export function unionToRpcMessage( type: RpcMessage, - accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { + accessor: (obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDAllReceiversCommandRequest|HIDTrackerCommandRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UnknownHIDDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDAllReceiversCommandRequest|HIDTrackerCommandRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UnknownHIDDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDAllReceiversCommandRequest|HIDTrackerCommandRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UnknownHIDDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(new HeartbeatRequest())! as HeartbeatRequest; @@ -246,15 +252,18 @@ export function unionToRpcMessage( case 'StartUserHeightCalibration': return accessor(new StartUserHeightCalibration())! as StartUserHeightCalibration; case 'CancelUserHeightCalibration': return accessor(new CancelUserHeightCalibration())! as CancelUserHeightCalibration; case 'UserHeightRecordingStatusResponse': return accessor(new UserHeightRecordingStatusResponse())! as UserHeightRecordingStatusResponse; + case 'UnknownHIDDeviceHandshakeNotification': return accessor(new UnknownHIDDeviceHandshakeNotification())! as UnknownHIDDeviceHandshakeNotification; + case 'HIDAllReceiversCommandRequest': return accessor(new HIDAllReceiversCommandRequest())! as HIDAllReceiversCommandRequest; + case 'HIDTrackerCommandRequest': return accessor(new HIDTrackerCommandRequest())! as HIDTrackerCommandRequest; default: return null; } } export function unionListToRpcMessage( type: RpcMessage, - accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null, + accessor: (index: number, obj:AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDAllReceiversCommandRequest|HIDTrackerCommandRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UnknownHIDDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse) => AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDAllReceiversCommandRequest|HIDTrackerCommandRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UnknownHIDDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null, index: number -): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { +): AddUnknownDeviceRequest|AssignTrackerRequest|AutoBoneApplyRequest|AutoBoneCancelRecordingRequest|AutoBoneEpochResponse|AutoBoneProcessRequest|AutoBoneProcessStatusResponse|AutoBoneStopRecordingRequest|CancelUserHeightCalibration|ChangeMagToggleRequest|ChangeSettingsRequest|ChangeSkeletonConfigRequest|ClearDriftCompensationRequest|ClearMountingResetRequest|CloseSerialRequest|DetectStayAlignedRelaxedPoseRequest|EnableStayAlignedRequest|FirmwareUpdateRequest|FirmwareUpdateStatusResponse|FirmwareUpdateStopQueuesRequest|ForgetDeviceRequest|HIDAllReceiversCommandRequest|HIDTrackerCommandRequest|HeartbeatRequest|HeartbeatResponse|HeightRequest|HeightResponse|IgnoreTrackingChecklistStepRequest|LegTweaksTmpChange|LegTweaksTmpClear|MagToggleRequest|MagToggleResponse|NewSerialDeviceResponse|OpenSerialRequest|OverlayDisplayModeChangeRequest|OverlayDisplayModeRequest|OverlayDisplayModeResponse|RecordBVHRequest|RecordBVHStatus|RecordBVHStatusRequest|ResetRequest|ResetResponse|ResetStayAlignedRelaxedPoseRequest|SaveFileNotification|SerialDevicesRequest|SerialDevicesResponse|SerialTrackerCustomCommandRequest|SerialTrackerFactoryResetRequest|SerialTrackerGetInfoRequest|SerialTrackerGetWifiScanRequest|SerialTrackerRebootRequest|SerialUpdateResponse|ServerInfosRequest|ServerInfosResponse|SetPauseTrackingRequest|SetWifiRequest|SettingsRequest|SettingsResetRequest|SettingsResponse|SkeletonConfigRequest|SkeletonConfigResponse|SkeletonResetAllRequest|StartUserHeightCalibration|StartWifiProvisioningRequest|StatusSystemFixed|StatusSystemRequest|StatusSystemResponse|StatusSystemUpdate|StopWifiProvisioningRequest|TapDetectionSetupNotification|TrackingChecklistRequest|TrackingChecklistResponse|TrackingPauseStateRequest|TrackingPauseStateResponse|UnknownDeviceHandshakeNotification|UnknownHIDDeviceHandshakeNotification|UserHeightRecordingStatusResponse|VRCConfigSettingToggleMute|VRCConfigStateChangeResponse|VRCConfigStateRequest|WifiProvisioningStatusResponse|null { switch(RpcMessage[type]) { case 'NONE': return null; case 'HeartbeatRequest': return accessor(index, new HeartbeatRequest())! as HeartbeatRequest; @@ -335,6 +344,9 @@ export function unionListToRpcMessage( case 'StartUserHeightCalibration': return accessor(index, new StartUserHeightCalibration())! as StartUserHeightCalibration; case 'CancelUserHeightCalibration': return accessor(index, new CancelUserHeightCalibration())! as CancelUserHeightCalibration; case 'UserHeightRecordingStatusResponse': return accessor(index, new UserHeightRecordingStatusResponse())! as UserHeightRecordingStatusResponse; + case 'UnknownHIDDeviceHandshakeNotification': return accessor(index, new UnknownHIDDeviceHandshakeNotification())! as UnknownHIDDeviceHandshakeNotification; + case 'HIDAllReceiversCommandRequest': return accessor(index, new HIDAllReceiversCommandRequest())! as HIDAllReceiversCommandRequest; + case 'HIDTrackerCommandRequest': return accessor(index, new HIDTrackerCommandRequest())! as HIDTrackerCommandRequest; default: return null; } } diff --git a/protocol/typescript/src/solarxr-protocol/rpc/unknown-hiddevice-handshake-notification.ts b/protocol/typescript/src/solarxr-protocol/rpc/unknown-hiddevice-handshake-notification.ts new file mode 100644 index 00000000..00e9dd5e --- /dev/null +++ b/protocol/typescript/src/solarxr-protocol/rpc/unknown-hiddevice-handshake-notification.ts @@ -0,0 +1,96 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + + + +/** + * Same as normal unknown device, but for HID tracker. + */ +export class UnknownHIDDeviceHandshakeNotification implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):UnknownHIDDeviceHandshakeNotification { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsUnknownHIDDeviceHandshakeNotification(bb:flatbuffers.ByteBuffer, obj?:UnknownHIDDeviceHandshakeNotification):UnknownHIDDeviceHandshakeNotification { + return (obj || new UnknownHIDDeviceHandshakeNotification()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsUnknownHIDDeviceHandshakeNotification(bb:flatbuffers.ByteBuffer, obj?:UnknownHIDDeviceHandshakeNotification):UnknownHIDDeviceHandshakeNotification { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new UnknownHIDDeviceHandshakeNotification()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +deviceAddress():string|null +deviceAddress(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +deviceAddress(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +receiverAddress():string|null +receiverAddress(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null +receiverAddress(optionalEncoding?:any):string|Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null; +} + +static startUnknownHIDDeviceHandshakeNotification(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addDeviceAddress(builder:flatbuffers.Builder, deviceAddressOffset:flatbuffers.Offset) { + builder.addFieldOffset(0, deviceAddressOffset, 0); +} + +static addReceiverAddress(builder:flatbuffers.Builder, receiverAddressOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, receiverAddressOffset, 0); +} + +static endUnknownHIDDeviceHandshakeNotification(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createUnknownHIDDeviceHandshakeNotification(builder:flatbuffers.Builder, deviceAddressOffset:flatbuffers.Offset, receiverAddressOffset:flatbuffers.Offset):flatbuffers.Offset { + UnknownHIDDeviceHandshakeNotification.startUnknownHIDDeviceHandshakeNotification(builder); + UnknownHIDDeviceHandshakeNotification.addDeviceAddress(builder, deviceAddressOffset); + UnknownHIDDeviceHandshakeNotification.addReceiverAddress(builder, receiverAddressOffset); + return UnknownHIDDeviceHandshakeNotification.endUnknownHIDDeviceHandshakeNotification(builder); +} + +unpack(): UnknownHIDDeviceHandshakeNotificationT { + return new UnknownHIDDeviceHandshakeNotificationT( + this.deviceAddress(), + this.receiverAddress() + ); +} + + +unpackTo(_o: UnknownHIDDeviceHandshakeNotificationT): void { + _o.deviceAddress = this.deviceAddress(); + _o.receiverAddress = this.receiverAddress(); +} +} + +export class UnknownHIDDeviceHandshakeNotificationT implements flatbuffers.IGeneratedObject { +constructor( + public deviceAddress: string|Uint8Array|null = null, + public receiverAddress: string|Uint8Array|null = null +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const deviceAddress = (this.deviceAddress !== null ? builder.createString(this.deviceAddress!) : 0); + const receiverAddress = (this.receiverAddress !== null ? builder.createString(this.receiverAddress!) : 0); + + return UnknownHIDDeviceHandshakeNotification.createUnknownHIDDeviceHandshakeNotification(builder, + deviceAddress, + receiverAddress + ); +} +} diff --git a/schema/rpc.fbs b/schema/rpc.fbs index c54f1504..1bfdcabd 100644 --- a/schema/rpc.fbs +++ b/schema/rpc.fbs @@ -95,7 +95,10 @@ union RpcMessage { IgnoreTrackingChecklistStepRequest, StartUserHeightCalibration, CancelUserHeightCalibration, - UserHeightRecordingStatusResponse + UserHeightRecordingStatusResponse, + UnknownHIDDeviceHandshakeNotification, + HIDAllReceiversCommandRequest, + HIDTrackerCommandRequest } table RpcMessageHeader { @@ -1070,3 +1073,22 @@ table UserHeightRecordingStatusResponse { hmdHeight: float; status: UserHeightCalibrationStatus; } + +/// Same as normal unknown device, but for HID tracker. +table UnknownHIDDeviceHandshakeNotification { + device_address: string; + receiver_address: string; +} + +// Also handle responding to handshake notification +// No reciver disambiguation, command will be sent to all connected receivers (this can include plugged in trackers with HID enabled!) +// TODO: is it ever needed to send a command to specific receivers? This request may need to be given "receiver_id" +table HIDAllReceiversCommandRequest { + command: string; +} + +// Send to specific HID tracker, or all if no HWID +table HIDTrackerCommandRequest { + device_address: string; + command: string; +}