libusbk 0.2.0

FFI bindings for libusbK.
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

use std::ffi::c_void;
use std::sync::Mutex;

use libusbk_sys::{
    HotK_Free, HotK_Init, KHOT_HANDLE, KHOT_PARAMS, KLST_DEVINFO_HANDLE, KLST_SYNC_FLAG,
};
use once_cell::sync::OnceCell;

use crate::device::{self, Device};
use crate::error::{try_unsafe, Result};

static DATA: OnceCell<Mutex<Option<Data>>> = OnceCell::new();

unsafe impl Send for Data {}

struct Data {
    callback: Box<dyn Hotplug>,
    vid: Option<i32>,
    pid: Option<i32>,
}

pub trait Hotplug: Send {
    fn device_arrived(&mut self, device: Device);
    fn device_left(&mut self, device: Device);
}

#[derive(Debug, Copy, Clone)]
pub struct HotplugBuilder {
    vendor_id: Option<i32>,
    product_id: Option<i32>,
    params: KHOT_PARAMS,
}

impl HotplugBuilder {
    pub fn new() -> Self {
        HotplugBuilder::default()
    }

    pub fn vendor_id(&mut self, vendor_id: i32) -> &mut Self {
        self.vendor_id = Some(vendor_id);
        self
    }

    pub fn product_id(&mut self, product_id: i32) -> &mut Self {
        self.product_id = Some(product_id);
        self
    }

    pub fn register(self, callback: Box<dyn Hotplug>) -> crate::Result<Registration> {
        let v = DATA.get_or_init(|| Mutex::new(None));
        let mut item = v.lock().unwrap();
        *item = Some(Data {
            callback,
            vid: self.vendor_id,
            pid: self.product_id,
        });
        Ok(Registration {
            params: self.params,
            handle: 0 as *mut c_void,
        })
    }
}

impl Default for HotplugBuilder {
    fn default() -> Self {
        Self {
            vendor_id: None,
            product_id: None,
            params: libusbk_sys::_KHOT_PARAMS::default(),
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum NotificationType {
    Arrival,
    Removal,
}

impl From<KLST_SYNC_FLAG> for NotificationType {
    fn from(flag: KLST_SYNC_FLAG) -> Self {
        const ADDED: i32 = 2;

        match flag {
            ADDED => NotificationType::Arrival,
            _ => NotificationType::Removal,
        }
    }
}

pub struct Registration {
    params: KHOT_PARAMS,
    handle: KHOT_HANDLE,
}

impl Registration {
    unsafe extern "C" fn on_hotplug(
        _handle: KHOT_HANDLE,
        device_info: KLST_DEVINFO_HANDLE,
        sync_flag: KLST_SYNC_FLAG,
    ) {
        let mut lock = DATA.get().unwrap().lock().unwrap();
        let data_s = lock.as_mut().unwrap();
        let callback = data_s.callback.as_mut();

        let vid = data_s.vid;
        let pid = data_s.pid;

        let device = device::Device(device_info);

        if let Some(vid) = vid {
            if vid != device.vendor_id() as i32 {
                return;
            }
        }

        if let Some(pid) = pid {
            if pid != device.product_id() as i32 {
                return;
            }
        }

        match sync_flag.into() {
            NotificationType::Arrival => callback.device_arrived(device),
            NotificationType::Removal => callback.device_left(device),
        }
    }

    pub fn init(&mut self) -> Result<()> {
        self.params.OnHotPlug = Some(Self::on_hotplug);

        try_unsafe!(HotK_Init(&mut self.handle, &mut self.params));
        Ok(())
    }
}

impl Drop for Registration {
    fn drop(&mut self) {
        unsafe { HotK_Free(self.handle) };
    }
}

pub fn has_hotplug() -> bool {
    true
}