usehid 0.1.2

Cross-platform virtual HID device library for AI agents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

//! Virtual Mouse implementation

use crate::error::Result;
use crate::hid::MouseReport;
use crate::platform::HidBackend;
use crate::Device;
use bitflags::bitflags;
use serde::{Deserialize, Serialize};

bitflags! {
    /// Mouse button flags
    #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
    pub struct MouseButton: u8 {
        const LEFT = 0x01;
        const RIGHT = 0x02;
        const MIDDLE = 0x04;
        const BUTTON4 = 0x08;
        const BUTTON5 = 0x10;
    }
}

/// Virtual mouse device
pub struct Mouse {
    backend: Option<Box<dyn HidBackend>>,
    report: MouseReport,
    name: String,
}

impl Mouse {
    /// Create a new virtual mouse
    pub fn new() -> Self {
        Self::with_name("useHID Virtual Mouse")
    }
    
    /// Create a new virtual mouse with custom name
    pub fn with_name(name: &str) -> Self {
        Self {
            backend: None,
            report: MouseReport::default(),
            name: name.to_string(),
        }
    }
    
    /// Move mouse by relative offset
    pub fn move_by(&mut self, dx: i32, dy: i32) -> Result<()> {
        // Clamp to i8 range, may need multiple reports for large movements
        let steps_x = (dx.abs() + 126) / 127;
        let steps_y = (dy.abs() + 126) / 127;
        let steps = steps_x.max(steps_y).max(1);
        
        for i in 0..steps {
            let x = if i < steps_x {
                (dx.signum() * (dx.abs() / steps).min(127)) as i8
            } else {
                0
            };
            let y = if i < steps_y {
                (dy.signum() * (dy.abs() / steps).min(127)) as i8
            } else {
                0
            };
            
            self.report.x = x;
            self.report.y = y;
            self.send_report()?;
        }
        
        self.report.x = 0;
        self.report.y = 0;
        Ok(())
    }
    
    /// Press mouse button(s)
    pub fn press(&mut self, button: MouseButton) -> Result<()> {
        self.report.buttons |= button.bits();
        self.send_report()
    }
    
    /// Release mouse button(s)
    pub fn release(&mut self, button: MouseButton) -> Result<()> {
        self.report.buttons &= !button.bits();
        self.send_report()
    }
    
    /// Click (press and release) mouse button
    pub fn click(&mut self, button: MouseButton) -> Result<()> {
        self.press(button)?;
        std::thread::sleep(std::time::Duration::from_millis(10));
        self.release(button)
    }
    
    /// Double click
    pub fn double_click(&mut self, button: MouseButton) -> Result<()> {
        self.click(button)?;
        std::thread::sleep(std::time::Duration::from_millis(50));
        self.click(button)
    }
    
    /// Scroll wheel
    pub fn scroll(&mut self, delta: i8) -> Result<()> {
        self.report.wheel = delta;
        self.send_report()?;
        self.report.wheel = 0;
        Ok(())
    }
    
    fn send_report(&self) -> Result<()> {
        if let Some(backend) = &self.backend {
            backend.send_report(self.report.as_bytes())
        } else {
            Err(crate::error::Error::DeviceNotCreated)
        }
    }
}

impl Default for Mouse {
    fn default() -> Self {
        Self::new()
    }
}

impl Device for Mouse {
    fn create(&mut self) -> Result<()> {
        if self.backend.is_some() {
            return Err(crate::error::Error::DeviceAlreadyExists);
        }
        
        let backend = crate::platform::create_mouse_backend(&self.name)?;
        self.backend = Some(backend);
        Ok(())
    }
    
    fn destroy(&mut self) -> Result<()> {
        if let Some(backend) = self.backend.take() {
            backend.destroy()
        } else {
            Err(crate::error::Error::DeviceNotCreated)
        }
    }
    
    fn is_created(&self) -> bool {
        self.backend.is_some()
    }
}