rdevin 0.1.0

Cross-platform simulation and global listening for keyboard and mouse input.
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use rdevin::{simulate, EventType, Key, SimulateError};
use std::{thread, time};

fn send(event_type: &EventType) {
    let delay = time::Duration::from_millis(20);
    match simulate(event_type) {
        Ok(()) => (),
        Err(SimulateError) => {
            println!("We could not send {:?}", event_type);
        }
    }
    // Let ths OS catchup (at least MacOS)
    thread::sleep(delay);
}

#[cfg(target_os = "macos")]
fn test_macos_keys() {
    let virtual_input = rdevin::VirtualInput::new(
        rdevin::CGEventSourceStateID::Private,
        rdevin::CGEventTapLocation::Session,
    )
    .unwrap();

    let key_caps = rdevin::Key::RawKey(rdevin::RawKey::MacVirtualKeycode(rdevin::kVK_CapsLock));
    let key_ansi_a = rdevin::Key::RawKey(rdevin::RawKey::MacVirtualKeycode(rdevin::kVK_ANSI_A));
    {
        println!(
            "caps lock satte 1 {}",
            rdevin::VirtualInput::get_key_state(
                rdevin::CGEventSourceStateID::CombinedSessionState,
                rdevin::kVK_CapsLock
            )
        );

        virtual_input
            .simulate(&rdevin::EventType::KeyPress(key_caps))
            .unwrap();
        thread::sleep(time::Duration::from_millis(20));

        println!(
            "caps lock satte 2 {}",
            rdevin::VirtualInput::get_key_state(
                rdevin::CGEventSourceStateID::CombinedSessionState,
                rdevin::kVK_CapsLock
            )
        );

        virtual_input
            .simulate(&rdevin::EventType::KeyPress(key_ansi_a))
            .unwrap();
        thread::sleep(time::Duration::from_millis(20));
        virtual_input
            .simulate(&rdevin::EventType::KeyRelease(key_ansi_a))
            .unwrap();
        thread::sleep(time::Duration::from_millis(20));

        virtual_input
            .simulate(&rdevin::EventType::KeyRelease(key_caps))
            .unwrap();
        thread::sleep(time::Duration::from_millis(20));

        println!(
            "caps lock satte 3 {}",
            rdevin::VirtualInput::get_key_state(
                rdevin::CGEventSourceStateID::CombinedSessionState,
                rdevin::kVK_CapsLock
            )
        );
    }

    let command_tab = rdevin::Key::RawKey(rdevin::RawKey::MacVirtualKeycode(rdevin::kVK_Command));
    let key_tab = rdevin::Key::RawKey(rdevin::RawKey::MacVirtualKeycode(rdevin::kVK_CapsLock));
    {
        virtual_input
            .simulate(&rdevin::EventType::KeyPress(command_tab))
            .unwrap();
        thread::sleep(time::Duration::from_millis(200));

        virtual_input
            .simulate(&rdevin::EventType::KeyPress(key_tab))
            .unwrap();
        thread::sleep(time::Duration::from_millis(200));
        virtual_input
            .simulate(&rdevin::EventType::KeyRelease(key_tab))
            .unwrap();
        thread::sleep(time::Duration::from_millis(200));

        virtual_input
            .simulate(&rdevin::EventType::KeyPress(key_tab))
            .unwrap();
        thread::sleep(time::Duration::from_millis(200));
        virtual_input
            .simulate(&rdevin::EventType::KeyRelease(key_tab))
            .unwrap();
        thread::sleep(time::Duration::from_millis(200));

        virtual_input
            .simulate(&rdevin::EventType::KeyRelease(command_tab))
            .unwrap();
        thread::sleep(time::Duration::from_millis(200));
    }
}

#[cfg(windows)]
fn test_simulate_vk() {
    let _ = rdevin::simulate_code(Some(0xA2), None, true);
    let _ = rdevin::simulate_code(Some(0x4F), None, true);
    let _ = rdevin::simulate_code(Some(0x4F), None, false);
    let _ = rdevin::simulate_code(Some(0xA2), None, false);
}

#[cfg(windows)]
fn test_simulate_char() {
    println!("{:?}", rdevin::simulate_char('A', false));
    println!("{:?}", rdevin::simulate_char('€', false));
    println!("{:?}", rdevin::simulate_char('€', true));
}

#[cfg(target_os = "linux")]
fn simulate_combination() -> Result<(), SimulateError> {
    send(&EventType::KeyPress(Key::ControlLeft));
    rdevin::linux::simulate_char('€', true)?;
    rdevin::linux::simulate_char('€', false)?;
    send(&EventType::KeyRelease(Key::ControlLeft));
    Ok(())
}

fn test_simulate_dead() {
    send(&EventType::KeyPress(Key::AltGr));
    send(&EventType::KeyPress(Key::KeyE));
    send(&EventType::KeyRelease(Key::KeyE));
    send(&EventType::KeyRelease(Key::AltGr));
}

fn main() {
    // Windows: LeftBracket
    // scancode 26 => [
    // in us: [
    // in fr: ^(dead key)

    // send(&EventType::KeyPress(Key::Unknown(219)));
    // send(&EventType::KeyRelease(Key::Unknown(219)));

    // send(&EventType::KeyPress(Key::LeftBracket));
    // send(&EventType::KeyRelease(Key::LeftBracket));

    // #[cfg(target_os = "linux")]
    // simulate_combination();

    test_simulate_dead();

    // #[cfg(windows)]
    // test_simulate_vk();

    #[cfg(windows)]
    test_simulate_char();

    #[cfg(target_os = "macos")]
    test_macos_keys();
}