fix: revert key events to raw key events on Linux (#9161)

Signed-off-by: fufesou <linlong1266@gmail.com>

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));
   }
 }

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,
+      newKeyboardMode(
-      // Show repeat event be converted to "release+press" events?
+          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

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.

src/ui_session_interface.rs

@@ -788,7 +788,7 @@ impl<T: InvokeUiSession> Session<T> {
     }
 
     #[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<T: InvokeUiSession> Session<T> {
     ) {
     }
 
+    #[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,