Moving to Fn(Event) -> () instead of fn pointer.

Author: Narsil

examples/channel.rs

@@ -1,35 +1,22 @@
-use lazy_static::lazy_static;
-use rdev::{listen, Event};
-use std::sync::mpsc::{channel, Receiver, Sender};
-use std::sync::Mutex;
+use rdev::listen;
+use std::sync::mpsc::channel;
 use std::thread;
 
-lazy_static! {
-    static ref EVENT_CHANNEL: (Mutex<Sender<Event>>, Mutex<Receiver<Event>>) = {
-        let (send, recv) = channel();
-        (Mutex::new(send), Mutex::new(recv))
-    };
-}
-
-fn send_event(event: Event) {
-    EVENT_CHANNEL
-        .0
-        .lock()
-        .expect("Failed to unlock Mutex")
-        .send(event)
-        .expect("Receiving end of EVENT_CHANNEL was closed");
-}
-
 fn main() {
     // spawn new thread because listen blocks
+    let (schan, rchan) = channel();
     let _listener = thread::spawn(move || {
-        listen(send_event).expect("Could not listen");
+        listen(move |event| {
+            schan
+                .send(event)
+                .unwrap_or_else(|e| println!("Could not send event {:?}", e));
+        })
+        .expect("Could not listen");
     });
 
-    let recv = EVENT_CHANNEL.1.lock().expect("Failed to unlock Mutex");
     let mut events = Vec::new();
-    for event in recv.iter() {
+    for event in rchan.iter() {
+        println!("Received {:?}", event);
         events.push(event);
-        println!("Received {} events", events.len());
     }
 }

src/lib.rs

@@ -171,7 +171,7 @@
 //! Serialization and deserialization. (Requires `serialize` feature).
 mod rdev;
 pub use crate::rdev::{
-    Button, Callback, DisplayError, Event, EventType, GrabCallback, GrabError, Key, KeyboardState,
+    Button, DisplayError, Event, EventType, GrabCallback, GrabError, Key, KeyboardState,
     ListenError, SimulateError,
 };
 
@@ -217,7 +217,10 @@ use crate::windows::{display_size as _display_size, listen as _listen, simulate
 ///     }
 /// }
 /// ```
-pub fn listen(callback: Callback) -> Result<(), ListenError> {
+pub fn listen<T: 'static>(callback: T) -> Result<(), ListenError>
+where
+    T: Fn(Event) -> (),
+{
     _listen(callback)
 }
 
@@ -306,7 +309,10 @@ pub use crate::windows::grab as _grab;
 /// }
 /// ```
 #[cfg(any(feature = "unstable_grab"))]
-pub fn grab(callback: GrabCallback) -> Result<(), GrabError> {
+pub fn grab<T>(callback: T) -> Result<(), GrabError>
+where
+    T: Fn(Event) -> Option<Event> + 'static,
+{
     _grab(callback)
 }
 

src/linux/grab.rs

@@ -1,6 +1,6 @@
 use crate::linux::common::Display;
 use crate::linux::keyboard::Keyboard;
-use crate::rdev::{Button, Event, EventType, GrabCallback, GrabError, Key, KeyboardState};
+use crate::rdev::{Button, Event, EventType, GrabError, Key, KeyboardState};
 use epoll::ControlOptions::{EPOLL_CTL_ADD, EPOLL_CTL_DEL};
 use evdev_rs::{
     enums::{EventCode, EV_KEY, EV_REL},
@@ -301,7 +301,10 @@ fn evdev_event_to_rdev_event(
 //     }
 // }
 
-pub fn grab(callback: GrabCallback) -> Result<(), GrabError> {
+pub fn grab<T>(callback: T) -> Result<(), GrabError>
+where
+    T: Fn(Event) -> Option<Event> + 'static,
+{
     let mut kb = Keyboard::new().ok_or(GrabError::KeyboardError)?;
     let display = Display::new().ok_or(GrabError::MissingDisplayError)?;
     let (width, height) = display.get_size().ok_or(GrabError::MissingDisplayError)?;

src/linux/listen.rs

@@ -2,27 +2,26 @@ extern crate libc;
 extern crate x11;
 use crate::linux::common::{convert, FALSE, KEYBOARD};
 use crate::linux::keyboard::Keyboard;
-use crate::rdev::{Callback, Event, ListenError};
+use crate::rdev::{Event, ListenError};
 use std::convert::TryInto;
 use std::ffi::CStr;
 use std::os::raw::{c_char, c_int, c_uchar, c_uint, c_ulong};
 use std::ptr::null;
 use x11::xlib;
 use x11::xrecord;
 
-fn default_callback(event: Event) {
-    println!("Default : Event {:?}", event);
-}
-
 static mut RECORD_ALL_CLIENTS: c_ulong = xrecord::XRecordAllClients;
-static mut GLOBAL_CALLBACK: Callback = default_callback;
+static mut GLOBAL_CALLBACK: Option<Box<dyn Fn(Event) -> ()>> = None;
 
-pub fn listen(callback: Callback) -> Result<(), ListenError> {
+pub fn listen<T>(callback: T) -> Result<(), ListenError>
+where
+    T: Fn(Event) -> () + 'static,
+{
     let keyboard = Keyboard::new().ok_or(ListenError::KeyboardError)?;
 
     unsafe {
         KEYBOARD = Some(keyboard);
-        GLOBAL_CALLBACK = callback;
+        GLOBAL_CALLBACK = Some(Box::new(callback));
         // Open displays
         let dpy_control = xlib::XOpenDisplay(null());
         if dpy_control.is_null() {
@@ -107,7 +106,9 @@ unsafe extern "C" fn record_callback(
     let y = xdatum.root_y as f64;
 
     if let Some(event) = convert(&mut KEYBOARD, code, type_, x, y) {
-        GLOBAL_CALLBACK(event);
+        if let Some(callback) = &GLOBAL_CALLBACK {
+            callback(event);
+        }
     }
     xrecord::XRecordFreeData(raw_data);
 }

src/macos/grab.rs

@@ -1,16 +1,12 @@
 #![allow(improper_ctypes_definitions)]
 use crate::macos::common::*;
-use crate::rdev::{Event, GrabCallback, GrabError};
+use crate::rdev::{Event, GrabError};
 use cocoa::base::nil;
 use cocoa::foundation::NSAutoreleasePool;
 use core_graphics::event::{CGEventTapLocation, CGEventType};
 use std::os::raw::c_void;
 
-fn default_callback(event: Event) -> Option<Event> {
-    println!("Default {:?}", event);
-    Some(event)
-}
-static mut GLOBAL_CALLBACK: GrabCallback = default_callback;
+static mut GLOBAL_CALLBACK: Option<Box<dyn Fn(Event) -> Option<Event>>> = None;
 
 unsafe extern "C" fn raw_callback(
     _proxy: CGEventTapProxy,
@@ -23,18 +19,23 @@ unsafe extern "C" fn raw_callback(
     let opt = KEYBOARD_STATE.lock();
     if let Ok(mut keyboard) = opt {
         if let Some(event) = convert(_type, &cg_event, &mut keyboard) {
-            if GLOBAL_CALLBACK(event).is_none() {
-                cg_event.set_type(CGEventType::Null);
+            if let Some(callback) = &GLOBAL_CALLBACK {
+                if callback(event).is_none() {
+                    cg_event.set_type(CGEventType::Null);
+                }
             }
         }
     }
     cg_event
 }
 
 #[link(name = "Cocoa", kind = "framework")]
-pub fn grab(callback: GrabCallback) -> Result<(), GrabError> {
+pub fn grab<T>(callback: T) -> Result<(), GrabError>
+where
+    T: Fn(Event) -> Option<Event> + 'static,
+{
     unsafe {
-        GLOBAL_CALLBACK = callback;
+        GLOBAL_CALLBACK = Some(Box::new(callback));
         let _pool = NSAutoreleasePool::new(nil);
         let tap = CGEventTapCreate(
             CGEventTapLocation::HID, // HID, Session, AnnotatedSession,

src/macos/listen.rs

@@ -1,15 +1,12 @@
 #![allow(improper_ctypes_definitions)]
 use crate::macos::common::*;
-use crate::rdev::{Callback, Event, ListenError};
+use crate::rdev::{Event, ListenError};
 use cocoa::base::nil;
 use cocoa::foundation::NSAutoreleasePool;
 use core_graphics::event::{CGEventTapLocation, CGEventType};
 use std::os::raw::c_void;
 
-fn default_callback(event: Event) {
-    println!("Default {:?}", event)
-}
-static mut GLOBAL_CALLBACK: Callback = default_callback;
+static mut GLOBAL_CALLBACK: Option<Box<dyn Fn(Event) -> ()>> = None;
 
 unsafe extern "C" fn raw_callback(
     _proxy: CGEventTapProxy,
@@ -22,7 +19,9 @@ unsafe extern "C" fn raw_callback(
     let opt = KEYBOARD_STATE.lock();
     if let Ok(mut keyboard) = opt {
         if let Some(event) = convert(_type, &cg_event, &mut keyboard) {
-            GLOBAL_CALLBACK(event);
+            if let Some(callback) = &GLOBAL_CALLBACK {
+                callback(event);
+            }
         }
     }
     // println!("Event ref END {:?}", cg_event_ptr);
@@ -31,9 +30,12 @@ unsafe extern "C" fn raw_callback(
 }
 
 #[link(name = "Cocoa", kind = "framework")]
-pub fn listen(callback: Callback) -> Result<(), ListenError> {
+pub fn listen<T>(callback: T) -> Result<(), ListenError>
+where
+    T: Fn(Event) -> () + 'static,
+{
     unsafe {
-        GLOBAL_CALLBACK = callback;
+        GLOBAL_CALLBACK = Some(Box::new(callback));
         let _pool = NSAutoreleasePool::new(nil);
         let tap = CGEventTapCreate(
             CGEventTapLocation::HID, // HID, Session, AnnotatedSession,

src/rdev.rs

@@ -3,8 +3,8 @@ use serde::{Deserialize, Serialize};
 use std::time::SystemTime;
 use std::{fmt, fmt::Display};
 
-/// Callback type to send to listen function.
-pub type Callback = fn(event: Event);
+// /// Callback type to send to listen function.
+// pub type Callback = dyn FnMut(Event) -> ();
 
 /// Callback type to send to grab function.
 pub type GrabCallback = fn(event: Event) -> Option<Event>;

src/windows/grab.rs

@@ -1,14 +1,10 @@
-use crate::rdev::{Event, EventType, GrabCallback, GrabError};
+use crate::rdev::{Event, EventType, GrabError};
 use crate::windows::common::{convert, set_key_hook, set_mouse_hook, HookError, HOOK, KEYBOARD};
 use std::ptr::null_mut;
 use std::time::SystemTime;
 use winapi::um::winuser::{CallNextHookEx, GetMessageA, HC_ACTION};
 
-fn default_callback(event: Event) -> Option<Event> {
-    println!("Default : Event {:?}", event);
-    Some(event)
-}
-static mut GLOBAL_CALLBACK: GrabCallback = default_callback;
+static mut GLOBAL_CALLBACK: Option<Box<dyn Fn(Event) -> Option<Event>>> = None;
 
 unsafe extern "system" fn raw_callback(code: i32, param: usize, lpdata: isize) -> isize {
     if code == HC_ACTION {
@@ -26,12 +22,14 @@ unsafe extern "system" fn raw_callback(code: i32, param: usize, lpdata: isize) -
                 time: SystemTime::now(),
                 name,
             };
-            if GLOBAL_CALLBACK(event).is_none() {
-                // https://stackoverflow.com/questions/42756284/blocking-windows-mouse-click-using-setwindowshookex
-                // https://android.developreference.com/article/14560004/Blocking+windows+mouse+click+using+SetWindowsHookEx()
-                // https://cboard.cprogramming.com/windows-programming/99678-setwindowshookex-wm_keyboard_ll.html
-                // let _result = CallNextHookEx(HOOK, code, param, lpdata);
-                return 1;
+            if let Some(callback) = &GLOBAL_CALLBACK {
+                if callback(event).is_none() {
+                    // https://stackoverflow.com/questions/42756284/blocking-windows-mouse-click-using-setwindowshookex
+                    // https://android.developreference.com/article/14560004/Blocking+windows+mouse+click+using+SetWindowsHookEx()
+                    // https://cboard.cprogramming.com/windows-programming/99678-setwindowshookex-wm_keyboard_ll.html
+                    // let _result = CallNextHookEx(HOOK, code, param, lpdata);
+                    return 1;
+                }
             }
         }
     }
@@ -46,9 +44,12 @@ impl From<HookError> for GrabError {
     }
 }
 
-pub fn grab(callback: GrabCallback) -> Result<(), GrabError> {
+pub fn grab<T>(callback: T) -> Result<(), GrabError>
+where
+    T: Fn(Event) -> Option<Event> + 'static,
+{
     unsafe {
-        GLOBAL_CALLBACK = callback;
+        GLOBAL_CALLBACK = Some(Box::new(callback));
         set_key_hook(raw_callback)?;
         set_mouse_hook(raw_callback)?;
 

src/windows/listen.rs

@@ -1,15 +1,12 @@
-use crate::rdev::{Callback, Event, EventType, ListenError};
+use crate::rdev::{Event, EventType, ListenError};
 use crate::windows::common::{convert, set_key_hook, set_mouse_hook, HookError, HOOK, KEYBOARD};
 use std::os::raw::c_int;
 use std::ptr::null_mut;
 use std::time::SystemTime;
 use winapi::shared::minwindef::{LPARAM, LRESULT, WPARAM};
 use winapi::um::winuser::{CallNextHookEx, GetMessageA, HC_ACTION};
 
-fn default_callback(event: Event) {
-    println!("Default : Event {:?}", event);
-}
-static mut GLOBAL_CALLBACK: Callback = default_callback;
+static mut GLOBAL_CALLBACK: Option<Box<dyn Fn(Event) -> ()>> = None;
 
 impl From<HookError> for ListenError {
     fn from(error: HookError) -> Self {
@@ -36,15 +33,20 @@ unsafe extern "system" fn raw_callback(code: c_int, param: WPARAM, lpdata: LPARA
                 time: SystemTime::now(),
                 name,
             };
-            GLOBAL_CALLBACK(event);
+            if let Some(callback) = &GLOBAL_CALLBACK {
+                callback(event);
+            }
         }
     }
     CallNextHookEx(HOOK, code, param, lpdata)
 }
 
-pub fn listen(callback: Callback) -> Result<(), ListenError> {
+pub fn listen<T>(callback: T) -> Result<(), ListenError>
+where
+    T: Fn(Event) -> () + 'static,
+{
     unsafe {
-        GLOBAL_CALLBACK = callback;
+        GLOBAL_CALLBACK = Some(Box::new(callback));
         set_key_hook(raw_callback)?;
         set_mouse_hook(raw_callback)?;