73 lines
2.6 KiB
Rust
73 lines
2.6 KiB
Rust
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
use alloc::sync::Arc;
|
|
use core::{any::Any, fmt::Debug};
|
|
|
|
use crate::{InputDevice, input_dev::InputEvent, unregister_handler_class};
|
|
|
|
/// Errors that can occur when connecting to an input device.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum ConnectError {
|
|
/// Device is not compatible with this handler class.
|
|
IncompatibleDevice,
|
|
/// Failed to create device node.
|
|
DeviceNodeCreationFailed,
|
|
/// Device is already connected.
|
|
AlreadyConnected,
|
|
/// Other internal error.
|
|
InternalError,
|
|
}
|
|
|
|
/// A trait that represents an input handler class.
|
|
///
|
|
/// Once registered to the input core (via [`register_handler_class`]), the
|
|
/// input handler class will try to connect to each input device (via
|
|
/// [`connect`]). If it succeeds, an [`InputHandler`] will be created to handle
|
|
/// the input events from that device.
|
|
///
|
|
/// [`register_handler_class`]: crate::register_handler_class
|
|
/// [`connect`]: Self::connect
|
|
pub trait InputHandlerClass: Send + Sync + Any + Debug {
|
|
/// Returns the class name of the handler class.
|
|
fn name(&self) -> &str;
|
|
|
|
/// Tries to connect to the input device.
|
|
///
|
|
/// On success, this method will return `Ok()` with a new input handler.
|
|
/// Otherwise, it will return `Err(ConnectError)`.
|
|
fn connect(&self, dev: Arc<dyn InputDevice>) -> Result<Arc<dyn InputHandler>, ConnectError>;
|
|
|
|
/// Disconnects from a device.
|
|
fn disconnect(&self, dev: &Arc<dyn InputDevice>);
|
|
}
|
|
|
|
/// A trait that represents an individual input handler instance for a specific device.
|
|
///
|
|
/// Each handler instance is created by an [`InputHandlerClass`] when it successfully
|
|
/// connects to an input device (via [`InputHandlerClass::connect`]). The handler
|
|
/// is responsible for processing input events from the associated device.
|
|
///
|
|
/// [`InputHandlerClass`]: crate::InputHandlerClass
|
|
/// [`InputHandlerClass::connect`]: crate::InputHandlerClass::connect
|
|
pub trait InputHandler: Send + Sync + Debug {
|
|
/// Handles multiple input events from the device.
|
|
fn handle_events(&self, events: &[InputEvent]);
|
|
}
|
|
|
|
/// An input handler bound with the class that created it.
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct BoundInputHandler {
|
|
pub(crate) handler: Arc<dyn InputHandler>,
|
|
pub(crate) handler_class: Arc<dyn InputHandlerClass>,
|
|
}
|
|
|
|
/// Registered input handler class that can create handlers.
|
|
#[derive(Debug)]
|
|
pub struct RegisteredInputHandlerClass(pub(crate) Arc<dyn InputHandlerClass>);
|
|
|
|
impl Drop for RegisteredInputHandlerClass {
|
|
fn drop(&mut self) {
|
|
unregister_handler_class(&self.0).unwrap();
|
|
}
|
|
}
|