use crate::{constants::*, raw_stream::RawDevice};
use crate::{AttributeSet, AttributeSetRef, InputEvent, InputEventKind, Key};
use std::time::SystemTime;
#[derive(Debug)]
pub struct DeviceState {
pub(crate) timestamp: SystemTime,
pub(crate) key_vals: Option<AttributeSet<Key>>,
pub(crate) abs_vals: Option<Box<[libc::input_absinfo; AbsoluteAxisType::COUNT]>>,
pub(crate) switch_vals: Option<AttributeSet<SwitchType>>,
pub(crate) led_vals: Option<AttributeSet<LedType>>,
}
impl Clone for DeviceState {
fn clone(&self) -> Self {
Self {
timestamp: self.timestamp,
key_vals: self.key_vals.clone(),
abs_vals: self.abs_vals.clone(),
switch_vals: self.switch_vals.clone(),
led_vals: self.led_vals.clone(),
}
}
fn clone_from(&mut self, other: &Self) {
self.timestamp.clone_from(&other.timestamp);
self.key_vals.clone_from(&other.key_vals);
self.abs_vals.clone_from(&other.abs_vals);
self.switch_vals.clone_from(&other.switch_vals);
self.led_vals.clone_from(&other.led_vals);
}
}
impl DeviceState {
pub(crate) fn new(device: &RawDevice) -> Self {
let supports = device.supported_events();
let key_vals = if supports.contains(EventType::KEY) {
Some(AttributeSet::new())
} else {
None
};
let abs_vals = if supports.contains(EventType::ABSOLUTE) {
Some(Box::new(crate::raw_stream::ABS_VALS_INIT))
} else {
None
};
let switch_vals = if supports.contains(EventType::SWITCH) {
Some(AttributeSet::new())
} else {
None
};
let led_vals = if supports.contains(EventType::LED) {
Some(AttributeSet::new())
} else {
None
};
DeviceState {
timestamp: std::time::UNIX_EPOCH,
key_vals,
abs_vals,
switch_vals,
led_vals,
}
}
pub fn timestamp(&self) -> SystemTime {
self.timestamp
}
pub fn key_vals(&self) -> Option<&AttributeSetRef<Key>> {
self.key_vals.as_deref()
}
pub fn abs_vals(&self) -> Option<&[libc::input_absinfo]> {
self.abs_vals.as_deref().map(|v| &v[..])
}
pub fn switch_vals(&self) -> Option<&AttributeSetRef<SwitchType>> {
self.switch_vals.as_deref()
}
pub fn led_vals(&self) -> Option<&AttributeSetRef<LedType>> {
self.led_vals.as_deref()
}
#[inline]
pub(crate) fn process_event(&mut self, ev: InputEvent) {
match ev.kind() {
InputEventKind::Key(code) => {
let keys = self
.key_vals
.as_deref_mut()
.expect("got a key event despite not supporting keys");
keys.set(code, ev.value() != 0);
}
InputEventKind::AbsAxis(axis) => {
let axes = self
.abs_vals
.as_deref_mut()
.expect("got an abs event despite not supporting absolute axes");
axes[axis.0 as usize].value = ev.value();
}
_ => {}
}
}
}