Add action preregistering api for xdg-desktop-portal

Author: tuxinal

Cargo.lock

@@ -16,7 +16,7 @@ napi-derive = { version = "2", optional = true }
 [target.'cfg(target_os = "linux")'.dependencies]
 xcb = { version = "1", features = ["x11", "xkb", "as-raw-xcb-connection"] }
 xkbcommon = { version = "0.8", features = ["x11"] }
-ashpd = { version = "0.10", features = ["wayland"] }
+ashpd = { version = "0.10", features = ["wayland", "async-std"], default-features = false }
 
 [features]
 default = ["node"]

Cargo.toml

@@ -2,16 +2,19 @@
 
 {
   packages = with pkgs; [
+    cmake
+    libclang
+    pkg-config
+
     xorg.libX11
     xorg.libXi
     xorg.libXtst
     xorg.libxcb
     libxkbcommon
     xorg.libxkbfile
-    cmake
-    libclang
-    pkg-config
+
     wayland
+
     ninja
     llvmPackages_latest.llvm
     cargo-xwin

devenv.nix

@@ -1,5 +1,10 @@
 export class Venbind {
-    startKeybinds(callback: (err: null | Error, id: number) => void): void
-    registerKeybind(keybind: string, keybindId: number): void;
-    unregisterKeybind(keybindId: number): void;
+  startKeybinds(callback: (err: null | Error, id: number) => void): void;
+  registerKeybind(keybind: string, keybindId: number): void;
+  unregisterKeybind(keybindId: number): void;
+  preregisterKeybinds(actions: PreRegisterAction[]): void;
+}
+export interface PreRegisterAction {
+  id: number
+  name: string
 }

lib/venbind.d.ts

@@ -8,6 +8,8 @@ use napi_derive::napi;
 
 use crate::structs::{KeybindId, KeybindTrigger};
 
+pub use crate::structs::PreRegisterAction;
+
 #[napi(ts_args_type = "callback: (err: null | Error, id: number) => void")]
 pub fn start_keybinds(callback: JsFunction) -> Result<()> {
     let (tx, rx) = channel::<KeybindTrigger>();
@@ -43,3 +45,15 @@ pub fn register_keybind(keybind: String, #[napi(ts_arg_type = "number")] id: Key
 pub fn unregister_keybind(#[napi(ts_arg_type = "number")] id: KeybindId) {
     crate::unregister_keybind(id);
 }
+
+#[napi]
+pub fn preregister_keybinds(#[napi(ts_arg_type = "PreRegisterAction[]")] actions: Vec<PreRegisterAction>) {
+    #[cfg(target_os = "linux")]
+    {
+        crate::platform::xdg_preregister_keybinds(actions).unwrap();
+    }
+    #[cfg(not(target_os = "linux"))]
+    {
+        panic!("Can't preregister keybinds on non-linux!");
+    }
+}

src/js.rs

@@ -1,6 +1,6 @@
 mod errors;
-#[cfg(all(feature = "node", not(test)))]
-pub mod js; // BREAKS TESTS
+#[cfg(feature = "node")]
+pub mod js;
 mod structs;
 
 #[cfg_attr(target_os = "linux", path = "linux.rs")]
@@ -27,16 +27,36 @@ pub fn unregister_keybind(id: KeybindId) {
 mod tests {
     use std::{sync::mpsc::channel, thread};
 
-    use crate::{register_keybind, start_keybinds, structs::KeybindTrigger};
+    use crate::{register_keybind, start_keybinds, structs::{KeybindTrigger, PreRegisterAction}};
     #[test]
     fn demo() {
         let (tx, rx) = channel::<KeybindTrigger>();
         thread::spawn(|| {
             start_keybinds(tx);
         });
         thread::sleep(std::time::Duration::from_secs(2));
-        register_keybind("shift+alt+m".to_string(), 1);
-        // register_keybind("SHIFT+CTRL+a".to_string(), 2);
+        #[cfg(target_os = "linux")]
+        if crate::is_wayland() || crate::use_xdg_on_x11() {
+            crate::xdg_preregister_keybinds(vec![
+                PreRegisterAction {
+                    id: 1,
+                    name: "Does a thing!".to_owned(),
+                },
+                PreRegisterAction {
+                    id: 2,
+                    name: "Does another thing!".to_owned(),
+                }
+            ]).unwrap();
+        } else {
+            register_keybind("shift+alt+m".to_string(), 1);
+            register_keybind("SHIFT+CTRL+a".to_string(), 2);
+        }
+        #[cfg(not(target_os = "linux"))]
+        {
+            register_keybind("shift+alt+m".to_string(), 1);
+            register_keybind("SHIFT+CTRL+a".to_string(), 2);
+        }
+        
         loop {
             match rx.recv() {
                 Err(err) => {

src/lib.rs

@@ -5,7 +5,7 @@ use ashpd::{
 use std::{
     cell::RefCell,
     env,
-    sync::{mpsc::Sender, LazyLock, Mutex, OnceLock},
+    sync::{mpsc::Sender, LazyLock, Mutex, OnceLock}
 };
 use uiohook_sys::{
     _event_type_EVENT_KEY_PRESSED, _uiohook_event, hook_run, hook_set_dispatch_proc,
@@ -14,8 +14,11 @@ use uiohook_sys::{
 use xcb::Extension;
 use xkbcommon::xkb::{self, State};
 
-use crate::errors::{Result, VenbindError};
 use crate::structs::{Keybind, KeybindId, KeybindTrigger, Keybinds};
+use crate::{
+    errors::{Result, VenbindError},
+    js::PreRegisterAction,
+};
 
 static KEYBINDS: LazyLock<Mutex<Keybinds>> = LazyLock::new(|| Mutex::new(Keybinds::default()));
 static TX: OnceLock<Sender<KeybindTrigger>> = OnceLock::new();
@@ -42,10 +45,9 @@ pub(crate) fn start_keybinds_internal(tx: Sender<KeybindTrigger>) -> Result<()>
 
 pub(crate) fn register_keybind_internal(keybind: String, id: KeybindId) -> Result<()> {
     if is_wayland() || use_xdg_on_x11() {
-        futures::executor::block_on(xdg_register_keybind(keybind, id))
-    } else {
-        uiohook_register_keybind(keybind, id)
+        panic!("Keybinds should be preregistered on wayland!");
     }
+    uiohook_register_keybind(keybind, id)
 }
 
 pub(crate) fn unregister_keybind_internal(id: KeybindId) -> Result<()> {
@@ -97,20 +99,19 @@ async fn xdg_input_thread() {
     }
 }
 
-async fn xdg_register_keybind(keybind: String, id: KeybindId) -> Result<()> {
-    let new_keybind = Keybind::from_string(keybind);
-    let mut keybinds = KEYBINDS.lock().unwrap();
-    keybinds.register_keybind(new_keybind.clone(), id);
-
-    let shortcut = NewShortcut::new(format!("{}", id), id.to_string())
-        .preferred_trigger(Some(new_keybind.to_string().as_str()));
-    let lock = XDG_STATE.lock().unwrap();
-    let state = lock.as_ref().unwrap();
-
-    state
-        .portal
-        .bind_shortcuts(&state.session, &[shortcut], None)
-        .await?;
+pub(crate) fn xdg_preregister_keybinds(actions: Vec<PreRegisterAction>) -> Result<()> {
+    futures::executor::block_on(async move {
+        let shortcuts: Vec<NewShortcut> = actions
+            .iter()
+            .map(|x| NewShortcut::new(format!("{}", x.id), x.name.clone()))
+            .collect();
+        let lock = XDG_STATE.lock().unwrap();
+        let state = lock.as_ref().unwrap();
+        state
+            .portal
+            .bind_shortcuts(&state.session, &shortcuts, None)
+            .await
+    })?;
     Ok(())
 }
 
@@ -186,7 +187,8 @@ fn uiohook_register_keybind(keybind: String, id: KeybindId) -> Result<()> {
 
 #[inline]
 pub(crate) fn is_wayland() -> bool {
-    env::var("WAYLAND_DISPLAY").is_ok()
+    env::var("XDG_SESSION_TYPE").is_ok_and(|x| x == "wayland".to_owned())
+        || env::var("WAYLAND_DISPLAY").is_ok()
 }
 
 #[inline]

src/linux.rs

@@ -2,6 +2,15 @@ use std::collections::HashMap;
 
 pub type KeybindId = u32;
 
+#[cfg(feature = "node")]
+use napi_derive::napi;
+
+#[cfg_attr(feature = "node", napi(object))]
+pub struct PreRegisterAction {
+    pub id: i32,
+    pub name: String,
+}
+
 #[derive(Default)]
 pub struct Keybinds {
     keybinds: HashMap<Keybind, KeybindId>,

src/structs.rs

@@ -17,8 +17,6 @@ static TX: OnceLock<Sender<KeybindTrigger>> = OnceLock::new();
 pub(crate) fn start_keybinds_internal(tx: Sender<KeybindTrigger>) -> Result<()> {
     TX.set(tx).unwrap();
 
-    // don't make a state with an xcb connection (state_new_from_device) so it only chooses the first layout
-    // TODO: if someone's first selected layout is not a latin based layout horrible things happen
     unsafe {
         hook_set_dispatch_proc(Some(dispatch_proc));
         if hook_run() != UIOHOOK_SUCCESS as i32 {