a657504
a65750432432bbdc3f24231a89570dc3adb38118ca44876
b2b2ba6| Status | File | + | - |
|---|---|---|---|
| M |
hyprkvm-daemon/src/input/evdev_grab.rs
|
2 | 20 |
| M |
hyprkvm-daemon/src/main.rs
|
18 | 47 |
hyprkvm-daemon/src/input/evdev_grab.rsmodified@@ -30,9 +30,6 @@ pub struct EvdevGrabber { | |||
| 30 | recovery_active: Arc<AtomicU64>, | 30 | recovery_active: Arc<AtomicU64>, |
| 31 | /// The direction to watch for in recovery mode (encoded as u8: 1=Up, 2=Down, 3=Left, 4=Right, 0=none) | 31 | /// The direction to watch for in recovery mode (encoded as u8: 1=Up, 2=Down, 3=Left, 4=Right, 0=none) |
| 32 | recovery_direction: Arc<AtomicU64>, | 32 | recovery_direction: Arc<AtomicU64>, |
| 33 | - /// Flag indicating whether this grabber has input devices to grab | ||
| 34 | - /// If false, this machine cannot initiate transfers (but can still receive them) | ||
| 35 | - has_devices: Arc<AtomicBool>, | ||
| 36 | event_rx: mpsc::Receiver<GrabEvent>, | 33 | event_rx: mpsc::Receiver<GrabEvent>, |
| 37 | _thread: thread::JoinHandle<()>, | 34 | _thread: thread::JoinHandle<()>, |
| 38 | } | 35 | } |
@@ -46,15 +43,13 @@ impl EvdevGrabber { | |||
| 46 | let recovery_clone = recovery_active.clone(); | 43 | let recovery_clone = recovery_active.clone(); |
| 47 | let recovery_direction = Arc::new(AtomicU64::new(0)); | 44 | let recovery_direction = Arc::new(AtomicU64::new(0)); |
| 48 | let recovery_dir_clone = recovery_direction.clone(); | 45 | let recovery_dir_clone = recovery_direction.clone(); |
| 49 | - let has_devices = Arc::new(AtomicBool::new(false)); | ||
| 50 | - let has_devices_clone = has_devices.clone(); | ||
| 51 | 46 | ||
| 52 | let (event_tx, event_rx) = mpsc::channel(); | 47 | let (event_tx, event_rx) = mpsc::channel(); |
| 53 | 48 | ||
| 54 | let thread = thread::Builder::new() | 49 | let thread = thread::Builder::new() |
| 55 | .name("evdev-grabber".to_string()) | 50 | .name("evdev-grabber".to_string()) |
| 56 | .spawn(move || { | 51 | .spawn(move || { |
| 57 | - if let Err(e) = run_evdev_grabber(active_clone, recovery_clone, recovery_dir_clone, has_devices_clone, event_tx) { | 52 | + if let Err(e) = run_evdev_grabber(active_clone, recovery_clone, recovery_dir_clone, event_tx) { |
| 58 | tracing::error!("Evdev grabber error: {}", e); | 53 | tracing::error!("Evdev grabber error: {}", e); |
| 59 | } | 54 | } |
| 60 | }) | 55 | }) |
@@ -64,7 +59,6 @@ impl EvdevGrabber { | |||
| 64 | active, | 59 | active, |
| 65 | recovery_active, | 60 | recovery_active, |
| 66 | recovery_direction, | 61 | recovery_direction, |
| 67 | - has_devices, | ||
| 68 | event_rx, | 62 | event_rx, |
| 69 | _thread: thread, | 63 | _thread: thread, |
| 70 | }) | 64 | }) |
@@ -107,13 +101,6 @@ impl EvdevGrabber { | |||
| 107 | self.active.load(Ordering::SeqCst) | 101 | self.active.load(Ordering::SeqCst) |
| 108 | } | 102 | } |
| 109 | 103 | ||
| 110 | - /// Check if this grabber has input devices available | ||
| 111 | - /// If false, this machine cannot initiate transfers (no devices to grab) | ||
| 112 | - /// but can still receive control from other machines | ||
| 113 | - pub fn has_devices(&self) -> bool { | ||
| 114 | - self.has_devices.load(Ordering::SeqCst) | ||
| 115 | - } | ||
| 116 | - | ||
| 117 | /// Try to receive a grab event (non-blocking) | 104 | /// Try to receive a grab event (non-blocking) |
| 118 | pub fn try_recv(&self) -> Option<GrabEvent> { | 105 | pub fn try_recv(&self) -> Option<GrabEvent> { |
| 119 | self.event_rx.try_recv().ok() | 106 | self.event_rx.try_recv().ok() |
@@ -197,20 +184,15 @@ fn run_evdev_grabber( | |||
| 197 | active: Arc<AtomicBool>, | 184 | active: Arc<AtomicBool>, |
| 198 | recovery_active: Arc<AtomicU64>, | 185 | recovery_active: Arc<AtomicU64>, |
| 199 | recovery_direction: Arc<AtomicU64>, | 186 | recovery_direction: Arc<AtomicU64>, |
| 200 | - has_devices: Arc<AtomicBool>, | ||
| 201 | event_tx: mpsc::Sender<GrabEvent>, | 187 | event_tx: mpsc::Sender<GrabEvent>, |
| 202 | ) -> Result<(), EvdevGrabError> { | 188 | ) -> Result<(), EvdevGrabError> { |
| 203 | let device_paths = find_input_devices(); | 189 | let device_paths = find_input_devices(); |
| 204 | 190 | ||
| 205 | if device_paths.is_empty() { | 191 | if device_paths.is_empty() { |
| 206 | - tracing::warn!("No input devices found - this machine cannot initiate transfers"); | ||
| 207 | - // Leave has_devices as false (default) | ||
| 208 | return Err(EvdevGrabError::NoDevices); | 192 | return Err(EvdevGrabError::NoDevices); |
| 209 | } | 193 | } |
| 210 | 194 | ||
| 211 | - // Mark that we have devices - transfers can be initiated from this machine | 195 | + tracing::info!("Found {} input device paths", device_paths.len()); |
| 212 | - has_devices.store(true, Ordering::SeqCst); | ||
| 213 | - tracing::info!("Found {} input device paths (can initiate transfers)", device_paths.len()); | ||
| 214 | for path in &device_paths { | 196 | for path in &device_paths { |
| 215 | tracing::debug!(" {}", path.display()); | 197 | tracing::debug!(" {}", path.display()); |
| 216 | } | 198 | } |
hyprkvm-daemon/src/main.rsmodified@@ -967,10 +967,6 @@ async fn run_daemon(config_path: &std::path::Path) -> anyhow::Result<()> { | |||
| 967 | 967 | ||
| 968 | if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) { | 968 | if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) { |
| 969 | info!("RECOVERY HOTKEY: Barrier enabled, blocking transfer"); | 969 | info!("RECOVERY HOTKEY: Barrier enabled, blocking transfer"); |
| 970 | - } else if !input_grabber.has_devices() { | ||
| 971 | - // Should never happen (no devices = no recovery hotkey events) | ||
| 972 | - // but guard against it anyway | ||
| 973 | - tracing::debug!("RECOVERY HOTKEY: No input devices, cannot initiate"); | ||
| 974 | } else { | 970 | } else { |
| 975 | info!("RECOVERY HOTKEY: At edge with peer, initiating transfer to {:?}", direction); | 971 | info!("RECOVERY HOTKEY: At edge with peer, initiating transfer to {:?}", direction); |
| 976 | if let Err(e) = transfer_manager.initiate_transfer( | 972 | if let Err(e) = transfer_manager.initiate_transfer( |
@@ -1080,14 +1076,6 @@ async fn run_daemon(config_path: &std::path::Path) -> anyhow::Result<()> { | |||
| 1080 | cursor_pos.0, | 1076 | cursor_pos.0, |
| 1081 | cursor_pos.1 | 1077 | cursor_pos.1 |
| 1082 | ); | 1078 | ); |
| 1083 | - } else if !input_grabber.has_devices() { | ||
| 1084 | - // No input devices = cannot initiate transfers (deviceless machine) | ||
| 1085 | - tracing::debug!( | ||
| 1086 | - "EDGE: {:?} at ({}, {}) - no input devices, cannot initiate", | ||
| 1087 | - direction, | ||
| 1088 | - cursor_pos.0, | ||
| 1089 | - cursor_pos.1 | ||
| 1090 | - ); | ||
| 1091 | } else { | 1079 | } else { |
| 1092 | info!( | 1080 | info!( |
| 1093 | "EDGE: {:?} at ({}, {}) - initiating transfer", | 1081 | "EDGE: {:?} at ({}, {}) - initiating transfer", |
@@ -1232,12 +1220,6 @@ async fn run_daemon(config_path: &std::path::Path) -> anyhow::Result<()> { | |||
| 1232 | "CURSOR EDGE: {:?} at ({}, {}) - barrier enabled, blocking", | 1220 | "CURSOR EDGE: {:?} at ({}, {}) - barrier enabled, blocking", |
| 1233 | edge_dir, cx, cy | 1221 | edge_dir, cx, cy |
| 1234 | ); | 1222 | ); |
| 1235 | - } else if !input_grabber.has_devices() { | ||
| 1236 | - // No input devices = cannot initiate transfers | ||
| 1237 | - tracing::debug!( | ||
| 1238 | - "CURSOR EDGE: {:?} at ({}, {}) - no input devices, cannot initiate", | ||
| 1239 | - edge_dir, cx, cy | ||
| 1240 | - ); | ||
| 1241 | } else { | 1223 | } else { |
| 1242 | info!( | 1224 | info!( |
| 1243 | "CURSOR EDGE: {:?} at ({}, {}) - initiating transfer", | 1225 | "CURSOR EDGE: {:?} at ({}, {}) - initiating transfer", |
@@ -1854,8 +1836,6 @@ async fn run_daemon(config_path: &std::path::Path) -> anyhow::Result<()> { | |||
| 1854 | // At edge with peer but received control from different direction | 1836 | // At edge with peer but received control from different direction |
| 1855 | if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) { | 1837 | if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) { |
| 1856 | IpcResponse::Error { message: "Barrier enabled".to_string() } | 1838 | IpcResponse::Error { message: "Barrier enabled".to_string() } |
| 1857 | - } else if !input_grabber.has_devices() { | ||
| 1858 | - IpcResponse::Error { message: "No input devices - cannot initiate transfer".to_string() } | ||
| 1859 | } else { | 1839 | } else { |
| 1860 | // Initiate new transfer | 1840 | // Initiate new transfer |
| 1861 | let cursor_pos = hypr_client.cursor_pos().await | 1841 | let cursor_pos = hypr_client.cursor_pos().await |
@@ -1899,8 +1879,6 @@ async fn run_daemon(config_path: &std::path::Path) -> anyhow::Result<()> { | |||
| 1899 | } | 1879 | } |
| 1900 | } else if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) { | 1880 | } else if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) { |
| 1901 | IpcResponse::Error { message: "Barrier enabled".to_string() } | 1881 | IpcResponse::Error { message: "Barrier enabled".to_string() } |
| 1902 | - } else if !input_grabber.has_devices() { | ||
| 1903 | - IpcResponse::Error { message: "No input devices - cannot initiate transfer".to_string() } | ||
| 1904 | } else { | 1882 | } else { |
| 1905 | // Initiate new transfer | 1883 | // Initiate new transfer |
| 1906 | let cursor_pos = hypr_client.cursor_pos().await | 1884 | let cursor_pos = hypr_client.cursor_pos().await |
@@ -2092,32 +2070,25 @@ async fn run_daemon(config_path: &std::path::Path) -> anyhow::Result<()> { | |||
| 2092 | if peers_guard.get(&dir).is_some() { | 2070 | if peers_guard.get(&dir).is_some() { |
| 2093 | drop(peers_guard); | 2071 | drop(peers_guard); |
| 2094 | 2072 | ||
| 2095 | - // Check if we have input devices before initiating | 2073 | + // Get cursor position (use center of total screen) |
| 2096 | - if !input_grabber.has_devices() { | 2074 | + let cursor_pos = hypr_client.cursor_pos().await |
| 2097 | - IpcResponse::Error { | 2075 | + .map(|c| (c.x, c.y)) |
| 2098 | - message: "No input devices - cannot initiate transfer".to_string(), | 2076 | + .unwrap_or(((screen_min_x + screen_max_x) / 2, (screen_min_y + screen_max_y) / 2)); |
| 2077 | + | ||
| 2078 | + // Initiate transfer (CLI-initiated, not keyboard) | ||
| 2079 | + info!("IPC Switch: calling initiate_transfer"); | ||
| 2080 | + match transfer_manager.initiate_transfer(dir, cursor_pos, screen_min_x, screen_min_y, screen_max_x, screen_max_y, false).await { | ||
| 2081 | + Ok(()) => { | ||
| 2082 | + let machine_name = config.machines.neighbors | ||
| 2083 | + .iter() | ||
| 2084 | + .find(|n| n.direction == dir) | ||
| 2085 | + .map(|n| n.name.clone()) | ||
| 2086 | + .unwrap_or_else(|| format!("{:?}", dir)); | ||
| 2087 | + info!("IPC Switch: initiate_transfer succeeded, returning response to CLI"); | ||
| 2088 | + IpcResponse::Transferred { to_machine: machine_name } | ||
| 2099 | } | 2089 | } |
| 2100 | - } else { | 2090 | + Err(e) => IpcResponse::Error { |
| 2101 | - // Get cursor position (use center of total screen) | 2091 | + message: format!("Transfer failed: {}", e), |
| 2102 | - let cursor_pos = hypr_client.cursor_pos().await | ||
| 2103 | - .map(|c| (c.x, c.y)) | ||
| 2104 | - .unwrap_or(((screen_min_x + screen_max_x) / 2, (screen_min_y + screen_max_y) / 2)); | ||
| 2105 | - | ||
| 2106 | - // Initiate transfer (CLI-initiated, not keyboard) | ||
| 2107 | - info!("IPC Switch: calling initiate_transfer"); | ||
| 2108 | - match transfer_manager.initiate_transfer(dir, cursor_pos, screen_min_x, screen_min_y, screen_max_x, screen_max_y, false).await { | ||
| 2109 | - Ok(()) => { | ||
| 2110 | - let machine_name = config.machines.neighbors | ||
| 2111 | - .iter() | ||
| 2112 | - .find(|n| n.direction == dir) | ||
| 2113 | - .map(|n| n.name.clone()) | ||
| 2114 | - .unwrap_or_else(|| format!("{:?}", dir)); | ||
| 2115 | - info!("IPC Switch: initiate_transfer succeeded, returning response to CLI"); | ||
| 2116 | - IpcResponse::Transferred { to_machine: machine_name } | ||
| 2117 | - } | ||
| 2118 | - Err(e) => IpcResponse::Error { | ||
| 2119 | - message: format!("Transfer failed: {}", e), | ||
| 2120 | - } | ||
| 2121 | } | 2092 | } |
| 2122 | } | 2093 | } |
| 2123 | } else { | 2094 | } else { |