Crate async_std_hidg

Source

Expand description

§HID Gadget Emulation in Rust

Rust crate for interfacing with Linux HID Gadget devices (/dev/hidgX). This crate supports async-std async runtime.

Since all functionality is dependent on Linux function calls, this crate only compiles for Linux systems.

§Crates

hidg-core - core abstractions and low level interface (not for end users)
hidg - std interface which supports synchronous operation only
tokio-hidg - async interface for tokio adepts
async-std-hidg - async interface for async-std adepts

§Features

fromstr - implements core::str::FromStr implementation for some types
display - implements std::fmt::Display implementation for some types
phf - use phf in core::str::FromStr trait implementations
serde - enables serde support for some types
keyboard - enables keyboard class support
mouse - enables mouse class support

§Usage examples

Keyboard input simulation:

use async_std_hidg::{Class, Device, Keyboard, Key, Led, StateChange};

#[async_std::main]
async fn main() -> std::io::Result<()> {
    let mut device = Device::<Keyboard>::open("hidg0").await?; // open device

    // Create input report
    let mut input = Keyboard.input();

    // Press left ctrl modifier
    input.press_key(Key::LeftCtrl);

    // Press key 'A'
    input.press_key(Key::A);

    // Print pressed keys
    println!("Keys: {:?}", input.pressed().collect::<Vec<Key>>());

    // Send input report
    device.input(&input).await?;

    // Release left ctrl modifier
    input.release_key(Key::LeftCtrl);

    // Release key 'A'
    input.release_key(Key::A);

    // Send input report
    device.input(&input).await?;

    // Create output report
    let mut output = Keyboard.output();

    // Receive output report
    device.output(&mut output).await?;

    // Print lit LEDs
    println!("LEDs: {:?}", output.lit().collect::<Vec<Led>>());

    Ok(())
}

Mouse input simulation:

use async_std_hidg::{Button, Class, Device, Mouse, StateChange, ValueChange};

#[async_std::main]
async fn main() -> std::io::Result<()> {
    let mut device = Device::<Mouse>::open("hidg0").await?; // open device

    // Create input report
    let mut input = Mouse.input();

    // Press primary button
    input.press_button(Button::Primary);

    // Set pointer coordinates
    input.change_pointer((150, 50), false);

    // Send input report
    device.input(&input).await?;

    // Move pointer relatively
    input.change_pointer((70, -30), true);

    // Print pressed buttons
    println!("Buttons: {:?}", input.pressed().collect::<Vec<Button>>());

    // Release primary button
    input.release_button(Button::Primary);

    // Send input report
    device.input(&input).await?;

    Ok(())
}

Structs§

Buttons: Button mask
Device: HID Gadget Device
Error: The error type for I/O operations of the Read, Write, Seek, and associated traits.
KeyStateChanges: Changes between keyboard input reports
Keyboard: Keyboard HID class
KeyboardInput: Keyboard input report
KeyboardOutput: Keyboard output report
LedStateChanges: Changes between keyboard output reports
Leds: LED mask
Modifiers: Modifier mask
Mouse: Mouse HID class
MouseInput: Mouse input report
MouseInputChanges: Changes between mouse input reports
MouseOutput: Keyboard output report
StateChange: Key/button/LED state change event
ValueChange: Pointer/cursor position change event

Enums§

Button: Button code
Key: Key code
Led: LED code
MouseInputChange: Change between mouse input reports

Traits§

Class: Device class trait

Type Aliases§

Result: A specialized Result type for I/O operations.

Crate async_std_hidgCopy item path