evdev

https://docs.rs/evdev/latest
Admin
A Rust library for handling Linux input devices (evdev) with support for reading input events, force...
Tokens:173,909
Snippets:1,890
Trust Score:9.1
Update:54 minutes ago
Show doc for...
Tokens:
Raw
### supported_keys method with example

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Returns the set of supported keys reported by the device. For keyboards, this is all possible keycodes the keyboard may emit; controllers, mice, and other peripherals may also report buttons as keys. The example checks if the device has an ENTER key.

```rust
pub fn supported_keys(&self) -> Option<&AttributeSetRef<KeyCode>> {
    self.raw.supported_keys()
}
```

```rust
/// # Examples
///
/// ```no_run
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use evdev::{Device, KeyCode};
/// let device = Device::open("/dev/input/event0")?;
///
/// // Does this device have an ENTER key?
/// let supported = device.supported_keys().map_or(false, |keys| keys.contains(KeyCode::KEY_ENTER));
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### Event handling example with EventSummary

Source: https://docs.rs/evdev/latest/src/evdev/lib.rs.html

Shows how to iterate over events and match on EventSummary variants to handle key presses, releases, and absolute axis movements. The example prints event details and includes an unreachable!() at the end, likely for demonstration purposes.

```rust
//!                 println!("Key {:?} was released", key_type);
//!             },
//!             EventSummary::AbsoluteAxis(_, axis, value) => {
//!                 println!("The Axis {:?} was moved to {}", axis, value);
//!             },
//!             _ => println!("got a different event!")
//!         }
//!     }
//! }
//! # unreachable!()
//! # }
```

--------------------------------

### supported_switches method with example

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Returns the set of supported switches reported by the device, typically used for laptop lid switches or headphone jack detection. The example checks if the device reports a laptop lid switch.

```rust
pub fn supported_switches(&self) -> Option<&AttributeSetRef<SwitchCode>> {
    self.raw.supported_switches()
}
```

```rust
/// # Examples
///
/// ```no_run
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use evdev::{Device, SwitchCode};
/// let device = Device::open("/dev/input/event0")?;
///
/// // Does the device report a laptop lid switch?
/// let supported = device
///     .supported_switches()
///     .map_or(false, |axes| axes.contains(SwitchCode::SW_LID));
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### UinputAbsSetup::new

Source: https://docs.rs/evdev/latest/evdev/struct.UinputAbsSetup.html

Creates a new `UinputAbsSetup` instance. This constructor takes an axis code and absolute axis information to initialize the setup.

```APIDOC
## UinputAbsSetup::new

### Description
Creates a new `UinputAbsSetup` instance.

### Method
`pub fn new(code: AbsoluteAxisCode, absinfo: AbsInfo) -> Self`

### Parameters
- **code** (`AbsoluteAxisCode`) - The absolute axis code.
- **absinfo** (`AbsInfo`) - The absolute axis information.

### Returns
- `Self` - A new `UinputAbsSetup` instance.

```

--------------------------------

### Create evdev Device from an existing file descriptor with Device::from_fd

Source: https://docs.rs/evdev/latest/evdev/

Creates a device from an already open file descriptor, useful when the descriptor is provided by an external privileged process such as systemd's logind. The example opens the file and converts it to an OwnedFd before passing it to Device::from_fd.

```rust
use evdev::Device;
use std::fs::File;
use std::os::fd::OwnedFd;
let f = File::open("/dev/input/event0")?;
let fd = OwnedFd::from(f);
let device = Device::from_fd(fd)?;
```

--------------------------------

### enumerate

Source: https://docs.rs/evdev/latest/evdev/

Crawls the /dev/input directory to discover available evdev devices. Returns an iterator over device paths.

```APIDOC
## Function: enumerate

### Description
Crawls `/dev/input` for evdev devices.

### Signature
`pub fn enumerate() -> impl Iterator<Item = PathBuf>`

### Returns
An iterator over device paths found in `/dev/input`.
```

--------------------------------

### supported_absolute_axes method with example

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Returns the set of supported absolute axes reported by the device, most typically supported by joysticks and touchpads. The example checks if the device has an absolute X axis.

```rust
pub fn supported_absolute_axes(&self) -> Option<&AttributeSetRef<AbsoluteAxisCode>> {
    self.raw.supported_absolute_axes()
}
```

```rust
/// # Examples
///
/// ```no_run
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use evdev::{Device, AbsoluteAxisCode};
/// let device = Device::open("/dev/input/event0")?;
///
/// // Does the device have an absolute X axis?
/// let supported = device
///     .supported_absolute_axes()
///     .map_or(false, |axes| axes.contains(AbsoluteAxisCode::ABS_X));
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### supported_relative_axes method with example

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Returns the set of supported relative axes reported by the device. Standard mice generally report REL_X and REL_Y along with wheel if supported. The example checks if the device has a scroll wheel.

```rust
pub fn supported_relative_axes(&self) -> Option<&AttributeSetRef<RelativeAxisCode>> {
    self.raw.supported_relative_axes()
}
```

```rust
/// # Examples
///
/// ```no_run
/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
/// use evdev::{Device, RelativeAxisCode};
/// let device = Device::open("/dev/input/event0")?;
///
/// // Does the device have a scroll wheel?
/// let supported = device
///     .supported_relative_axes()
///     .map_or(false, |axes| axes.contains(RelativeAxisCode::REL_WHEEL));
/// # Ok(())
/// # }
/// ```
```

--------------------------------

### Check device support for a key using Device::supported_keys()

Source: https://docs.rs/evdev/latest/evdev/

Opens an evdev device and checks whether it supports the ENTER key via `Device::supported_keys()` and `KeyCode::KEY_ENTER`. Prints a message based on the result. Requires a valid device path like `/dev/input/event0`.

```rust
use evdev::{Device, KeyCode};
let device = Device::open("/dev/input/event0")?;
// check if the device has an ENTER key
if device.supported_keys().map_or(false, |keys| keys.contains(KeyCode::KEY_ENTER)) {
    println!("are you prepared to ENTER the world of evdev?");
} else {
    println!(":(");
}
```

--------------------------------

### VirtualDeviceBuilder::build

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDeviceBuilder.html

Finalizes and registers this device. Returns an error if device setup or creation fails.

```APIDOC
## VirtualDeviceBuilder::build

### Description
Finalizes and registers this device.

### Method
`pub fn build(self) -> Result<VirtualDevice>`

### Parameters
None.

### Returns
- `Result<VirtualDevice>` - The created virtual device, or an error if device setup or creation fails.

### Errors
Returns an error if device setup or creation fails.
```

--------------------------------

### Open evdev device by path with Device::open

Source: https://docs.rs/evdev/latest/evdev/

Opens an input device directly from its path, e.g. /dev/input/event0. Requires appropriate privileges, typically root, to access the device node.

```rust
use evdev::Device;
let device = Device::open("/dev/input/event0")?;
```

--------------------------------

### UinputAbsSetup::absinfo

Source: https://docs.rs/evdev/latest/evdev/struct.UinputAbsSetup.html

Returns the absolute axis information of the uinput absolute setup. This method provides access to the `absinfo` field of the underlying `uinput_abs_setup` struct.

```APIDOC
## UinputAbsSetup::absinfo

### Description
Returns the absolute axis information of the uinput absolute setup.

### Method
`pub fn absinfo(&self) -> AbsInfo`

### Parameters
None

### Returns
- `AbsInfo` - The absolute axis information.

```

--------------------------------

### Destructure InputEvent into EventSummary example

Source: https://docs.rs/evdev/latest/evdev/struct.InputEvent.html

Example from the destructure method documentation. Creates an InputEvent with type 1, key code KEY_A, and value 1, then matches the destructured EventSummary to verify it is a Key event. Panics if the match fails.

```rust
use evdev::*;
let event =  InputEvent::new(1, KeyCode::KEY_A.0, 1);
match event.destructure() {
    EventSummary::Key(KeyEvent, KeyCode::KEY_A, 1) => (),
    _=> panic!(),
}
```

--------------------------------

### UinputAbsSetup::code

Source: https://docs.rs/evdev/latest/evdev/struct.UinputAbsSetup.html

Returns the axis code of the uinput absolute setup. This method provides access to the `code` field of the underlying `uinput_abs_setup` struct.

```APIDOC
## UinputAbsSetup::code

### Description
Returns the axis code of the uinput absolute setup.

### Method
`pub fn code(&self) -> u16`

### Parameters
None

### Returns
- `u16` - The axis code.

```

--------------------------------

### Match events using InputEvent::destructure and EventSummary

Source: https://docs.rs/evdev/latest/evdev/

Continuously fetches events from a device and matches them using `InputEvent::destructure()` to handle key presses, key releases, and absolute axis movements. Uses `EventSummary` variants and prints relevant information for each event type.

```rust
use evdev::*;
let mut device = Device::open("/dev/input/event0")?;
loop {
    for event in device.fetch_events().unwrap(){
        match event.destructure(){
            EventSummary::Key(ev, KeyCode::KEY_A, 1) => {
                println!("Key 'a' was pressed, got event: {:?}", ev);
            },
            EventSummary::Key(_, key_type, 0) => {
                println!("Key {:?} was released", key_type);
            },
            EventSummary::AbsoluteAxis(_, axis, value) => {
                println!("The Axis {:?} was moved to {}", axis, value);
            },
            _ => println!("got a different event!")
        }
    }
}
```

--------------------------------

### get_absinfo

Source: https://docs.rs/evdev/latest/evdev/struct.Device.html

Get the AbsInfo for each supported AbsoluteAxis.

```APIDOC
## get_absinfo

### Description
Get the AbsInfo for each supported AbsoluteAxis.

### Method
pub fn get_absinfo(&self) -> Result<impl Iterator<Item = (AbsoluteAxisCode, AbsInfo)> + '_>

### Parameters
None

### Returns
- **Result<impl Iterator<Item = (AbsoluteAxisCode, AbsInfo)> + '_>** - An iterator over supported absolute axes and their AbsInfo.
```

--------------------------------

### VirtualDevice::enumerate_dev_nodes

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDevice.html

Get the syspaths of the corresponding device nodes in /dev/input. Available on crate feature `tokio` only.

```APIDOC
## VirtualDevice::enumerate_dev_nodes

### Description
Get the syspaths of the corresponding device nodes in /dev/input. Available on crate feature `tokio` only.

### Method
`pub async fn enumerate_dev_nodes(&mut self) -> Result<DevNodes>`

### Parameters
None

### Returns
- `Result<DevNodes>` - A result containing a `DevNodes` iterator.
```

--------------------------------

### get_absinfo

Source: https://docs.rs/evdev/latest/evdev/raw_stream/struct.RawDevice.html

Get the AbsInfo for each supported AbsoluteAxis

```APIDOC
## get_absinfo

### Description
Get the AbsInfo for each supported AbsoluteAxis

### Method
pub fn get_absinfo(&self) -> Result<impl Iterator<Item = (AbsoluteAxisCode, AbsInfo)> + '_>

### Parameters
None

### Returns
- **Result<impl Iterator<Item = (AbsoluteAxisCode, AbsInfo)> + '_>** - An iterator over the supported absolute axes and their AbsInfo.
```

--------------------------------

### UinputAbsSetup

Source: https://docs.rs/evdev/latest/src/evdev/lib.rs.html

A wrapped `uinput_abs_setup`, used to set up analogue axes with uinput. Provides accessors for the code and absinfo fields, and a constructor for creating new instances.

```APIDOC
## UinputAbsSetup

### Description
A wrapped `uinput_abs_setup`, used to set up analogue axes with uinput. Provides accessors for the code and absinfo fields, and a constructor for creating new instances.

### Methods
- `code(&self) -> u16` - Returns the `code` field.
- `absinfo(&self) -> AbsInfo` - Returns the `absinfo` field as an `AbsInfo`.
- `new(code: AbsoluteAxisCode, absinfo: AbsInfo) -> Self` - Creates a new `UinputAbsSetup` instance.
```

--------------------------------

### get_absinfo

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Get the AbsInfo for each supported AbsoluteAxis.

```APIDOC
## get_absinfo

### Description
Get the AbsInfo for each supported AbsoluteAxis.

### Method
get_absinfo

### Parameters
None

### Returns
- `io::Result<impl Iterator<Item = (AbsoluteAxisCode, AbsInfo)> + '_>` - An iterator over supported absolute axes and their AbsInfo.
```

--------------------------------

### RawDevice::open and _open methods

Source: https://docs.rs/evdev/latest/src/evdev/raw_stream.rs.html

Opens a device by its system path (e.g., /dev/input/event0). Attempts read/write access first, then falls back to read-only if that fails.

```rust
    /// Opens a device, given its system path.
    ///
    /// Paths are typically something like `/dev/input/event0`.
    #[inline(always)]
    pub fn open(path: impl AsRef<Path>) -> io::Result<RawDevice> {
        Self::_open(path.as_ref())
    }

    fn _open(path: &Path) -> io::Result<RawDevice> {
        let mut options = OpenOptions::new();

        // Try to load read/write, then fall back to read-only.
        let fd: OwnedFd = options
            .read(true)
            .write(true)
            .open(path)
            .or_else(|_| options.write(false).open(path))?
            .into();

        Self::from_fd(fd)
    }
```

--------------------------------

### VirtualDevice::builder

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDevice.html

Convenience method for creating a VirtualDeviceBuilder.

```APIDOC
## VirtualDevice::builder

### Description
Convenience method for creating a `VirtualDeviceBuilder`.

### Method
`pub fn builder<'a>() -> Result<VirtualDeviceBuilder<'a>>`

### Parameters
None

### Returns
- `Result<VirtualDeviceBuilder<'a>>` - A result containing a `VirtualDeviceBuilder` on success.
```

--------------------------------

### VirtualDevice::get_syspath

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDevice.html

Get the syspath representing this uinput device.

```APIDOC
## VirtualDevice::get_syspath

### Description
Get the syspath representing this uinput device. The syspath returned is the one of the input node itself (e.g. `/sys/devices/virtual/input/input123`), not the syspath of the device node.

### Method
`pub fn get_syspath(&mut self) -> Result<PathBuf>`

### Parameters
None

### Returns
- `Result<PathBuf>` - A result containing the syspath as a `PathBuf`.
```

--------------------------------

### Device::get_scancode_by_index

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Retrieve the keycode and scancode by index, starting at 0.

```APIDOC
## Device::get_scancode_by_index

### Description
Retrieve the keycode and scancode by index, starting at 0.

### Method
get_scancode_by_index

### Signature
pub fn get_scancode_by_index(&self, index: u16) -> io::Result<(u32, Vec<u8>)>

### Parameters
- **index** (u16) - Required - The index to look up.

### Returns
- **io::Result<(u32, Vec<u8>)>** - A tuple of keycode and scancode bytes, or an I/O error.
```

--------------------------------

### RawDevice::from_fd method

Source: https://docs.rs/evdev/latest/src/evdev/raw_stream.rs.html

Constructs a RawDevice from an already opened file descriptor. Queries device type, name, phys, uniq, id, and driver version via ioctls.

```rust
    /// Opens a device, given an already opened file descriptor
    pub fn from_fd(fd: OwnedFd) -> io::Result<RawDevice> {
        let ty = {
            let mut ty = AttributeSet::<EventType>::new();
            unsafe { sys::eviocgbit_type(fd.as_raw_fd(), ty.as_mut_raw_slice())? };
            ty
        };

        let name = ioctl_get_cstring(sys::eviocgname, fd.as_raw_fd()).map(bytes_into_string_lossy);
        let phys = ioctl_get_cstring(sys::eviocgphys, fd.as_raw_fd()).map(bytes_into_string_lossy);
        let uniq = ioctl_get_cstring(sys::eviocguniq, fd.as_raw_fd()).map(bytes_into_string_lossy);

        let id = unsafe {
            let mut id = MaybeUninit::uninit();
            sys::eviocgid(fd.as_raw_fd(), id.as_mut_ptr())?;
            id.assume_init()
        };
        let mut driver_version: i32 = 0;
        unsafe {
            sys::eviocgversion(fd.as_raw_fd(), &mut driver_version)?;
        }
```

--------------------------------

### get_scancode_by_index

Source: https://docs.rs/evdev/latest/evdev/raw_stream/struct.RawDevice.html

Retrieve the keycode and scancode by index, starting at 0

```APIDOC
## get_scancode_by_index

### Description
Retrieve the keycode and scancode by index, starting at 0

### Method
pub fn get_scancode_by_index(&self, index: u16) -> Result<(u32, Vec<u8>)>

### Parameters
- **index** (u16) - Required - The index of the scancode entry.

### Returns
- **Result<(u32, Vec<u8>)>** - A tuple containing the keycode and scancode.
```

--------------------------------

### grab

Source: https://docs.rs/evdev/latest/evdev/raw_stream/struct.RawDevice.html

Grab the device for exclusive use.

```APIDOC
## grab

### Description
Grab the device for exclusive use.

### Method
pub fn grab(&mut self) -> Result<()>

### Parameters
None

### Returns
- **Result<()>** - Indicates success or failure.
```

--------------------------------

### into_event_stream

Source: https://docs.rs/evdev/latest/evdev/raw_stream/struct.RawDevice.html

Available on **crate feature `tokio`** only.

```APIDOC
## into_event_stream

### Description
Available on **crate feature `tokio`** only.

### Method
pub fn into_event_stream(self) -> Result<EventStream>

### Parameters
None

### Returns
- **Result<EventStream>** - An event stream.
```

--------------------------------

### Device::from_fd

Source: https://docs.rs/evdev/latest/evdev/struct.Device.html

Opens a device given an already opened file descriptor.

```APIDOC
## Device::from_fd

### Description
Opens a device given an already opened file descriptor.

### Method
from_fd

### Parameters
- **fd** (OwnedFd) - Required - The already opened file descriptor.

### Returns
- **Result<Device>** - The opened device or an error.
```

--------------------------------

### Device TryFrom<File> implementation

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Converts a File into a Device, returning io::Error on failure.

```rust
impl TryFrom<File> for Device {
    type Error = io::Error;

    fn try_from(file: File) -> Result<Self, Self::Error> {
        RawDevice::try_from(file).map(Self::from_raw_device)
    }
}
```

--------------------------------

### FFEraseEvent methods

Source: https://docs.rs/evdev/latest/src/evdev/uinput.rs.html

Provides access to force feedback erase event data and allows setting the return value.

```APIDOC
## FFEraseEvent methods

### Description
Represents a force feedback erase event being processed.

### Methods
- **effect_id** - Returns the effect ID to erase.
  - Signature: `pub fn effect_id(&self) -> u32`
- **retval** - Returns the currently set return value for the erase event.
  - Signature: `pub fn retval(&self) -> i32`
- **set_retval** - Sets the return value to return for the erase event.
  - Signature: `pub fn set_retval(&mut self, value: i32)`
```

--------------------------------

### EventType::MISC

Source: https://docs.rs/evdev/latest/evdev/struct.EventType.html

Miscellaneous events that don’t fall into other categories. For example, Key presses may send `MSC_SCAN` events before each KEY event

```APIDOC
## EventType::MISC

### Description
Miscellaneous events that don’t fall into other categories. For example, Key presses may send `MSC_SCAN` events before each KEY event

### Signature
`pub const MISC: Self`

### Availability
Unix only.
```

--------------------------------

### process_ff_erase

Source: https://docs.rs/evdev/latest/src/evdev/uinput.rs.html

Processes a force feedback erase event. This function starts the force feedback erasure and returns an `FFEraseEvent` that allows the user to access the effect ID.

```APIDOC
## process_ff_erase

### Description
Processes a force feedback erase event. This function starts the force feedback erasure and returns an `FFEraseEvent` that allows the user to access the effect ID.

### Method
process_ff_erase

### Signature
pub fn process_ff_erase(&mut self, event: UInputEvent) -> io::Result<FFEraseEvent>

### Parameters
- **event** (`UInputEvent`) - Required - The force feedback erase event to process.

### Returns
- **FFEraseEvent** - An event that allows the user to access the effect ID.

### Panics
This function will panic if `event.code()` is not `UI_FF_ERASE`.

### Errors
Returns an `io::Error` if the erasure cannot be started.
```

--------------------------------

### Device::open

Source: https://docs.rs/evdev/latest/evdev/struct.Device.html

Opens a device given its system path. Paths are typically something like /dev/input/event0.

```APIDOC
## Device::open

### Description
Opens a device given its system path. Paths are typically something like /dev/input/event0.

### Method
open

### Parameters
- **path** (impl AsRef<Path>) - Required - The system path to the device.

### Returns
- **Result<Device>** - The opened device or an error.
```

--------------------------------

### process_ff_upload

Source: https://docs.rs/evdev/latest/src/evdev/uinput.rs.html

Processes a force feedback upload event. This function starts the force feedback upload and returns an `FFUploadEvent` that allows the user to allocate and set the effect ID.

```APIDOC
## process_ff_upload

### Description
Processes a force feedback upload event. This function starts the force feedback upload and returns an `FFUploadEvent` that allows the user to allocate and set the effect ID.

### Method
process_ff_upload

### Signature
pub fn process_ff_upload(&mut self, event: UInputEvent) -> io::Result<FFUploadEvent>

### Parameters
- **event** (`UInputEvent`) - Required - The force feedback upload event to process.

### Returns
- **FFUploadEvent** - An event that allows the user to allocate and set the effect ID.

### Panics
This function will panic if `event.code()` is not `UI_FF_UPLOAD`.

### Errors
Returns an `io::Error` if the upload cannot be started.
```

--------------------------------

### Device open and from_fd constructors

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Provides public constructors for opening a device by path or from an existing file descriptor. The path-based open delegates to a private _open method that uses RawDevice::open.

```rust
impl Device {
    /// Opens a device, given its system path.
    ///
    /// Paths are typically something like `/dev/input/event0`.
    #[inline(always)]
    pub fn open(path: impl AsRef<Path>) -> io::Result<Device> {
        Self::_open(path.as_ref())
    }

    /// Opens a device, given an already opened file descriptor.
    #[inline(always)]
    pub fn from_fd(fd: OwnedFd) -> io::Result<Device> {
        RawDevice::from_fd(fd).map(Self::from_raw_device)
    }

    #[inline]
    fn _open(path: &Path) -> io::Result<Device> {
        RawDevice::open(path).map(Self::from_raw_device)
    }

    // TODO: should this be public?
    pub(crate) fn from_raw_device(raw: RawDevice) -> Device {
        let state = DeviceState::new(&raw);
        let prev_state = state.clone();

        Device {
            raw,
            prev_state,
            state,
            block_dropped: false,
        }
    }
```

--------------------------------

### Display implementation for Device

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Implements fmt::Display for Device, printing device name, driver version, physical address, unique name, bus type, vendor, product, version, properties, supported keys with pressed state, relative axes, absolute axes, misc capabilities, switches, LEDs, sounds, and force feedback/power/status support. Uses writeln! and write! macros.

```rust
impl fmt::Display for Device {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        writeln!(f, "{}:", self.name().unwrap_or("Unnamed device"))?;
        let (maj, min, pat) = self.driver_version();
        writeln!(f, "  Driver version: {maj}.{min}.{pat}")?;
        if let Some(ref phys) = self.physical_path() {
            writeln!(f, "  Physical address: {phys:?}")?;
        }
        if let Some(ref uniq) = self.unique_name() {
            writeln!(f, "  Unique name: {uniq:?}")?;
        }

        let id = self.input_id();

        writeln!(f, "  Bus: {}", id.bus_type())?;
        writeln!(f, "  Vendor: {:#x}", id.vendor())?;
        writeln!(f, "  Product: {:#x}", id.product())?;
        writeln!(f, "  Version: {:#x}", id.version())?;
        writeln!(f, "  Properties: {:?}", self.properties())?;

        if let (Some(supported_keys), Some(key_vals)) =
            (self.supported_keys(), self.state.key_vals())
        {
            writeln!(f, "  KeyTypes supported:")?;
            for key in supported_keys.iter() {
                let key_idx = key.code() as usize;
                writeln!(
                    f,
                    "    {:?} ({}index {})",
                    key,
                    if key_vals.contains(key) {
                        "pressed, "
                    } else {
                        ""
                    },
                    key_idx
                )?;
            }
        }

        if let Some(supported_relative) = self.supported_relative_axes() {
            writeln!(f, "  Relative Axes: {supported_relative:?}")?;
        }

        if let (Some(supported_abs), Some(abs_vals)) =
            (self.supported_absolute_axes(), &self.state.abs_vals)
        {
            writeln!(f, "  Absolute Axes:")?;
            for abs in supported_abs.iter() {
                writeln!(
                    f,
                    "    {:?} ({:?}, index {})",
                    abs, abs_vals[abs.0 as usize], abs.0
                )?;
            }
        }

        if let Some(supported_misc) = self.misc_properties() {
            writeln!(f, "  Miscellaneous capabilities: {supported_misc:?}")?;
        }

        if let (Some(supported_switch), Some(switch_vals)) =
            (self.supported_switches(), self.state.switch_vals())
        {
            writeln!(f, "  Switches:")?;
            for sw in supported_switch.iter() {
                writeln!(
                    f,
                    "    {:?} ({:?}, index {})",
                    sw,
                    switch_vals.contains(sw),
                    sw.0
                )?;
            }
        }

        if let (Some(supported_led), Some(led_vals)) =
            (self.supported_leds(), self.state.led_vals())
        {
            writeln!(f, "  LEDs:")?;
            for led in supported_led.iter() {
                writeln!(
                    f,
                    "    {:?} ({:?}, index {})",
                    led,
                    led_vals.contains(led),
                    led.0
                )?;
            }
        }

        if let Some(supported_snd) = self.supported_sounds() {
            write!(f, "  Sounds:")?;
            for snd in supported_snd.iter() {
                writeln!(f, "    {:?} (index {})", snd, snd.0)?;
            }
        }

        // if let Some(rep) = self.rep {
        //     writeln!(f, "  Repeats: {:?}", rep)?;
        // }

        let evs = self.supported_events();

        if evs.contains(EventType::FORCEFEEDBACK) {
            writeln!(f, "  Force Feedback supported")?;
        }

        if evs.contains(EventType::POWER) {
            writeln!(f, "  Power supported")?;
        }

        if evs.contains(EventType::FORCEFEEDBACKSTATUS) {
            writeln!(f, "  Force Feedback status supported")?;
        }

        Ok(())
    }
}
```

--------------------------------

### Query device capabilities and construct RawDevice

Source: https://docs.rs/evdev/latest/src/evdev/raw_stream.rs.html

Rust code that queries various device capabilities via evdev syscalls and constructs a RawDevice. It reads driver version, properties, supported keys, relative/absolute axes, switches, LEDs, misc codes, force feedback effects, sound codes, and auto-repeat settings. Uses unsafe sys calls and handles old kernels with a FIXME comment.

```rust
        let driver_version = (
            ((driver_version >> 16) & 0xff) as u8,
            ((driver_version >> 8) & 0xff) as u8,
            (driver_version & 0xff) as u8,
        );

        let props = {
            let mut props = AttributeSet::<PropType>::new();
            unsafe { sys::eviocgprop(fd.as_raw_fd(), props.as_mut_raw_slice())? };
            props
        }; // FIXME: handle old kernel

        let supported_keys = if ty.contains(EventType::KEY) {
            let mut keys = AttributeSet::<KeyCode>::new();
            unsafe { sys::eviocgbit_key(fd.as_raw_fd(), keys.as_mut_raw_slice())? };
            Some(keys)
        } else {
            None
        };

        let supported_relative = if ty.contains(EventType::RELATIVE) {
            let mut rel = AttributeSet::<RelativeAxisCode>::new();
            unsafe { sys::eviocgbit_relative(fd.as_raw_fd(), rel.as_mut_raw_slice())? };
            Some(rel)
        } else {
            None
        };

        let supported_absolute = if ty.contains(EventType::ABSOLUTE) {
            let mut abs = AttributeSet::<AbsoluteAxisCode>::new();
            unsafe { sys::eviocgbit_absolute(fd.as_raw_fd(), abs.as_mut_raw_slice())? };
            Some(abs)
        } else {
            None
        };

        let supported_switch = if ty.contains(EventType::SWITCH) {
            let mut switch = AttributeSet::<SwitchCode>::new();
            unsafe { sys::eviocgbit_switch(fd.as_raw_fd(), switch.as_mut_raw_slice())? };
            Some(switch)
        } else {
            None
        };

        let supported_led = if ty.contains(EventType::LED) {
            let mut led = AttributeSet::<LedCode>::new();
            unsafe { sys::eviocgbit_led(fd.as_raw_fd(), led.as_mut_raw_slice())? };
            Some(led)
        } else {
            None
        };

        let supported_misc = if ty.contains(EventType::MISC) {
            let mut misc = AttributeSet::<MiscCode>::new();
            unsafe { sys::eviocgbit_misc(fd.as_raw_fd(), misc.as_mut_raw_slice())? };
            Some(misc)
        } else {
            None
        };

        let supported_ff = if ty.contains(EventType::FORCEFEEDBACK) {
            let mut ff = AttributeSet::<FFEffectCode>::new();
            unsafe { sys::eviocgbit_ff(fd.as_raw_fd(), ff.as_mut_raw_slice())? };
            Some(ff)
        } else {
            None
        };

        let max_ff_effects = if ty.contains(EventType::FORCEFEEDBACK) {
            let mut max_ff_effects = 0;
            unsafe { sys::eviocgeffects(fd.as_raw_fd(), &mut max_ff_effects)? };
            usize::try_from(max_ff_effects).unwrap_or(0)
        } else {
            0
        };

        let supported_snd = if ty.contains(EventType::SOUND) {
            let mut snd = AttributeSet::<SoundCode>::new();
            unsafe { sys::eviocgbit_sound(fd.as_raw_fd(), snd.as_mut_raw_slice())? };
            Some(snd)
        } else {
            None
        };

        let auto_repeat = if ty.contains(EventType::REPEAT) {
            let mut auto_repeat: AutoRepeat = AutoRepeat {
                delay: 0,
                period: 0,
            };

            unsafe {
                sys::eviocgrep(
                    fd.as_raw_fd(),
                    &mut auto_repeat as *mut AutoRepeat as *mut [u32; 2],
                )?;
            }

            Some(auto_repeat)
        } else {
            None
        };

        Ok(RawDevice {
            fd,
            ty,
            name,
            phys,
            uniq,
            id,
            props,
            driver_version,
            supported_keys,
            supported_relative,
            supported_absolute,
            supported_switch,
            supported_led,
            supported_misc,
            supported_ff,
            supported_snd,
            auto_repeat,
            max_ff_effects,
            event_buf: Vec::new(),
            grabbed: false,
        })
```

--------------------------------

### try_into

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualEventStream.html

Performs the conversion from self into U.

```APIDOC
## try_into

### Description
Performs the conversion.

### Method
Function

### Signature
`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

### Returns
- `Result<U, <U as TryFrom<T>>::Error>` - The result of the conversion.

```

--------------------------------

### Tap::tap_borrow_dbg

Source: https://docs.rs/evdev/latest/evdev/struct.KeyCode.html

Calls `.tap_borrow()` only in debug builds, and is erased in release builds.

```APIDOC
## tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where Self: Borrow<B>, B: ?Sized

### Description
Calls `.tap_borrow()` only in debug builds, and is erased in release builds. The closure receives an immutable reference to the borrowed type, and the original value is returned.

### Method
`fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where Self: Borrow<B>, B: ?Sized`

### Parameters
- `self` (Self) - The value to tap.
- `func` (impl FnOnce(&B)) - A closure that takes an immutable reference to the borrowed type.

### Returns
- `Self` - The original value, unchanged.
```

--------------------------------

### VirtualDevice::emit

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDevice.html

Post a batch of events to the virtual device.

```APIDOC
## VirtualDevice::emit

### Description
Post a batch of events to the virtual device. The batch is automatically terminated with a `SYN_REPORT` event. Events from physical devices are batched based on if they occur simultaneously, for example movement of a mouse triggers a movement events for the X and Y axes separately in a batch of 2 events. Single events such as a `KEY` event must still be followed by a `SYN_REPORT`.

### Method
`pub fn emit(&mut self, events: &[InputEvent]) -> Result<()>`

### Parameters
- **events** (`&[InputEvent]`) - Required - A slice of `InputEvent` to post to the virtual device.

### Returns
- `Result<()>` - A result indicating success or failure.
```

--------------------------------

### LedCode::from_str

Source: https://docs.rs/evdev/latest/evdev/struct.LedCode.html

Parses a string to create a LedCode.

```APIDOC
## LedCode::from_str

### Description
Parses a string `s` to return a value of this type.

### Signature
`fn from_str(s: &str) -> Result<Self, Self::Err>`

### Parameters
- `s` (&str) - Required - The string to parse.

### Returns
- `Result<Self, Self::Err>` - The parsed LedCode or an error.
```

--------------------------------

### Device::properties

Source: https://docs.rs/evdev/latest/evdev/struct.Device.html

Returns the set of supported 'properties' for the device (see INPUT_PROP_* in kernel headers).

```APIDOC
## Device::properties

### Description
Returns the set of supported 'properties' for the device (see INPUT_PROP_* in kernel headers).

### Method
properties

### Returns
- **&AttributeSetRef<PropType>** - The set of supported properties.
```

--------------------------------

### into_event_stream

Source: https://docs.rs/evdev/latest/src/evdev/raw_stream.rs.html

Converts the device into an asynchronous event stream (requires the 'tokio' feature).

```APIDOC
## into_event_stream

### Description
Converts the device into an asynchronous event stream. This method is only available when the `tokio` feature is enabled.

### Method
Rust method

### Signature
```rust
pub fn into_event_stream(self) -> io::Result<EventStream>
```

### Returns
- `io::Result<EventStream>` - An event stream, or an I/O error.
```

--------------------------------

### VirtualDevice::into_event_stream

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDevice.html

Converts the virtual device into an event stream. Available on crate feature `tokio` only.

```APIDOC
## VirtualDevice::into_event_stream

### Description
Converts the virtual device into an event stream. Available on crate feature `tokio` only.

### Method
`pub fn into_event_stream(self) -> Result<VirtualEventStream>`

### Parameters
None

### Returns
- `Result<VirtualEventStream>` - A result containing a `VirtualEventStream`.
```

--------------------------------

### TryInto::try_into

Source: https://docs.rs/evdev/latest/evdev/struct.KeyCode.html

Performs the conversion from `self` to `U`.

```APIDOC
## try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from `self` to `U`. Returns a `Result` indicating success or failure.

### Method
`fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

### Parameters
- `self` (T) - The value to convert.

### Returns
- `Result<U, <U as TryFrom<T>>::Error>` - The converted value or an error.
```

--------------------------------

### VirtualDevice::fetch_events

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDevice.html

Fetches and returns events from the kernel ring buffer without doing synchronization on SYN_DROPPED.

```APIDOC
## VirtualDevice::fetch_events

### Description
Fetches and returns events from the kernel ring buffer without doing synchronization on SYN_DROPPED. By default this will block until events are available. Typically, users will want to call this in a tight loop within a thread.

### Method
`pub fn fetch_events(&mut self) -> Result<impl Iterator<Item = InputEvent> + '_>`

### Parameters
None

### Returns
- `Result<impl Iterator<Item = InputEvent> + '_>` - A result containing an iterator over `InputEvent`.
```

--------------------------------

### RawDevice::open

Source: https://docs.rs/evdev/latest/evdev/raw_stream/struct.RawDevice.html

Opens a device given its system path. The path is typically something like `/dev/input/event0`.

```APIDOC
## [Rust] RawDevice::open

### Description
Opens a device, given its system path. Paths are typically something like `/dev/input/event0`.

### Method
`pub fn open(path: impl AsRef<Path>) -> Result<RawDevice>`

### Parameters
- `path` (impl AsRef<Path>) - Required - The system path to the device.

### Returns
- `Result<RawDevice>` - The opened device or an error.
```

--------------------------------

### FFUploadEvent methods

Source: https://docs.rs/evdev/latest/src/evdev/uinput.rs.html

Provides access to force feedback upload event data and allows setting the effect ID and return value.

```APIDOC
## FFUploadEvent methods

### Description
Represents a force feedback upload event being processed.

### Methods
- **old_effect** - Returns the old effect data.
  - Signature: `pub fn old_effect(&self) -> FFEffectData`
- **effect_id** - Returns the new effect ID.
  - Signature: `pub fn effect_id(&self) -> i16`
- **set_effect_id** - Sets the new effect ID.
  - Signature: `pub fn set_effect_id(&mut self, id: i16)`
- **effect** - Returns the new effect data.
  - Signature: `pub fn effect(&self) -> FFEffectData`
- **retval** - Returns the currently set return value for the upload event.
  - Signature: `pub fn retval(&self) -> i32`
- **set_retval** - Sets the return value to return for the upload event.
  - Signature: `pub fn set_retval(&mut self, value: i32)`
```

--------------------------------

### Tap::tap_borrow_mut_dbg

Source: https://docs.rs/evdev/latest/evdev/struct.KeyCode.html

Calls `.tap_borrow_mut()` only in debug builds, and is erased in release builds.

```APIDOC
## tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut<B>, B: ?Sized

### Description
Calls `.tap_borrow_mut()` only in debug builds, and is erased in release builds. The closure receives a mutable reference to the borrowed type, and the original value is returned.

### Method
`fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut<B>, B: ?Sized`

### Parameters
- `self` (Self) - The value to tap.
- `func` (impl FnOnce(&mut B)) - A closure that takes a mutable reference to the borrowed type.

### Returns
- `Self` - The original value, unchanged.
```

--------------------------------

### SoundCode::from_str

Source: https://docs.rs/evdev/latest/evdev/struct.SoundCode.html

Parses a string to create a SoundCode.

```APIDOC
## from_str

### Description
Parses a string `s` to return a value of this type.

### Signature
`fn from_str(s: &str) -> Result<Self, Self::Err>`

### Parameters
- **s** (&str) - The string to parse.

### Returns
- `Result<Self, Self::Err>` - The parsed SoundCode or an error.
```

--------------------------------

### AbsInfo::new

Source: https://docs.rs/evdev/latest/evdev/struct.AbsInfo.html

Creates a new AbsInfo instance with the given field values. Particularly useful for uinput.

```APIDOC
## [Rust] AbsInfo::new

### Description
Creates a new `AbsInfo` with the specified field values. Particularly useful for uinput.

### Method
`pub fn new(value: i32, minimum: i32, maximum: i32, fuzz: i32, flat: i32, resolution: i32) -> Self`

### Parameters
- `value` (i32) - Required - The value field.
- `minimum` (i32) - Required - The minimum field.
- `maximum` (i32) - Required - The maximum field.
- `fuzz` (i32) - Required - The fuzz field.
- `flat` (i32) - Required - The flat field.
- `resolution` (i32) - Required - The resolution field.

### Returns
- `Self` - A new `AbsInfo` instance.
```

--------------------------------

### properties method

Source: https://docs.rs/evdev/latest/src/evdev/sync_stream.rs.html

Returns the set of supported properties for the device, referencing INPUT_PROP_* constants from kernel headers.

```rust
pub fn properties(&self) -> &AttributeSetRef<PropType> {
    self.raw.properties()
}
```

--------------------------------

### fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

Source: https://docs.rs/evdev/latest/evdev/raw_stream/struct.EnumerateDevices.html

Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well. This is a nightly-only experimental API.

```APIDOC
## fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>

### Description
Calls the given function `f` for each contiguous window of size `N` over `self` and returns an iterator over the outputs of `f`. Like `slice::windows()`, the windows during mapping overlap as well. This is a nightly-only experimental API.

### Method
`fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N>`

### Parameters
- `f` (F) - Required - A closure that takes a reference to an array of size `N` and returns a value of type `R`.

### Return Value
Returns a `MapWindows<Self, F, N>` iterator adapter.

```

--------------------------------

### fn partition<B, F>(self, f: F) -> (B, B)

Source: https://docs.rs/evdev/latest/evdev/raw_stream/struct.EnumerateDevices.html

Consumes an iterator, creating two collections from it.

```APIDOC
## fn partition<B, F>(self, f: F) -> (B, B)

### Description
Consumes an iterator, creating two collections from it.

### Method
`fn partition<B, F>(self, f: F) -> (B, B)`

### Parameters
- `f` (F) - Required - A closure that determines which collection each item goes into.

### Return Value
Returns a tuple of two collections.

```

--------------------------------

### VirtualDevice::process_ff_upload

Source: https://docs.rs/evdev/latest/evdev/uinput/struct.VirtualDevice.html

Processes the given `UInputEvent` if it is a force feedback upload event.

```APIDOC
## VirtualDevice::process_ff_upload

### Description
Processes the given `UInputEvent` if it is a force feedback upload event, in which case this function will start the force feedback upload and claim ownership over the `UInputEvent` and return a `FFUploadEvent` instead. The returned event allows the user to allocate and set the effect ID as well as access the effect data.

### Method
`pub fn process_ff_upload(&mut self, event: UInputEvent) -> Result<FFUploadEvent>`

### Parameters
- **event** (`UInputEvent`) - Required - The `UInputEvent` to process.

### Returns
- `Result<FFUploadEvent>` - A result containing a `FFUploadEvent` on success.

### Panics
This function will panic if `event.code()` is not `UI_FF_UPLOAD`.
```

--------------------------------

### into_event_stream

Source: https://docs.rs/evdev/latest/evdev/struct.Device.html

Converts the device into an asynchronous event stream. Available on crate feature `tokio` only.

```APIDOC
## into_event_stream

### Description
Converts the device into an asynchronous event stream. Available on crate feature `tokio` only.

### Method
pub fn into_event_stream(self) -> Result<EventStream>

### Parameters
None

### Returns
- **Result<EventStream>** - An asynchronous event stream.
```
Tokens:
Raw