diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 79e68f52a..a39531879 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -13,6 +13,7 @@ jobs: runs-on: ubuntu-latest outputs: matrix: ${{ steps.set-matrix.outputs.matrix }} + matrix-cpp: ${{ steps.set-matrix.outputs.matrix-cpp }} steps: - id: set-matrix shell: bash @@ -25,7 +26,44 @@ jobs: else RESULT=$(echo "$BASE" | jq -c '.') fi + RESULT_CPP=$(echo "$RESULT" | jq -c '[ .[] | select ( (.platform != "macos") and ( (.platform != "windows") or (.os | endswith("-arm") | not) ) ) ]') + echo "matrix={\"include\":$RESULT}" >> "$GITHUB_OUTPUT" + echo "matrix-cpp={\"include\":$RESULT_CPP}" >> "$GITHUB_OUTPUT" + + build-bindings-provider: + name: Build bindings provider for ${{ matrix.os }} + needs: [setup-matrix] + strategy: + fail-fast: false + matrix: ${{ fromJson(needs.setup-matrix.outputs.matrix-cpp) }} + runs-on: ${{ matrix.os }} + steps: + - name: Checkout + uses: actions/checkout@v6 + with: + submodules: recursive + - if: matrix.platform == 'linux' + name: Install GCC + uses: egor-tensin/setup-gcc@v2 + with: + version: 16 + - name: Get CMake + uses: lukka/get-cmake@latest + - name: Configure + run: cmake -S bindings-provider/ -B bindings-provider/build -DCMAKE_BUILD_TYPE=Release + - name: Build + run: cmake --build bindings-provider/build --config Release -j6 + - name: Upload artifact + uses: actions/upload-artifact@v7 + with: + name: bindings-provider-${{ matrix.platform }}-${{ matrix.os }} + path: | + bindings-provider/build/slimevr-bindings-provider + bindings-provider/build/libopenvr_api.so + bindings-provider/build/Release/SlimeVR-Bindings-Provider.exe + bindings-provider/build/openvr_api.dll + gui-checks: name: Gui Checks runs-on: ubuntu-latest @@ -125,7 +163,7 @@ jobs: package-desktop: name: Package Desktop (${{ matrix.platform }} - ${{ matrix.os }}) - needs: [setup-matrix, build-server-jar, build-gui-frontend] + needs: [setup-matrix, build-server-jar, build-gui-frontend, build-bindings-provider] strategy: fail-fast: false matrix: ${{ fromJson(needs.setup-matrix.outputs.matrix) }} @@ -149,6 +187,12 @@ jobs: with: name: server-jar path: server + - if: contains(fromJson(needs.setup-matrix.outputs.matrix-cpp).include.*.os, matrix.os) + name: Download bindings provider artifact + uses: actions/download-artifact@v8 + with: + name: bindings-provider-${{ matrix.platform }}-${{ matrix.os }} + path: bindings-provider/build/${{ matrix.platform == 'windows' && 'win' || 'linux' }}-${{ endsWith(matrix.os, '-arm') && 'arm64' || 'x64' }} - name: Download GUI Dist uses: actions/download-artifact@v8 with: diff --git a/.gitmodules b/.gitmodules index 286659e33..8364078ff 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,6 @@ [submodule "solarxr-protocol"] path = solarxr-protocol url = https://github.com/SlimeVR/SolarXR-Protocol.git +[submodule "svr-bindings-provider/openvr"] + path = bindings-provider/openvr + url = https://github.com/ValveSoftware/openvr.git diff --git a/bindings-provider/.gitignore b/bindings-provider/.gitignore new file mode 100644 index 000000000..5a0d18c3e --- /dev/null +++ b/bindings-provider/.gitignore @@ -0,0 +1,12 @@ +# Garbage left behind on Windows + +.vs/ +out/ +CMakeFiles/ +vcpkg_installed/ +src/resources/resources.hpp +CMakeCache.txt +build.ninja +*.cmake +*.dll +*.log diff --git a/bindings-provider/CMakeLists.txt b/bindings-provider/CMakeLists.txt new file mode 100644 index 000000000..76c8818b5 --- /dev/null +++ b/bindings-provider/CMakeLists.txt @@ -0,0 +1,78 @@ +cmake_minimum_required(VERSION 3.26) + +project(SlimeVR-Bindings-Provider) + +set(SOLARXR_PROTOCOL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../solarxr-protocol") +set(FLATBUFFERS_GENERATED_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../solarxr-protocol/protocol/cpp") + +# These are used to determine the OpenVR library path +if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(PROCESSOR_ARCH "64") +else() + set(PROCESSOR_ARCH "32") +endif() +if(WIN32) + set(OPENVR_LIBRARY_NAME "openvr_api") + set(OPENVR_LIBRARY_EXT "dll") + set(PLATFORM_NAME "win") +elseif(APPLE) + set(OPENVR_LIBRARY_NAME "libopenvr_api") + set(OPENVR_LIBRARY_EXT "dylib") + set(PLATFORM_NAME "osx") +elseif(LINUX) + set(OPENVR_LIBRARY_NAME "libopenvr_api") + set(OPENVR_LIBRARY_EXT "so") + if (CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64") + set(PLATFORM_NAME "linuxarm") + elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") + set(PLATFORM_NAME "linux") + else() + message(FATAL_ERROR "Unknown/unsupported CPU architecture") + endif() +else() + message(FATAL_ERROR "Unknown/unsupported platform") +endif() + +set(OPENVR_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/openvr") + +message(STATUS "OpenVR library search path: ${OPENVR_ROOT}/lib/${PLATFORM_NAME}${PROCESSOR_ARCH}") +find_library(OPENVR_LIBRARY NAMES openvr_api REQUIRED PATHS "${OPENVR_ROOT}/lib/${PLATFORM_NAME}${PROCESSOR_ARCH}/" NO_DEFAULT_PATH) +message(STATUS "Found OpenVR library at: ${OPENVR_LIBRARY}") + +add_executable("${PROJECT_NAME}" + "${CMAKE_CURRENT_SOURCE_DIR}/src/paths.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/logger.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/solarxr.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/vr_utils.cpp" + "${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp" +) +set_target_properties("${PROJECT_NAME}" PROPERTIES CXX_STANDARD 23) +target_include_directories("${PROJECT_NAME}" PRIVATE "${SOLARXR_PROTOCOL_ROOT}/lib/flatbuffers/include" "${SOLARXR_PROTOCOL_ROOT}/lib/flatbuffers/" "${FLATBUFFERS_GENERATED_ROOT}/include" "${CMAKE_CURRENT_SOURCE_DIR}/include" "${OPENVR_ROOT}/headers") +target_link_libraries("${PROJECT_NAME}" PRIVATE "${OPENVR_LIBRARY}") + +if(LINUX) + set_target_properties("${PROJECT_NAME}" PROPERTIES OUTPUT_NAME slimevr-bindings-provider) +endif() + +set(OPENVR_RUNTIME_LIBRARY "${OPENVR_ROOT}/bin/${PLATFORM_NAME}${PROCESSOR_ARCH}/${OPENVR_LIBRARY_NAME}.${OPENVR_LIBRARY_EXT}") +message(STATUS "Found OpenVR runtime library: ${OPENVR_RUNTIME_LIBRARY}") +configure_file("${OPENVR_RUNTIME_LIBRARY}" "${CMAKE_CURRENT_BINARY_DIR}/." COPYONLY) + +# Embed the resources into resources.hpp +set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS + src/resources/manifest.vrmanifest + src/resources/action_manifest.json + src/resources/generic.json + src/resources/knuckles.json + src/resources/oculus_touch.json + src/resources/vive_controller.json +) +file(STRINGS src/resources/manifest.vrmanifest SVR_VRAPP_MANIFEST NEWLINE_CONSUME) +file(STRINGS src/resources/action_manifest.json SVR_VRAPP_ACTION_MANIFEST NEWLINE_CONSUME) +file(STRINGS src/resources/generic.json SVR_VRAPP_GENERIC_BINDS NEWLINE_CONSUME) +file(STRINGS src/resources/knuckles.json SVR_VRAPP_KNUCKLES_BINDS NEWLINE_CONSUME) +file(STRINGS src/resources/oculus_touch.json SVR_VRAPP_OCULUS_BINDS NEWLINE_CONSUME) +file(STRINGS src/resources/vive_controller.json SVR_VRAPP_VIVE_BINDS NEWLINE_CONSUME) + +configure_file(src/resources/resources.hpp.in src/resources/resources.hpp @ONLY) +target_include_directories("${PROJECT_NAME}" PRIVATE "${CMAKE_CURRENT_BINARY_DIR}/src") diff --git a/bindings-provider/openvr b/bindings-provider/openvr new file mode 160000 index 000000000..918253051 --- /dev/null +++ b/bindings-provider/openvr @@ -0,0 +1 @@ +Subproject commit 91825305130f446f82054c1ec3d416321ace0072 diff --git a/bindings-provider/src/logger.cpp b/bindings-provider/src/logger.cpp new file mode 100644 index 000000000..703ad4e2a --- /dev/null +++ b/bindings-provider/src/logger.cpp @@ -0,0 +1,22 @@ +#include "logger.hpp" +#include "paths.hpp" + +#ifdef _WIN32 +#define WIN32_MEAN_AND_LEAN +#include +#endif + +Logger::Logger() + : log_stream(Paths::getLogPath() / "slimevr-bindings-provider.log", + std::ios::out | std::ios::app) +#ifdef _WIN32 + , + should_log_to_std_streams(GetConsoleWindow() != nullptr) +#endif +{ +} + +Logger &Logger::get() { + static Logger logger; + return logger; +} diff --git a/bindings-provider/src/logger.hpp b/bindings-provider/src/logger.hpp new file mode 100644 index 000000000..4f0abe3af --- /dev/null +++ b/bindings-provider/src/logger.hpp @@ -0,0 +1,77 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +class Logger { +private: + std::ofstream log_stream; +#ifdef _WIN32 + bool should_log_to_std_streams; +#endif + + template + void log(std::string_view suffix, std::format_string fmt, + Args &&...args) { + auto now = std::chrono::system_clock::now(); + auto time_t = std::chrono::system_clock::to_time_t(now); + + auto s = std::format(fmt, std::forward(args)...); +#ifdef _WIN32 + if (should_log_to_std_streams) { +#endif + if constexpr (important) + std::cerr << suffix << ' ' << s << '\n'; + else + std::cout << suffix << ' ' << s << '\n'; +#ifdef _WIN32 + } +#endif + + log_stream << std::put_time(std::localtime(&time_t), "[%F %T]") // + << ' ' << suffix << ' ' << s << '\n'; + } + +public: + Logger(); + + template + void debug(std::format_string fmt, Args &&...args) { +#ifndef NDEBUG + log("[DEBUG]", fmt, std::forward(args)...); +#endif + } + + template + void info(std::format_string fmt, Args &&...args) { + log("[INFO]", fmt, std::forward(args)...); + } + + template + void warning(std::format_string fmt, Args &&...args) { + log("[WARN]", fmt, std::forward(args)...); + } + + template + void error(std::format_string fmt, Args &&...args) { + log("[ERROR]", fmt, std::forward(args)...); + } + + void flush() { +#ifdef _WIN32 + if (should_log_to_std_streams) { +#endif + std::cerr.flush(); + std::cout.flush(); +#ifdef _WIN32 + } +#endif + log_stream.flush(); + } + + static Logger &get(); +}; diff --git a/bindings-provider/src/main.cpp b/bindings-provider/src/main.cpp new file mode 100644 index 000000000..f6d8cf92a --- /dev/null +++ b/bindings-provider/src/main.cpp @@ -0,0 +1,274 @@ +#include +#include +#include +#include +#include +#include + +// These must be included before Windows.h because of some macro collisions. +#include "flatbuffers/flatbuffers.h" +#include "solarxr_protocol/generated/all_generated.h" + +#include "logger.hpp" +#include "solarxr.hpp" +#include "vr_utils.hpp" + +#include "openvr.h" + +using namespace std::chrono_literals; +using namespace solarxr_protocol; + +static void shutdown_vr(vr::IVRSystem *_sys) { vr::VR_Shutdown(); } + +static void onYawReset(SolarXRConnection &conn) { + flatbuffers::FlatBufferBuilder fbb; + + auto resetReq = rpc::CreateResetRequest(fbb, rpc::ResetType::Yaw, 0, 0.f); + auto msgHeader = rpc::CreateRpcMessageHeader( + fbb, nullptr, rpc::RpcMessage::ResetRequest, resetReq.Union()); + + auto rpcMsgs = fbb.CreateVector({msgHeader}); + auto bundle = CreateMessageBundle(fbb, 0, rpcMsgs, 0); + fbb.Finish(bundle); + conn.sendMsg(fbb); +} +static void onFullReset(SolarXRConnection &conn) { + flatbuffers::FlatBufferBuilder fbb; + + auto resetReq = rpc::CreateResetRequest(fbb, rpc::ResetType::Full, 0, 0.f); + auto msgHeader = rpc::CreateRpcMessageHeader( + fbb, nullptr, rpc::RpcMessage::ResetRequest, resetReq.Union()); + + auto rpcMsgs = fbb.CreateVector({msgHeader}); + auto bundle = CreateMessageBundle(fbb, 0, rpcMsgs, 0); + fbb.Finish(bundle); + conn.sendMsg(fbb); +} +static void onMountingCalibration(SolarXRConnection &conn) { + flatbuffers::FlatBufferBuilder fbb; + + auto resetReq = + rpc::CreateResetRequest(fbb, rpc::ResetType::Mounting, 0, 0.f); + auto msgHeader = rpc::CreateRpcMessageHeader( + fbb, nullptr, rpc::RpcMessage::ResetRequest, resetReq.Union()); + + auto rpcMsgs = fbb.CreateVector({msgHeader}); + auto bundle = CreateMessageBundle(fbb, 0, rpcMsgs, 0); + fbb.Finish(bundle); + conn.sendMsg(fbb); +} +static void onFeetMountingCalibration(SolarXRConnection &conn) { + flatbuffers::FlatBufferBuilder fbb; + + auto bodyParts = fbb.CreateVector( + {datatypes::BodyPart::LEFT_FOOT, datatypes::BodyPart::RIGHT_FOOT}); + auto resetReq = + rpc::CreateResetRequest(fbb, rpc::ResetType::Mounting, bodyParts, 0.f); + auto msgHeader = rpc::CreateRpcMessageHeader( + fbb, nullptr, rpc::RpcMessage::ResetRequest, resetReq.Union()); + + auto rpcMsgs = fbb.CreateVector({msgHeader}); + auto bundle = CreateMessageBundle(fbb, 0, rpcMsgs, 0); + fbb.Finish(bundle); + conn.sendMsg(fbb); +} +static void onToggleTracking(SolarXRConnection &conn) { + static bool shouldPause = false; + flatbuffers::FlatBufferBuilder fbb; + + shouldPause = !shouldPause; + auto toggleReq = rpc::CreateSetPauseTrackingRequest(fbb, shouldPause); + auto msgHeader = rpc::CreateRpcMessageHeader( + fbb, nullptr, rpc::RpcMessage::SetPauseTrackingRequest, + toggleReq.Union()); + + auto rpcMsgs = fbb.CreateVector({msgHeader}); + auto bundle = CreateMessageBundle(fbb, 0, rpcMsgs, 0); + fbb.Finish(bundle); + conn.sendMsg(fbb); +} + +sig_atomic_t should_exit = 0; + +static void signal_handler(int signal) { + Logger::get().info("Received signal {}", signal); + should_exit = 1; +} + +int main() { + auto &logger = Logger::get(); + + try { + SolarXRConnection conn; + std::unique_ptr sys{nullptr, + shutdown_vr}; + + // On vrlink, VR_Init returns + // VRInitError_Driver_WirelessHmdNotConnected while the connection + // is initialising, so keep calling VR_Init until it ends up + // succeeding + + vr::EVRInitError err{vr::VRInitError_Driver_WirelessHmdNotConnected}; + while (err == vr::VRInitError_Driver_WirelessHmdNotConnected) { + sys.reset(vr::VR_Init(&err, vr::VRApplication_Background)); + if (err == vr::VRInitError_Driver_WirelessHmdNotConnected) + std::this_thread::sleep_for(500ms); + } + + if (sys == nullptr or err != vr::VRInitError_None) { + logger.error("Failed to init OpenVR: {} ({})", + vr::VR_GetVRInitErrorAsSymbol(err), + vr::VR_GetVRInitErrorAsEnglishDescription(err)); + return 1; + } + + logger.info("Initialised OpenVR, HMD model '{}'", + VRUtils::getStringProp(vr::k_unTrackedDeviceIndex_Hmd, + vr::Prop_ModelNumber_String) + .value_or("")); + + vr::IVRApplications *app = vr::VRApplications(); + vr::IVRInput *input = vr::VRInput(); + + auto [appManifestPath, actionManifestPath] = VRUtils::initialiseManifest(); + + if (auto err = + app->AddApplicationManifest(appManifestPath.string().data(), true); + err != vr::VRApplicationError_None) { + logger.error("Failed to add application manifest: {}", + app->GetApplicationsErrorNameFromEnum(err)); + return 1; + } + + if (auto err = + input->SetActionManifestPath(actionManifestPath.string().data()); + err != vr::VRInputError_None) { + logger.error("Failed to set action manifest path: {}", + std::to_underlying(err)); + return 1; + } + + vr::VRActionSetHandle_t action_set; + if (auto err = input->GetActionSetHandle("/actions/main", &action_set); + err != vr::VRInputError_None) { + logger.error("Failed to get main action set handle: {}", + std::to_underlying(err)); + return 1; + } + + std::map>> + actions{ + {"/actions/main/in/YawReset", + std::make_tuple(vr::k_ulInvalidActionHandle, onYawReset)}, + {"/actions/main/in/FullReset", + std::make_tuple(vr::k_ulInvalidActionHandle, onFullReset)}, + {"/actions/main/in/MountingCalibration", + std::make_tuple(vr::k_ulInvalidActionHandle, + onMountingCalibration)}, + {"/actions/main/in/FeetMountingCalibration", + std::make_tuple(vr::k_ulInvalidActionHandle, + onFeetMountingCalibration)}, + {"/actions/main/in/ToggleTracking", + std::make_tuple(vr::k_ulInvalidActionHandle, onToggleTracking)}, + }; + + for (auto &[name, tuple] : actions) { + auto &[handle, _] = tuple; + if (auto err = input->GetActionHandle(name.c_str(), &handle); + err != vr::VRInputError_None || + handle == vr::k_ulInvalidActionHandle) { + logger.warning("Failed to get action handle for action {}: {}", name, + std::to_underlying(err)); + } + } + + constexpr auto interval = 1000ms / 30; + + signal(SIGINT, signal_handler); + signal(SIGTERM, signal_handler); + while (!should_exit) { + vr::VREvent_t event{}; + while (sys->PollNextEvent(&event, sizeof(event))) { + switch (event.eventType) { + case vr::VREvent_Quit: + logger.info("OpenVR runtime requested quit"); + should_exit = 1; + break; + case vr::VREvent_Input_BindingLoadFailed: { + auto &loadData = event.data.inputBinding; + logger.debug("Binding load failed (ulAppContainer={} " + "pathMessage={} pathUrl={} pathControllerType={})", + loadData.ulAppContainer, loadData.pathMessage, + loadData.pathUrl, loadData.pathControllerType); + break; + } + case vr::VREvent_Input_BindingLoadSuccessful: { + auto &loadData = event.data.inputBinding; + logger.debug("Binding load successful (ulAppContainer={} " + "pathMessage={} pathUrl={} pathControllerType={})", + loadData.ulAppContainer, loadData.pathMessage, + loadData.pathUrl, loadData.pathControllerType); + break; + } + case vr::VREvent_Input_ActionManifestReloaded: + logger.debug("Action manifest reloaded"); + break; + case vr::VREvent_Input_ActionManifestLoadFailed: { + auto &manifestData = event.data.actionManifest; + logger.debug( + "Action manifest load failed (pathAppKey={} pathMessage={} " + "pathMessageParam={} pathManifestPath={})", + manifestData.pathAppKey, manifestData.pathMessage, + manifestData.pathMessageParam, manifestData.pathManifestPath); + break; + } + default: + break; + } + } + + vr::VRActiveActionSet_t set{ + .ulActionSet = action_set, + .ulRestrictedToDevice = vr::k_ulInvalidInputValueHandle, + .ulSecondaryActionSet = vr::k_ulInvalidActionSetHandle, + .nPriority = 0, + }; + if (auto err = input->UpdateActionState(&set, sizeof(set), 1); + err != vr::VRInputError_None) { + logger.warning("Error when updating action states: {}", + std::to_underlying(err)); + } + + for (auto &[name, tuple] : actions) { + auto &[handle, callback] = tuple; + vr::InputDigitalActionData_t action_data{}; + if (auto err = input->GetDigitalActionData( + handle, &action_data, sizeof(action_data), + vr::k_ulInvalidInputValueHandle); + err != vr::VRInputError_None) { + logger.warning("Failed to get action state for {} ({}): {}", name, + handle, std::to_underlying(err)); + continue; + } + + if (action_data.bActive && action_data.bChanged && action_data.bState) { + logger.debug("Action {} triggered", name); + callback(conn); + } + } + + logger.flush(); + std::this_thread::sleep_for(interval); + } + + logger.info("Main loop done"); + } catch (std::exception &ex) { + logger.error("Exception in main: {}", ex.what()); + logger.flush(); + return 1; + } + + logger.flush(); + return 0; +} diff --git a/bindings-provider/src/paths.cpp b/bindings-provider/src/paths.cpp new file mode 100644 index 000000000..8d24426c3 --- /dev/null +++ b/bindings-provider/src/paths.cpp @@ -0,0 +1,33 @@ +#include "paths.hpp" + +namespace fs = std::filesystem; + +fs::path Paths::getDataPath() { + fs::path basePath{}; + +#if defined(__linux__) + if (const char *dataHomeOverride = getenv("XDG_DATA_HOME")) { + basePath = dataHomeOverride; + } else { + const char *homeDir = getenv("HOME"); + if (homeDir == nullptr) + throw std::runtime_error("HOME is unset"); + + basePath = fs::path(homeDir) / ".local" / "share"; + } +#elif defined(_WIN32) + { + const char *appData = getenv("APPDATA"); + if (appData == nullptr) + throw std::runtime_error("APPDATA is unset"); + + basePath = appData; + } +#else +#error "Unsupported platform" +#endif + + return basePath / "dev.slimevr.SlimeVR"; +} + +fs::path Paths::getLogPath() { return Paths::getDataPath() / "logs"; } diff --git a/bindings-provider/src/paths.hpp b/bindings-provider/src/paths.hpp new file mode 100644 index 000000000..6ca2cf5ac --- /dev/null +++ b/bindings-provider/src/paths.hpp @@ -0,0 +1,11 @@ +#pragma once + +#include + +namespace Paths { +// Throws when path cannot be found +std::filesystem::path getDataPath() noexcept(false); + +// Throws when path cannot be found +std::filesystem::path getLogPath() noexcept(false); +} // namespace Paths diff --git a/bindings-provider/src/resources/action_manifest.json b/bindings-provider/src/resources/action_manifest.json new file mode 100644 index 000000000..1fec4f4f4 --- /dev/null +++ b/bindings-provider/src/resources/action_manifest.json @@ -0,0 +1,64 @@ +{ + "default_bindings": [ + { + "controller_type": "generic", + "binding_url": "generic.json" + }, + { + "controller_type": "oculus_touch", + "binding_url": "oculus_touch.json" + }, + { + "controller_type": "knuckles", + "binding_url": "knuckles.json" + }, + { + "controller_type": "vive_controller", + "binding_url": "vive_controller.json" + } + ], + "actions": [ + { + "name": "/actions/main/in/YawReset", + "requirement": "optional", + "type": "boolean" + }, + { + "name": "/actions/main/in/FullReset", + "requirement": "optional", + "type": "boolean" + }, + { + "name": "/actions/main/in/MountingCalibration", + "requirement": "optional", + "type": "boolean" + }, + { + "name": "/actions/main/in/FeetMountingCalibration", + "requirement": "optional", + "type": "boolean" + }, + { + "name": "/actions/main/in/ToggleTracking", + "requirement": "optional", + "type": "boolean" + } + ], + "action_sets": [ + { + "name": "/actions/main", + "usage": "leftright" + } + ], + "localization": [ + { + "language_tag": "en_us", + "/actions/main": "Utility Bindings", + "/actions/main/in/YawReset": "Yaw Reset", + "/actions/main/in/FullReset": "Full Reset", + "/actions/main/in/MountingCalibration": "Mounting Calibration", + "/actions/main/in/FeetMountingCalibration": "Feet Mounting Calibration", + "/actions/main/in/ToggleTracking": "Toggle Tracking" + } + ] +} diff --git a/bindings-provider/src/resources/generic.json b/bindings-provider/src/resources/generic.json new file mode 100644 index 000000000..5b50aac96 --- /dev/null +++ b/bindings-provider/src/resources/generic.json @@ -0,0 +1,12 @@ +{ + "name": "Default Bindings for Generic", + "controller_type": "generic", + "bindings": { + "/actions/main": { + "sources": [], + "skeleton": [], + "haptics": [], + "poses": [] + } + } +} diff --git a/bindings-provider/src/resources/knuckles.json b/bindings-provider/src/resources/knuckles.json new file mode 100644 index 000000000..74e7a96a2 --- /dev/null +++ b/bindings-provider/src/resources/knuckles.json @@ -0,0 +1,12 @@ +{ + "name": "Default Bindings for Knuckles", + "controller_type": "knuckles", + "bindings": { + "/actions/main": { + "sources": [], + "skeleton": [], + "haptics": [], + "poses": [] + } + } +} \ No newline at end of file diff --git a/bindings-provider/src/resources/manifest.vrmanifest b/bindings-provider/src/resources/manifest.vrmanifest new file mode 100644 index 000000000..e701796a1 --- /dev/null +++ b/bindings-provider/src/resources/manifest.vrmanifest @@ -0,0 +1,14 @@ +{ + "source": "builtin", + "applications": [{ + "app_key": "dev.slimevr.BindingsProvider", + "is_dashboard_overlay": false, + "action_manifest_path": "action_manifest.json", + "strings": { + "en_us": { + "name": "SlimeVR Bindings Provider", + "description": "SlimeVR Bindings Provider" + } + } + }] +} diff --git a/bindings-provider/src/resources/oculus_touch.json b/bindings-provider/src/resources/oculus_touch.json new file mode 100644 index 000000000..ae0902e40 --- /dev/null +++ b/bindings-provider/src/resources/oculus_touch.json @@ -0,0 +1,12 @@ +{ + "name": "Default Bindings for Oculus Touch", + "controller_type": "oculus_touch", + "bindings": { + "/actions/main": { + "sources": [], + "skeleton": [], + "haptics": [], + "poses": [] + } + } +} \ No newline at end of file diff --git a/bindings-provider/src/resources/resources.hpp.in b/bindings-provider/src/resources/resources.hpp.in new file mode 100644 index 000000000..f08f2edad --- /dev/null +++ b/bindings-provider/src/resources/resources.hpp.in @@ -0,0 +1,8 @@ +#pragma once + +#cmakedefine SVR_VRAPP_MANIFEST R"(@SVR_VRAPP_MANIFEST@)" +#cmakedefine SVR_VRAPP_ACTION_MANIFEST R"(@SVR_VRAPP_ACTION_MANIFEST@)" +#cmakedefine SVR_VRAPP_GENERIC_BINDS R"(@SVR_VRAPP_GENERIC_BINDS@)" +#cmakedefine SVR_VRAPP_KNUCKLES_BINDS R"(@SVR_VRAPP_KNUCKLES_BINDS@)" +#cmakedefine SVR_VRAPP_OCULUS_BINDS R"(@SVR_VRAPP_OCULUS_BINDS@)" +#cmakedefine SVR_VRAPP_VIVE_BINDS R"(@SVR_VRAPP_VIVE_BINDS@)" diff --git a/bindings-provider/src/resources/vive_controller.json b/bindings-provider/src/resources/vive_controller.json new file mode 100644 index 000000000..cedc703e7 --- /dev/null +++ b/bindings-provider/src/resources/vive_controller.json @@ -0,0 +1,12 @@ +{ + "name": "Default Bindings for Vive Wands", + "controller_type": "vive_controller", + "bindings": { + "/actions/main": { + "sources": [], + "skeleton": [], + "haptics": [], + "poses": [] + } + } +} diff --git a/bindings-provider/src/solarxr.cpp b/bindings-provider/src/solarxr.cpp new file mode 100644 index 000000000..0cda24dc1 --- /dev/null +++ b/bindings-provider/src/solarxr.cpp @@ -0,0 +1,140 @@ +#include "solarxr.hpp" +#include "logger.hpp" + +#include + +#if defined(__linux__) +#include +#include +#elif defined(_WIN32) +#include +#else +#error "Unsupported platform" +#endif + +namespace fs = std::filesystem; + +fs::path SolarXRConnection::getSocketPath() { + using namespace std::string_view_literals; +#if defined(__linux__) +#define MAKE_SOCKET_PATH(PATH) \ + std::make_pair(PATH##sv, static_cast(getenv(PATH))) + + constexpr std::string_view socketName = "SlimeVRRpc"; + std::array, 4> socketPaths{ + MAKE_SOCKET_PATH("SLIMEVR_SOCKET_DIR"), + MAKE_SOCKET_PATH("XDG_RUNTIME_DIR"), + MAKE_SOCKET_PATH("TMPDIR"), + {"/tmp", "/tmp"}}; + +#undef MAKE_SOCKET_PATH + + for (auto [name, path] : socketPaths) { + if (path == nullptr) { + Logger::get().info( + "Skipping socket directory {} because it doesn't exist", name); + continue; + } + fs::path socketPath = fs::path(path) / socketName; + if (fs::exists(socketPath)) + return socketPath; + + Logger::get().info( + "Skipping socket directory {} because socket does not exist", name); + } +#elif defined(_WIN32) + throw std::logic_error( + "SolarXRConnection::getSocketPath should not be called on Windows"); +#else +#error "Unsupported platform" +#endif + + throw std::runtime_error("Failed to find socket directory"); +} + +SolarXRConnection::SolarXRConnection() { +#if defined(__linux__) + sockaddr_un addr{}; + addr.sun_family = AF_UNIX; + strcpy(addr.sun_path, getSocketPath().string().data()); + + fd = socket(AF_UNIX, SOCK_STREAM, 0); + if (fd == -1) { + throw std::runtime_error( + std::format("Failed to create listen socket: {}", strerror(errno))); + } + + if (connect(fd, reinterpret_cast(&addr), sizeof(addr)) == -1) { + int e = errno; + close(fd); + throw std::runtime_error(std::format("Failed to connect to socket {}: {}", + addr.sun_path, strerror(e))); + } + +#elif defined(_WIN32) + const char *pipeName = R"(\\.\pipe\SlimeVRRpc)"; + if (!WaitNamedPipe(pipeName, 5000)) { + throw std::runtime_error("Timed out waiting for pipe"); + } + + pipe = CreateFile(pipeName, GENERIC_READ | GENERIC_WRITE, 0, nullptr, + OPEN_EXISTING, 0, nullptr); + if (pipe == INVALID_HANDLE_VALUE) { + throw std::runtime_error( + std::format("Unable to open pipe (error={})", GetLastError())); + } +#else +#error "Unsupported platform" +#endif +} + +SolarXRConnection::~SolarXRConnection() { +#if defined(__linux__) + if (fd != -1) + close(fd); +#elif defined(_WIN32) + if (pipe != INVALID_HANDLE_VALUE) + CloseHandle(pipe); +#else +#error "Unsupported platform" +#endif +} + +void SolarXRConnection::sendMsg(flatbuffers::FlatBufferBuilder &fbb) { + // The server expects the total size of the buffer to be written at the + // start of the packet, including the first 4 bytes for the size + int size = fbb.GetSize() + 4; + // This may be wrong on mixed-endianness, but oh well... + if constexpr (std::endian::native != std::endian::little) + size = std::byteswap(size); + +#if defined(__linux__) + if (write(fd, &size, sizeof(size)) == -1) { + Logger::get().warning("Failed to write message size to socket: {}", + strerror(errno)); + return; + } + + if (write(fd, fbb.GetBufferPointer(), fbb.GetSize()) == -1) { + Logger::get().warning("Failed to write message to socket: {}", + strerror(errno)); + return; + } +#elif defined(_WIN32) + uint8_t tempBuf[2048]; + if (fbb.GetSize() > 2048 - 4) { + Logger::get().warning("Message is too big for temporary buffer"); + return; + } + + *reinterpret_cast(&tempBuf[0]) = size; + memcpy(&tempBuf[4], fbb.GetBufferPointer(), fbb.GetSize()); + if (!WriteFile(pipe, tempBuf, fbb.GetSize() + 4, nullptr, nullptr)) { + Logger::get().warning("Failed to write message to pipe (error={})", + GetLastError()); + return; + } +#else +#error "Unsupported platform" +#endif +} diff --git a/bindings-provider/src/solarxr.hpp b/bindings-provider/src/solarxr.hpp new file mode 100644 index 000000000..1384c4027 --- /dev/null +++ b/bindings-provider/src/solarxr.hpp @@ -0,0 +1,30 @@ +#pragma once + +#include + +#if defined(_WIN32) +#define WIN32_MEAN_AND_LEAN +#include +#endif + +#include "flatbuffers/flatbuffer_builder.h" + +class SolarXRConnection { +private: +#if defined(__linux__) + int fd{-1}; +#elif defined(_WIN32) + HANDLE pipe{INVALID_HANDLE_VALUE}; +#else +#error "Unsupported platform" +#endif + + static std::filesystem::path getSocketPath(); + +public: + SolarXRConnection() noexcept(false); + + ~SolarXRConnection(); + + void sendMsg(flatbuffers::FlatBufferBuilder &fbb); +}; diff --git a/bindings-provider/src/vr_utils.cpp b/bindings-provider/src/vr_utils.cpp new file mode 100644 index 000000000..189552d2d --- /dev/null +++ b/bindings-provider/src/vr_utils.cpp @@ -0,0 +1,73 @@ +#include "vr_utils.hpp" +#include "logger.hpp" +#include "paths.hpp" +#include "resources/resources.hpp" + +#include +#include +#include +#include + +namespace fs = std::filesystem; + +std::optional +VRUtils::getStringProp(vr::TrackedDeviceIndex_t deviceIndex, + vr::ETrackedDeviceProperty prop) { + vr::IVRSystem *sys = vr::VRSystem(); + vr::ETrackedPropertyError err{vr::TrackedProp_Success}; + + uint32_t required_len = + sys->GetStringTrackedDeviceProperty(deviceIndex, prop, nullptr, 0, &err); + if (err != vr::TrackedProp_BufferTooSmall) { + Logger::get().info( + "Failed to get size of string property {} for device {}: {}", + std::to_underlying(prop), deviceIndex, + sys->GetPropErrorNameFromEnum(err)); + return std::nullopt; + } + + std::string s(required_len - 1, '\0'); + sys->GetStringTrackedDeviceProperty(deviceIndex, prop, s.data(), required_len, + &err); + if (err != vr::TrackedProp_Success) { + Logger::get().info("Failed to get string property {} for device {}: {}", + std::to_underlying(prop), deviceIndex, + sys->GetPropErrorNameFromEnum(err)); + return std::nullopt; + } + + return s; +} + +std::tuple VRUtils::initialiseManifest() { + fs::path manifestDir = Paths::getDataPath() / "bindings-provider"; + std::error_code ec; + fs::create_directories(manifestDir, ec); + if (ec) { + throw std::runtime_error( + std::format("Failed to create manifest folder: {}", ec.message())); + } + + using namespace std::string_view_literals; + // Make sure the vrmanifest and action manifest are 1st and 2nd respectively + // in the array + std::array requiredFiles{ + std::make_pair("manifest.vrmanifest"sv, SVR_VRAPP_MANIFEST), + std::make_pair("action_manifest.json"sv, SVR_VRAPP_ACTION_MANIFEST), + std::make_pair("generic.json"sv, SVR_VRAPP_GENERIC_BINDS), + std::make_pair("knuckles.json"sv, SVR_VRAPP_KNUCKLES_BINDS), + std::make_pair("oculus_touch.json"sv, SVR_VRAPP_OCULUS_BINDS), + std::make_pair("vive_controller.json"sv, SVR_VRAPP_VIVE_BINDS), + }; + + for (auto &[name, contents] : requiredFiles) { + fs::path path = manifestDir / name; + if (!fs::exists(path)) { + std::ofstream stream(path); + stream << contents; + } + } + + return {manifestDir / requiredFiles.at(0).first, + manifestDir / requiredFiles.at(1).first}; +} diff --git a/bindings-provider/src/vr_utils.hpp b/bindings-provider/src/vr_utils.hpp new file mode 100644 index 000000000..996b93c4c --- /dev/null +++ b/bindings-provider/src/vr_utils.hpp @@ -0,0 +1,16 @@ +#pragma once + +#include +#include +#include +#include + +#include "openvr.h" + +namespace VRUtils { +std::optional getStringProp(vr::TrackedDeviceIndex_t deviceIndex, + vr::ETrackedDeviceProperty prop); + +// Returns +std::tuple initialiseManifest(); +} // namespace VRUtils diff --git a/gui/electron-builder.yml b/gui/electron-builder.yml index 0f2452621..04cfc4598 100644 --- a/gui/electron-builder.yml +++ b/gui/electron-builder.yml @@ -35,6 +35,10 @@ linux: extraFiles: - from: "../server/desktop/build/libs/slimevr.jar" to: "." + - from: "../bindings-provider/build/linux-${arch}/slimevr-bindings-provider" + to: "." + - from: "../bindings-provider/build/linux-${arch}/libopenvr_api.so" + to: "." - from: "./electron/resources/69-slimevr-devices.rules" to: "." icon: "./electron/resources/icons" @@ -59,6 +63,10 @@ win: - from: "../server/core/resources" to: "." filter: ["**/*"] + - from: "../bindings-provider/build/${os}-${arch}/Release/SlimeVR-Bindings-Provider.exe" + to: "." + - from: "../bindings-provider/build/${os}-${arch}/openvr_api.dll" + to: "." mac: target: dmg diff --git a/gui/electron/main/index.ts b/gui/electron/main/index.ts index 4a967943d..1c7c9c77c 100644 --- a/gui/electron/main/index.ts +++ b/gui/electron/main/index.ts @@ -404,18 +404,16 @@ const spawnServer = async () => { logger.info({ javaBin, serverJar }, 'Found Java and server jar'); const platform = getPlatform(); - const serverWorkdir = getServerDataFolder() - const serverArgs = ['-Xmx128M', '-jar', serverJar] - if (options.steam) serverArgs.push(`--steam`) - if (options.install) serverArgs.push(`--install`) - if (options.noUdev) serverArgs.push(`--no-udev`) - - serverArgs.push('run') + const serverArgs = ['-Xmx128M', '-jar', serverJar]; + if (options.steam) serverArgs.push(`--steam`); + if (options.install) serverArgs.push(`--install`); + if (options.noUdev) serverArgs.push(`--no-udev`); + serverArgs.push('run'); const serverProcess = spawn(javaBin, serverArgs, { - cwd: serverWorkdir, + cwd: sharedDir, shell: false, env: platform === 'windows' diff --git a/server/core/src/main/java/dev/slimevr/VRServer.kt b/server/core/src/main/java/dev/slimevr/VRServer.kt index 074631cc6..f5e5cf6a7 100644 --- a/server/core/src/main/java/dev/slimevr/VRServer.kt +++ b/server/core/src/main/java/dev/slimevr/VRServer.kt @@ -195,19 +195,20 @@ class VRServer @JvmOverloads constructor( return false } - // FIXME: Code using this function normally uses this to get the SteamVR driver but - // that's because we first save the SteamVR driver bridge and then the feeder in the array. - // Not really a great thing to have. @ThreadSafe - fun getVRBridge(bridgeClass: Class): E? { + fun getVRBridge(pred: (Bridge) -> Boolean): Bridge? { for (bridge in bridges) { - if (bridgeClass.isAssignableFrom(bridge.javaClass)) { - return bridgeClass.cast(bridge) - } + if (pred(bridge)) return bridge } return null } + @ThreadSafe + fun removeVRBridge(bridge: Bridge) { + bridge.stopBridge() + bridges.remove(bridge) + } + fun addOnTick(runnable: Runnable) { onTick.add(runnable) } @@ -305,7 +306,11 @@ class VRServer @JvmOverloads constructor( queueTask { humanPoseManager.updateSkeletonModelFromServer() vrcOSCHandler.setHeadTracker(TrackerUtils.getTrackerForSkeleton(trackers, TrackerPosition.HEAD)) - this.getVRBridge(ISteamVRBridge::class.java)?.updateShareSettingsAutomatically() + + val bridge = this.getVRBridge { + it is ISteamVRBridge + } as? ISteamVRBridge + bridge?.updateShareSettingsAutomatically() RPCSettingsHandler.sendSteamVRUpdatedSettings(protocolAPI, protocolAPI.rpcHandler) } } @@ -332,7 +337,10 @@ class VRServer @JvmOverloads constructor( queueTask { humanPoseManager.setPauseTracking(pauseTracking, sourceName) // Toggle trackers as they don't toggle when tracking is paused - this.getVRBridge(ISteamVRBridge::class.java)?.updateShareSettingsAutomatically() + val bridge = this.getVRBridge { + it is ISteamVRBridge + } as? ISteamVRBridge + bridge?.updateShareSettingsAutomatically() RPCSettingsHandler.sendSteamVRUpdatedSettings(protocolAPI, protocolAPI.rpcHandler) } } @@ -341,7 +349,10 @@ class VRServer @JvmOverloads constructor( queueTask { humanPoseManager.togglePauseTracking(sourceName) // Toggle trackers as they don't toggle when tracking is paused - this.getVRBridge(ISteamVRBridge::class.java)?.updateShareSettingsAutomatically() + val bridge = this.getVRBridge { + it is ISteamVRBridge + } as? ISteamVRBridge + bridge?.updateShareSettingsAutomatically() RPCSettingsHandler.sendSteamVRUpdatedSettings(protocolAPI, protocolAPI.rpcHandler) } } diff --git a/server/core/src/main/java/dev/slimevr/bridge/Bridge.kt b/server/core/src/main/java/dev/slimevr/bridge/Bridge.kt index 5750b53b3..ec43966a0 100644 --- a/server/core/src/main/java/dev/slimevr/bridge/Bridge.kt +++ b/server/core/src/main/java/dev/slimevr/bridge/Bridge.kt @@ -41,6 +41,9 @@ interface Bridge { @VRServerThread fun startBridge() + @VRServerThread + fun stopBridge() + fun isConnected(): Boolean } diff --git a/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsBuilder.kt b/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsBuilder.kt index b7d41288a..0735c1831 100644 --- a/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsBuilder.kt +++ b/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsBuilder.kt @@ -163,6 +163,9 @@ fun createTapDetectionSettings( tapDetectionConfig.mountingResetTaps, tapDetectionConfig.setupMode, tapDetectionConfig.numberTrackersOverThreshold, + 0, + 0, + 0, ) fun createSteamVRSettings(fbb: FlatBufferBuilder, bridge: ISteamVRBridge?): Int { @@ -372,7 +375,9 @@ fun createArmsResetModeSettings( ) fun createSettingsResponse(fbb: FlatBufferBuilder, server: VRServer): Int { - val bridge = server.getVRBridge(ISteamVRBridge::class.java) + val bridge = server.getVRBridge { + it is ISteamVRBridge + } as? ISteamVRBridge return SettingsResponse .createSettingsResponse( diff --git a/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsHandler.kt b/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsHandler.kt index b2aae0599..713b70e98 100644 --- a/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsHandler.kt +++ b/server/core/src/main/java/dev/slimevr/protocol/rpc/settings/RPCSettingsHandler.kt @@ -32,8 +32,9 @@ class RPCSettingsHandler(var rpcHandler: RPCHandler, var api: ProtocolAPI) { .message(ChangeSettingsRequest()) as? ChangeSettingsRequest ?: return if (req.steamVrTrackers() != null) { - val bridge = api.server - .getVRBridge(ISteamVRBridge::class.java) + val bridge = api.server.getVRBridge { + it is ISteamVRBridge + } as? ISteamVRBridge if (bridge != null) { bridge.changeShareSettings(TrackerRole.WAIST, req.steamVrTrackers().waist()) @@ -371,8 +372,9 @@ class RPCSettingsHandler(var rpcHandler: RPCHandler, var api: ProtocolAPI) { companion object { fun sendSteamVRUpdatedSettings(api: ProtocolAPI, rpcHandler: RPCHandler) { val fbb = FlatBufferBuilder(32) - val bridge: ISteamVRBridge = - api.server.getVRBridge(ISteamVRBridge::class.java) ?: return + val bridge = api.server.getVRBridge { + it is ISteamVRBridge + } as? ISteamVRBridge ?: return val settings = SettingsResponse .createSettingsResponse( diff --git a/server/core/src/main/java/dev/slimevr/trackingchecklist/TrackingChecklistManager.kt b/server/core/src/main/java/dev/slimevr/trackingchecklist/TrackingChecklistManager.kt index 249831d29..17dc84a2e 100644 --- a/server/core/src/main/java/dev/slimevr/trackingchecklist/TrackingChecklistManager.kt +++ b/server/core/src/main/java/dev/slimevr/trackingchecklist/TrackingChecklistManager.kt @@ -273,7 +273,9 @@ class TrackingChecklistManager(private val vrServer: VRServer) : VRCConfigListen } } - val steamVRBridge = vrServer.getVRBridge(ISteamVRBridge::class.java) + val steamVRBridge = vrServer.getVRBridge { + it is ISteamVRBridge + } as? ISteamVRBridge if (steamVRBridge != null) { val steamvrConnected = steamVRBridge.isConnected() updateValidity( diff --git a/server/core/src/main/java/dev/slimevr/websocketapi/WebSocketVRBridge.kt b/server/core/src/main/java/dev/slimevr/websocketapi/WebSocketVRBridge.kt index 63ea4eecd..a0b080e15 100644 --- a/server/core/src/main/java/dev/slimevr/websocketapi/WebSocketVRBridge.kt +++ b/server/core/src/main/java/dev/slimevr/websocketapi/WebSocketVRBridge.kt @@ -231,6 +231,10 @@ class WebSocketVRBridge( start() } + override fun stopBridge() { + stop() + } + override fun isConnected(): Boolean = super.getConnections().isNotEmpty() companion object { diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt b/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt index f8d78050f..0a1ce2805 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt @@ -15,6 +15,7 @@ import dev.slimevr.desktop.platform.SteamVRBridge import dev.slimevr.desktop.platform.linux.UnixSocketBridge import dev.slimevr.desktop.platform.linux.UnixSocketRpcBridge import dev.slimevr.desktop.platform.windows.WindowsNamedPipeBridge +import dev.slimevr.desktop.platform.windows.WindowsNamedPipeRpcBridge import dev.slimevr.desktop.serial.DesktopSerialHandler import dev.slimevr.desktop.tracking.trackers.hid.DesktopHIDManager import dev.slimevr.tracking.trackers.Tracker @@ -211,18 +212,26 @@ fun provideBridges( FastList(), ), ) + + yield( + WindowsNamedPipeRpcBridge( + server, + """\\.\pipe\SlimeVRRpc""", + ), + ) } OperatingSystem.LINUX -> { - var linuxBridge: SteamVRBridge? = null try { - linuxBridge = UnixSocketBridge( - server, - "steamvr", - "SteamVR Driver Bridge", - Paths.get(OperatingSystem.socketDirectory, "SlimeVRDriver") - .toString(), - computedTrackers, + yield( + UnixSocketBridge( + server, + "steamvr", + "SteamVR Driver Bridge", + Paths.get(OperatingSystem.socketDirectory, "SlimeVRDriver") + .toString(), + computedTrackers, + ), ) } catch (ex: Exception) { LogManager.severe( @@ -230,19 +239,7 @@ fun provideBridges( ex, ) } - if (linuxBridge != null) { - // Close the named socket on shutdown, or otherwise it's not going to get removed - Runtime.getRuntime().addShutdownHook( - Thread { - try { - (linuxBridge as? UnixSocketBridge)?.close() - } catch (e: Exception) { - throw RuntimeException(e) - } - }, - ) - yield(linuxBridge) - } + yield( UnixSocketBridge( server, diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Linux.kt b/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Linux.kt index e6db3da2e..0f9717cc8 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Linux.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Linux.kt @@ -9,7 +9,6 @@ class Linux { fun updateLinux() { updateLinuxSteamVRDriver() - feeder() } fun updateLinuxSteamVRDriver() { @@ -33,28 +32,7 @@ class Linux { LogManager.info("SteamVR driver successfully installed") } - fun feeder() { - executeShellCommand("chmod", "+x", "$path/$LINUX_FEEDER_DIRECTORY/SlimeVR-Feeder-App") - - val command = if (featureFlags.steam) { - arrayOf("steam-runtime-launch-client", "--alongside-steam", "--", "$path/$LINUX_FEEDER_DIRECTORY/SlimeVR-Feeder-App", "--install") - } else { - arrayOf("$path/$LINUX_FEEDER_DIRECTORY/SlimeVR-Feeder-App", "--install") - } - val feederOutput = executeShellCommand(*command) - if (feederOutput == null) { - LogManager.warning("Error installing feeder") - return - } - if (feederOutput.lowercase().contains("manifest is not installed")) { - LogManager.warning("Could not install feeder application") - } else { - LogManager.info("Successfully installed feeder application") - } - } - companion object { private const val LINUX_STEAM_DRIVER_DIRECTORY = "slimevr-openvr-driver-x64-linux" - private const val LINUX_FEEDER_DIRECTORY = "SlimeVR-Feeder-App-Linux" } } diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Windows.kt b/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Windows.kt index fbdc894ed..8d747ba18 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Windows.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/install/drivers/Windows.kt @@ -10,20 +10,6 @@ class Windows { fun updateWindows() { steamVRDriver() - feeder() - } - - fun feeder() { - val feederOutput = executeShellCommand("${path}\\${WINDOWS_FEEDER_DIRECTORY}\\SlimeVR-Feeder-App.exe", "--install") - if (feederOutput == null) { - LogManager.warning("Error installing feeder") - return - } - if (feederOutput.lowercase().contains("manifest is not installed")) { - LogManager.warning("Could not install feeder application") - } else { - LogManager.info("Successfully installed feeder application") - } } fun steamVRDriver() { @@ -57,6 +43,5 @@ class Windows { companion object { private const val WINDOWS_STEAMVR_DRIVER_DIRECTORY = "slimevr-openvr-driver-win64" - private const val WINDOWS_FEEDER_DIRECTORY = "SlimeVR-Feeder-App-win64" } } diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.kt b/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.kt index fdbee0672..e6b60aaf5 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.kt @@ -46,7 +46,7 @@ abstract class ProtobufBridge(@JvmField protected val bridgeName: String) : ISte @BridgeThread protected abstract fun sendMessageReal(message: ProtobufMessage?): Boolean - private var remoteProtocolVersion: Int = 0 + protected var remoteProtocolVersion: Int = 0 @BridgeThread protected fun messageReceived(message: ProtobufMessage) { @@ -295,6 +295,6 @@ abstract class ProtobufBridge(@JvmField protected val bridgeName: String) : ISte companion object { private const val resetSourceNamePrefix = "ProtobufBridge" - private const val PROTOCOL_VERSION = 1 + private const val PROTOCOL_VERSION = 2 } } diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/SteamVRBridge.kt b/server/desktop/src/main/java/dev/slimevr/desktop/platform/SteamVRBridge.kt index 0c33ea16f..6c80417ee 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/platform/SteamVRBridge.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/SteamVRBridge.kt @@ -4,6 +4,7 @@ import dev.slimevr.VRServer import dev.slimevr.VRServer.Companion.getNextLocalTrackerId import dev.slimevr.VRServer.Companion.instance import dev.slimevr.bridge.BridgeThread +import dev.slimevr.bridge.ISteamVRBridge import dev.slimevr.config.BridgeConfig import dev.slimevr.desktop.platform.ProtobufMessages.* import dev.slimevr.protocol.rpc.settings.RPCSettingsHandler @@ -14,7 +15,83 @@ import dev.slimevr.tracking.trackers.TrackerRole import dev.slimevr.tracking.trackers.TrackerRole.Companion.getById import dev.slimevr.tracking.trackers.TrackerUtils.getTrackerForSkeleton import dev.slimevr.util.ann.VRServerThread +import io.eiren.util.OperatingSystem import io.eiren.util.collections.FastList +import io.eiren.util.logging.LogManager +import java.nio.file.Path +import kotlin.io.path.Path +import kotlin.io.path.exists + +class BindingsProviderManager : Runnable { + private var process: Process? = null + private var watcherThread: Thread? = null + + private fun getBinaryPath(): Path? { + // First we want to try to find it in the working directory, its location on + // Steam/Windows/portable. + val binaryName = if (OperatingSystem.currentPlatform == OperatingSystem.WINDOWS) { + "SlimeVR-Bindings-Provider.exe" + } else { + "slimevr-bindings-provider" + } + val workingDir = System.getProperty("user.dir")!! + + val binaryPath = Path(workingDir, binaryName) + if (binaryPath.exists()) return binaryPath + + // Then look through PATH to find the binary. + // PATH shouldn't be null, but if it is just gracefully fail + val path = System.getenv("PATH") ?: return null + val pathSeparator = System.getProperty("path.separator")!! + for (path in path.split(pathSeparator)) { + val binaryPath = Path(path, binaryName) + if (binaryPath.exists()) return binaryPath + } + + // :( + return null + } + + fun start() { + check(process == null && watcherThread == null) { + "BindingsProviderManager already running" + } + + val binaryPath = getBinaryPath() ?: throw RuntimeException("Unable to find bindings provider binary") + process = ProcessBuilder(binaryPath.toString()) + .redirectErrorStream(true) + .start() + LogManager.info("[BindingsProviderManager] Started process") + watcherThread = Thread(this, "Bindings provider watcher") + watcherThread!!.start() + } + fun stop() { + process?.let { + it.destroy() + } + process = null + watcherThread?.interrupt() + watcherThread = null + } + + override fun run() { + try { + val interval = 1000L / 30L + while (process?.isAlive == true) { + Thread.sleep(interval) + } + + val exitCode = process?.exitValue() + if (exitCode != null) { + LogManager.info("[BindingsProviderManager] Process has exited with exit code $exitCode") + } else { + LogManager.info("[BindingsProviderManager] Process has exited") + } + } catch (_: InterruptedException) { + // Ignore it + } + } +} abstract class SteamVRBridge( protected val server: VRServer, @@ -25,6 +102,7 @@ abstract class SteamVRBridge( ) : ProtobufBridge(bridgeName), Runnable { protected val runnerThread: Thread = Thread(this, threadName) + private var bindingsProviderManager: BindingsProviderManager? = null protected val config: BridgeConfig = server.configManager.vrConfig.getBridge(bridgeSettingsKey) var connected: Boolean = false @@ -40,6 +118,13 @@ abstract class SteamVRBridge( runnerThread.start() } + @VRServerThread + override fun stopBridge() { + bindingsProviderManager?.stop() + bindingsProviderManager = null + runnerThread.interrupt() + } + @VRServerThread override fun getShareSetting(role: TrackerRole): Boolean { for (tr in shareableTrackers) { @@ -150,10 +235,10 @@ abstract class SteamVRBridge( // Display name, needsReset and isHmd val displayName: String = trackerAdded.trackerName - val isHmd = trackerAdded.trackerId == 0 // trackerPosition val role = getById(trackerAdded.trackerRole) + val isHmd = trackerAdded.trackerId == 0 val trackerPosition = if (role != null) { getByTrackerRole(role) } else { @@ -181,6 +266,33 @@ abstract class SteamVRBridge( return tracker } + @VRServerThread + override fun versionReceived(versionMessage: Version) { + super.versionReceived(versionMessage) + if (bridgeSettingsKey == "steamvr" && remoteProtocolVersion >= 2) { + instance.queueTask { + // Shut off the feeder bridge if the connected driver is recent enough + val bridge = instance.getVRBridge { + it is ISteamVRBridge && it.getBridgeConfigKey() == "steamvr_feeder" + } as? SteamVRBridge + bridge?.let { + LogManager.info("[$bridgeName] Driver version is new enough, deactivating feeder bridge") + instance.removeVRBridge(it) + } + + // Start the bindings utility when the driver starts up + if (bindingsProviderManager == null) { + bindingsProviderManager = BindingsProviderManager() + } + try { + bindingsProviderManager!!.start() + } catch (e: Exception) { + LogManager.warning("[$bridgeName] Failed to start bindings provider", e) + } + } + } + } + // Battery Status @VRServerThread override fun writeBatteryUpdate(localTracker: Tracker) { @@ -412,6 +524,7 @@ abstract class SteamVRBridge( @BridgeThread protected fun reportDisconnected() { + bindingsProviderManager?.stop() connected = false } diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketBridge.java b/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketBridge.java index 1c29cedd2..86a3f49c8 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketBridge.java +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketBridge.java @@ -16,10 +16,7 @@ import java.net.StandardProtocolFamily; import java.net.UnixDomainSocketAddress; import java.nio.ByteBuffer; import java.nio.ByteOrder; -import java.nio.channels.ServerSocketChannel; -import java.nio.channels.SocketChannel; -import java.nio.channels.Selector; -import java.nio.channels.SelectionKey; +import java.nio.channels.*; import java.util.List; @@ -30,6 +27,7 @@ public class UnixSocketBridge extends SteamVRBridge implements AutoCloseable { private final ByteBuffer dst = ByteBuffer.allocate(2048).order(ByteOrder.LITTLE_ENDIAN); private final ByteBuffer src = ByteBuffer.allocate(2048).order(ByteOrder.LITTLE_ENDIAN); + private File socketFile; private ServerSocketChannel server; private SocketChannel channel; private Selector selector; @@ -47,7 +45,7 @@ public class UnixSocketBridge extends SteamVRBridge implements AutoCloseable { this.socketPath = socketPath; this.socketAddress = UnixDomainSocketAddress.of(socketPath); - File socketFile = new File(socketPath); + socketFile = new File(socketPath); if (socketFile.exists()) { if (SocketUtils.isSocketInUse(socketPath)) { throw new RuntimeException( @@ -110,10 +108,13 @@ public class UnixSocketBridge extends SteamVRBridge implements AutoCloseable { } } } + } catch (ClosedByInterruptException e) { + // We've been told to stop } catch (IOException e) { - // TODO Auto-generated catch block - e.printStackTrace(); + LogManager.severe("[" + bridgeName + "] Exception in runner thread", e); } + + this.socketFile.delete(); } @Override diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketRpcBridge.java b/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketRpcBridge.java index 42dab98fb..b71f218f9 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketRpcBridge.java +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/linux/UnixSocketRpcBridge.java @@ -92,6 +92,12 @@ public class UnixSocketRpcBridge implements dev.slimevr.bridge.Bridge, this.runnerThread.start(); } + @Override + @VRServerThread + public void stopBridge() { + this.runnerThread.interrupt(); + } + @Override @BridgeThread public void run() { diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipe.java b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipe.java new file mode 100644 index 000000000..9bde6ef7e --- /dev/null +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipe.java @@ -0,0 +1,371 @@ +package dev.slimevr.desktop.platform.windows; + +import com.sun.jna.Native; +import com.sun.jna.platform.win32.*; +import com.sun.jna.ptr.IntByReference; +import com.sun.jna.win32.W32APIOptions; +import io.eiren.util.logging.LogManager; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.nio.ByteOrder; + + +interface Kernel32IO extends Kernel32 { + Kernel32IO INSTANCE = Native.load("kernel32", Kernel32IO.class, W32APIOptions.DEFAULT_OPTIONS); + + boolean GetOverlappedResult( + /* [in] */ HANDLE hFile, + /* [in] */ WinBase.OVERLAPPED lpOverlapped, + /* [out] */ IntByReference lpNumberOfBytesTransferred, + /* [in] */ boolean bWait + ); +} + + +public class WindowsNamedPipe implements AutoCloseable { + private static final Kernel32 k32 = Kernel32.INSTANCE; + private static final Kernel32IO k32io = Kernel32IO.INSTANCE; + private static final Advapi32 adv32 = Advapi32.INSTANCE; + + public interface PipeMessageReader { + void onMessage(PipeConnection conn, ByteBuffer buf); + } + + public static class PipeConnection implements AutoCloseable { + private final String pipeName; + private WinNT.HANDLE handle; + private PipeState state; + + protected WinNT.HANDLE openEvent = k32.CreateEvent(null, false, false, null); + protected WinNT.HANDLE readEvent = k32.CreateEvent(null, false, false, null); + protected WinNT.HANDLE writeEvent = k32.CreateEvent(null, false, false, null); + protected WinNT.HANDLE rxEvent = k32.CreateEvent(null, false, false, null); + protected WinNT.HANDLE wakeEvent = k32.CreateEvent(null, false, false, null); + protected WinNT.HANDLE[] events = new WinNT.HANDLE[] { openEvent, rxEvent, wakeEvent }; + private final WinBase.OVERLAPPED overlappedOpen = new WinBase.OVERLAPPED(); + private final WinBase.OVERLAPPED overlappedWrite = new WinBase.OVERLAPPED(); + private final WinBase.OVERLAPPED overlappedRead = new WinBase.OVERLAPPED(); + private final WinBase.OVERLAPPED overlappedWait = new WinBase.OVERLAPPED(); + private final ByteBuffer buf = ByteBuffer.allocate(2048); + private final IntByReference bytesWritten = new IntByReference(0); + private final IntByReference bytesAvailable = new IntByReference(0); + private final IntByReference bytesRead = new IntByReference(0); + private boolean pendingWait = false; + + PipeConnection(String pipeName, WinNT.HANDLE pipeHandle) { + this.pipeName = pipeName; + this.handle = pipeHandle; + this.state = PipeState.CREATED; + + // Kick off pipe connection. + tryConnect(); + } + + protected void tryConnect() { + overlappedOpen.clear(); + overlappedOpen.hEvent = openEvent; + + boolean ok = k32.ConnectNamedPipe(handle, overlappedOpen); + int err = k32.GetLastError(); + if (!ok && err != WinError.ERROR_IO_PENDING) { + if (!k32io.GetOverlappedResult(handle, overlappedOpen, bytesRead, true)) { + setError("ConnectNamedPipe failed: " + err); + } + } + } + + // Returns true when: + // Pipe has just been opened. + // Pipe is open and we got data. + public boolean update(PipeMessageReader reader) { + switch (state) { + case ERROR: { + // Do nothing. + return false; + } + case CREATED: { + // Check if any events are signaled. + int evIdx = k32.WaitForMultipleObjects(events.length, events, false, 0); + if (evIdx == WinError.WAIT_TIMEOUT) { + // Do nothing if timed out. + return false; + } + if (evIdx == WinBase.WAIT_FAILED) { + setError("Wait failed: " + k32.GetLastError()); + } + + // Did open succeed? + if (evIdx == 0) { + LogManager + .info("[WindowsNamedPipeConnection] Pipe " + pipeName + " opened"); + state = PipeState.OPEN; + return true; + } + break; + } + case OPEN: { + // Did we get data? + if (waitForData(0)) { + return tryRead(reader); + } + break; + } + } + return false; + } + + @Override + public void close() { + if (state == PipeState.OPEN) + disconnect(); + + if (wakeEvent != null) { + k32.CloseHandle(wakeEvent); + wakeEvent = null; + } + if (rxEvent != null) { + k32.CloseHandle(rxEvent); + rxEvent = null; + } + if (writeEvent != null) { + k32.CloseHandle(writeEvent); + writeEvent = null; + } + if (readEvent != null) { + k32.CloseHandle(readEvent); + readEvent = null; + } + if (openEvent != null) { + k32.CloseHandle(openEvent); + openEvent = null; + } + if (handle != null) { + k32.CloseHandle(handle); + handle = null; + } + } + + public void setError(String err) { + pendingWait = false; + state = PipeState.ERROR; + LogManager + .severe("[WindowsNamedPipeConnection] Error on pipe " + pipeName + ": " + err); + } + + // Wake up immediately from waitForData. + // Could be used by the caller to pump a message queue immediately. + public void wakeUp() { + k32.SetEvent(wakeEvent); + } + + // Try to wait timeoutMs for something to be written to the pipe. + public boolean waitForData(int timeoutMs) { + if (state != PipeState.OPEN) + return false; + if (!pendingWait) { + overlappedWait.clear(); + overlappedWait.hEvent = rxEvent; + boolean immediate = k32.ReadFile(handle, null, 0, null, overlappedWait); + int err = k32.GetLastError(); + if (!immediate && err != WinError.ERROR_IO_PENDING) { + if (err == WinError.ERROR_BROKEN_PIPE || err == WinError.ERROR_NO_DATA) { + setError("Pipe closed"); + } else { + setError("ReadFile failed: " + err); + } + return false; + } + pendingWait = true; + } + + // Did we get data? + int evIdx = k32.WaitForMultipleObjects(events.length, events, false, timeoutMs); + if (evIdx == 1) { + // events[0] == overlappedWait.hEvent == rxEvent + pendingWait = false; + return true; + } + return false; + } + + // Send a message to the pipe. + public boolean sendBuffer(byte[] buffer, int len) { + overlappedWrite.clear(); + overlappedWrite.hEvent = writeEvent; + boolean immediate = k32 + .WriteFile(handle, buffer, len, null, overlappedWrite); + int err = k32.GetLastError(); + if (!immediate && err != WinError.ERROR_IO_PENDING) { + setError("WriteFile failed: " + err); + return false; + } + + if (!k32io.GetOverlappedResult(handle, overlappedWrite, bytesWritten, true)) { + setError( + "sendMessageReal/GetOverlappedResult failed: " + k32.GetLastError() + ); + return false; + } + + if (bytesWritten.getValue() != len) { + setError("Bytes written " + bytesWritten.getValue() + ", expected " + len); + return false; + } + + return true; + } + + // Try to read messages from the buffer into reader. + protected boolean tryRead(PipeMessageReader reader) { + if (state != PipeState.OPEN) { + return false; + } + + boolean anyReceived = false; + buf.clear(); + while (k32.PeekNamedPipe(handle, buf.array(), 4, null, bytesAvailable, null)) { + if (bytesAvailable.getValue() < 4) { + return anyReceived; // Wait for more data + } + buf.position(0); + buf.order(ByteOrder.LITTLE_ENDIAN); + int messageLength = buf.getInt(); + if (messageLength > 1024) { // Overflow + setError("Pipe overflow. Message length: " + messageLength); + return anyReceived; + } + if (bytesAvailable.getValue() < messageLength) { + return anyReceived; // Wait for more data + } + + overlappedRead.clear(); + overlappedRead.hEvent = readEvent; + buf.position(0); + boolean immediate = k32 + .ReadFile(handle, buf.array(), messageLength, null, overlappedRead); + int err = k32.GetLastError(); + if (!immediate && err != WinError.ERROR_IO_PENDING) { + setError("ReadFile failed: " + err); + return anyReceived; + } + + if (!k32io.GetOverlappedResult(handle, overlappedRead, bytesRead, true)) { + setError( + "updatePipe/GetOverlappedResult failed: " + k32.GetLastError() + ); + return anyReceived; + } + + if (bytesRead.getValue() != messageLength) { + setError( + "Bytes read " + bytesRead.getValue() + ", expected " + messageLength + ); + return anyReceived; + } + + buf.clear(); + buf.position(4); // skip size + buf.limit(messageLength); + reader.onMessage(this, buf); + anyReceived = true; + + if (state != PipeState.OPEN) + return anyReceived; + } + + int err = k32.GetLastError(); + if (err == WinError.ERROR_BROKEN_PIPE) { + setError("Pipe closed"); + } else { + setError("Pipe error: " + err); + } + return anyReceived; + } + + public void disconnect() { + if (!k32.DisconnectNamedPipe(handle)) { + LogManager + .warning( + "[WindowsNamedPipeConnection] Disconnect failed: " + k32.GetLastError() + ); + } + + state = PipeState.CREATED; + tryConnect(); + } + + public PipeState getState() { + return state; + } + } + + protected final String pipeName; + private final PipeConnection[] pipeConnections; + + public WindowsNamedPipe(String pipeName, int maxConnections) throws IOException { + this.pipeName = pipeName; + this.pipeConnections = new PipeConnection[maxConnections]; + + try { + WinNT.SECURITY_DESCRIPTOR descriptor = new WinNT.SECURITY_DESCRIPTOR(64 * 1024); + adv32.InitializeSecurityDescriptor(descriptor, WinNT.SECURITY_DESCRIPTOR_REVISION); + adv32.SetSecurityDescriptorDacl(descriptor, true, null, false); + adv32 + .SetSecurityDescriptorControl( + descriptor, + (short) WinNT.SE_DACL_PROTECTED, + (short) WinNT.SE_DACL_PROTECTED + ); + + WinBase.SECURITY_ATTRIBUTES attributes = new WinBase.SECURITY_ATTRIBUTES(); + attributes.lpSecurityDescriptor = descriptor.getPointer(); + attributes.bInheritHandle = false; + + for (int i = 0; i < maxConnections; i++) { + WinNT.HANDLE pipeHandle = k32 + .CreateNamedPipe( + pipeName, + WinBase.PIPE_ACCESS_DUPLEX | WinNT.FILE_FLAG_OVERLAPPED, // dwOpenMode + WinBase.PIPE_TYPE_BYTE | WinBase.PIPE_READMODE_BYTE | WinBase.PIPE_WAIT, // dwPipeMode + maxConnections, // nMaxInstances, + 1024 * 16, // nOutBufferSize, + 1024 * 16, // nInBufferSize, + 0, // nDefaultTimeOut, + attributes // lpSecurityAttributes + ); + if (WinBase.INVALID_HANDLE_VALUE.equals(pipeHandle)) { + throw new IOException( + "Failed to open " + pipeName + " pipe: " + k32.GetLastError() + ); + } + this.pipeConnections[i] = new PipeConnection(pipeName, pipeHandle); + } + LogManager.info("[WindowsNamedPipe] Pipe " + pipeName + " created"); + + } catch (IOException e) { + for (PipeConnection conn : this.pipeConnections) { + if (conn != null) + conn.close(); + } + throw e; + } + } + + public PipeConnection tryAccept() { + for (PipeConnection conn : this.pipeConnections) { + if (conn.getState() == PipeState.CREATED && conn.update(null)) { + // We got the pipe. + return conn; + } + } + return null; + } + + @Override + public void close() { + for (PipeConnection pipeConnection : this.pipeConnections) { + pipeConnection.close(); + } + } +} diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeBridge.java b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeBridge.java index 5099fccd8..09cdec422 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeBridge.java +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeBridge.java @@ -2,11 +2,6 @@ package dev.slimevr.desktop.platform.windows; import com.google.protobuf.CodedOutputStream; import com.google.protobuf.InvalidProtocolBufferException; -import com.sun.jna.Native; -import com.sun.jna.platform.win32.*; -import com.sun.jna.platform.win32.Kernel32; -import com.sun.jna.ptr.IntByReference; -import com.sun.jna.win32.W32APIOptions; import dev.slimevr.VRServer; import dev.slimevr.bridge.BridgeThread; import dev.slimevr.desktop.platform.ProtobufMessages.ProtobufMessage; @@ -17,44 +12,17 @@ import io.eiren.util.logging.LogManager; import org.jetbrains.annotations.NotNull; import java.io.IOException; +import java.nio.ByteBuffer; import java.util.List; -interface Kernel32IO extends Kernel32 { - Kernel32IO INSTANCE = Native.load("kernel32", Kernel32IO.class, W32APIOptions.DEFAULT_OPTIONS); - - boolean GetOverlappedResult( - /* [in] */ HANDLE hFile, - /* [in] */ WinBase.OVERLAPPED lpOverlapped, - /* [out] */ IntByReference lpNumberOfBytesTransferred, - /* [in] */ boolean bWait - ); -} - - -public class WindowsNamedPipeBridge extends SteamVRBridge { - private static final Kernel32 k32 = Kernel32.INSTANCE; - private static final Kernel32IO k32io = Kernel32IO.INSTANCE; - private static final Advapi32 adv32 = Advapi32.INSTANCE; - +public class WindowsNamedPipeBridge extends SteamVRBridge + implements WindowsNamedPipe.PipeMessageReader { protected final String pipeName; protected final String bridgeSettingsKey; - private final byte[] buffArray = new byte[2048]; - protected WindowsPipe pipe; - protected WinNT.HANDLE openEvent = k32.CreateEvent(null, false, false, null); - protected WinNT.HANDLE readEvent = k32.CreateEvent(null, false, false, null); - protected WinNT.HANDLE writeEvent = k32.CreateEvent(null, false, false, null); - protected WinNT.HANDLE rxEvent = k32.CreateEvent(null, false, false, null); - protected WinNT.HANDLE txEvent = k32.CreateEvent(null, false, false, null); - protected WinNT.HANDLE[] events = new WinNT.HANDLE[] { rxEvent, txEvent }; - private final WinBase.OVERLAPPED overlappedOpen = new WinBase.OVERLAPPED(); - private final WinBase.OVERLAPPED overlappedWrite = new WinBase.OVERLAPPED(); - private final WinBase.OVERLAPPED overlappedRead = new WinBase.OVERLAPPED(); - private final WinBase.OVERLAPPED overlappedWait = new WinBase.OVERLAPPED(); - private final IntByReference bytesWritten = new IntByReference(0); - private final IntByReference bytesAvailable = new IntByReference(0); - private final IntByReference bytesRead = new IntByReference(0); - private boolean pendingWait = false; + protected WindowsNamedPipe pipe = null; + protected WindowsNamedPipe.PipeConnection connection = null; + private final byte[] buf = new byte[2048]; public WindowsNamedPipeBridge( VRServer server, @@ -63,266 +31,115 @@ public class WindowsNamedPipeBridge extends SteamVRBridge { String pipeName, List shareableTrackers ) { - super(server, "Named pipe thread", bridgeName, bridgeSettingsKey, shareableTrackers); + super( + server, + bridgeName + " named pipe thread", + bridgeName, + bridgeSettingsKey, + shareableTrackers + ); this.pipeName = pipeName; this.bridgeSettingsKey = bridgeSettingsKey; - overlappedWait.hEvent = rxEvent; } @Override @BridgeThread public void run() { try { - createPipe(); + pipe = new WindowsNamedPipe(this.pipeName, 1); while (true) { boolean pipesUpdated = false; - if (pipe.state == PipeState.CREATED) { + if (connection == null) { // Report that our pipe is disconnected right now reportDisconnected(); - tryOpeningPipe(pipe); + if ((connection = pipe.tryAccept()) != null) + VRServer.Companion.getInstance().queueTask(this::reconnected); } - if (pipe.state == PipeState.OPEN) { - pipesUpdated = updatePipe(); - if (pipesUpdated) { - reportConnected(); + if (connection != null) { + if (connection.getState() == PipeState.OPEN) { + pipesUpdated = connection.update(this); + if (pipesUpdated) { + reportConnected(); + } + updateMessageQueue(); + } + if (connection.getState() == PipeState.ERROR) { + connection.disconnect(); + connection = null; + disconnected(); } - updateMessageQueue(); - } - if (pipe.state == PipeState.ERROR) { - resetPipe(); } if (!pipesUpdated) { - if (pipe.state == PipeState.OPEN) { - waitForData(10); + if (connection != null && connection.getState() == PipeState.OPEN) { + connection.waitForData(10); } else { try { Thread.sleep(10); } catch (InterruptedException e) { - e.printStackTrace(); + // Do nothing. } } } } } catch (IOException e) { - // TODO Auto-generated catch block - e.printStackTrace(); + LogManager.severe("[" + bridgeName + "] Exception in runner thread", e); } + pipe.close(); } @Override @ThreadSafe protected void signalSend() { - k32.SetEvent(txEvent); + if (connection != null) + connection.wakeUp(); } - @BridgeThread - private void waitForData(int timeoutMs) { - if (pipe.state != PipeState.OPEN) + @Override + public void onMessage(WindowsNamedPipe.PipeConnection connection, ByteBuffer buf) { + if (this.connection != connection) { + LogManager + .severe("[" + bridgeName + "] Got message from connection we don't know about"); return; - if (!pendingWait) { - k32.ReadFile(pipe.pipeHandle, null, 0, null, overlappedWait); - pendingWait = true; } - int evIdx = k32.WaitForMultipleObjects(events.length, events, false, timeoutMs); - if (evIdx == 0) { - // events[0] == overlappedWait.hEvent == rxEvent - pendingWait = false; + + try { + ProtobufMessage message = ProtobufMessage + .parser() + .parseFrom(buf); + messageReceived(message); + } catch (InvalidProtocolBufferException parseEx) { + LogManager.severe("[" + bridgeName + "] Failed to parse message", parseEx); + connection.setError("Failed to parse message"); } } @Override @BridgeThread protected boolean sendMessageReal(ProtobufMessage message) { - if (pipe.state != PipeState.OPEN) { + if (connection == null || connection.getState() != PipeState.OPEN) { return false; } try { int size = message.getSerializedSize(); - CodedOutputStream os = CodedOutputStream.newInstance(buffArray, 4, size); + CodedOutputStream os = CodedOutputStream.newInstance(buf, 4, size); message.writeTo(os); size += 4; - buffArray[0] = (byte) (size & 0xFF); - buffArray[1] = (byte) ((size >> 8) & 0xFF); - buffArray[2] = (byte) ((size >> 16) & 0xFF); - buffArray[3] = (byte) ((size >> 24) & 0xFF); - overlappedWrite.clear(); - overlappedWrite.hEvent = writeEvent; - boolean immediate = k32 - .WriteFile(pipe.pipeHandle, buffArray, size, null, overlappedWrite); - int err = k32.GetLastError(); - if (!immediate && err != WinError.ERROR_IO_PENDING) { - setPipeError("WriteFile failed: " + err); - return false; - } + buf[0] = (byte) (size & 0xFF); + buf[1] = (byte) ((size >> 8) & 0xFF); + buf[2] = (byte) ((size >> 16) & 0xFF); + buf[3] = (byte) ((size >> 24) & 0xFF); - if (!k32io.GetOverlappedResult(pipe.pipeHandle, overlappedWrite, bytesWritten, true)) { - setPipeError( - "sendMessageReal/GetOverlappedResult failed: " + k32.GetLastError() - ); - return false; - } - - if (bytesWritten.getValue() != size) { - setPipeError("Bytes written " + bytesWritten.getValue() + ", expected " + size); - return false; - } - - return true; + return connection.sendBuffer(buf, size); } catch (IOException e) { e.printStackTrace(); } return false; } - private boolean updatePipe() throws IOException { - if (pipe.state != PipeState.OPEN) { - return false; - } - boolean readAnything = false; - while (k32.PeekNamedPipe(pipe.pipeHandle, buffArray, 4, null, bytesAvailable, null)) { - if (bytesAvailable.getValue() < 4) { - return readAnything; // Wait for more data - } - int messageLength = (Byte.toUnsignedInt(buffArray[3]) << 24) - | (Byte.toUnsignedInt(buffArray[2]) << 16) - | (Byte.toUnsignedInt(buffArray[1]) << 8) - | Byte.toUnsignedInt(buffArray[0]); - if (messageLength > 1024) { // Overflow - setPipeError("Pipe overflow. Message length: " + messageLength); - return readAnything; - } - if (bytesAvailable.getValue() < messageLength) { - return readAnything; // Wait for more data - } - - overlappedRead.clear(); - overlappedRead.hEvent = readEvent; - boolean immediate = k32 - .ReadFile(pipe.pipeHandle, buffArray, messageLength, null, overlappedRead); - int err = k32.GetLastError(); - if (!immediate && err != WinError.ERROR_IO_PENDING) { - setPipeError("ReadFile failed: " + err); - return readAnything; - } - - if (!k32io.GetOverlappedResult(pipe.pipeHandle, overlappedRead, bytesRead, true)) { - setPipeError( - "updatePipe/GetOverlappedResult failed: " + k32.GetLastError() - ); - return readAnything; - } - - if (bytesRead.getValue() != messageLength) { - setPipeError( - "Bytes read " + bytesRead.getValue() + ", expected " + messageLength - ); - return readAnything; - } - - try { - ProtobufMessage message = ProtobufMessage - .parser() - .parseFrom(buffArray, 4, messageLength - 4); - messageReceived(message); - readAnything = true; - } catch (InvalidProtocolBufferException parseEx) { - parseEx.printStackTrace(); - setPipeError("Failed to parse message: " + parseEx.getMessage()); - return readAnything; - } - } - - int err = k32.GetLastError(); - if (err == WinError.ERROR_BROKEN_PIPE) { - setPipeError("Pipe closed"); - } else { - setPipeError("Pipe error: " + err); - } - return readAnything; - } - - private void setPipeError(String message) { - pipe.state = PipeState.ERROR; - LogManager.severe("[" + bridgeName + "] " + message); - } - - private void resetPipe() { - WindowsPipe.safeDisconnect(pipe); - pipe.state = PipeState.CREATED; - VRServer.Companion.getInstance().queueTask(this::disconnected); - } - - private void createPipe() throws IOException { - try { - WinNT.SECURITY_DESCRIPTOR descriptor = new WinNT.SECURITY_DESCRIPTOR(64 * 1024); - adv32.InitializeSecurityDescriptor(descriptor, WinNT.SECURITY_DESCRIPTOR_REVISION); - adv32.SetSecurityDescriptorDacl(descriptor, true, null, false); - adv32 - .SetSecurityDescriptorControl( - descriptor, - (short) WinNT.SE_DACL_PROTECTED, - (short) WinNT.SE_DACL_PROTECTED - ); - - WinBase.SECURITY_ATTRIBUTES attributes = new WinBase.SECURITY_ATTRIBUTES(); - attributes.lpSecurityDescriptor = descriptor.getPointer(); - attributes.bInheritHandle = false; - - pipe = new WindowsPipe( - k32 - .CreateNamedPipe( - pipeName, - WinBase.PIPE_ACCESS_DUPLEX | WinNT.FILE_FLAG_OVERLAPPED, // dwOpenMode - WinBase.PIPE_TYPE_BYTE | WinBase.PIPE_READMODE_BYTE | WinBase.PIPE_WAIT, // dwPipeMode - 1, // nMaxInstances, - 1024 * 16, // nOutBufferSize, - 1024 * 16, // nInBufferSize, - 0, // nDefaultTimeOut, - attributes // lpSecurityAttributes - ), - pipeName - ); - LogManager.info("[" + bridgeName + "] Pipe " + pipe.name + " created"); - if (WinBase.INVALID_HANDLE_VALUE.equals(pipe.pipeHandle)) { - throw new IOException("Can't open " + pipeName + " pipe: " + k32.GetLastError()); - } - LogManager.info("[" + bridgeName + "] Pipes are created"); - } catch (IOException e) { - WindowsPipe.safeDisconnect(pipe); - throw e; - } - } - - private boolean tryOpeningPipe(WindowsPipe pipe) { - overlappedOpen.clear(); - overlappedOpen.hEvent = openEvent; - - boolean ok = k32.ConnectNamedPipe(pipe.pipeHandle, overlappedOpen); - int err = k32.GetLastError(); - if (!ok && err != WinError.ERROR_PIPE_CONNECTED) { - if (err != WinError.ERROR_IO_PENDING) { - setPipeError("ConnectNamedPipe failed: " + err); - return false; - } - - if (!k32io.GetOverlappedResult(pipe.pipeHandle, overlappedOpen, bytesRead, true)) { - setPipeError( - "tryOpeningPipe/GetOverlappedResult failed: " + k32.GetLastError() - ); - return false; - } - } - - pipe.state = PipeState.OPEN; - LogManager.info("[" + bridgeName + "] Pipe " + pipe.name + " is open"); - VRServer.Companion.getInstance().queueTask(this::reconnected); - return true; - } - @Override public boolean isConnected() { - return pipe != null && pipe.state == PipeState.OPEN; + return connection != null && connection.getState() == PipeState.OPEN; } @NotNull diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeRpcBridge.java b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeRpcBridge.java new file mode 100644 index 000000000..1e9c461ed --- /dev/null +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeRpcBridge.java @@ -0,0 +1,130 @@ +package dev.slimevr.desktop.platform.windows; + +import dev.slimevr.VRServer; +import dev.slimevr.bridge.BridgeThread; +import dev.slimevr.protocol.GenericConnection; +import dev.slimevr.protocol.ProtocolAPI; +import dev.slimevr.tracking.trackers.Tracker; +import dev.slimevr.util.ann.VRServerThread; +import io.eiren.util.collections.FastList; +import io.eiren.util.logging.LogManager; + +import java.io.IOException; +import java.nio.ByteBuffer; + + +public class WindowsNamedPipeRpcBridge implements WindowsNamedPipe.PipeMessageReader, + dev.slimevr.bridge.Bridge, dev.slimevr.protocol.ProtocolAPIServer, Runnable, AutoCloseable { + private static final int maxConnections = 16; + private final Thread runnerThread = new Thread(this, "Named pipe RPC thread"); + private final String pipePath; + private final ProtocolAPI protocolAPI; + private WindowsNamedPipe pipe; + private FastList connections = new FastList(maxConnections); + + public WindowsNamedPipeRpcBridge(VRServer server, String pipePath) { + this.pipePath = pipePath; + this.protocolAPI = server.protocolAPI; + + server.protocolAPI.registerAPIServer(this); + } + + @Override + @BridgeThread + public void run() { + try { + this.pipe = new WindowsNamedPipe(pipePath, maxConnections); + FastList removedConnections = new FastList( + maxConnections + ); + while (true) { + WindowsNamedPipe.PipeConnection newConnection = this.pipe.tryAccept(); + if (newConnection != null) { + this.connections.add(new WindowsNamedPipeRpcConnection(newConnection)); + } + + for (WindowsNamedPipeRpcConnection connection : this.connections) { + if (connection.getState() == PipeState.OPEN) { + connection.update(this); + } + + if (connection.getState() == PipeState.ERROR) { + connection.disconnect(); + removedConnections.add(connection); + } + } + + this.connections.removeAll(removedConnections); + removedConnections.clear(); + Thread.sleep(2); + } + } catch (IOException e) { + LogManager.severe("[SolarXR RPC Bridge] Exception in runner thread", e); + } catch (InterruptedException e) { + // Do nothing. + } + } + + @Override + @BridgeThread + public void onMessage(WindowsNamedPipe.PipeConnection conn, ByteBuffer buf) { + for (WindowsNamedPipeRpcConnection connection : this.connections) { + if (connection.getConnection() == conn) { + this.protocolAPI.onMessage(connection, buf); + return; + } + } + + LogManager.severe("[SolarXR RPC Bridge] Got message from connection we don't know about"); + } + + @Override + @VRServerThread + public void dataRead() { + } + + @Override + @VRServerThread + public void dataWrite() { + } + + @Override + @VRServerThread + public void addSharedTracker(Tracker tracker) { + } + + @Override + @VRServerThread + public void removeSharedTracker(Tracker tracker) { + } + + @Override + @VRServerThread + public void startBridge() { + this.runnerThread.start(); + } + + @Override + @VRServerThread + public void stopBridge() { + this.runnerThread.interrupt(); + } + + @Override + public void close() { + this.connections.clear(); + if (this.pipe != null) + this.pipe.close(); + } + + @Override + public boolean isConnected() { + return !this.connections.isEmpty(); + } + + @Override + public java.util.stream.Stream getApiConnections() { + return this.connections.stream().map(conn -> (GenericConnection) conn); + } +} + diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeRpcConnection.java b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeRpcConnection.java new file mode 100644 index 000000000..7f57b2121 --- /dev/null +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/windows/WindowsNamedPipeRpcConnection.java @@ -0,0 +1,62 @@ +package dev.slimevr.desktop.platform.windows; + +import dev.slimevr.protocol.ConnectionContext; +import dev.slimevr.protocol.GenericConnection; + +import java.nio.ByteBuffer; +import java.nio.ByteOrder; +import java.util.UUID; + + +public class WindowsNamedPipeRpcConnection implements GenericConnection { + private final UUID id; + private final ConnectionContext context; + private final WindowsNamedPipe.PipeConnection connection; + + WindowsNamedPipeRpcConnection(WindowsNamedPipe.PipeConnection connection) { + this.id = UUID.randomUUID(); + this.context = new ConnectionContext(); + this.connection = connection; + } + + @Override + public UUID getConnectionId() { + return id; + } + + @Override + public ConnectionContext getContext() { + return this.context; + } + + public boolean update(WindowsNamedPipe.PipeMessageReader reader) { + return this.connection.update(reader); + } + + public void disconnect() { + this.connection.disconnect(); + } + + public PipeState getState() { + return this.connection.getState(); + } + + public WindowsNamedPipe.PipeConnection getConnection() { + return this.connection; + } + + @Override + public void send(ByteBuffer bytes) { + if (this.connection.getState() != PipeState.OPEN) + return; + + ByteBuffer src = ByteBuffer.allocate(4 + bytes.remaining()); + src.order(ByteOrder.LITTLE_ENDIAN); + src.putInt(4 + bytes.remaining()); + src.put(bytes); + src.flip(); + synchronized (this) { + this.connection.sendBuffer(bytes.array(), bytes.remaining()); + } + } +} diff --git a/solarxr-protocol b/solarxr-protocol index 740ead6df..5d572629c 160000 --- a/solarxr-protocol +++ b/solarxr-protocol @@ -1 +1 @@ -Subproject commit 740ead6df20281185d44ad2f5e3fa1804157015a +Subproject commit 5d572629c94f895574162225ec69443705ce35af