Rust fixes

.dockerignore

@@ -5,3 +5,7 @@
 !include
 !cmake/
 !docker/startup.sh
+!share/
+
+# Rust bindings
+!bindings/rust/

CMakeLists.txt

@@ -163,6 +163,13 @@ if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
         install(FILES "${CMAKE_CURRENT_BINARY_DIR}/include/inputtino/${export_file_name}"
                 COMPONENT libinputtino-dev
                 DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/inputtino")
+        configure_file(
+                ${CMAKE_CURRENT_SOURCE_DIR}/share/pkgconfig/libinputtino.pc.in
+                ${CMAKE_CURRENT_BINARY_DIR}/libinputtino.pc
+                @ONLY
+        )
+        install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libinputtino.pc
+                DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig)
     endif ()
 endif ()
 

bindings/rust/.dockerignore

@@ -0,0 +1 @@
+target/

bindings/rust/Cargo.toml

@@ -1,15 +1,29 @@
 [package]
 name = "inputtino"
-version = "0.1.0"
+version = "2024.8.1"
 edition = "2021"
 license = "MIT"
 rust-version = "1.72"
 links = "libinputtino"
+homepage = "https://github.com/games-on-whales/inputtino"
+authors = ["ABeltramo"]
+description = "Rust bindings for inputtino"
 
 [lib]
-name = "inputtino_rs"
+name = "inputtino"
 path = "src/lib.rs"
 
 [build-dependencies]
 bindgen = "0.69.4"
 cmake = "0.1"
+pkg-config = "0.3.30"
+
+[dev-dependencies]
+input = "0.9.0"
+rustix = { version = "0.38.18", features = ["fs"] }
+approx = "0.5.1"
+sdl2 = "0.37.0"
+serial_test = "3.1.1"
+
+[dependencies]
+strum_macros = "0.26.4"

bindings/rust/build.rs

@@ -1,64 +1,61 @@
-extern crate bindgen;
-
 use std::env;
 use std::path::PathBuf;
 
 use cmake::Config;
 
 fn main() {
-    let build_static = false;
-
-    // This is the directory where the `c` library is located.
-    let libdir_path = PathBuf::from("../../")
-        // Canonicalize the path as `rustc-link-search` requires an absolute
-        // path.
-        .canonicalize()
-        .expect("cannot canonicalize path");
-
-    // Compile the library using CMake
-    let dst = Config::new(libdir_path)
-        .target("libinputtino")
-        .define("BUILD_SHARED_LIBS", if build_static { "OFF" } else { "ON" })
-        .define("LIBINPUTTINO_INSTALL", "ON")
-        .define("BUILD_TESTING", "OFF")
-        .define("BUILD_SERVER", "OFF")
-        .define("BUILD_C_BINDINGS", "ON")
-        .profile("Release")
-        .define("CMAKE_CONFIGURATION_TYPES", "Release")
-        .build();
-
-    // Dependencies
-    if !build_static {
-        println!("cargo:rustc-link-lib=evdev");
-        println!("cargo:rustc-link-lib=stdc++");
-    }
-
-    //libinputtino
-    println!("cargo:rustc-link-search=native={}/lib", dst.display());
-    println!("cargo:rustc-link-lib={}libinputtino", if build_static { "static=" } else { "" });
+    // Options
+    let build_c_bindings = env::var("INPUTTINO_BUILD_C_BINDINGS").unwrap_or("TRUE".to_string()) == "TRUE";
+    let build_static = env::var("INPUTTINO_BUILD_STATIC").unwrap_or("TRUE".to_string()) == "TRUE";
 
     // The bindgen::Builder is the main entry point
     // to bindgen, and lets you build up options for
     // the resulting bindings.
-    let bindings = bindgen::Builder::default()
+    let mut bindings = bindgen::Builder::default()
         .use_core()
         .default_enum_style(bindgen::EnumVariation::Rust {
             non_exhaustive: false,
         })
-        // Add the include directory
-        .clang_arg(format!("-I{}/include/", dst.display()))
         // Set the INPUTTINO_STATIC_DEFINE macro
-        .clang_arg(if build_static {"-D INPUTTINO_STATIC_DEFINE=1"} else {""})
+        .clang_arg(if build_static { "-D INPUTTINO_STATIC_DEFINE=1" } else { "" })
         // The input header we would like to generate bindings for.
-        .header("wrapper.hpp")
-        // Finish the builder and generate the bindings.
-        .generate()
-        // Unwrap the Result and panic on failure.
-        .expect("Unable to generate bindings");
+        .header("wrapper.hpp");
+
+    if build_c_bindings {
+        let libdir_path = PathBuf::from("../../")
+            // Canonicalize the path as `rustc-link-search` requires an absolute
+            // path.
+            .canonicalize()
+            .expect("cannot canonicalize path");
+
+        // Compile the library using CMake
+        let dst = Config::new(libdir_path)
+            .define("BUILD_SHARED_LIBS", if build_static { "OFF" } else { "ON" })
+            .define("LIBINPUTTINO_INSTALL", "ON")
+            .define("BUILD_TESTING", "OFF")
+            .define("BUILD_SERVER", "OFF")
+            .define("BUILD_C_BINDINGS", "ON")
+            .profile("Release")
+            .define("CMAKE_CONFIGURATION_TYPES", "Release")
+            .build();
+
+        println!("cargo:rustc-link-search=native={}/lib", dst.display());
+        bindings = bindings.clang_arg(format!("-I{}/include/", dst.display()))
+    } else {
+        let lib = pkg_config::probe_library("libinputtino").unwrap();
+        bindings = bindings.clang_arg(format!("-I{}", lib.include_paths[0].display()));
+    }
+
+    // Dependencies
+    println!("cargo:rustc-link-lib=evdev");
+    println!("cargo:rustc-link-lib=stdc++");
+    println!("cargo:rustc-link-lib={}libinputtino", if build_static { "static=" } else { "" });
+
+    let out = bindings.generate().expect("Unable to generate bindings");
 
     // Write the bindings to the $OUT_DIR/bindings.rs file.
     let out_path = PathBuf::from(env::var("OUT_DIR").unwrap()).join("bindings.rs");
-    bindings
+    out
         .write_to_file(out_path)
         .expect("Couldn't write bindings!");
 }

bindings/rust/src/c_bindings.rs

@@ -0,0 +1,5 @@
+#![allow(non_upper_case_globals)]
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+#![allow(dead_code)]
+include!(concat!(env!("OUT_DIR"), "/bindings.rs"));

bindings/rust/src/common.rs

@@ -0,0 +1,76 @@
+use std::ffi::CString;
+use crate::c_bindings;
+
+#[allow(dead_code)]
+pub struct DeviceDefinition {
+    pub def: c_bindings::InputtinoDeviceDefinition,
+    // Keep those around since we are passing them as pointers
+    name: CString,
+    phys: CString,
+    uniq: CString,
+}
+
+impl DeviceDefinition {
+    pub fn new(name: &str, vendor_id: u16, product_id: u16, version: u16, phys: &str, uniq: &str) -> Self {
+        let name = CString::new(name).unwrap();
+        let phys = CString::new(phys).unwrap();
+        let uniq = CString::new(uniq).unwrap();
+        let def = c_bindings::InputtinoDeviceDefinition {
+            name: name.as_ptr(),
+            vendor_id: vendor_id,
+            product_id: product_id,
+            version: version,
+            device_phys: phys.as_ptr(), // TODO: optional, if not present random MAC address
+            device_uniq: uniq.as_ptr(),
+        };
+        DeviceDefinition { def, name, phys, uniq }
+    }
+}
+
+pub unsafe extern "C" fn error_handler_fn(error_message: *const ::core::ffi::c_char,
+                                          user_data: *mut ::core::ffi::c_void) {
+    let error_str = std::ffi::CStr::from_ptr(error_message);
+    let user_data = user_data as *mut CString;
+    *user_data = CString::from(error_str);
+}
+
+
+#[macro_export]
+macro_rules! get_nodes {
+    ( $fn_call:expr,$var:expr ) => {
+        {
+            let mut nodes_count: core::ffi::c_int = 0;
+            let nodes = $fn_call($var, &mut nodes_count);
+            if nodes.is_null() {
+                return Err("Failed to get nodes".to_string());
+            }
+
+            let mut result = Vec::new();
+            for i in 0..nodes_count {
+                let node = std::ffi::CString::from_raw(*nodes.offset(i as isize));
+                result.push(node.to_str().unwrap().to_string());
+            }
+            Ok(result)
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! make_device {
+    ($fn_call:expr, $device:expr) => {
+        {
+            let mut error_str = std::ffi::CString::new("").unwrap();
+            let error_handler = crate::c_bindings::InputtinoErrorHandler {
+                eh: Some(error_handler_fn),
+                user_data: &mut error_str as *mut _ as *mut std::ffi::c_void,
+            };
+            let device = $fn_call(&$device.def, &error_handler);
+            if device.is_null() { // TODO: test this
+                let error_msg = (&mut error_str as *mut std::ffi::CString).as_ref().unwrap().to_str().unwrap();
+                Err(format!("Failed to create input device: {error_msg}"))
+            } else {
+                Ok(device)
+            }
+        }
+    };
+}

bindings/rust/src/joypad.rs

@@ -0,0 +1,67 @@
+use strum_macros::FromRepr;
+
+use crate::{
+    DeviceDefinition, JoypadStickPosition, PS5Joypad, SwitchJoypad, XboxOneJoypad
+};
+
+#[derive(Debug, FromRepr)]
+#[repr(u8)]
+pub enum JoypadKind {
+	Unknown = 0x00,
+	Xbox = 0x01,
+	PlayStation = 0x02,
+	Nintendo = 0x03,
+}
+
+#[repr(u8)]
+pub enum Joypad {
+    XOne(XboxOneJoypad),
+    PS5(PS5Joypad),
+    Switch(SwitchJoypad),
+}
+
+impl Joypad {
+    pub fn new(kind: &JoypadKind, device: &DeviceDefinition) -> Result<Joypad, String> {
+        match kind {
+            JoypadKind::Unknown | JoypadKind::Xbox => XboxOneJoypad::new(device).map(Joypad::XOne),
+            JoypadKind::PlayStation => PS5Joypad::new(device).map(Joypad::PS5),
+            JoypadKind::Nintendo => SwitchJoypad::new(device).map(Joypad::Switch),
+        }
+    }
+
+    pub fn new_xone(device: &DeviceDefinition) -> Result<Joypad, String> {
+        Joypad::new(&JoypadKind::Xbox, device)
+    }
+
+    pub fn new_ps5(device: &DeviceDefinition) -> Result<Joypad, String> {
+        Joypad::new(&JoypadKind::PlayStation, device)
+    }
+
+    pub fn new_switch(device: &DeviceDefinition) -> Result<Joypad, String> {
+        Joypad::new(&JoypadKind::Xbox, device)
+    }
+
+    pub fn set_pressed(&self, buttons: i32) {
+        match self {
+            Joypad::XOne(joypad) => joypad.set_pressed(buttons),
+            Joypad::PS5(joypad) => joypad.set_pressed(buttons),
+            Joypad::Switch(joypad) => joypad.set_pressed(buttons),
+        }
+    }
+
+    pub fn set_triggers(&self, left_trigger: i16, right_trigger: i16) {
+        match self {
+            Joypad::XOne(joypad) => joypad.set_triggers(left_trigger, right_trigger),
+            Joypad::PS5(joypad) => joypad.set_triggers(left_trigger, right_trigger),
+            Joypad::Switch(joypad) => joypad.set_triggers(left_trigger, right_trigger),
+        }
+    }
+
+    pub fn set_stick(&self, stick_type: JoypadStickPosition, x: i16, y: i16) {
+        match self {
+            Joypad::XOne(joypad) => joypad.set_stick(stick_type, x, y),
+            Joypad::PS5(joypad) => joypad.set_stick(stick_type, x, y),
+            Joypad::Switch(joypad) => joypad.set_stick(stick_type, x, y),
+        }
+    }
+}

bindings/rust/src/joypad_nintendo.rs

@@ -0,0 +1,79 @@
+use std::ffi::{c_int, c_void};
+use crate::c_bindings::{
+    inputtino_joypad_switch_create,
+    inputtino_joypad_switch_destroy,
+    inputtino_joypad_switch_get_nodes,
+    inputtino_joypad_switch_set_on_rumble,
+    inputtino_joypad_switch_set_pressed_buttons,
+    inputtino_joypad_switch_set_stick,
+    inputtino_joypad_switch_set_triggers,
+};
+use crate::common::{DeviceDefinition, error_handler_fn};
+use crate::{get_nodes, make_device, JoypadStickPosition};
+
+pub struct SwitchJoypad {
+    joypad: *mut crate::c_bindings::InputtinoSwitchJoypad,
+    on_rumble_fn: Box<dyn FnMut(i32, i32) -> ()>,
+}
+
+impl SwitchJoypad {
+    pub fn new(device: &DeviceDefinition) -> Result<Self, String> {
+        unsafe {
+            let dev = make_device!(inputtino_joypad_switch_create, device);
+            match dev {
+                Ok(joypad) => {
+                    Ok(SwitchJoypad { joypad, on_rumble_fn: Box::new(|_, _| {}) })
+                }
+                Err(e) => Err(e),
+            }
+        }
+    }
+
+    pub fn get_nodes(&self) -> Result<Vec<String>, String> {
+        unsafe {
+            get_nodes!(inputtino_joypad_switch_get_nodes, self.joypad)
+        }
+    }
+
+    pub fn set_pressed(&self, buttons: i32) {
+        unsafe {
+            inputtino_joypad_switch_set_pressed_buttons(self.joypad, buttons);
+        }
+    }
+
+    pub fn set_triggers(&self, left_trigger: i16, right_trigger: i16) {
+        unsafe {
+            inputtino_joypad_switch_set_triggers(self.joypad, left_trigger, right_trigger);
+        }
+    }
+
+    pub fn set_stick(&self, stick_type: JoypadStickPosition, x: i16, y: i16) {
+        unsafe {
+            inputtino_joypad_switch_set_stick(self.joypad, stick_type, x, y);
+        }
+    }
+
+    pub fn set_on_rumble(&mut self, on_rumble_fn: impl FnMut(i32, i32) -> () + 'static) {
+        self.on_rumble_fn = Box::new(on_rumble_fn);
+        unsafe {
+            let state_ptr = self as *const _ as *mut c_void;
+            inputtino_joypad_switch_set_on_rumble(self.joypad, Some(on_rumble_c_fn), state_ptr);
+        }
+    }
+}
+
+impl Drop for SwitchJoypad {
+    fn drop(&mut self) {
+        unsafe {
+            inputtino_joypad_switch_destroy(self.joypad);
+        }
+    }
+}
+
+#[allow(dead_code)]
+pub unsafe extern "C" fn on_rumble_c_fn(left_motor: c_int, right_motor: c_int, user_data: *mut ::core::ffi::c_void) {
+    let joypad: &mut SwitchJoypad = &mut *(user_data as *mut SwitchJoypad);
+    ((*joypad).on_rumble_fn)(left_motor, right_motor);
+}
+
+unsafe impl Send for SwitchJoypad { }