WIP org.freedesktop.a11y.Manager dbus protocol

Author: ids1024

Cargo.lock

@@ -64,6 +64,7 @@ rand = "0.9.0"
 reis = { version = "0.4", features = ["calloop"] }
 # CLI arguments
 clap_lex = "0.7"
+futures-executor = "0.3.31"
 
 [dependencies.id_tree]
 branch = "feature/copy_clone"

Cargo.toml

@@ -0,0 +1,307 @@
+// https://gitlab.gnome.org/mwcampbell/mutter/-/blob/newton/data/dbus-interfaces/org.freedesktop.a11y.xml
+//
+// TODO: Restrict protocol acccess?
+
+use futures_executor::ThreadPool;
+use smithay::backend::input::KeyState;
+use std::collections::HashMap;
+use std::collections::HashSet;
+use std::sync::{Arc, Mutex};
+use std::{error::Error, future::pending};
+use xkbcommon::xkb::{self, Keysym};
+use zbus::message::Header;
+use zbus::names::UniqueName;
+use zbus::SignalContext;
+use std::sync::OnceLock;
+
+// As defined in at-spi2-core
+const ATSPI_DEVICE_A11Y_MANAGER_VIRTUAL_MOD_START: u32 = 15;
+
+#[derive(Debug, Default)]
+struct Client {
+    grabbed: bool,
+    watched: bool,
+    virtual_modifiers: Vec<Keysym>,
+    keystrokes: Vec<(Keysym, Modifiers)>,
+}
+
+#[derive(Debug, Default)]
+struct Clients(HashMap<UniqueName<'static>, Client>);
+
+impl Clients {
+    fn get(&mut self, name: &UniqueName<'_>) -> &mut Client {
+        self.0.entry(name.to_owned()).or_default()
+    }
+
+    fn remove(&mut self, name: &UniqueName<'_>) -> bool {
+        self.0.remove(&name.to_owned()).is_some()
+    }
+}
+
+#[derive(Debug)]
+pub struct A11yKeyboardMonitorState {
+    executor: ThreadPool,
+    clients: Arc<Mutex<Clients>>,
+    active_virtual_modifiers: HashSet<Keysym>,
+    conn: Arc<OnceLock<zbus::Connection>>,
+}
+
+impl A11yKeyboardMonitorState {
+    pub fn new() -> Self {
+        let clients = Arc::new(Mutex::new(Clients::default()));
+        let clients_clone = clients.clone();
+        let executor = ThreadPool::builder().pool_size(1).create().unwrap();
+        let conn_cell = Arc::new(OnceLock::new());
+        let conn_cell_clone = conn_cell.clone();
+        executor.spawn_ok(async move {
+            match serve(clients_clone).await {
+                Ok(conn) => {
+                    conn_cell_clone.set(conn).unwrap();
+                }
+                Err(err) => {
+                    tracing::error!("Failed to serve `org.freedesktop.a11y.Manager`: {err}");
+                }
+            }
+        });
+        Self {
+            clients,
+            executor,
+            active_virtual_modifiers: HashSet::new(),
+            conn: conn_cell,
+        }
+    }
+
+    pub fn has_virtual_modifier(&self, keysym: Keysym) -> bool {
+        self.clients
+            .lock()
+            .unwrap()
+            .0
+            .values()
+            .any(|client| client.virtual_modifiers.contains(&keysym))
+    }
+
+    pub fn key_event(
+        &self,
+        modifiers: &smithay::input::keyboard::ModifiersState,
+        keysym: &smithay::input::keyboard::KeysymHandle,
+        state: smithay::backend::input::KeyState,
+        unichar: char,
+    ) {
+        let Some(conn) = self.conn.get() else {
+            return;
+        };
+
+        // Test if any client is watching key input
+        if !self
+            .clients
+            .lock()
+            .unwrap()
+            .0
+            .values()
+            .any(|client| client.watched)
+        {
+            return;
+        }
+
+        let signal_context = SignalContext::new(conn, "/org/freedesktop/a11y/Manager").unwrap();
+        let released = match state {
+            KeyState::Pressed => false,
+            KeyState::Released => true,
+        };
+        // XXX keysym and keycode?
+        // XXX need to add virtual modifiers?
+        let future = KeyboardMonitor::key_event(
+            signal_context,
+            released,
+            modifiers.serialized.depressed,
+            keysym.modified_sym().raw(),
+            unichar as u32,
+            keysym.raw_code().raw() as u16,
+        );
+        self.executor.spawn_ok(async {
+            future.await;
+        });
+    }
+}
+
+trait A11yKeyboardMonitorHandler {}
+
+struct KeyboardMonitor {
+    clients: Arc<Mutex<Clients>>,
+    //mod_names: Vec<String>,
+}
+
+impl KeyboardMonitor {
+    fn map_mods(&self, virtual_mods: &[Keysym], mods: u32) -> Vec<&str> {
+        /*
+        // TODO warn unrecognized modifier
+        self.mod_names
+            .iter()
+            .map(|name| name.as_str())
+            .enumerate()
+            .filter(|(i, _)| {
+                (*i as u32) < ATSPI_DEVICE_A11Y_MANAGER_VIRTUAL_MOD_START && (mods & (1 << i) != 0)
+            })
+            .map(|(_, name)| name)
+            // XXX unwrap
+            .chain(
+                virtual_mods
+                    .iter()
+                    .enumerate()
+                    .filter(|(i, _)| {
+                        mods & (1 << (*i as u32 + ATSPI_DEVICE_A11Y_MANAGER_VIRTUAL_MOD_START)) != 0
+                    })
+                    .map(|(_, keysym)| keysym.name().unwrap()),
+            )
+            .collect()
+        */
+        Vec::new()
+    }
+}
+
+#[zbus::interface(name = "org.freedesktop.a11y.KeyboardMonitor")]
+impl KeyboardMonitor {
+    fn grab_keyboard(&mut self, #[zbus(header)] header: Header<'_>) {
+        if let Some(sender) = header.sender() {
+            let mut clients = self.clients.lock().unwrap();
+            clients.get(sender).grabbed = true;
+            eprintln!("grab keyboard by {}", sender);
+        }
+    }
+
+    fn ungrab_keyboard(&mut self, #[zbus(header)] header: Header<'_>) {
+        if let Some(sender) = header.sender() {
+            let mut clients = self.clients.lock().unwrap();
+            clients.get(sender).grabbed = false;
+            eprintln!("ungrab keyboard by {}", sender);
+        }
+    }
+
+    fn watch_keyboard(&mut self, #[zbus(header)] header: Header<'_>) {
+        if let Some(sender) = header.sender() {
+            let mut clients = self.clients.lock().unwrap();
+            clients.get(sender).watched = true;
+            eprintln!("watch keyboard by {}", sender);
+        }
+    }
+
+    fn unwatch_keyboard(&mut self, #[zbus(header)] header: Header<'_>) {
+        if let Some(sender) = header.sender() {
+            let mut clients = self.clients.lock().unwrap();
+            clients.get(sender).watched = false;
+            eprintln!("unwatch keyboard by {}", sender);
+        }
+    }
+
+    fn set_key_grabs(&self, virtual_modifiers: Vec<u32>, keystrokes: Vec<(u32, u32)>) {
+        let virtual_modifiers = virtual_modifiers
+            .into_iter()
+            .map(Keysym::from)
+            .collect::<Vec<_>>();
+        let keystrokes = keystrokes
+            .into_iter()
+            .map(|(k, mods)| (Keysym::from(k), self.map_mods(&virtual_modifiers, mods)))
+            .collect::<Vec<_>>();
+        dbg!(virtual_modifiers, keystrokes);
+    }
+
+    // TODO signal
+    #[zbus(signal)]
+    async fn key_event(
+        ctx: SignalContext<'_>,
+        released: bool,
+        state: u32,
+        keysym: u32,
+        unichar: u32,
+        keycode: u16,
+    ) -> zbus::Result<()>;
+}
+
+#[derive(Debug)]
+struct Modifiers(u32);
+
+enum Event {
+    GrabKeyboard,
+    UngrabKeyboard,
+    WatchKeyboard,
+    UnwatchKeyboard,
+    SetKeyGrabs {
+        virtual_modifiers: Vec<Keysym>,
+        keystrokes: Vec<(Keysym, Modifiers)>,
+    },
+}
+
+/*
+pub fn spawn() -> calloop::channel::Channel<Event> {
+    let (sender, channel) = calloop::channel::channel();
+
+    // TODO: Use calloop executor when it's confirmed to no longer be buggy
+    std::thread::spawn(|| {
+        let res = futures_executor::block_on(async {
+            let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
+            // XXX
+            // multiple layout mods?
+            let keymap = xkb::Keymap::new_from_names(
+                &context,
+                "",
+                "",
+                "",
+                "",
+                None,
+                xkb::KEYMAP_COMPILE_NO_FLAGS,
+            )
+            //xkb::Keymap::new_from_names(&context, "", "pc105", "us", "", None, xkb::KEYMAP_COMPILE_NO_FLAGS)
+            //xkb::Keymap::new_from_names(&context, "", "pc105", "ru", "", None, xkb::KEYMAP_COMPILE_NO_FLAGS)
+            //xkb::Keymap::new_from_names(&context, "", "pc105", "es,de,jp", "", None, xkb::KEYMAP_COMPILE_NO_FLAGS)
+            .unwrap();
+            let mut mod_names = Vec::new();
+            for i in 0.. {
+                let name = keymap.mod_get_name(i);
+                if name == "" {
+                    break;
+                }
+                mod_names.push(name.to_string());
+            }
+            dbg!(&mod_names);
+
+            let keyboard_monitor = KeyboardMonitor { mod_names };
+            let _conn = zbus::connection::Builder::session()?
+                .name("org.freedesktop.a11y.Manager")?
+                .serve_at("/org/freedesktop/a11y/Manager", keyboard_monitor)?
+                .build()
+                .await?;
+
+            pending::<zbus::Result<()>>().await
+        });
+        if let Err(err) = res {
+            tracing::error!("Failed to serve `org.freedesktop.a11y.Manager`: {err}");
+        }
+    });
+
+    channel
+}
+*/
+
+/*
+async fn serve() -> zbus::Result<()> {
+    let keyboard_monitor = KeyboardMonitor {};
+    let _conn = zbus::connection::Builder::session()?
+        .name("org.freedesktop.a11y.Manager")?
+        .serve_at("/org/freedesktop/a11y/Manager", keyboard_monitor)?
+        .build()
+        .await?;
+
+    pending::<zbus::Result<()>>().await
+}
+*/
+
+async fn serve(
+    clients: Arc<Mutex<Clients>>,
+    ) -> zbus::Result<zbus::Connection> {
+    let keyboard_monitor = KeyboardMonitor {clients};
+    zbus::connection::Builder::session()?
+        .name("org.freedesktop.a11y.Manager")?
+        .serve_at("/org/freedesktop/a11y/Manager", keyboard_monitor)?
+        .build()
+        .await
+}

src/dbus/a11y_keyboard_monitor.rs

@@ -4,6 +4,7 @@ use calloop::{InsertError, LoopHandle, RegistrationToken};
 use std::collections::HashMap;
 use zbus::blocking::{fdo::DBusProxy, Connection};
 
+pub mod a11y_keyboard_monitor;
 mod power;
 
 pub fn init(evlh: &LoopHandle<'static, State>) -> Result<Vec<RegistrationToken>> {

src/dbus/mod.rs

@@ -1557,12 +1557,15 @@ impl State {
                 .unwrap_or(false)
         });
 
+        // TODO update keyboard monitor
         self.common.atspi_ei.input(
             modifiers,
             &handle,
             event.state(),
             event.time() as u64 * 1000,
         );
+        let unichar = '\0'; // XXX
+        self.common.a11y_keyboard_monitor_state.key_event(modifiers, &handle, event.state(), unichar);
 
         // Leave move overview mode, if any modifier was released
         if let Some(Trigger::KeyboardMove(action_modifiers)) =

src/input/mod.rs

@@ -8,6 +8,7 @@ use crate::{
         x11::X11State,
     },
     config::{Config, OutputConfig, OutputState, ScreenFilter},
+    dbus::a11y_keyboard_monitor::A11yKeyboardMonitorState,
     input::{gestures::GestureState, PointerFocusState},
     shell::{grabs::SeatMoveGrabState, CosmicSurface, SeatExt, Shell},
     utils::prelude::OutputExt,
@@ -233,6 +234,7 @@ pub struct Common {
     pub xdg_decoration_state: XdgDecorationState,
     pub overlap_notify_state: OverlapNotifyState,
     pub a11y_state: A11yState,
+    pub a11y_keyboard_monitor_state: A11yKeyboardMonitorState,
 
     // shell-related wayland state
     pub xdg_shell_state: XdgShellState,
@@ -604,6 +606,8 @@ impl State {
 
         let a11y_state = A11yState::new::<State, _>(dh, client_is_privileged);
 
+        let a11y_keyboard_monitor_state = A11yKeyboardMonitorState::new();
+
         // TODO: Restrict to only specific client?
         let atspi_state = AtspiState::new::<State, _>(dh, |_| true);
 
@@ -661,6 +665,7 @@ impl State {
                 xdg_foreign_state,
                 workspace_state,
                 a11y_state,
+                a11y_keyboard_monitor_state,
                 xwayland_scale: None,
                 xwayland_state: None,
                 xwayland_shell_state,