fix(server_openvr): ✨ Conditional HMD initialization strategy (#2875)

zmerp · zmerp · commit 52db4466610e · 2025-06-30T14:33:57.000+10:00
* fix(server_openvr): ⏪ Revert HMD initialization at driver startup

* Initialize HMD early only when dashboard is alive

* Address review comments
diff --git a/alvr/server_openvr/cpp/alvr_server/TrackedDevice.cpp b/alvr/server_openvr/cpp/alvr_server/TrackedDevice.cpp
@@ -83,7 +83,7 @@ void TrackedDevice::submit_pose(vr::DriverPose_t pose) {
     );
 }
 
-bool TrackedDevice::register_device() {
+bool TrackedDevice::register_device(bool await_activation) {
     if (!vr::VRServerDriverHost()->TrackedDeviceAdded(
             this->get_serial_number().c_str(),
             this->device_class,
@@ -94,12 +94,16 @@ bool TrackedDevice::register_device() {
         return false;
     }
 
-    auto lock = std::unique_lock<std::mutex>(this->activation_mutex);
-    this->activation_condvar.wait_for(lock, std::chrono::seconds(1), [this] {
-        return this->activation_state != ActivationState::Pending;
-    });
+    if (await_activation) {
+        auto lock = std::unique_lock<std::mutex>(this->activation_mutex);
+        this->activation_condvar.wait_for(lock, std::chrono::seconds(1), [this] {
+            return this->activation_state != ActivationState::Pending;
+        });
 
-    return this->activation_state == ActivationState::Success;
+        return this->activation_state == ActivationState::Success;
+    } else {
+        return true;
+    }
 }
 
 vr::EVRInitError TrackedDevice::Activate(vr::TrackedDeviceIndex_t object_id) {
diff --git a/alvr/server_openvr/cpp/alvr_server/TrackedDevice.h b/alvr/server_openvr/cpp/alvr_server/TrackedDevice.h
@@ -19,7 +19,7 @@ class TrackedDevice : vr::ITrackedDeviceServerDriver {
     vr::PropertyContainerHandle_t prop_container = vr::k_ulInvalidPropertyContainer;
     vr::DriverPose_t last_pose;
 
-    bool register_device();
+    bool register_device(bool await_activation);
     void set_prop(FfiOpenvrProperty prop);
 
 protected:
diff --git a/alvr/server_openvr/cpp/alvr_server/alvr_server.cpp b/alvr/server_openvr/cpp/alvr_server/alvr_server.cpp
@@ -79,6 +79,8 @@ static void load_debug_privilege(void) {
 
 class DriverProvider : public vr::IServerTrackedDeviceProvider {
 public:
+    bool early_hmd_initialization = false;
+
     std::unique_ptr<Hmd> hmd;
     std::unique_ptr<Controller> left_controller, right_controller;
     std::unique_ptr<Controller> left_hand_tracker, right_hand_tracker;
@@ -94,6 +96,15 @@ class DriverProvider : public vr::IServerTrackedDeviceProvider {
         VR_INIT_SERVER_DRIVER_CONTEXT(pContext);
         InitDriverLog(vr::VRDriverLog());
 
+        if (this->early_hmd_initialization) {
+            auto hmd = new Hmd();
+            // Note: we disable awaiting for Acivate() call. That will only be called after
+            // IServerTrackedDeviceProvider::Init() (this function) returns.
+            hmd->register_device(false);
+            this->hmd = std::unique_ptr<Hmd>(hmd);
+            this->tracked_devices.insert({ HEAD_ID, this->hmd.get() });
+        }
+
         return vr::VRInitError_None;
     }
     virtual void Cleanup() override {
@@ -210,7 +221,9 @@ void (*SetOpenvrProps)(void* instancePtr, unsigned long long deviceID);
 void (*RegisterButtons)(void* instancePtr, unsigned long long deviceID);
 void (*WaitForVSync)();
 
-void CppInit() {
+void CppInit(bool earlyHmdInitialization) {
+    g_driver_provider.early_hmd_initialization = earlyHmdInitialization;
+
     HookCrashHandler();
 
     // Initialize path constants
@@ -235,13 +248,15 @@ bool InitializeStreaming() {
     Settings::Instance().Load();
 
     if (!g_driver_provider.devices_initialized) {
-        auto hmd = new Hmd();
-        if (!hmd->register_device()) {
-            Error("Failed to register HMD");
-            return false;
+        if (!g_driver_provider.early_hmd_initialization) {
+            auto hmd = new Hmd();
+            if (!hmd->register_device(false)) {
+                Error("Failed to register HMD");
+                return false;
+            }
+            g_driver_provider.hmd = std::unique_ptr<Hmd>(hmd);
+            g_driver_provider.tracked_devices.insert({ HEAD_ID, g_driver_provider.hmd.get() });
         }
-        g_driver_provider.hmd = std::unique_ptr<Hmd>(hmd);
-        g_driver_provider.tracked_devices.insert({ HEAD_ID, g_driver_provider.hmd.get() });
 
         // Note: for controllers, hands and trackers don't bail out if registration fails
         if (Settings::Instance().m_enableControllers) {
@@ -250,15 +265,15 @@ bool InitializeStreaming() {
                 : vr::VRSkeletalTracking_Partial;
 
             auto left_controller = new Controller(HAND_LEFT_ID, controllerSkeletonLevel);
-            if (left_controller->register_device()) {
+            if (left_controller->register_device(true)) {
                 g_driver_provider.left_controller = std::unique_ptr<Controller>(left_controller);
                 g_driver_provider.tracked_devices.insert(
                     { HAND_LEFT_ID, g_driver_provider.left_controller.get() }
                 );
             }
 
             auto right_controller = new Controller(HAND_RIGHT_ID, controllerSkeletonLevel);
-            if (right_controller->register_device()) {
+            if (right_controller->register_device(true)) {
                 g_driver_provider.right_controller = std::unique_ptr<Controller>(right_controller);
                 g_driver_provider.tracked_devices.insert(
                     { HAND_RIGHT_ID, g_driver_provider.right_controller.get() }
@@ -268,7 +283,7 @@ bool InitializeStreaming() {
             if (Settings::Instance().m_useSeparateHandTrackers) {
                 auto left_hand_tracker
                     = new Controller(HAND_TRACKER_LEFT_ID, vr::VRSkeletalTracking_Full);
-                if (left_hand_tracker->register_device()) {
+                if (left_hand_tracker->register_device(true)) {
                     g_driver_provider.left_hand_tracker
                         = std::unique_ptr<Controller>(left_hand_tracker);
                     g_driver_provider.tracked_devices.insert(
@@ -278,7 +293,7 @@ bool InitializeStreaming() {
 
                 auto right_hand_tracker
                     = new Controller(HAND_TRACKER_RIGHT_ID, vr::VRSkeletalTracking_Full);
-                if (right_hand_tracker->register_device()) {
+                if (right_hand_tracker->register_device(true)) {
                     g_driver_provider.right_hand_tracker
                         = std::unique_ptr<Controller>(right_hand_tracker);
                     g_driver_provider.tracked_devices.insert(
@@ -290,55 +305,55 @@ bool InitializeStreaming() {
 
         if (Settings::Instance().m_enableBodyTrackingFakeVive) {
             auto chestTracker = std::make_unique<FakeViveTracker>(BODY_CHEST_ID);
-            if (chestTracker->register_device()) {
+            if (chestTracker->register_device(true)) {
                 g_driver_provider.tracked_devices.insert({ BODY_CHEST_ID, chestTracker.get() });
                 g_driver_provider.generic_trackers.push_back(std::move(chestTracker));
             }
 
             auto waistTracker = std::make_unique<FakeViveTracker>(BODY_HIPS_ID);
-            if (waistTracker->register_device()) {
+            if (waistTracker->register_device(true)) {
                 g_driver_provider.tracked_devices.insert({ BODY_HIPS_ID, waistTracker.get() });
                 g_driver_provider.generic_trackers.push_back(std::move(waistTracker));
             }
 
             auto leftElbowTracker = std::make_unique<FakeViveTracker>(BODY_LEFT_ELBOW_ID);
-            if (leftElbowTracker->register_device()) {
+            if (leftElbowTracker->register_device(true)) {
                 g_driver_provider.tracked_devices.insert({ BODY_LEFT_ELBOW_ID,
                                                            leftElbowTracker.get() });
                 g_driver_provider.generic_trackers.push_back(std::move(leftElbowTracker));
             }
 
             auto rightElbowTracker = std::make_unique<FakeViveTracker>(BODY_RIGHT_ELBOW_ID);
-            if (rightElbowTracker->register_device()) {
+            if (rightElbowTracker->register_device(true)) {
                 g_driver_provider.tracked_devices.insert({ BODY_RIGHT_ELBOW_ID,
                                                            rightElbowTracker.get() });
                 g_driver_provider.generic_trackers.push_back(std::move(rightElbowTracker));
             }
 
             if (Settings::Instance().m_bodyTrackingHasLegs) {
                 auto leftKneeTracker = std::make_unique<FakeViveTracker>(BODY_LEFT_KNEE_ID);
-                if (leftKneeTracker->register_device()) {
+                if (leftKneeTracker->register_device(true)) {
                     g_driver_provider.tracked_devices.insert({ BODY_LEFT_KNEE_ID,
                                                                leftKneeTracker.get() });
                     g_driver_provider.generic_trackers.push_back(std::move(leftKneeTracker));
                 }
 
                 auto leftFootTracker = std::make_unique<FakeViveTracker>(BODY_LEFT_FOOT_ID);
-                if (leftFootTracker->register_device()) {
+                if (leftFootTracker->register_device(true)) {
                     g_driver_provider.tracked_devices.insert({ BODY_LEFT_FOOT_ID,
                                                                leftFootTracker.get() });
                     g_driver_provider.generic_trackers.push_back(std::move(leftFootTracker));
                 }
 
                 auto rightKneeTracker = std::make_unique<FakeViveTracker>(BODY_RIGHT_KNEE_ID);
-                if (rightKneeTracker->register_device()) {
+                if (rightKneeTracker->register_device(true)) {
                     g_driver_provider.tracked_devices.insert({ BODY_RIGHT_KNEE_ID,
                                                                rightKneeTracker.get() });
                     g_driver_provider.generic_trackers.push_back(std::move(rightKneeTracker));
                 }
 
                 auto rightFootTracker = std::make_unique<FakeViveTracker>(BODY_RIGHT_FOOT_ID);
-                if (rightFootTracker->register_device()) {
+                if (rightFootTracker->register_device(true)) {
                     g_driver_provider.tracked_devices.insert({ BODY_RIGHT_FOOT_ID,
                                                                rightFootTracker.get() });
                     g_driver_provider.generic_trackers.push_back(std::move(rightFootTracker));
diff --git a/alvr/server_openvr/cpp/alvr_server/bindings.h b/alvr/server_openvr/cpp/alvr_server/bindings.h
@@ -133,7 +133,7 @@ extern "C" void (*SetOpenvrProps)(void* instancePtr, unsigned long long deviceID
 extern "C" void (*RegisterButtons)(void* instancePtr, unsigned long long deviceID);
 extern "C" void (*WaitForVSync)();
 
-extern "C" void CppInit();
+extern "C" void CppInit(bool earlyHmdInitialization);
 extern "C" void* CppOpenvrEntryPoint(const char* pInterfaceName, int* pReturnCode);
 extern "C" bool InitializeStreaming();
 extern "C" void DeinitializeStreaming();
diff --git a/alvr/server_openvr/src/lib.rs b/alvr/server_openvr/src/lib.rs
@@ -407,17 +407,6 @@ pub extern "C" fn shutdown_driver() {
     SERVER_CORE_CONTEXT.write().take();
 }
 
-// Check that there is no active dashboard instance not part of this driver installation
-pub fn should_initialize_driver(driver_layout: &afs::Layout) -> bool {
-    // Note: if the iterator is empty, `all()` returns true
-    sysinfo::System::new_all()
-        .processes_by_name(OsStr::new(&afs::dashboard_fname()))
-        .all(|proc| {
-            proc.exe()
-                .is_none_or(|path| path == driver_layout.dashboard_exe()) // if path is unreadable then don't care
-        })
-}
-
 /// This is the SteamVR/OpenVR entry point
 /// # Safety
 #[no_mangle]
@@ -434,7 +423,17 @@ pub unsafe extern "C" fn HmdDriverFactory(
         return ptr::null_mut();
     };
 
-    if !should_initialize_driver(&filesystem_layout) {
+    let dashboard_process_paths = sysinfo::System::new_all()
+        .processes_by_name(OsStr::new(&afs::dashboard_fname()))
+        .filter_map(|proc| Some(proc.exe()?.to_owned()))
+        .collect::<Vec<_>>();
+
+    // Check that there is no active dashboard instance not part of this driver installation
+    // Note: if the iterator is empty, `all()` returns true
+    if !dashboard_process_paths
+        .iter()
+        .all(|path| *path == filesystem_layout.dashboard_exe())
+    {
         return ptr::null_mut();
     }
 
@@ -486,7 +485,12 @@ pub unsafe extern "C" fn HmdDriverFactory(
             WaitForVSync = Some(wait_for_vsync);
             ShutdownRuntime = Some(shutdown_driver);
 
-            CppInit();
+            // When there is already a ALVR dashboard running, initialize the HMD device early to
+            // avoid buggy SteamVR behavior
+            // NB: we already bail out before if the dashboards don't belong to this streamer
+            let early_hmd_initialization = !dashboard_process_paths.is_empty();
+
+            CppInit(early_hmd_initialization);
         }
 
         let (context, events_receiver) = ServerCoreContext::new();
