Wayland support

Cargo.toml

@@ -9,7 +9,7 @@ readme = "README.md"
 repository = "https://github.com/amrbashir/global-hotkey"
 documentation = "https://docs.rs/global-hotkey"
 categories = ["gui"]
-rust-version = "1.71"
+rust-version = "1.77"
 
 [features]
 serde = ["dep:serde"]
@@ -22,6 +22,7 @@ once_cell = "1"
 thiserror = "2"
 serde = { version = "1", optional = true, features = ["derive"] }
 tracing = { version = "0.1", optional = true }
+itertools = "0.14.0"
 
 [target.'cfg(target_os = "macos")'.dependencies]
 objc2 = "0.6.0"
@@ -44,6 +45,9 @@ features = [
 [target.'cfg(any(target_os = "linux", target_os = "dragonfly", target_os = "freebsd", target_os = "openbsd", target_os = "netbsd"))'.dependencies]
 x11rb = { version = "0.13.1", features = ["xkb"] }
 xkeysym = "0.2.1"
+ashpd = "0.12.0"
+tokio = { version = "1.47.1", features = ["macros", "rt-multi-thread"] }
+futures = "0.3.31"
 
 [dev-dependencies]
 winit = "0.30"

README.md

@@ -4,12 +4,14 @@ global_hotkey lets you register Global HotKeys for Desktop Applications.
 
 - Windows
 - macOS
-- Linux (X11 Only)
+- Linux (X11/Wayland)
 
 ## Platform-specific notes:
 
 - On Windows a win32 event loop must be running on the thread. It doesn't need to be the main thread but you have to create the global hotkey manager on the same thread as the event loop.
 - On macOS, an event loop must be running on the main thread so you also need to create the global hotkey manager on the main thread.
+- Global HotKeys work differently on Linux/Wayland. See the [wayland](https://docs.rs/global-hotkey/latest/global_hotkey/wayland/index.html) module for more details.
+
 
 ## Example
 

src/lib.rs

@@ -10,12 +10,13 @@
 //!
 //! - Windows
 //! - macOS
-//! - Linux (X11 Only)
+//! - Linux (X11/Wayland)
 //!
 //! ## Platform-specific notes:
 //!
 //! - On Windows a win32 event loop must be running on the thread. It doesn't need to be the main thread but you have to create the global hotkey manager on the same thread as the event loop.
 //! - On macOS, an event loop must be running on the main thread so you also need to create the global hotkey manager on the main thread.
+//! - Global HotKeys work differently on Linux/Wayland. See the [`wayland`] module for more details.
 //!
 //! # Example
 //!
@@ -55,7 +56,15 @@ use once_cell::sync::{Lazy, OnceCell};
 
 mod error;
 pub mod hotkey;
+pub(crate) mod macros;
 mod platform_impl;
+pub mod wayland;
+
+use crate::macros::not_on_linux_cfg;
+use crate::macros::on_linux;
+use crate::macros::on_linux_cfg;
+use crate::wayland::WlHotKeyAction;
+use crate::wayland::WlNewHotKeyAction;
 
 pub use self::error::*;
 use hotkey::HotKey;
@@ -160,4 +169,88 @@ impl GlobalHotKeyManager {
         self.platform_impl.unregister_all(hotkeys)?;
         Ok(())
     }
+
+    /// Register a set of hotkey actions on Wayland.
+    ///
+    /// # Arguments
+    ///
+    /// * `app_id` - a constant string to identify the application. See the [official GNOME
+    ///   documentation](https://developer.gnome.org/documentation/tutorials/application-id.html) for
+    ///   more details about how to create an app id. This app id should correspond to the base
+    ///   name of the .desktop file for your app, installed in a standard location (e.g.
+    ///   `~/.local/share/applications/`).
+    ///
+    ///   If registering the app id fails, a warning will be thrown using the `tracing` library (if
+    ///   the `tracing` feature is enabled). This warning may be ignored in sandboxed applications
+    ///   (e.g. Flatpaks).
+    ///
+    ///   This argument will be ignored after the first call to this function.
+    ///
+    /// * `hotkeys` - a list of hotkey actions to register. Ideally, you should register all of
+    ///   your application's actions in one call to this function.
+    ///
+    /// See the [`wayland`] module for more information about how to register hotkeys on Wayland.
+    ///
+    /// ## Note
+    ///
+    /// This function has no effect if the user is not using Wayland.
+    pub fn wl_register_all(
+        &self,
+        app_id: impl Into<String>,
+        hotkeys: &[WlNewHotKeyAction],
+    ) -> crate::Result<()> {
+        self.wl_register_all_impl(app_id, hotkeys)
+    }
+
+    /// Unregister a set of hotkey actions on Wayland.
+    ///
+    /// # Arguments
+    ///
+    /// * `hotkey_action_ids` - a list of ids corresponding to actions previously registered with
+    ///   [`GlobalHotKeyManager::wl_register_all`].
+    ///
+    /// ## Note
+    ///
+    /// This doesn't necessarily delete the specified actions from the user's system's settings; it
+    /// just prevents any more events from being received from them.
+    ///
+    /// This function has no effect if the user is not using Wayland.
+    pub fn wl_unregister_all(&self, hotkey_action_ids: &[u32]) {
+        self.wl_unregister_all_impl(hotkey_action_ids)
+    }
+
+    on_linux_cfg! {
+        fn wl_register_all_impl(&self, app_id: impl Into<String>, hotkeys: &[WlNewHotKeyAction]) -> crate::Result<()> {
+            self.platform_impl.wl_register_all(app_id, hotkeys)?;
+            Ok(())
+        }
+    }
+
+    not_on_linux_cfg! {
+        fn wl_register_all_impl(&self, _app_id: impl Into<String>, _hotkeys: &[WlNewHotKeyAction]) -> crate::Result<()> {
+            Ok(())
+        }
+    }
+
+    on_linux_cfg! {
+        fn wl_unregister_all_impl(&self, hotkey_action_ids: &[u32]) {
+            self.platform_impl.wl_unregister_all(hotkey_action_ids);
+        }
+    }
+
+    not_on_linux_cfg! {
+        fn wl_unregister_all_impl(&self, _hotkey_action_ids: &[u32]) {}
+    }
+
+    on_linux_cfg! {
+        pub fn wl_get_hotkeys(&self) -> Box<[WlHotKeyAction]> {
+            self.platform_impl.wl_get_hotkeys()
+        }
+    }
+
+    not_on_linux_cfg! {
+        pub fn wl_get_hotkeys(&self) -> Box<[WlHotKeyAction]> {
+            Box::new([])
+        }
+    }
 }

src/macros.rs

@@ -0,0 +1,44 @@
+// Copyright 2022-2022 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+macro_rules! on_linux {
+    () => {
+        cfg!(any(
+            target_os = "linux",
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))
+    };
+}
+macro_rules! on_linux_cfg {
+    ($i:item) => {
+        #[cfg(any(
+            target_os = "linux",
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        ))]
+        $i
+    };
+}
+
+macro_rules! not_on_linux_cfg {
+    ($x:item) => {
+        #[cfg(not(any(
+            target_os = "linux",
+            target_os = "dragonfly",
+            target_os = "freebsd",
+            target_os = "openbsd",
+            target_os = "netbsd"
+        )))]
+        $x
+    };
+}
+
+pub(crate) use not_on_linux_cfg;
+pub(crate) use on_linux;
+pub(crate) use on_linux_cfg;

src/platform_impl/linux/mod.rs

@@ -0,0 +1,142 @@
+// Copyright 2022-2022 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use crossbeam_channel::{unbounded, Sender};
+
+use crate::{
+    hotkey::HotKey,
+    wayland::{using_wayland, WlHotKeyAction, WlNewHotKeyAction},
+};
+
+mod wayland;
+mod x11;
+
+pub(crate) use wayland::wl_hotkeys_changed_receiver;
+
+enum ThreadMessage {
+    WlRegisterHotKeys(Vec<WlNewHotKeyAction>, String, Sender<crate::Result<()>>),
+    WlUnRegisterHotKeys(Vec<u32>),
+    WlGetHotKeys(Sender<Box<[WlHotKeyAction]>>),
+
+    RegisterHotKey(HotKey, Sender<crate::Result<()>>),
+    RegisterHotKeys(Vec<HotKey>, Sender<crate::Result<()>>),
+    UnRegisterHotKey(HotKey, Sender<crate::Result<()>>),
+    UnRegisterHotKeys(Vec<HotKey>, Sender<crate::Result<()>>),
+    DropThread,
+}
+
+pub struct GlobalHotKeyManager {
+    thread_tx: Sender<ThreadMessage>,
+}
+
+impl GlobalHotKeyManager {
+    pub fn new() -> crate::Result<Self> {
+        let (thread_tx, thread_rx) = unbounded();
+        std::thread::spawn(|| {
+            if let Err(_err) = if using_wayland() {
+                wayland::events_processor(thread_rx)
+            } else {
+                x11::events_processor(thread_rx)
+            } {
+                #[cfg(feature = "tracing")]
+                tracing::error!("{}", _err);
+            }
+        });
+        Ok(Self { thread_tx })
+    }
+
+    pub fn register(&self, hotkey: HotKey) -> crate::Result<()> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        let _ = self
+            .thread_tx
+            .send(ThreadMessage::RegisterHotKey(hotkey, tx));
+
+        if let Ok(result) = rx.recv() {
+            result?;
+        }
+
+        Ok(())
+    }
+
+    pub fn unregister(&self, hotkey: HotKey) -> crate::Result<()> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        let _ = self
+            .thread_tx
+            .send(ThreadMessage::UnRegisterHotKey(hotkey, tx));
+
+        if let Ok(result) = rx.recv() {
+            result?;
+        }
+
+        Ok(())
+    }
+
+    pub fn register_all(&self, hotkeys: &[HotKey]) -> crate::Result<()> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        let _ = self
+            .thread_tx
+            .send(ThreadMessage::RegisterHotKeys(hotkeys.to_vec(), tx));
+
+        if let Ok(result) = rx.recv() {
+            result?;
+        }
+
+        Ok(())
+    }
+
+    pub fn unregister_all(&self, hotkeys: &[HotKey]) -> crate::Result<()> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        let _ = self
+            .thread_tx
+            .send(ThreadMessage::UnRegisterHotKeys(hotkeys.to_vec(), tx));
+
+        if let Ok(result) = rx.recv() {
+            result?;
+        }
+
+        Ok(())
+    }
+
+    pub fn wl_register_all(
+        &self,
+        app_id: impl Into<String>,
+        hotkeys: &[WlNewHotKeyAction],
+    ) -> crate::Result<()> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        let _ = self.thread_tx.send(ThreadMessage::WlRegisterHotKeys(
+            hotkeys.to_vec(),
+            app_id.into(),
+            tx,
+        ));
+
+        if let Ok(result) = rx.recv() {
+            result?;
+        }
+
+        Ok(())
+    }
+
+    pub fn wl_unregister_all(&self, ids: &[u32]) {
+        let _ = self
+            .thread_tx
+            .send(ThreadMessage::WlUnRegisterHotKeys(ids.to_vec()));
+    }
+
+    pub fn wl_get_hotkeys(&self) -> Box<[WlHotKeyAction]> {
+        let (tx, rx) = crossbeam_channel::bounded(1);
+        let _ = self.thread_tx.send(ThreadMessage::WlGetHotKeys(tx));
+
+        if let Ok(result) = rx.recv() {
+            result
+        } else {
+            Box::new([])
+        }
+    }
+}
+
+impl Drop for GlobalHotKeyManager {
+    fn drop(&mut self) {
+        let _ = self.thread_tx.send(ThreadMessage::DropThread);
+    }
+}