@desklink/host 0.1.0

package/engine/vendor/inputtino/bindings/rust/inputtino/src/joypad_xbox.rs

@@ -0,0 +1,134 @@
+use std::ffi::{c_int, c_void};
+use std::path::PathBuf;
+
+use crate::common::{get_nodes, make_device, DeviceDefinition};
+use crate::sys::{
+    inputtino_joypad_xone_create, inputtino_joypad_xone_destroy, inputtino_joypad_xone_get_nodes,
+    inputtino_joypad_xone_set_on_rumble, inputtino_joypad_xone_set_pressed_buttons,
+    inputtino_joypad_xone_set_stick, inputtino_joypad_xone_set_triggers,
+};
+use crate::{InputtinoError, JoypadStickPosition};
+
+/// Emulated XBox One joypad.
+pub struct XboxOneJoypad {
+    joypad: *mut crate::sys::InputtinoXOneJoypad,
+    on_rumble_fn: *mut c_void,
+}
+
+impl XboxOneJoypad {
+    /// Create a new emulated XBox One joypad device with the given device definition.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let definition = inputtino::DeviceDefinition::new(
+    ///     "Inputtino XBox One controller",
+    ///     0x045E,
+    ///     0x02DD,
+    ///     0x0100,
+    ///     "00:11:22:33:44",
+    ///     "00:11:22:33:44",
+    /// );
+    /// let device = inputtino::SwitchJoypad::new(&definition);
+    /// ```
+    pub fn new(device: &DeviceDefinition) -> Result<Self, InputtinoError> {
+        make_device(inputtino_joypad_xone_create, device).map(|joypad| XboxOneJoypad {
+            joypad,
+            on_rumble_fn: std::ptr::null_mut(),
+        })
+    }
+
+    /// Set the state of all buttons.
+    ///
+    /// Any buttons that are not set are released if they were set before.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.set_pressed(inputtino::JoypadButton::A | inputtino::JoypadButton::B);
+    /// ```
+    pub fn set_pressed(&self, buttons: i32) {
+        unsafe {
+            inputtino_joypad_xone_set_pressed_buttons(self.joypad, buttons);
+        }
+    }
+
+    /// Set the state of the triggers.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.set_triggers(0, -i16::MAX);
+    /// ```
+    pub fn set_triggers(&self, left_trigger: i16, right_trigger: i16) {
+        unsafe {
+            inputtino_joypad_xone_set_triggers(self.joypad, left_trigger, right_trigger);
+        }
+    }
+
+    /// Set the state of the joysticks.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.set_stick(inputtino::JoypadStickPosition::LS, 0, -i16::MAX);
+    /// ```
+    pub fn set_stick(&self, stick_type: JoypadStickPosition, x: i16, y: i16) {
+        unsafe {
+            inputtino_joypad_xone_set_stick(self.joypad, stick_type, x, y);
+        }
+    }
+
+    /// Sets a callback to be called when this device receives a rumble event.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.set_on_rumble(|low, high| {
+    ///     println!("Received rumble event with frequencies low: {low}, high: {high}");
+    /// });
+    /// ```
+    pub fn set_on_rumble(&mut self, on_rumble_fn: impl FnMut(i32, i32) + 'static) {
+        let on_rumble_fn = Box::new(RumbleFunction {
+            on_rumble_fn: Box::new(on_rumble_fn),
+        });
+        self.on_rumble_fn = Box::into_raw(on_rumble_fn) as *mut c_void;
+        unsafe {
+            inputtino_joypad_xone_set_on_rumble(
+                self.joypad,
+                Some(on_rumble_c_fn),
+                self.on_rumble_fn,
+            );
+        }
+    }
+
+    pub fn get_nodes(&self) -> Result<Vec<PathBuf>, InputtinoError> {
+        get_nodes(inputtino_joypad_xone_get_nodes, self.joypad)
+    }
+}
+
+impl Drop for XboxOneJoypad {
+    fn drop(&mut self) {
+        unsafe {
+            inputtino_joypad_xone_destroy(self.joypad);
+            if !self.on_rumble_fn.is_null() {
+                drop(Box::from_raw(self.on_rumble_fn as *mut RumbleFunction));
+            }
+        }
+    }
+}
+
+struct RumbleFunction {
+    on_rumble_fn: Box<dyn FnMut(i32, i32)>,
+}
+
+unsafe extern "C" fn on_rumble_c_fn(
+    left_motor: c_int,
+    right_motor: c_int,
+    user_data: *mut ::core::ffi::c_void,
+) {
+    let on_rumble_fn = user_data as *mut RumbleFunction;
+    ((*on_rumble_fn).on_rumble_fn)(left_motor, right_motor);
+}
+
+unsafe impl Send for XboxOneJoypad {}

package/engine/vendor/inputtino/bindings/rust/inputtino/src/keyboard.rs

@@ -0,0 +1,76 @@
+use std::path::PathBuf;
+
+use crate::common::{get_nodes, make_device, DeviceDefinition};
+use crate::sys::{
+    inputtino_keyboard_create, inputtino_keyboard_destroy, inputtino_keyboard_get_nodes,
+    inputtino_keyboard_press, inputtino_keyboard_release,
+};
+use crate::InputtinoError;
+
+/// Emulated keyboard device.
+pub struct Keyboard {
+    kb: *mut crate::sys::InputtinoKeyboard,
+}
+
+impl Keyboard {
+    /// Create a new emulated keyboard device with the given device definition.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let definition = inputtino::DeviceDefinition::new(
+    ///     "Inputtino Keyboard",
+    ///     0xBEEF,
+    ///     0xDEAD,
+    ///     0x111,
+    ///     "00:11:22:33:44",
+    ///     "00:11:22:33:44",
+    /// );
+    /// let device = inputtino::Keyboard::new(&definition);
+    /// ```
+    pub fn new(device: &DeviceDefinition) -> Result<Self, InputtinoError> {
+        make_device(inputtino_keyboard_create, device).map(|kb| Keyboard { kb })
+    }
+
+    pub fn get_nodes(&self) -> Result<Vec<PathBuf>, InputtinoError> {
+        get_nodes(inputtino_keyboard_get_nodes, self.kb)
+    }
+
+    /// Simulate a keypress on this keyboard device.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.press_key(0x41); // KEY_A
+    /// ```
+    pub fn press_key(&self, key: i16) {
+        // TODO: Export key mapping in Rust.
+        unsafe {
+            inputtino_keyboard_press(self.kb, key);
+        }
+    }
+
+    /// Simulate a release of a key from this keyboard device.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.release_key(0x41); // KEY_A
+    /// ```
+    pub fn release_key(&self, key: i16) {
+        // TODO: Export key mapping in Rust.
+        unsafe {
+            inputtino_keyboard_release(self.kb, key);
+        }
+    }
+}
+
+impl Drop for Keyboard {
+    fn drop(&mut self) {
+        unsafe {
+            inputtino_keyboard_destroy(self.kb);
+        }
+    }
+}
+
+unsafe impl Send for Keyboard {}

package/engine/vendor/inputtino/bindings/rust/inputtino/src/lib.rs

@@ -0,0 +1,32 @@
+mod common;
+pub use common::DeviceDefinition;
+
+mod error;
+pub use error::InputtinoError;
+
+mod mouse;
+pub use mouse::Mouse;
+
+mod keyboard;
+pub use keyboard::Keyboard;
+
+mod joypad;
+pub use joypad::Joypad;
+
+mod joypad_ps5;
+pub use joypad_ps5::PS5Joypad;
+
+mod joypad_nintendo;
+pub use joypad_nintendo::SwitchJoypad;
+
+pub use joypad_xbox::XboxOneJoypad;
+mod joypad_xbox;
+
+pub use inputtino_sys::{
+    INPUTTINO_JOYPAD_BTN as JoypadButton, INPUTTINO_JOYPAD_MOTION_TYPE as JoypadMotionType,
+    INPUTTINO_JOYPAD_STICK_POSITION as JoypadStickPosition, INPUTTINO_MOUSE_BUTTON as MouseButton,
+    BATTERY_STATE as BatteryState,
+};
+
+// Low level automatic c bindings.
+pub use inputtino_sys as sys;

package/engine/vendor/inputtino/bindings/rust/inputtino/src/mouse.rs

@@ -0,0 +1,178 @@
+use std::path::PathBuf;
+
+use crate::common::{get_nodes, make_device, DeviceDefinition};
+use crate::sys::{
+    inputtino_mouse_create, inputtino_mouse_destroy, inputtino_mouse_get_nodes,
+    inputtino_mouse_move, inputtino_mouse_move_absolute, inputtino_mouse_press_button,
+    inputtino_mouse_release_button, inputtino_mouse_scroll_horizontal,
+    inputtino_mouse_scroll_vertical,
+};
+
+use crate::{InputtinoError, MouseButton};
+
+pub struct Mouse {
+    mouse: *mut crate::sys::InputtinoMouse,
+}
+
+impl Mouse {
+    /// Create a new emulated mouse device with the given device definition.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let definition = inputtino::DeviceDefinition::new(
+    ///     "Inputtino Mouse",
+    ///     0x0,
+    ///     0x0,
+    ///     0x0,
+    ///     "00:11:22:33:44",
+    ///     "00:11:22:33:44",
+    /// );
+    /// let device = inputtino::Mouse::new(&definition);
+    /// ```
+    pub fn new(device: &DeviceDefinition) -> Result<Self, InputtinoError> {
+        make_device(inputtino_mouse_create, device).map(|mouse| Mouse { mouse })
+    }
+
+    pub fn get_nodes(&self) -> Result<Vec<PathBuf>, InputtinoError> {
+        get_nodes(inputtino_mouse_get_nodes, self.mouse)
+    }
+
+    /// Move the mouse relative to its current position.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.move_rel(10, -10);
+    /// ```
+    pub fn move_rel(&self, x: i32, y: i32) {
+        unsafe {
+            inputtino_mouse_move(self.mouse, x, y);
+        }
+    }
+
+    /// Move the mouse to absolute coordinates on the screen.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.move_abs(100, 100, 1920, 1080);
+    /// ```
+    pub fn move_abs(&self, x: i32, y: i32, screen_width: i32, screen_height: i32) {
+        unsafe {
+            inputtino_mouse_move_absolute(self.mouse, x, y, screen_width, screen_height);
+        }
+    }
+
+    /// Simulate a button press.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.press_button(inputtino::MouseButton::LEFT);
+    /// ```
+    pub fn press_button(&self, button: MouseButton) {
+        unsafe {
+            inputtino_mouse_press_button(self.mouse, button);
+        }
+    }
+
+    /// Simulate the release of a button.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.release_button(inputtino::MouseButton::LEFT);
+    /// ```
+    pub fn release_button(&self, button: MouseButton) {
+        unsafe {
+            inputtino_mouse_release_button(self.mouse, button);
+        }
+    }
+
+    /// Simulate scrolling vertically for an amount of ticks.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.scroll_vertical(10);
+    /// ```
+    pub fn scroll_vertical(&self, amount: i32) {
+        unsafe {
+            inputtino_mouse_scroll_vertical(self.mouse, amount);
+        }
+    }
+
+    /// Simulate scrolling horizontally for an amount of ticks.
+    ///
+    /// # Examples
+    ///
+    /// ```ignore
+    /// device.scroll_horizontal(-10);
+    /// ```
+    pub fn scroll_horizontal(&self, amount: i32) {
+        unsafe {
+            inputtino_mouse_scroll_horizontal(self.mouse, amount);
+        }
+    }
+}
+
+impl Drop for Mouse {
+    fn drop(&mut self) {
+        unsafe {
+            inputtino_mouse_destroy(self.mouse);
+        }
+    }
+}
+
+unsafe impl Send for Mouse {}
+
+#[cfg(test)]
+mod tests {
+    use crate::common::error_handler_fn;
+    use std::ffi::CString;
+
+    use super::*;
+
+    #[test]
+    fn test_inputtino_c_mouse() {
+        let device_name = CString::new("Rusty Mouse").unwrap();
+        let device_phys = CString::new("Rusty Mouse Phys").unwrap();
+        let device_uniq = CString::new("Rusty Mouse Uniq").unwrap();
+        let def = crate::sys::InputtinoDeviceDefinition {
+            name: device_name.as_ptr(),
+            vendor_id: 0,
+            product_id: 0,
+            version: 0,
+            device_phys: device_phys.as_ptr(),
+            device_uniq: device_uniq.as_ptr(),
+        };
+        // TODO: test this somehow
+        let error_str = std::ptr::null_mut();
+        let error_handler = crate::sys::InputtinoErrorHandler {
+            eh: Some(error_handler_fn),
+            user_data: error_str,
+        };
+
+        unsafe {
+            let mouse = inputtino_mouse_create(&def, &error_handler);
+            assert!(!mouse.is_null());
+
+            let mut nodes_count: core::ffi::c_int = 0;
+            let nodes = inputtino_mouse_get_nodes(mouse, &mut nodes_count);
+            assert_eq!(nodes_count, 2);
+            assert!(!nodes.is_null());
+            // Check that the nodes start with /dev/input/event
+            assert!(CString::from_raw(*nodes.offset(0))
+                .to_str()
+                .unwrap()
+                .starts_with("/dev/input/event"));
+            assert!(CString::from_raw(*nodes.offset(1))
+                .to_str()
+                .unwrap()
+                .starts_with("/dev/input/event"));
+
+            inputtino_mouse_destroy(mouse);
+        }
+    }
+}

package/engine/vendor/inputtino/bindings/rust/inputtino/tests/common.rs

@@ -0,0 +1,38 @@
+use input::{Event, Libinput, LibinputInterface};
+use rustix::fs::{open, Mode, OFlags};
+use std::os::fd::OwnedFd;
+use std::path::Path;
+
+pub struct NixInterface;
+
+impl LibinputInterface for NixInterface {
+    fn open_restricted(&mut self, path: &Path, flags: i32) -> Result<OwnedFd, i32> {
+        open(
+            path,
+            OFlags::from_bits_truncate(flags as u32),
+            Mode::empty(),
+        )
+        .map_err(|err| err.raw_os_error())
+    }
+    fn close_restricted(&mut self, fd: OwnedFd) {
+        let _ = fd;
+    }
+}
+
+pub trait SyncEvent {
+    fn wait_next_event(&mut self) -> Option<Event>;
+}
+
+impl SyncEvent for Libinput {
+    fn wait_next_event(&mut self) -> Option<Event> {
+        for _ in 0..10 {
+            // loop maximum 10 times to avoid infinite loop
+            self.dispatch().unwrap();
+            if let Some(event) = self.next() {
+                return Some(event);
+            }
+            std::thread::sleep(std::time::Duration::from_millis(50));
+        }
+        None
+    }
+}

package/engine/vendor/inputtino/bindings/rust/inputtino/tests/joypads.rs

@@ -0,0 +1,150 @@
+use inputtino::{DeviceDefinition, JoypadButton, JoypadStickPosition, SwitchJoypad};
+use serial_test::serial;
+
+#[test]
+#[serial]
+fn test_switch_joypad() {
+    let device = DeviceDefinition::new(
+        "Rusty Switch controller",
+        // https://github.com/torvalds/linux/blob/276f98efb64a2c31c099465ace78d3054c662a0f/drivers/hid/hid-ids.h#L990
+        0x057e,
+        0x2009,
+        0x8111,
+        "00:11:22:33:44",
+        "00:11:22:33:44",
+    );
+    let mut joypad = SwitchJoypad::new(&device).unwrap();
+
+    let nodes = joypad.get_nodes().unwrap();
+    {
+        assert_eq!(nodes.len(), 2);
+        assert!(nodes[0]
+            .to_str()
+            .expect("valid utf-8")
+            .starts_with("/dev/input/event"));
+        assert!(nodes[1]
+            .to_str()
+            .expect("valid utf-8")
+            .starts_with("/dev/input/js"));
+    }
+
+    // Sleep to let the system detect the anew device
+    std::thread::sleep(std::time::Duration::from_millis(500));
+
+    let sdl = sdl2::init().unwrap();
+    let joystick_subsystem = sdl.game_controller().unwrap();
+
+    assert_eq!(joystick_subsystem.num_joysticks().unwrap(), 1);
+
+    let mut sdl_js = joystick_subsystem.open(0).unwrap();
+    let mut event_pump = sdl.event_pump().unwrap();
+
+    for event in event_pump.poll_iter() {
+        match event {
+            sdl2::event::Event::JoyDeviceAdded { which, .. } => {
+                assert_eq!(which, 0);
+            }
+            sdl2::event::Event::ControllerDeviceAdded { which, .. } => {
+                assert_eq!(which, 0);
+            }
+            _ => panic!("Unexpected event : {:?}", event),
+        }
+    }
+
+    assert_eq!(sdl_js.name(), "Nintendo Switch Pro Controller");
+    assert!(sdl_js.has_rumble());
+
+    {
+        joypad.set_pressed(JoypadButton::A as i32);
+        for event in event_pump.wait_timeout_iter(50) {
+            match event {
+                sdl2::event::Event::ControllerButtonDown { button, .. } => {
+                    assert_eq!(button, sdl2::controller::Button::A);
+                }
+                sdl2::event::Event::JoyButtonDown { button_idx, .. } => {
+                    // Old joystick API uses the "xbox" layout for indexes
+                    // A on a switch pad is on the same position as B on an xbox pad
+                    assert_eq!(button_idx, sdl2::controller::Button::B as u8);
+                    break;
+                }
+                _ => panic!("Unexpected event : {:?}", event),
+            }
+        }
+    }
+
+    {
+        joypad.set_triggers(0, 0);
+        for event in event_pump.wait_timeout_iter(50) {
+            match event {
+                sdl2::event::Event::ControllerAxisMotion { axis, value, .. } => {
+                    assert_eq!(axis, sdl2::controller::Axis::TriggerLeft);
+                    assert_eq!(value, 0);
+                }
+                sdl2::event::Event::JoyAxisMotion {
+                    axis_idx, value, ..
+                } => {
+                    assert_eq!(axis_idx, sdl2::controller::Axis::TriggerLeft as u8);
+                    assert_eq!(value, 0);
+                    break;
+                }
+                sdl2::event::Event::Unknown { .. } => {}
+                _ => panic!("Unexpected event : {:?}", event),
+            }
+        }
+    }
+
+    {
+        joypad.set_stick(JoypadStickPosition::LS, 0, 0);
+        for event in event_pump.wait_timeout_iter(50) {
+            match event {
+                sdl2::event::Event::ControllerAxisMotion { axis, value, .. } => {
+                    assert_eq!(axis, sdl2::controller::Axis::LeftX);
+                    assert_eq!(value, 0);
+                }
+                sdl2::event::Event::JoyAxisMotion {
+                    axis_idx, value, ..
+                } => {
+                    assert_eq!(axis_idx, sdl2::controller::Axis::LeftX as u8);
+                    assert_eq!(value, 0);
+                    break;
+                }
+                _ => panic!("Unexpected event : {:?}", event),
+            }
+        }
+    }
+
+    {
+        joypad.set_stick(JoypadStickPosition::RS, 0, 0);
+        for event in event_pump.wait_timeout_iter(50) {
+            match event {
+                sdl2::event::Event::ControllerAxisMotion { axis, value, .. } => {
+                    assert_eq!(axis, sdl2::controller::Axis::RightX);
+                    assert_eq!(value, 0);
+                }
+                sdl2::event::Event::JoyAxisMotion {
+                    axis_idx, value, ..
+                } => {
+                    assert_eq!(axis_idx, sdl2::controller::Axis::RightX as u8);
+                    assert_eq!(value, 0);
+                    break;
+                }
+                _ => panic!("Unexpected event : {:?}", event),
+            }
+        }
+    }
+
+    {
+        joypad.set_on_rumble(move |left, right| {
+            assert_eq!(left, 100);
+            assert_eq!(right, 200);
+        });
+        let res = sdl_js.set_rumble(100, 200, 150);
+        assert!(res.is_ok());
+        std::thread::sleep(std::time::Duration::from_millis(25));
+        joypad.set_on_rumble(move |left, right| {
+            assert_eq!(left, 0);
+            assert_eq!(right, 0);
+        });
+        std::thread::sleep(std::time::Duration::from_millis(125));
+    }
+}

package/engine/vendor/inputtino/bindings/rust/inputtino/tests/keyboard.rs

@@ -0,0 +1,73 @@
+use input::event::keyboard::KeyboardEventTrait;
+use input::event::DeviceEvent;
+use input::{Event, Libinput};
+use inputtino::{DeviceDefinition, Keyboard};
+mod common;
+use crate::common::{NixInterface, SyncEvent};
+
+#[test]
+fn test_inputtino_keyboard() {
+    let device = DeviceDefinition::new(
+        "Rusty Keyboard",
+        0xAB,
+        0xCD,
+        0xEF,
+        "Rusty Keyboard Phys",
+        "Rusty Keyboard Uniq",
+    );
+    let keyboard = Keyboard::new(&device).unwrap();
+    let nodes = keyboard.get_nodes().unwrap();
+    {
+        assert_eq!(nodes.len(), 1);
+
+        // Check that the node start with /dev/input/event
+        assert!(nodes[0]
+            .to_str()
+            .expect("valid utf-8")
+            .starts_with("/dev/input/event"));
+    }
+
+    let mut input = Libinput::new_from_path(NixInterface);
+    let kb_dev = input
+        .path_add_device(nodes[0].to_str().expect("valid utf-8"))
+        .expect("to get the device");
+
+    {
+        assert_eq!(kb_dev.name(), "Rusty Keyboard");
+        assert_eq!(kb_dev.id_vendor(), 0xAB);
+        assert_eq!(kb_dev.id_product(), 0xCD);
+        for event in &mut input {
+            assert!(matches!(event, Event::Device(DeviceEvent::Added(_))));
+        }
+    }
+
+    {
+        // Test keyboard key press
+        keyboard.press_key(0x41); // KEY_A
+
+        let ev = input.wait_next_event();
+        assert!(matches!(ev, Some(Event::Keyboard(_))));
+        match ev {
+            Some(Event::Keyboard(ev)) => {
+                assert_eq!(ev.key(), 30); // KEY_A
+                assert_eq!(ev.key_state(), input::event::keyboard::KeyState::Pressed);
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    {
+        // Test keyboard key release
+        keyboard.release_key(0x41);
+
+        let ev = input.wait_next_event().unwrap();
+        assert!(matches!(ev, Event::Keyboard(_)));
+        match ev {
+            Event::Keyboard(ev) => {
+                assert_eq!(ev.key(), 30); // KEY_A
+                assert_eq!(ev.key_state(), input::event::keyboard::KeyState::Released);
+            }
+            _ => unreachable!(),
+        }
+    }
+}