1.0

Author: InconsolableCellist

application/src/DeviceManager/DeviceManager.cpp

@@ -1,25 +1,41 @@
 #include "DeviceManager.hpp"
 #include "../../../common/Logger.hpp"
+#include <thread>
+#include <chrono>
 
 namespace StayPutVR {
     bool DeviceManager::Initialize() {
-        // Connect to IPC server
-        if (!ipc_client_.Connect()) {
-            if (Logger::IsInitialized()) {
-                Logger::Error("Failed to connect to driver IPC server");
-            }
-            return false;
-        }
-        
-        // Set device update callback
+        // Set device update callback first
         ipc_client_.SetDeviceUpdateCallback([this](const std::vector<DevicePositionData>& devices) {
             this->OnDeviceUpdate(devices);
         });
 
-        return true;
+        // Try initial connection
+        if (ipc_client_.Connect()) {
+            if (Logger::IsInitialized()) {
+                Logger::Info("DeviceManager: Successfully connected to driver IPC server");
+            }
+            return true;
+        }
+        
+        // If initial connection fails, start auto-reconnection if enabled
+        if (auto_reconnect_enabled_) {
+            if (Logger::IsInitialized()) {
+                Logger::Warning("DeviceManager: Initial connection failed, starting auto-reconnection");
+            }
+            StartReconnectThread();
+            // Return true to allow application to continue running
+            return true;
+        } else {
+            if (Logger::IsInitialized()) {
+                Logger::Error("DeviceManager: Failed to connect to driver IPC server and auto-reconnect is disabled");
+            }
+            return false;
+        }
     }
 
     void DeviceManager::Shutdown() {
+        StopReconnectThread();
         ipc_client_.Disconnect();
     }
 
@@ -30,6 +46,14 @@ namespace StayPutVR {
     void DeviceManager::Update() {
         // Process IPC messages
         ipc_client_.ProcessMessages();
+        
+        // Check for connection loss and start reconnection if needed
+        if (auto_reconnect_enabled_ && !ipc_client_.IsConnected() && !reconnect_thread_running_) {
+            if (Logger::IsInitialized()) {
+                Logger::Warning("DeviceManager: Connection lost, starting auto-reconnection");
+            }
+            StartReconnectThread();
+        }
     }
 
     const std::vector<DevicePositionData>& DeviceManager::GetDevices() const {
@@ -52,4 +76,111 @@ namespace StayPutVR {
             device_map_[devices_[i].serial] = i;
         }
     }
+    
+    void DeviceManager::StartReconnectThread() {
+        if (reconnect_thread_running_) {
+            return; // Already running
+        }
+        
+        // Ensure any previous thread is fully cleaned up
+        if (reconnect_thread_.joinable()) {
+            reconnect_thread_.join();
+        }
+        
+        reconnect_thread_running_ = true;
+        last_reconnect_attempt_ = std::chrono::steady_clock::now();
+        reconnect_thread_ = std::thread(&DeviceManager::ReconnectThreadFunction, this);
+        
+        if (Logger::IsInitialized()) {
+            Logger::Info("DeviceManager: Auto-reconnection thread started");
+        }
+    }
+    
+    void DeviceManager::StopReconnectThread() {
+        if (!reconnect_thread_running_) {
+            return; // Not running
+        }
+        
+        reconnect_thread_running_ = false;
+        
+        if (reconnect_thread_.joinable()) {
+            reconnect_thread_.join();
+        }
+        
+        if (Logger::IsInitialized()) {
+            Logger::Info("DeviceManager: Auto-reconnection thread stopped");
+        }
+    }
+    
+    void DeviceManager::ReconnectThreadFunction() {
+        if (Logger::IsInitialized()) {
+            Logger::Info("DeviceManager: Reconnection thread started");
+        }
+        
+        // Wait initial delay before first reconnection attempt
+        std::this_thread::sleep_for(INITIAL_RECONNECT_DELAY);
+        
+        while (reconnect_thread_running_ && auto_reconnect_enabled_) {
+            if (!ipc_client_.IsConnected()) {
+                auto now = std::chrono::steady_clock::now();
+                if (now - last_reconnect_attempt_ >= RECONNECT_INTERVAL) {
+                    if (TryReconnect()) {
+                        if (Logger::IsInitialized()) {
+                            Logger::Info("DeviceManager: Successfully reconnected to driver");
+                        }
+                        break; // Exit thread on successful connection
+                    }
+                    last_reconnect_attempt_ = now;
+                }
+            } else {
+                // Already connected, exit thread
+                break;
+            }
+            
+            // Sleep briefly before next check
+            std::this_thread::sleep_for(std::chrono::milliseconds(500));
+        }
+        
+        reconnect_thread_running_ = false;
+        if (Logger::IsInitialized()) {
+            Logger::Info("DeviceManager: Reconnection thread exiting");
+        }
+    }
+    
+    bool DeviceManager::TryReconnect() {
+        if (Logger::IsInitialized()) {
+            Logger::Debug("DeviceManager: Attempting to reconnect to driver...");
+        }
+        
+        // Ensure clean state before reconnecting
+        if (ipc_client_.IsConnected()) {
+            ipc_client_.Disconnect();
+            // Brief delay to ensure cleanup completes
+            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+        }
+        
+        return ipc_client_.Connect();
+    }
+    
+    bool DeviceManager::ManualReconnect() {
+        if (Logger::IsInitialized()) {
+            Logger::Info("DeviceManager: Manual reconnection requested");
+        }
+        
+        // Stop auto-reconnection thread to avoid conflicts
+        StopReconnectThread();
+        
+        // Try to reconnect
+        bool success = TryReconnect();
+        
+        // If manual reconnection fails and auto-reconnect is enabled, restart the thread
+        if (!success && auto_reconnect_enabled_) {
+            if (Logger::IsInitialized()) {
+                Logger::Info("DeviceManager: Manual reconnection failed, restarting auto-reconnection");
+            }
+            StartReconnectThread();
+        }
+        
+        return success;
+    }
 }

application/src/DeviceManager/DeviceManager.hpp

@@ -2,6 +2,9 @@
 #include <string>
 #include <vector>
 #include <unordered_map>
+#include <thread>
+#include <atomic>
+#include <chrono>
 #include "../../../common/DeviceTypes.hpp"
 #include "../IPC/IPCClient.hpp"
 
@@ -17,11 +20,30 @@ namespace StayPutVR {
         const std::vector<DevicePositionData>& GetDevices() const;
         bool LockDevice(const std::string& serial, bool lock);
 
+        // Auto-reconnection control
+        void SetAutoReconnect(bool enabled) { auto_reconnect_enabled_ = enabled; }
+        bool IsAutoReconnectEnabled() const { return auto_reconnect_enabled_; }
+        
+        // Manual reconnection (thread-safe, stops auto-reconnection temporarily)
+        bool ManualReconnect();
+        
     private:
         IPCClient ipc_client_;
         std::vector<DevicePositionData> devices_;
         std::unordered_map<std::string, size_t> device_map_; // serial to index
 
+        // Auto-reconnection
+        std::atomic<bool> auto_reconnect_enabled_ = true;
+        std::atomic<bool> reconnect_thread_running_ = false;
+        std::thread reconnect_thread_;
+        std::chrono::steady_clock::time_point last_reconnect_attempt_;
+        static constexpr std::chrono::seconds RECONNECT_INTERVAL{5};
+        static constexpr std::chrono::seconds INITIAL_RECONNECT_DELAY{2};
+        
         void OnDeviceUpdate(const std::vector<DevicePositionData>& devices);
+        void ReconnectThreadFunction();
+        void StartReconnectThread();
+        void StopReconnectThread();
+        bool TryReconnect();
     };
 }

application/src/IPC/IPCClient.cpp

@@ -16,13 +16,27 @@ namespace StayPutVR {
     }
 
     bool IPCClient::Connect() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        
         Logger::Info("IPCClient: Connecting to pipe");
 
         if (connected_) {
             Logger::Warning("IPCClient: Already connected");
             return true;
         }
 
+        // Ensure we're in a clean state before connecting
+        if (pipe_handle_ != INVALID_HANDLE_VALUE) {
+            CloseHandle(pipe_handle_);
+            pipe_handle_ = INVALID_HANDLE_VALUE;
+        }
+        
+        // Ensure reader thread is stopped
+        if (reader_thread_.joinable()) {
+            running_ = false;
+            reader_thread_.join();
+        }
+        
         // Try to connect to the named pipe
         HANDLE pipe_handle = CreateFileA(
             PIPE_NAME,                      // Pipe name
@@ -87,6 +101,8 @@ namespace StayPutVR {
     }
 
     void IPCClient::Disconnect() {
+        std::lock_guard<std::mutex> lock(mutex_);
+        
         Logger::Info("IPCClient: Disconnecting");
 
         // Check if we're already disconnected

application/src/ui/UIManager.cpp

@@ -1213,11 +1213,8 @@ namespace StayPutVR {
 
             if (ImGui::Button("Retry Connection")) {
                 if (device_manager_) {
-                    // First disconnect if needed
-                    device_manager_->Shutdown();
-                    
-                    // Then try to reconnect
-                    if (device_manager_->Initialize()) {
+                    // Use the new thread-safe manual reconnection method
+                    if (device_manager_->ManualReconnect()) {
                         if (StayPutVR::Logger::IsInitialized()) {
                             StayPutVR::Logger::Info("Successfully reconnected to driver");
                         }