feat: use set_keymap and get_keymap to proper handle keymap

Author: Bot-wxt1221

src/wayland/virtual_keyboard/virtual_keyboard_handle.rs

@@ -1,21 +1,22 @@
-use std::os::unix::io::OwnedFd;
 use std::{
     fmt,
+    fs::File,
+    io::Read,
+    os::unix::io::OwnedFd,
     sync::{Arc, Mutex},
 };
 
+use memmap2::MmapOptions;
 use tracing::debug;
 use wayland_protocols_misc::zwp_virtual_keyboard_v1::server::zwp_virtual_keyboard_v1::Error::NoKeymap;
 use wayland_protocols_misc::zwp_virtual_keyboard_v1::server::zwp_virtual_keyboard_v1::{
     self, ZwpVirtualKeyboardV1,
 };
-use wayland_server::{
-    backend::ClientId, protocol::wl_keyboard::KeymapFormat, Client, DataInit, Dispatch, DisplayHandle,
-    Resource,
-};
+use wayland_server::protocol::wl_keyboard::KeymapFormat;
+use wayland_server::{backend::ClientId, Client, DataInit, Dispatch, DisplayHandle, Resource};
 use xkbcommon::xkb;
 
-use crate::input::keyboard::{KeyboardTarget, KeymapFile, ModifiersState};
+use crate::input::keyboard::{KeyboardTarget, Keymap, ModifiersState};
 use crate::wayland::input_method::InputMethodSeat;
 use crate::{
     input::{Seat, SeatHandler},
@@ -33,15 +34,18 @@ pub(crate) struct VirtualKeyboard {
 }
 
 struct VirtualKeyboardState {
-    keymap: KeymapFile,
+    keymap: Keymap,
     mods: ModifiersState,
     state: xkb::State,
 }
 
 impl fmt::Debug for VirtualKeyboardState {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("VirtualKeyboardState")
-            .field("keymap", &self.keymap.id())
+            .field(
+                "keymap",
+                &self.keymap.inner.get_as_string(xkb::KEYMAP_FORMAT_USE_ORIGINAL),
+            )
             .field("mods", &self.mods)
             .field("state", &self.state.get_raw_ptr())
             .finish()
@@ -96,7 +100,7 @@ where
         };
         match request {
             zwp_virtual_keyboard_v1::Request::Keymap { format, fd, size } => {
-                update_keymap(data, format, fd, size as usize);
+                update_keymap(user_data, data, format, fd, size as usize);
             }
 
             zwp_virtual_keyboard_v1::Request::Key { time, key, state } => {
@@ -116,10 +120,11 @@ where
                     .map(|grab| grab.client().as_ref() == Some(client))
                     .unwrap_or(false)
                 {
+                    let old_keymap = keyboard_handle.get_keymap().clone();
+                    let _ = keyboard_handle.set_keymap(user_data, &vk_state.keymap);
                     use wayland_server::protocol::wl_keyboard::KeyState;
                     let mut internal = keyboard_handle.arc.internal.lock().unwrap();
                     let focus = internal.focus.as_mut().map(|(focus, _)| focus);
-                    keyboard_handle.send_keymap(user_data, &focus, &vk_state.keymap, vk_state.mods);
                     if let Some(wl_surface) = focus.and_then(|f| f.wl_surface()) {
                         for_each_focused_kbds(&data.seat, &wl_surface, |kbd| {
                             // This should be wl_keyboard::KeyState, but the protocol does not state
@@ -133,18 +138,18 @@ where
                             kbd.key(SERIAL_COUNTER.next_serial().0, time, key, key_state);
                         });
                     }
+                    drop(internal);
+                    keyboard_handle.set_keymap(user_data, &old_keymap);
                 } else {
-                    {
-                        let mut internal = keyboard_handle.arc.internal.lock().unwrap();
-                        let focus = internal.focus.as_mut().map(|(focus, _)| focus);
-                        keyboard_handle.send_keymap(user_data, &focus, &vk_state.keymap, vk_state.mods);
-                    }
+                    let old_keymap = keyboard_handle.get_keymap().clone();
+                    let _ = keyboard_handle.set_keymap(user_data, &vk_state.keymap);
                     let key_state = if state == 1 {
                         KeyState::Pressed
                     } else {
                         KeyState::Released
                     };
-                    user_data.on_keyboard_event((key + 8).into(), key_state, time, keyboard_handle);
+                    user_data.on_keyboard_event((key + 8).into(), key_state, time, keyboard_handle.clone());
+                    keyboard_handle.set_keymap(user_data, &old_keymap);
                 }
             }
             zwp_virtual_keyboard_v1::Request::Modifiers {
@@ -171,15 +176,13 @@ where
 
                 // Ensure virtual keyboard's keymap is active.
                 let keyboard_handle = data.seat.get_keyboard().unwrap();
+                let old_keymap = keyboard_handle.get_keymap().clone();
+                let _ = keyboard_handle.set_keymap(user_data, &state.keymap);
                 {
                     let mut internal = keyboard_handle.arc.internal.lock().unwrap();
                     let focus = internal.focus.as_mut().map(|(focus, _)| focus);
-                    let keymap_changed =
-                        keyboard_handle.send_keymap(user_data, &focus, &state.keymap, state.mods);
-                    if !keymap_changed {
-                        if let Some(focus) = focus {
-                            focus.modifiers(&data.seat, user_data, state.mods, SERIAL_COUNTER.next_serial());
-                        }
+                    if let Some(focus) = focus {
+                        focus.modifiers(&data.seat, user_data, state.mods, SERIAL_COUNTER.next_serial());
                     }
                 }
                 if ime_keyboard_grabbed.is_none()
@@ -189,9 +192,10 @@ where
                         mods_depressed,
                         mods_latched,
                         mods_locked,
-                        keyboard_handle,
+                        keyboard_handle.clone(),
                     );
                 }
+                keyboard_handle.set_keymap(user_data, &old_keymap);
             }
             zwp_virtual_keyboard_v1::Request::Destroy => {
                 // Nothing to do
@@ -212,8 +216,13 @@ where
 /// Handle the zwp_virtual_keyboard_v1::keymap request.
 ///
 /// The `true` returns when keymap was properly loaded.
-fn update_keymap<D>(data: &VirtualKeyboardUserData<D>, format: u32, fd: OwnedFd, size: usize)
-where
+fn update_keymap<D>(
+    user_data: &mut D,
+    data: &VirtualKeyboardUserData<D>,
+    format: u32,
+    fd: OwnedFd,
+    size: usize,
+) where
     D: SeatHandler + 'static,
 {
     // Only libxkbcommon compatible keymaps are supported.
@@ -222,34 +231,27 @@ where
         return;
     }
 
-    let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
-    // SAFETY: we can map the keymap into the memory.
-    let new_keymap = match unsafe {
-        xkb::Keymap::new_from_fd(
-            &context,
-            fd,
-            size,
-            xkb::KEYMAP_FORMAT_TEXT_V1,
-            xkb::KEYMAP_COMPILE_NO_FLAGS,
-        )
-    } {
-        Ok(Some(new_keymap)) => new_keymap,
-        Ok(None) => {
-            debug!("Invalid libxkbcommon keymap");
-            return;
-        }
-        Err(err) => {
-            debug!("Could not map the keymap: {err:?}");
-            return;
-        }
+    let map = unsafe {
+        MmapOptions::new()
+            .len(size as usize)
+            .map_copy_read_only(&File::from(fd))
+            .unwrap()
     };
-
+    let keymap_string = String::from_utf8_lossy(&map[..]).to_string();
     // Store active virtual keyboard map.
     let mut inner = data.handle.inner.lock().unwrap();
     let mods = inner.state.take().map(|state| state.mods).unwrap_or_default();
+    let keyboard_handle = data.seat.get_keyboard().unwrap();
+    let old_keymap = keyboard_handle.get_keymap().clone();
+    let keymap = {
+        let _ = keyboard_handle.set_keymap_from_string(user_data, keymap_string);
+        keyboard_handle.get_keymap().clone()
+    };
+    let state = xkb::State::new(&keymap.inner);
     inner.state = Some(VirtualKeyboardState {
         mods,
-        keymap: KeymapFile::new(&new_keymap),
-        state: xkb::State::new(&new_keymap),
+        keymap: keymap.clone(),
+        state,
     });
+    keyboard_handle.set_keymap(user_data, &old_keymap);
 }