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

refacotor: simplify mod of keyboard

Browse Source
This commit is contained in:
Asura 2022-12-07 19:31:32 -08:00 committed by Chieh Wang
parent dff5d55f50
commit 176ed43807
6 changed files with 495 additions and 590 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/client.rs
View File

@ -6,8 +6,6 @@ use cpal::{
}; };
use magnum_opus::{Channels::*, Decoder as AudioDecoder}; use magnum_opus::{Channels::*, Decoder as AudioDecoder};
use sha2::{Digest, Sha256}; use sha2::{Digest, Sha256};
#[cfg(any(target_os = "android", target_os = "ios", feature = "flutter"))]
use std::sync::atomic::Ordering;
use std::{ use std::{
collections::HashMap, collections::HashMap,
net::SocketAddr, net::SocketAddr,

269
src/keyboard.rs
View File

@ -2,14 +2,20 @@ use crate::client::get_key_state;
use crate::common::GrabState; use crate::common::GrabState;
#[cfg(feature = "flutter")] #[cfg(feature = "flutter")]
use crate::flutter::FlutterHandler; use crate::flutter::FlutterHandler;
use crate::platform;
use crate::ui_session_interface::Session; use crate::ui_session_interface::Session;
use hbb_common::{allow_err, log, message_proto::*}; use hbb_common::{log, message_proto::*};
use rdev::{Event, EventType, Key}; use rdev::{Event, EventType, Key};
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
use std::sync::{mpsc, Arc, Mutex, RwLock}; use std::sync::atomic::AtomicBool;
#[cfg(any(target_os = "windows", target_os = "macos"))]
use std::sync::atomic::Ordering;
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
use std::time::SystemTime; use std::time::SystemTime;
static mut IS_ALT_GR: bool = false;
pub static KEYBOARD_HOOKED: AtomicBool = AtomicBool::new(false);
#[cfg(feature = "flutter")] #[cfg(feature = "flutter")]
lazy_static::lazy_static! { lazy_static::lazy_static! {
pub static ref CUR_SESSION: Arc<Mutex<Option<Session<FlutterHandler>>>> = Default::default(); pub static ref CUR_SESSION: Arc<Mutex<Option<Session<FlutterHandler>>>> = Default::default();
@ -34,20 +40,27 @@ lazy_static::lazy_static! {
} }
pub mod client { pub mod client {
use super::{client_keyboard_mode, components, *}; use super::*;
pub fn get_keyboard_mode() -> String { pub fn get_keyboard_mode() -> String {
return components::get_keyboard_mode(); if let Some(handler) = CUR_SESSION.lock().unwrap().as_ref() {
handler.get_keyboard_mode()
} else {
"legacy".to_string()
}
} }
pub fn save_keyboard_mode(value: String) { pub fn save_keyboard_mode(value: String) {
components::save_keyboard_mode(value); release_remote_keys();
if let Some(handler) = CUR_SESSION.lock().unwrap().as_mut() {
handler.save_keyboard_mode(value);
}
} }
pub fn start_grab_loop() { pub fn start_grab_loop() {
let (sender, receiver) = mpsc::channel::<GrabState>(); let (sender, receiver) = mpsc::channel::<GrabState>();
unsafe { unsafe {
components::grab_loop(receiver); grab_loop(receiver);
*GRAB_SENDER.lock().unwrap() = Some(sender); *GRAB_SENDER.lock().unwrap() = Some(sender);
} }
change_grab_status(GrabState::Ready); change_grab_status(GrabState::Ready);
@ -55,7 +68,7 @@ pub mod client {
pub fn change_grab_status(state: GrabState) { pub fn change_grab_status(state: GrabState) {
if GrabState::Wait == state { if GrabState::Wait == state {
components::release_remote_keys(); release_remote_keys();
} }
unsafe { unsafe {
if let Some(sender) = &*GRAB_SENDER.lock().unwrap() { if let Some(sender) = &*GRAB_SENDER.lock().unwrap() {
@ -66,12 +79,12 @@ pub mod client {
} }
pub fn process_event(event: Event) { pub fn process_event(event: Event) {
if components::is_long_press(&event) { if is_long_press(&event) {
return; return;
} }
let key_event = components::event_to_key_event(&event); let key_event = event_to_key_event(&event);
log::info!("key event: {:?}", key_event); log::info!("key event: {:?}", key_event);
components::send_key_event(&key_event); send_key_event(&key_event);
} }
pub fn get_modifiers_state( pub fn get_modifiers_state(
@ -80,7 +93,7 @@ pub mod client {
shift: bool, shift: bool,
command: bool, command: bool,
) -> (bool, bool, bool, bool) { ) -> (bool, bool, bool, bool) {
components::get_modifiers_state(alt, ctrl, shift, command) get_modifiers_state(alt, ctrl, shift, command)
} }
pub fn legacy_modifiers( pub fn legacy_modifiers(
@ -90,30 +103,56 @@ pub mod client {
shift: bool, shift: bool,
command: bool, command: bool,
) { ) {
components::legacy_modifiers(key_event, alt, ctrl, shift, command); if alt
&& !crate::is_control_key(&key_event, &ControlKey::Alt)
&& !crate::is_control_key(&key_event, &ControlKey::RAlt)
{
key_event.modifiers.push(ControlKey::Alt.into());
}
if shift
&& !crate::is_control_key(&key_event, &ControlKey::Shift)
&& !crate::is_control_key(&key_event, &ControlKey::RShift)
{
key_event.modifiers.push(ControlKey::Shift.into());
}
if ctrl
&& !crate::is_control_key(&key_event, &ControlKey::Control)
&& !crate::is_control_key(&key_event, &ControlKey::RControl)
{
key_event.modifiers.push(ControlKey::Control.into());
}
if command
&& !crate::is_control_key(&key_event, &ControlKey::Meta)
&& !crate::is_control_key(&key_event, &ControlKey::RWin)
{
key_event.modifiers.push(ControlKey::Meta.into());
}
} }
pub fn lock_screen() { pub fn lock_screen() {
components::lock_screen(); let mut key_event = KeyEvent::new();
key_event.set_control_key(ControlKey::LockScreen);
key_event.down = true;
key_event.mode = KeyboardMode::Legacy.into();
send_key_event(&key_event);
} }
pub fn ctrl_alt_del() { pub fn ctrl_alt_del() {
components::ctrl_alt_del(); let mut key_event = KeyEvent::new();
if get_peer_platform() == "Windows" {
key_event.set_control_key(ControlKey::CtrlAltDel);
key_event.down = true;
} else {
key_event.set_control_key(ControlKey::Delete);
legacy_modifiers(&mut key_event, true, true, false, false);
key_event.press = true;
}
key_event.mode = KeyboardMode::Legacy.into();
send_key_event(&key_event);
} }
} }
pub mod server { pub fn grab_loop(recv: mpsc::Receiver<GrabState>) {
pub fn simulate() {}
}
mod components {
use super::*;
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::thread;
pub static KEYBOARD_HOOKED: AtomicBool = AtomicBool::new(false);
pub fn grab_loop(recv: mpsc::Receiver<GrabState>) {
thread::spawn(move || loop { thread::spawn(move || loop {
if let Some(state) = recv.recv().ok() { if let Some(state) = recv.recv().ok() {
match state { match state {
@ -174,9 +213,9 @@ mod components {
} }
} }
}); });
} }
pub fn is_long_press(event: &Event) -> bool { pub fn is_long_press(event: &Event) -> bool {
let mut keys = MODIFIERS_STATE.lock().unwrap(); let mut keys = MODIFIERS_STATE.lock().unwrap();
match event.event_type { match event.event_type {
EventType::KeyPress(k) => { EventType::KeyPress(k) => {
@ -189,9 +228,9 @@ mod components {
_ => {} _ => {}
}; };
return false; return false;
} }
pub fn release_remote_keys() { pub fn release_remote_keys() {
// todo!: client quit suddenly, how to release keys? // todo!: client quit suddenly, how to release keys?
let to_release = TO_RELEASE.lock().unwrap(); let to_release = TO_RELEASE.lock().unwrap();
let keys = to_release.iter().map(|&key| key).collect::<Vec<Key>>(); let keys = to_release.iter().map(|&key| key).collect::<Vec<Key>>();
@ -202,41 +241,26 @@ mod components {
log::info!("release key: {:?}", key); log::info!("release key: {:?}", key);
client::process_event(event); client::process_event(event);
} }
} }
pub fn get_keyboard_mode() -> String { pub fn get_keyboard_mode_enum() -> KeyboardMode {
if let Some(handler) = CUR_SESSION.lock().unwrap().as_ref() { match client::get_keyboard_mode().as_str() {
handler.get_keyboard_mode()
} else {
"legacy".to_string()
}
}
pub fn save_keyboard_mode(value: String) {
release_remote_keys();
if let Some(handler) = CUR_SESSION.lock().unwrap().as_mut() {
handler.save_keyboard_mode(value);
}
}
pub fn get_keyboard_mode_enum() -> KeyboardMode {
match get_keyboard_mode().as_str() {
"map" => KeyboardMode::Map, "map" => KeyboardMode::Map,
"translate" => KeyboardMode::Translate, "translate" => KeyboardMode::Translate,
_ => KeyboardMode::Legacy, _ => KeyboardMode::Legacy,
} }
} }
pub fn add_numlock_capslock_state(key_event: &mut KeyEvent) { pub fn add_numlock_capslock_state(key_event: &mut KeyEvent) {
if get_key_state(enigo::Key::CapsLock) { if get_key_state(enigo::Key::CapsLock) {
key_event.modifiers.push(ControlKey::CapsLock.into()); key_event.modifiers.push(ControlKey::CapsLock.into());
} }
if get_key_state(enigo::Key::NumLock) { if get_key_state(enigo::Key::NumLock) {
key_event.modifiers.push(ControlKey::NumLock.into()); key_event.modifiers.push(ControlKey::NumLock.into());
} }
} }
pub fn convert_numpad_keys(key: Key) -> Key { pub fn convert_numpad_keys(key: Key) -> Key {
if get_key_state(enigo::Key::NumLock) { if get_key_state(enigo::Key::NumLock) {
return key; return key;
} }
@ -254,14 +278,14 @@ mod components {
Key::Kp9 => Key::PageUp, Key::Kp9 => Key::PageUp,
_ => key, _ => key,
} }
} }
pub fn get_modifiers_state( pub fn get_modifiers_state(
alt: bool, alt: bool,
ctrl: bool, ctrl: bool,
shift: bool, shift: bool,
command: bool, command: bool,
) -> (bool, bool, bool, bool) { ) -> (bool, bool, bool, bool) {
let modifiers_lock = MODIFIERS_STATE.lock().unwrap(); let modifiers_lock = MODIFIERS_STATE.lock().unwrap();
let ctrl = *modifiers_lock.get(&Key::ControlLeft).unwrap() let ctrl = *modifiers_lock.get(&Key::ControlLeft).unwrap()
|| *modifiers_lock.get(&Key::ControlRight).unwrap() || *modifiers_lock.get(&Key::ControlRight).unwrap()
@ -272,14 +296,13 @@ mod components {
let command = *modifiers_lock.get(&Key::MetaLeft).unwrap() let command = *modifiers_lock.get(&Key::MetaLeft).unwrap()
|| *modifiers_lock.get(&Key::MetaRight).unwrap() || *modifiers_lock.get(&Key::MetaRight).unwrap()
|| command; || command;
let alt = *modifiers_lock.get(&Key::Alt).unwrap() let alt =
|| *modifiers_lock.get(&Key::AltGr).unwrap() *modifiers_lock.get(&Key::Alt).unwrap() || *modifiers_lock.get(&Key::AltGr).unwrap() || alt;
|| alt;
(alt, ctrl, shift, command) (alt, ctrl, shift, command)
} }
fn update_modifiers_state(event: &Event) { fn update_modifiers_state(event: &Event) {
// for mouse // for mouse
let mut keys = MODIFIERS_STATE.lock().unwrap(); let mut keys = MODIFIERS_STATE.lock().unwrap();
match event.event_type { match event.event_type {
@ -295,42 +318,9 @@ mod components {
} }
_ => {} _ => {}
}; };
} }
pub fn legacy_modifiers( pub fn event_to_key_event(event: &Event) -> KeyEvent {
key_event: &mut KeyEvent,
alt: bool,
ctrl: bool,
shift: bool,
command: bool,
) {
if alt
&& !crate::is_control_key(&key_event, &ControlKey::Alt)
&& !crate::is_control_key(&key_event, &ControlKey::RAlt)
{
key_event.modifiers.push(ControlKey::Alt.into());
}
if shift
&& !crate::is_control_key(&key_event, &ControlKey::Shift)
&& !crate::is_control_key(&key_event, &ControlKey::RShift)
{
key_event.modifiers.push(ControlKey::Shift.into());
}
if ctrl
&& !crate::is_control_key(&key_event, &ControlKey::Control)
&& !crate::is_control_key(&key_event, &ControlKey::RControl)
{
key_event.modifiers.push(ControlKey::Control.into());
}
if command
&& !crate::is_control_key(&key_event, &ControlKey::Meta)
&& !crate::is_control_key(&key_event, &ControlKey::RWin)
{
key_event.modifiers.push(ControlKey::Meta.into());
}
}
pub fn event_to_key_event(event: &Event) -> KeyEvent {
let mut key_event = KeyEvent::new(); let mut key_event = KeyEvent::new();
update_modifiers_state(event); update_modifiers_state(event);
@ -350,22 +340,22 @@ mod components {
key_event.mode = keyboard_mode.into(); key_event.mode = keyboard_mode.into();
match keyboard_mode { match keyboard_mode {
KeyboardMode::Map => { KeyboardMode::Map => {
client_keyboard_mode::map_keyboard_mode(event, &mut key_event); map_keyboard_mode(event, &mut key_event);
} }
KeyboardMode::Translate => { KeyboardMode::Translate => {
client_keyboard_mode::translate_keyboard_mode(event, &mut key_event); translate_keyboard_mode(event, &mut key_event);
} }
_ => { _ => {
client_keyboard_mode::legacy_keyboard_mode(event, &mut key_event); legacy_keyboard_mode(event, &mut key_event);
} }
}; };
#[cfg(not(any(target_os = "android", target_os = "ios")))] #[cfg(not(any(target_os = "android", target_os = "ios")))]
add_numlock_capslock_state(&mut key_event); add_numlock_capslock_state(&mut key_event);
return key_event; return key_event;
} }
pub fn event_type_to_event(event_type: EventType) -> Event { pub fn event_type_to_event(event_type: EventType) -> Event {
Event { Event {
event_type, event_type,
time: SystemTime::now(), time: SystemTime::now(),
@ -373,56 +363,26 @@ mod components {
code: 0, code: 0,
scan_code: 0, scan_code: 0,
} }
} }
pub fn ctrl_alt_del() { #[cfg(feature = "flutter")]
let mut key_event = KeyEvent::new(); pub fn send_key_event(key_event: &KeyEvent) {
if get_peer_platform() == "Windows" {
key_event.set_control_key(ControlKey::CtrlAltDel);
key_event.down = true;
} else {
key_event.set_control_key(ControlKey::Delete);
legacy_modifiers(&mut key_event, true, true, false, false);
key_event.press = true;
}
key_event.mode = KeyboardMode::Legacy.into();
send_key_event(&key_event);
}
pub fn lock_screen() {
let mut key_event = KeyEvent::new();
key_event.set_control_key(ControlKey::LockScreen);
key_event.down = true;
key_event.mode = KeyboardMode::Legacy.into();
send_key_event(&key_event);
}
#[cfg(feature = "flutter")]
pub fn send_key_event(key_event: &KeyEvent) {
if let Some(handler) = CUR_SESSION.lock().unwrap().as_ref() { if let Some(handler) = CUR_SESSION.lock().unwrap().as_ref() {
log::info!("Sending key even {:?}", key_event); log::info!("Sending key even {:?}", key_event);
handler.send_key_event(key_event); handler.send_key_event(key_event);
} }
} }
pub fn get_peer_platform() -> String { pub fn get_peer_platform() -> String {
if let Some(handler) = CUR_SESSION.lock().unwrap().as_ref() { if let Some(handler) = CUR_SESSION.lock().unwrap().as_ref() {
handler.peer_platform() handler.peer_platform()
} else { } else {
log::error!("get peer platform error"); log::error!("get peer platform error");
"Windows".to_string() "Windows".to_string()
} }
}
} }
mod client_keyboard_mode { pub fn legacy_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
use super::*;
use components;
use rdev::EventType;
static mut IS_ALT_GR: bool = false;
pub fn legacy_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
// legacy mode(0): Generate characters locally, look for keycode on other side. // legacy mode(0): Generate characters locally, look for keycode on other side.
let (mut key, down_or_up) = match event.event_type { let (mut key, down_or_up) = match event.event_type {
EventType::KeyPress(key) => (key, true), EventType::KeyPress(key) => (key, true),
@ -432,17 +392,16 @@ mod client_keyboard_mode {
} }
}; };
let peer = components::get_peer_platform(); let peer = get_peer_platform();
let is_win = peer == "Windows"; let is_win = peer == "Windows";
if is_win { if is_win {
key = components::convert_numpad_keys(key); key = convert_numpad_keys(key);
} }
let alt = get_key_state(enigo::Key::Alt); let alt = get_key_state(enigo::Key::Alt);
#[cfg(windows)] #[cfg(windows)]
let ctrl = { let ctrl = {
let mut tmp = let mut tmp = get_key_state(enigo::Key::Control) || get_key_state(enigo::Key::RightControl);
get_key_state(enigo::Key::Control) || get_key_state(enigo::Key::RightControl);
unsafe { unsafe {
if IS_ALT_GR { if IS_ALT_GR {
if alt || key == Key::AltGr { if alt || key == Key::AltGr {
@ -506,7 +465,7 @@ mod client_keyboard_mode {
Key::UpArrow => Some(ControlKey::UpArrow), Key::UpArrow => Some(ControlKey::UpArrow),
Key::Delete => { Key::Delete => {
if is_win && ctrl && alt { if is_win && ctrl && alt {
components::ctrl_alt_del(); client::ctrl_alt_del();
return; return;
} }
Some(ControlKey::Delete) Some(ControlKey::Delete)
@ -627,7 +586,7 @@ mod client_keyboard_mode {
} }
if chr != '\0' { if chr != '\0' {
if chr == 'l' && is_win && command { if chr == 'l' && is_win && command {
components::lock_screen(); client::lock_screen();
return; return;
} }
key_event.set_chr(chr as _); key_event.set_chr(chr as _);
@ -636,17 +595,16 @@ mod client_keyboard_mode {
return; return;
} }
} }
let (alt, ctrl, shift, command) = let (alt, ctrl, shift, command) = get_modifiers_state(alt, ctrl, shift, command);
components::get_modifiers_state(alt, ctrl, shift, command); client::legacy_modifiers(key_event, alt, ctrl, shift, command);
components::legacy_modifiers(key_event, alt, ctrl, shift, command);
if down_or_up == true { if down_or_up == true {
key_event.down = true; key_event.down = true;
} }
} }
pub fn map_keyboard_mode(event: &Event, key_event: &mut KeyEvent) { pub fn map_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
let peer = components::get_peer_platform(); let peer = get_peer_platform();
let key = match event.event_type { let key = match event.event_type {
EventType::KeyPress(key) => { EventType::KeyPress(key) => {
@ -665,17 +623,6 @@ mod client_keyboard_mode {
_ => rdev::linux_keycode_from_key(key).unwrap_or_default().into(), _ => rdev::linux_keycode_from_key(key).unwrap_or_default().into(),
}; };
key_event.set_chr(keycode); key_event.set_chr(keycode);
}
pub fn translate_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {}
} }
pub mod server_keyboard_mode { pub fn translate_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {}
use super::*;
pub fn legacy_keyboard_mode(key_event: &KeyEvent) {}
pub fn map_keyboard_mode(key_event: &KeyEvent) {}
pub fn translate_keyboard_mode(key_event: &KeyEvent) {}
}

19
src/platform/linux.rs
View File

@ -716,22 +716,3 @@ pub fn get_double_click_time() -> u32 {
} }
} }
pub mod keyboard {
use crate::common::GrabState;
use hbb_common::{allow_err, log, message_proto::*};
use rdev::{Event, EventType, Key};
use std::sync::mpsc;
use std::thread;
pub fn _legacy_keyboard_mode(event: &Event, key_event: &KeyEvent) {
log::info!("{:?}", event);
}
pub fn _client_map_keyboard_mode(event: &Event, key_event: &KeyEvent) {
}
pub fn _translate_keyboard_mode(event: &Event, key_event: &KeyEvent) {}
}

4
src/platform/macos.rs
View File

@ -542,7 +542,3 @@ pub fn get_double_click_time() -> u32 {
// to-do: https://github.com/servo/core-foundation-rs/blob/786895643140fa0ee4f913d7b4aeb0c4626b2085/cocoa/src/appkit.rs#L2823 // to-do: https://github.com/servo/core-foundation-rs/blob/786895643140fa0ee4f913d7b4aeb0c4626b2085/cocoa/src/appkit.rs#L2823
500 as _ 500 as _
} }
pub mod keyboard{
}

14
src/platform/windows.rs
View File

@ -1712,17 +1712,3 @@ pub fn send_message_to_hnwd(
} }
return true; return true;
} }
pub mod keyboard {
use crate::common::GrabState;
use hbb_common::{allow_err, log, message_proto::*};
use rdev::{Event, EventType, Key};
use std::sync::mpsc;
use crate::keyboard;
}

3
src/server/input_service.rs
View File

@ -1002,9 +1002,6 @@ pub fn handle_key_(evt: &KeyEvent) {
} }
match evt.mode.unwrap() { match evt.mode.unwrap() {
KeyboardMode::Legacy => {
legacy_keyboard_mode(evt);
}
KeyboardMode::Map => { KeyboardMode::Map => {
map_keyboard_mode(evt); map_keyboard_mode(evt);
} }