From aa1e1225320e50ceb8227a04a880afa06e113b6b Mon Sep 17 00:00:00 2001 From: fufesou <13586388+fufesou@users.noreply.github.com> Date: Sun, 25 Aug 2024 00:03:31 +0800 Subject: [PATCH] fix: revert key events to raw key events on Linux (#9161) Signed-off-by: fufesou --- flutter/lib/common/widgets/remote_input.dart | 13 +- flutter/lib/models/input_model.dart | 245 ++++++++++++++++++- src/flutter_ffi.rs | 21 ++ src/ui_session_interface.rs | 76 +++++- 4 files changed, 350 insertions(+), 5 deletions(-) diff --git a/flutter/lib/common/widgets/remote_input.dart b/flutter/lib/common/widgets/remote_input.dart index 73e5d8f39..fb19c4c23 100644 --- a/flutter/lib/common/widgets/remote_input.dart +++ b/flutter/lib/common/widgets/remote_input.dart @@ -27,6 +27,10 @@ class RawKeyFocusScope extends StatelessWidget { @override Widget build(BuildContext context) { + // https://github.com/flutter/flutter/issues/154053 + final useRawKeyEvents = isLinux && !isWeb; + // FIXME: On Windows, `AltGr` will generate `Alt` and `Control` key events, + // while `Alt` and `Control` are seperated key events for en-US input method. return FocusScope( autofocus: true, child: Focus( @@ -34,7 +38,14 @@ class RawKeyFocusScope extends StatelessWidget { canRequestFocus: true, focusNode: focusNode, onFocusChange: onFocusChange, - onKeyEvent: (node, event) => inputModel.handleKeyEvent(event), + onKey: useRawKeyEvents + ? (FocusNode data, RawKeyEvent event) => + inputModel.handleRawKeyEvent(event) + : null, + onKeyEvent: useRawKeyEvents + ? null + : (FocusNode node, KeyEvent event) => + inputModel.handleKeyEvent(event), child: child)); } } diff --git a/flutter/lib/models/input_model.dart b/flutter/lib/models/input_model.dart index 35f00c3e1..54e7a3f4d 100644 --- a/flutter/lib/models/input_model.dart +++ b/flutter/lib/models/input_model.dart @@ -177,6 +177,111 @@ class PointerEventToRust { } } +class ToReleaseRawKeys { + RawKeyEvent? lastLShiftKeyEvent; + RawKeyEvent? lastRShiftKeyEvent; + RawKeyEvent? lastLCtrlKeyEvent; + RawKeyEvent? lastRCtrlKeyEvent; + RawKeyEvent? lastLAltKeyEvent; + RawKeyEvent? lastRAltKeyEvent; + RawKeyEvent? lastLCommandKeyEvent; + RawKeyEvent? lastRCommandKeyEvent; + RawKeyEvent? lastSuperKeyEvent; + + reset() { + lastLShiftKeyEvent = null; + lastRShiftKeyEvent = null; + lastLCtrlKeyEvent = null; + lastRCtrlKeyEvent = null; + lastLAltKeyEvent = null; + lastRAltKeyEvent = null; + lastLCommandKeyEvent = null; + lastRCommandKeyEvent = null; + lastSuperKeyEvent = null; + } + + updateKeyDown(LogicalKeyboardKey logicKey, RawKeyDownEvent e) { + if (e.isAltPressed) { + if (logicKey == LogicalKeyboardKey.altLeft) { + lastLAltKeyEvent = e; + } else if (logicKey == LogicalKeyboardKey.altRight) { + lastRAltKeyEvent = e; + } + } else if (e.isControlPressed) { + if (logicKey == LogicalKeyboardKey.controlLeft) { + lastLCtrlKeyEvent = e; + } else if (logicKey == LogicalKeyboardKey.controlRight) { + lastRCtrlKeyEvent = e; + } + } else if (e.isShiftPressed) { + if (logicKey == LogicalKeyboardKey.shiftLeft) { + lastLShiftKeyEvent = e; + } else if (logicKey == LogicalKeyboardKey.shiftRight) { + lastRShiftKeyEvent = e; + } + } else if (e.isMetaPressed) { + if (logicKey == LogicalKeyboardKey.metaLeft) { + lastLCommandKeyEvent = e; + } else if (logicKey == LogicalKeyboardKey.metaRight) { + lastRCommandKeyEvent = e; + } else if (logicKey == LogicalKeyboardKey.superKey) { + lastSuperKeyEvent = e; + } + } + } + + updateKeyUp(LogicalKeyboardKey logicKey, RawKeyUpEvent e) { + if (e.isAltPressed) { + if (logicKey == LogicalKeyboardKey.altLeft) { + lastLAltKeyEvent = null; + } else if (logicKey == LogicalKeyboardKey.altRight) { + lastRAltKeyEvent = null; + } + } else if (e.isControlPressed) { + if (logicKey == LogicalKeyboardKey.controlLeft) { + lastLCtrlKeyEvent = null; + } else if (logicKey == LogicalKeyboardKey.controlRight) { + lastRCtrlKeyEvent = null; + } + } else if (e.isShiftPressed) { + if (logicKey == LogicalKeyboardKey.shiftLeft) { + lastLShiftKeyEvent = null; + } else if (logicKey == LogicalKeyboardKey.shiftRight) { + lastRShiftKeyEvent = null; + } + } else if (e.isMetaPressed) { + if (logicKey == LogicalKeyboardKey.metaLeft) { + lastLCommandKeyEvent = null; + } else if (logicKey == LogicalKeyboardKey.metaRight) { + lastRCommandKeyEvent = null; + } else if (logicKey == LogicalKeyboardKey.superKey) { + lastSuperKeyEvent = null; + } + } + } + + release(KeyEventResult Function(RawKeyEvent e) handleRawKeyEvent) { + for (final key in [ + lastLShiftKeyEvent, + lastRShiftKeyEvent, + lastLCtrlKeyEvent, + lastRCtrlKeyEvent, + lastLAltKeyEvent, + lastRAltKeyEvent, + lastLCommandKeyEvent, + lastRCommandKeyEvent, + lastSuperKeyEvent, + ]) { + if (key != null) { + handleRawKeyEvent(RawKeyUpEvent( + data: key.data, + character: key.character, + )); + } + } + } +} + class ToReleaseKeys { KeyEvent? lastLShiftKeyEvent; KeyEvent? lastRShiftKeyEvent; @@ -229,6 +334,7 @@ class InputModel { var alt = false; var command = false; + final ToReleaseRawKeys toReleaseRawKeys = ToReleaseRawKeys(); final ToReleaseKeys toReleaseKeys = ToReleaseKeys(); // trackpad @@ -361,6 +467,56 @@ class InputModel { } } + KeyEventResult handleRawKeyEvent(RawKeyEvent e) { + if (isViewOnly) return KeyEventResult.handled; + if ((isDesktop || isWebDesktop) && !isInputSourceFlutter) { + return KeyEventResult.handled; + } + + final key = e.logicalKey; + if (e is RawKeyDownEvent) { + if (!e.repeat) { + if (e.isAltPressed && !alt) { + alt = true; + } else if (e.isControlPressed && !ctrl) { + ctrl = true; + } else if (e.isShiftPressed && !shift) { + shift = true; + } else if (e.isMetaPressed && !command) { + command = true; + } + } + toReleaseRawKeys.updateKeyDown(key, e); + } + if (e is RawKeyUpEvent) { + if (key == LogicalKeyboardKey.altLeft || + key == LogicalKeyboardKey.altRight) { + alt = false; + } else if (key == LogicalKeyboardKey.controlLeft || + key == LogicalKeyboardKey.controlRight) { + ctrl = false; + } else if (key == LogicalKeyboardKey.shiftRight || + key == LogicalKeyboardKey.shiftLeft) { + shift = false; + } else if (key == LogicalKeyboardKey.metaLeft || + key == LogicalKeyboardKey.metaRight || + key == LogicalKeyboardKey.superKey) { + command = false; + } + + toReleaseRawKeys.updateKeyUp(key, e); + } + + // * Currently mobile does not enable map mode + if ((isDesktop || isWebDesktop) && keyboardMode == 'map') { + mapKeyboardModeRaw(e); + } else { + legacyKeyboardModeRaw(e); + } + + return KeyEventResult.handled; + } + KeyEventResult handleKeyEvent(KeyEvent e) { if (isViewOnly) return KeyEventResult.handled; if ((isDesktop || isWebDesktop) && !isInputSourceFlutter) { @@ -383,8 +539,10 @@ class InputModel { // * Currently mobile does not enable map mode if ((isDesktop || isWebDesktop)) { // FIXME: e.character is wrong for dead keys, eg: ^ in de - newKeyboardMode(e.character ?? '', e.physicalKey.usbHidUsage & 0xFFFF, - // Show repeat event be converted to "release+press" events? + newKeyboardMode( + e.character ?? '', + e.physicalKey.usbHidUsage & 0xFFFF, + // Show repeat event be converted to "release+press" events? e is KeyDownEvent || e is KeyRepeatEvent); } else { legacyKeyboardMode(e); @@ -419,6 +577,88 @@ class InputModel { downOrUp: down); } + void mapKeyboardModeRaw(RawKeyEvent e) { + int positionCode = -1; + int platformCode = -1; + bool down; + + if (e.data is RawKeyEventDataMacOs) { + RawKeyEventDataMacOs newData = e.data as RawKeyEventDataMacOs; + positionCode = newData.keyCode; + platformCode = newData.keyCode; + } else if (e.data is RawKeyEventDataWindows) { + RawKeyEventDataWindows newData = e.data as RawKeyEventDataWindows; + positionCode = newData.scanCode; + platformCode = newData.keyCode; + } else if (e.data is RawKeyEventDataLinux) { + RawKeyEventDataLinux newData = e.data as RawKeyEventDataLinux; + // scanCode and keyCode of RawKeyEventDataLinux are incorrect. + // 1. scanCode means keycode + // 2. keyCode means keysym + positionCode = newData.scanCode; + platformCode = newData.keyCode; + } else if (e.data is RawKeyEventDataAndroid) { + RawKeyEventDataAndroid newData = e.data as RawKeyEventDataAndroid; + positionCode = newData.scanCode + 8; + platformCode = newData.keyCode; + } else {} + + if (e is RawKeyDownEvent) { + down = true; + } else { + down = false; + } + inputRawKey(e.character ?? '', platformCode, positionCode, down); + } + + /// Send raw Key Event + void inputRawKey(String name, int platformCode, int positionCode, bool down) { + const capslock = 1; + const numlock = 2; + const scrolllock = 3; + int lockModes = 0; + if (HardwareKeyboard.instance.lockModesEnabled + .contains(KeyboardLockMode.capsLock)) { + lockModes |= (1 << capslock); + } + if (HardwareKeyboard.instance.lockModesEnabled + .contains(KeyboardLockMode.numLock)) { + lockModes |= (1 << numlock); + } + if (HardwareKeyboard.instance.lockModesEnabled + .contains(KeyboardLockMode.scrollLock)) { + lockModes |= (1 << scrolllock); + } + bind.sessionHandleFlutterRawKeyEvent( + sessionId: sessionId, + name: name, + platformCode: platformCode, + positionCode: positionCode, + lockModes: lockModes, + downOrUp: down); + } + + void legacyKeyboardModeRaw(RawKeyEvent e) { + if (e is RawKeyDownEvent) { + if (e.repeat) { + sendRawKey(e, press: true); + } else { + sendRawKey(e, down: true); + } + } + if (e is RawKeyUpEvent) { + sendRawKey(e); + } + } + + void sendRawKey(RawKeyEvent e, {bool? down, bool? press}) { + // for maximum compatibility + final label = physicalKeyMap[e.physicalKey.usbHidUsage] ?? + logicalKeyMap[e.logicalKey.keyId] ?? + e.logicalKey.keyLabel; + inputKey(label, down: down, press: press ?? false); + } + void legacyKeyboardMode(KeyEvent e) { if (e is KeyDownEvent) { sendKey(e, down: true); @@ -533,6 +773,7 @@ class InputModel { void enterOrLeave(bool enter) { toReleaseKeys.release(handleKeyEvent); + toReleaseRawKeys.release(handleRawKeyEvent); _pointerMovedAfterEnter = false; // Fix status diff --git a/src/flutter_ffi.rs b/src/flutter_ffi.rs index e310febb1..48efda3af 100644 --- a/src/flutter_ffi.rs +++ b/src/flutter_ffi.rs @@ -508,6 +508,27 @@ pub fn session_handle_flutter_key_event( } } +pub fn session_handle_flutter_raw_key_event( + session_id: SessionID, + name: String, + platform_code: i32, + position_code: i32, + lock_modes: i32, + down_or_up: bool, +) { + if let Some(session) = sessions::get_session_by_session_id(&session_id) { + let keyboard_mode = session.get_keyboard_mode(); + session.handle_flutter_raw_key_event( + &keyboard_mode, + &name, + platform_code, + position_code, + lock_modes, + down_or_up, + ); + } +} + // SyncReturn<()> is used to make sure enter() and leave() are executed in the sequence this function is called. // // If the cursor jumps between remote page of two connections, leave view and enter view will be called. diff --git a/src/ui_session_interface.rs b/src/ui_session_interface.rs index 423794be5..6686e5419 100644 --- a/src/ui_session_interface.rs +++ b/src/ui_session_interface.rs @@ -788,7 +788,7 @@ impl Session { } #[cfg(any(target_os = "ios"))] - pub fn handle_flutter_key_event( + pub fn handle_flutter_raw_key_event( &self, _keyboard_mode: &str, _name: &str, @@ -799,6 +799,78 @@ impl Session { ) { } + #[cfg(not(any(target_os = "ios")))] + pub fn handle_flutter_raw_key_event( + &self, + keyboard_mode: &str, + name: &str, + platform_code: i32, + position_code: i32, + lock_modes: i32, + down_or_up: bool, + ) { + if name == "flutter_key" { + self._handle_key_flutter_simulation(keyboard_mode, platform_code, down_or_up); + } else { + self._handle_raw_key_non_flutter_simulation( + keyboard_mode, + platform_code, + position_code, + lock_modes, + down_or_up, + ); + } + } + + #[cfg(not(any(target_os = "ios")))] + fn _handle_raw_key_non_flutter_simulation( + &self, + keyboard_mode: &str, + platform_code: i32, + position_code: i32, + lock_modes: i32, + down_or_up: bool, + ) { + if position_code < 0 || platform_code < 0 { + return; + } + let platform_code: u32 = platform_code as _; + let position_code: KeyCode = position_code as _; + + #[cfg(not(target_os = "windows"))] + let key = rdev::key_from_code(position_code) as rdev::Key; + // Windows requires special handling + #[cfg(target_os = "windows")] + let key = rdev::get_win_key(platform_code, position_code); + + let event_type = if down_or_up { + KeyPress(key) + } else { + KeyRelease(key) + }; + let event = Event { + time: SystemTime::now(), + unicode: None, + platform_code, + position_code: position_code as _, + event_type, + #[cfg(any(target_os = "windows", target_os = "macos"))] + extra_data: 0, + }; + keyboard::client::process_event(keyboard_mode, &event, Some(lock_modes)); + } + + #[cfg(any(target_os = "ios"))] + pub fn handle_flutter_key_event( + &self, + _keyboard_mode: &str, + _character: &str, + _usb_hid: i32, + _lock_modes: i32, + _down_or_up: bool, + ) { + } + #[cfg(not(any(target_os = "ios")))] pub fn handle_flutter_key_event( &self, @@ -870,7 +942,7 @@ impl Session { // We need to set the platform code (keysym) if is AltGr. // https://github.com/rustdesk/rustdesk/blob/07cf1b4db5ef2f925efd3b16b87c33ce03c94809/src/keyboard.rs#L1029 // https://github.com/flutter/flutter/issues/153811 - #[cfg(target_os = "linux")] + #[cfg(target_os = "linux")] let platform_code: u32 = position_code as _; let event_type = if down_or_up {