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 sha2::{Digest, Sha256};
#[cfg(any(target_os = "android", target_os = "ios", feature = "flutter"))]
use std::sync::atomic::Ordering;
use std::{
collections::HashMap,
net::SocketAddr,

269
src/keyboard.rs
View File

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

14
src/platform/windows.rs
View File

@ -1712,17 +1712,3 @@ pub fn send_message_to_hnwd(
}
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() {
KeyboardMode::Legacy => {
legacy_keyboard_mode(evt);
}
KeyboardMode::Map => {
map_keyboard_mode(evt);
}