hongshaorou/rustdesk
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refact, sync lock modifiers, macOS, not debug yet

Browse Source 
Signed-off-by: fufesou <shuanglongchen@yeah.net>
This commit is contained in:
fufesou 2023-03-25 23:44:20 +08:00
parent d0881cee10
commit f1e0d64732
4 changed files with 81 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Cargo.lock generated
View File

@ -4674,7 +4674,7 @@ dependencies = [
[[package]] [[package]]
name = "rdev" name = "rdev"
version = "0.5.0-2" version = "0.5.0-2"
source = "git+https://github.com/fufesou/rdev#eaa35ff9af22891b4aae3a0a5e83472c16177cd8" source = "git+https://github.com/fufesou/rdev#cd0d6ad907f8fda5cf77487bc962ef4246221d0c"
dependencies = [ dependencies = [
"cocoa", "cocoa",
"core-foundation 0.9.3", "core-foundation 0.9.3",

48
src/keyboard.rs
View File

@ -10,7 +10,7 @@ use crate::ui::CUR_SESSION;
#[cfg(not(any(target_os = "android", target_os = "ios")))] #[cfg(not(any(target_os = "android", target_os = "ios")))]
use hbb_common::log; use hbb_common::log;
use hbb_common::message_proto::*; use hbb_common::message_proto::*;
use rdev::{Event, EventType, Key}; use rdev::{Event, EventType, Key, KeyCode};
#[cfg(any(target_os = "windows", target_os = "macos"))] #[cfg(any(target_os = "windows", target_os = "macos"))]
use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::atomic::{AtomicBool, Ordering};
use std::{ use std::{
@ -46,26 +46,26 @@ lazy_static::lazy_static! {
m.insert(Key::MetaRight, false); m.insert(Key::MetaRight, false);
Mutex::new(m) Mutex::new(m)
}; };
static ref NUMPAD_POSITION_CODES: Arc<Vec<u32>> = { static ref NUMPAD_POSITION_CODES: Arc<Vec<KeyCode>> = {
let numpad_keys = [ let numpad_keys = [
rdev::Key::KpMinus, Key::KpMinus,
rdev::Key::KpPlus, Key::KpPlus,
rdev::Key::KpMultiply, Key::KpMultiply,
rdev::Key::KpDivide, Key::KpDivide,
rdev::Key::KpDecimal, Key::KpDecimal,
rdev::Key::KpReturn, Key::KpReturn,
rdev::Key::KpEqual, Key::KpEqual,
rdev::Key::KpComma, Key::KpComma,
rdev::Key::Kp0, Key::Kp0,
rdev::Key::Kp1, Key::Kp1,
rdev::Key::Kp2, Key::Kp2,
rdev::Key::Kp3, Key::Kp3,
rdev::Key::Kp4, Key::Kp4,
rdev::Key::Kp5, Key::Kp5,
rdev::Key::Kp6, Key::Kp6,
rdev::Key::Kp7, Key::Kp7,
rdev::Key::Kp8, Key::Kp8,
rdev::Key::Kp9, Key::Kp9,
]; ];
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
let codes = numpad_keys.iter().filter_map(|k| rdev::win_scancode_from_key(*k)).collect(); let codes = numpad_keys.iter().filter_map(|k| rdev::win_scancode_from_key(*k)).collect();
@ -257,7 +257,7 @@ pub fn start_grab_loop() {
let mut _keyboard_mode = KeyboardMode::Map; let mut _keyboard_mode = KeyboardMode::Map;
let _scan_code = event.position_code; let _scan_code = event.position_code;
let _code = event.platform_code; let _code = event.platform_code as KeyCode;
let res = if KEYBOARD_HOOKED.load(Ordering::SeqCst) { let res = if KEYBOARD_HOOKED.load(Ordering::SeqCst) {
_keyboard_mode = client::process_event(&event, None); _keyboard_mode = client::process_event(&event, None);
if is_press { if is_press {
@ -293,7 +293,7 @@ pub fn start_grab_loop() {
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
unsafe { unsafe {
if _code as u32 == rdev::kVK_Option { if _code == rdev::kVK_Option {
IS_LEFT_OPTION_DOWN = is_press; IS_LEFT_OPTION_DOWN = is_press;
} }
} }
@ -496,7 +496,7 @@ pub fn event_to_key_events(
}; };
if keyboard_mode != KeyboardMode::Translate { if keyboard_mode != KeyboardMode::Translate {
let is_numpad_key = NUMPAD_POSITION_CODES.contains(&event.position_code); let is_numpad_key = NUMPAD_POSITION_CODES.contains(&(event.position_code as _));
for key_event in &mut key_events { for key_event in &mut key_events {
#[cfg(not(any(target_os = "android", target_os = "ios")))] #[cfg(not(any(target_os = "android", target_os = "ios")))]
if let Some(lock_modes) = lock_modes { if let Some(lock_modes) = lock_modes {
@ -929,7 +929,7 @@ pub fn translate_keyboard_mode(peer: &str, event: &Event, key_event: KeyEvent) -
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
// ignore right option key // ignore right option key
if event.platform_code as u32 == rdev::kVK_RightOption { if event.platform_code == rdev::kVK_RightOption as u32 {
return events; return events;
} }

80
src/server/input_service.rs
View File

@ -5,7 +5,7 @@ use crate::common::IS_X11;
use dispatch::Queue; use dispatch::Queue;
use enigo::{Enigo, Key, KeyboardControllable, MouseButton, MouseControllable}; use enigo::{Enigo, Key, KeyboardControllable, MouseButton, MouseControllable};
use hbb_common::{config::COMPRESS_LEVEL, get_time, protobuf::EnumOrUnknown}; use hbb_common::{config::COMPRESS_LEVEL, get_time, protobuf::EnumOrUnknown};
use rdev::{self, EventType, Key as RdevKey, RawKey}; use rdev::{self, EventType, Key as RdevKey, KeyCode, RawKey};
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
use rdev::{CGEventSourceStateID, CGEventTapLocation, VirtualInput}; use rdev::{CGEventSourceStateID, CGEventTapLocation, VirtualInput};
use std::time::Duration; use std::time::Duration;
@ -113,23 +113,32 @@ impl Subscriber for MouseCursorSub {
} }
} }
#[cfg(not(target_os = "macos"))]
struct LockModesHandler { struct LockModesHandler {
caps_lock_changed: bool, caps_lock_changed: bool,
num_lock_changed: bool, num_lock_changed: bool,
} }
#[cfg(target_os = "macos")]
struct LockModesHandler;
impl LockModesHandler { impl LockModesHandler {
#[inline]
fn is_modifier_enabled(key_event: &KeyEvent, modifier: ControlKey) {
key_event.modifiers.contains(&modifier.into());
}
#[cfg(not(target_os = "macos"))]
fn new(key_event: &KeyEvent) -> Self { fn new(key_event: &KeyEvent) -> Self {
let mut en = ENIGO.lock().unwrap(); let mut en = ENIGO.lock().unwrap();
let event_caps_enabled = Self::is_modifier_enabled(key_event, ControlKey::CapsLock);
let event_caps_enabled = key_event.modifiers.contains(&ControlKey::CapsLock.into());
let local_caps_enabled = en.get_key_state(enigo::Key::CapsLock); let local_caps_enabled = en.get_key_state(enigo::Key::CapsLock);
let caps_lock_changed = event_caps_enabled != local_caps_enabled; let caps_lock_changed = event_caps_enabled != local_caps_enabled;
if caps_lock_changed { if caps_lock_changed {
click_capslock(&mut en); en.key_click(enigo::Key::CapsLock);
} }
let event_num_enabled = key_event.modifiers.contains(&ControlKey::NumLock.into()); let event_num_enabled = Self::is_modifier_enabled(key_event, ControlKey::NumLock);
let local_num_enabled = en.get_key_state(enigo::Key::NumLock); let local_num_enabled = en.get_key_state(enigo::Key::NumLock);
#[cfg(not(target_os = "windows"))] #[cfg(not(target_os = "windows"))]
let disable_numlock = false; let disable_numlock = false;
@ -137,7 +146,7 @@ impl LockModesHandler {
let disable_numlock = is_numlock_disabled(key_event); let disable_numlock = is_numlock_disabled(key_event);
let num_lock_changed = event_num_enabled != local_num_enabled && !disable_numlock; let num_lock_changed = event_num_enabled != local_num_enabled && !disable_numlock;
if num_lock_changed { if num_lock_changed {
click_numlock(&mut en); en.key_click(enigo::Key::NumLock);
} }
Self { Self {
@ -145,16 +154,36 @@ impl LockModesHandler {
num_lock_changed, num_lock_changed,
} }
} }
#[cfg(target_os = "macos")]
fn new(key_event: &KeyEvent) -> Self {
let event_caps_enabled = Self::is_modifier_enabled(key_event, ControlKey::CapsLock);
let local_caps_enabled = VirtualInput::get_key_state(
CGEventSourceStateID::CombinedSessionState,
rdev::kVK_CapsLock,
);
let caps_key = RdevKey::RawKey(rdev::RawKey::MacVirtualKeycode(rdev::kVK_CapsLock));
if event_caps_enabled && !local_caps_enabled {
simulate_(&EventType::KeyPress(caps_key));
key_sleep();
} else if !event_caps_enabled && local_caps_enabled {
simulate_(&EventType::KeyRelease(caps_key));
key_sleep();
}
Self {}
}
} }
#[cfg(not(target_os = "macos"))]
impl Drop for LockModesHandler { impl Drop for LockModesHandler {
fn drop(&mut self) { fn drop(&mut self) {
let mut en = ENIGO.lock().unwrap(); let mut en = ENIGO.lock().unwrap();
if self.caps_lock_changed { if self.caps_lock_changed {
click_capslock(&mut en); en.key_click(enigo::Key::CapsLock);
} }
if self.num_lock_changed { if self.num_lock_changed {
click_numlock(&mut en); en.key_click(enigo::Key::NumLock);
} }
} }
} }
@ -391,6 +420,12 @@ fn is_pressed(key: &Key, en: &mut Enigo) -> bool {
get_modifier_state(key.clone(), en) get_modifier_state(key.clone(), en)
} }
#[inline]
#[cfg(target_os = "macos")]
fn key_sleep() {
std::thread::sleep(Duration::from_millis(20));
}
#[inline] #[inline]
fn get_modifier_state(key: Key, en: &mut Enigo) -> bool { fn get_modifier_state(key: Key, en: &mut Enigo) -> bool {
// https://github.com/rustdesk/rustdesk/issues/332 // https://github.com/rustdesk/rustdesk/issues/332
@ -459,6 +494,7 @@ pub fn fix_key_down_timeout_at_exit() {
log::info!("fix_key_down_timeout_at_exit"); log::info!("fix_key_down_timeout_at_exit");
} }
#[inline]
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
pub fn clear_remapped_keycode() { pub fn clear_remapped_keycode() {
ENIGO.lock().unwrap().tfc_clear_remapped(); ENIGO.lock().unwrap().tfc_clear_remapped();
@ -792,7 +828,7 @@ pub fn handle_key(evt: &KeyEvent) {
// having GUI, run main GUI thread, otherwise crash // having GUI, run main GUI thread, otherwise crash
let evt = evt.clone(); let evt = evt.clone();
QUEUE.exec_async(move || handle_key_(&evt)); QUEUE.exec_async(move || handle_key_(&evt));
std::thread::sleep(Duration::from_millis(20)); key_sleep();
return; return;
} }
#[cfg(windows)] #[cfg(windows)]
@ -800,7 +836,7 @@ pub fn handle_key(evt: &KeyEvent) {
#[cfg(not(windows))] #[cfg(not(windows))]
handle_key_(evt); handle_key_(evt);
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
std::thread::sleep(Duration::from_millis(20)); key_sleep();
} }
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
@ -822,7 +858,7 @@ pub fn reset_input_ondisconn() {
} }
} }
fn sim_rdev_rawkey_position(code: u32, keydown: bool) { fn sim_rdev_rawkey_position(code: KeyCode, keydown: bool) {
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
let rawkey = RawKey::ScanCode(code); let rawkey = RawKey::ScanCode(code);
#[cfg(target_os = "linux")] #[cfg(target_os = "linux")]
@ -927,20 +963,6 @@ fn is_numlock_disabled(key_event: &KeyEvent) -> bool {
} }
} }
fn click_capslock(en: &mut Enigo) {
#[cfg(not(targe_os = "macos"))]
en.key_click(enigo::Key::CapsLock);
#[cfg(target_os = "macos")]
let _ = en.key_down(enigo::Key::CapsLock);
}
#[inline]
fn click_numlock(_en: &mut Enigo) {
// without numlock in macos
#[cfg(not(target_os = "macos"))]
_en.key_click(enigo::Key::NumLock);
}
fn map_keyboard_mode(evt: &KeyEvent) { fn map_keyboard_mode(evt: &KeyEvent) {
#[cfg(windows)] #[cfg(windows)]
crate::platform::windows::try_change_desktop(); crate::platform::windows::try_change_desktop();
@ -959,7 +981,7 @@ fn map_keyboard_mode(evt: &KeyEvent) {
return; return;
} }
sim_rdev_rawkey_position(evt.chr(), evt.down); sim_rdev_rawkey_position(evt.chr() as _, evt.down);
} }
#[cfg(target_os = "macos")] #[cfg(target_os = "macos")]
@ -1137,7 +1159,7 @@ fn legacy_keyboard_mode(evt: &KeyEvent) {
fn translate_process_code(code: u32, down: bool) { fn translate_process_code(code: u32, down: bool) {
crate::platform::windows::try_change_desktop(); crate::platform::windows::try_change_desktop();
match code >> 16 { match code >> 16 {
0 => sim_rdev_rawkey_position(code, down), 0 => sim_rdev_rawkey_position(code as _, down),
vk_code => sim_rdev_rawkey_virtual(vk_code, down), vk_code => sim_rdev_rawkey_virtual(vk_code, down),
}; };
} }
@ -1168,7 +1190,7 @@ fn translate_keyboard_mode(evt: &KeyEvent) {
#[cfg(target_os = "windows")] #[cfg(target_os = "windows")]
translate_process_code(evt.chr(), evt.down); translate_process_code(evt.chr(), evt.down);
#[cfg(not(target_os = "windows"))] #[cfg(not(target_os = "windows"))]
sim_rdev_rawkey_position(evt.chr(), evt.down); sim_rdev_rawkey_position(evt.chr() as _, evt.down);
} }
Some(key_event::Union::Unicode(..)) => { Some(key_event::Union::Unicode(..)) => {
// Do not handle unicode for now. // Do not handle unicode for now.
@ -1187,7 +1209,7 @@ pub fn handle_key_(evt: &KeyEvent) {
let _lock_mode_handler = match &evt.union { let _lock_mode_handler = match &evt.union {
Some(key_event::Union::Unicode(..)) | Some(key_event::Union::Seq(..)) => { Some(key_event::Union::Unicode(..)) | Some(key_event::Union::Seq(..)) => {
Some(LockModesHandler::new(&evt)) Some(LockModesHandler::new(&evt))
}, }
_ => { _ => {
if evt.down { if evt.down {
Some(LockModesHandler::new(&evt)) Some(LockModesHandler::new(&evt))

10
src/ui_session_interface.rs
View File

@ -10,7 +10,7 @@ use std::time::{Duration, SystemTime};
use async_trait::async_trait; use async_trait::async_trait;
use bytes::Bytes; use bytes::Bytes;
use rdev::{Event, EventType::*}; use rdev::{Event, EventType::*, KeyCode};
use uuid::Uuid; use uuid::Uuid;
use hbb_common::config::{Config, LocalConfig, PeerConfig}; use hbb_common::config::{Config, LocalConfig, PeerConfig};
@ -421,7 +421,7 @@ impl<T: InvokeUiSession> Session<T> {
rdev::win_scancode_from_key(key).unwrap_or_default() rdev::win_scancode_from_key(key).unwrap_or_default()
} }
"macos" => { "macos" => {
let key = rdev::macos_key_from_code(code); let key = rdev::macos_key_from_code(code as _);
let key = match key { let key = match key {
rdev::Key::ControlLeft => rdev::Key::MetaLeft, rdev::Key::ControlLeft => rdev::Key::MetaLeft,
rdev::Key::MetaLeft => rdev::Key::ControlLeft, rdev::Key::MetaLeft => rdev::Key::ControlLeft,
@ -429,7 +429,7 @@ impl<T: InvokeUiSession> Session<T> {
rdev::Key::MetaRight => rdev::Key::ControlLeft, rdev::Key::MetaRight => rdev::Key::ControlLeft,
_ => key, _ => key,
}; };
rdev::macos_keycode_from_key(key).unwrap_or_default() rdev::macos_keycode_from_key(key).unwrap_or_default() as _
} }
_ => { _ => {
let key = rdev::linux_key_from_code(code); let key = rdev::linux_key_from_code(code);
@ -545,8 +545,8 @@ impl<T: InvokeUiSession> Session<T> {
if scancode < 0 || keycode < 0 { if scancode < 0 || keycode < 0 {
return; return;
} }
let keycode: u32 = keycode as u32; let keycode: KeyCode = keycode as _;
let scancode: u32 = scancode as u32; let scancode: u32 = scancode as _;
#[cfg(not(target_os = "windows"))] #[cfg(not(target_os = "windows"))]
let key = rdev::key_from_code(keycode) as rdev::Key; let key = rdev::key_from_code(keycode) as rdev::Key;