mirror of
https://github.com/feschber/lan-mouse.git
synced 2026-03-10 23:00:55 +03:00
382 lines
14 KiB
Rust
382 lines
14 KiB
Rust
use std::{
|
|
collections::HashMap,
|
|
io,
|
|
os::{
|
|
fd::{FromRawFd, RawFd},
|
|
unix::net::UnixStream,
|
|
},
|
|
time::{SystemTime, UNIX_EPOCH},
|
|
};
|
|
|
|
use anyhow::{anyhow, Result};
|
|
use ashpd::desktop::remote_desktop::{DeviceType, RemoteDesktop};
|
|
use async_trait::async_trait;
|
|
use futures::StreamExt;
|
|
|
|
use reis::{
|
|
ei::{self, button::ButtonState, handshake::ContextType, keyboard::KeyState},
|
|
tokio::EiEventStream,
|
|
PendingRequestResult,
|
|
};
|
|
|
|
use crate::{
|
|
client::{ClientEvent, ClientHandle},
|
|
consumer::EventConsumer,
|
|
event::Event,
|
|
};
|
|
|
|
pub struct LibeiConsumer {
|
|
handshake: bool,
|
|
context: ei::Context,
|
|
events: EiEventStream,
|
|
pointer: Option<(ei::Device, ei::Pointer)>,
|
|
has_pointer: bool,
|
|
scroll: Option<(ei::Device, ei::Scroll)>,
|
|
has_scroll: bool,
|
|
button: Option<(ei::Device, ei::Button)>,
|
|
has_button: bool,
|
|
keyboard: Option<(ei::Device, ei::Keyboard)>,
|
|
has_keyboard: bool,
|
|
capabilities: HashMap<String, u64>,
|
|
capability_mask: u64,
|
|
sequence: u32,
|
|
serial: u32,
|
|
}
|
|
|
|
async fn get_ei_fd() -> Result<RawFd, ashpd::Error> {
|
|
let proxy = RemoteDesktop::new().await?;
|
|
let session = proxy.create_session().await?;
|
|
|
|
// I HATE EVERYTHING, THIS TOOK 8 HOURS OF DEBUGGING
|
|
proxy
|
|
.select_devices(
|
|
&session,
|
|
DeviceType::Pointer | DeviceType::Keyboard | DeviceType::Touchscreen,
|
|
)
|
|
.await?;
|
|
|
|
proxy
|
|
.start(&session, &ashpd::WindowIdentifier::default())
|
|
.await?
|
|
.response()?;
|
|
proxy.connect_to_eis(&session).await
|
|
}
|
|
|
|
impl LibeiConsumer {
|
|
pub async fn new() -> Result<Self> {
|
|
// fd is owned by the message, so we need to dup it
|
|
let eifd = get_ei_fd().await?;
|
|
let eifd = unsafe {
|
|
let ret = libc::dup(eifd);
|
|
if ret < 0 {
|
|
Err(io::Error::last_os_error())
|
|
} else {
|
|
Ok(ret)
|
|
}
|
|
}?;
|
|
let stream = unsafe { UnixStream::from_raw_fd(eifd) };
|
|
// let stream = UnixStream::connect("/run/user/1000/eis-0")?;
|
|
stream.set_nonblocking(true)?;
|
|
let context = ei::Context::new(stream)?;
|
|
context.flush()?;
|
|
let events = EiEventStream::new(context.clone())?;
|
|
Ok(Self {
|
|
handshake: false,
|
|
context,
|
|
events,
|
|
pointer: None,
|
|
button: None,
|
|
scroll: None,
|
|
keyboard: None,
|
|
has_pointer: false,
|
|
has_button: false,
|
|
has_scroll: false,
|
|
has_keyboard: false,
|
|
capabilities: HashMap::new(),
|
|
capability_mask: 0,
|
|
sequence: 0,
|
|
serial: 0,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl EventConsumer for LibeiConsumer {
|
|
async fn consume(&mut self, event: Event, _client_handle: ClientHandle) {
|
|
let now = SystemTime::now()
|
|
.duration_since(UNIX_EPOCH)
|
|
.unwrap()
|
|
.as_micros() as u64;
|
|
match event {
|
|
Event::Pointer(p) => match p {
|
|
crate::event::PointerEvent::Motion {
|
|
time: _,
|
|
relative_x,
|
|
relative_y,
|
|
} => {
|
|
if !self.has_pointer {
|
|
return;
|
|
}
|
|
if let Some((d, p)) = self.pointer.as_mut() {
|
|
p.motion_relative(relative_x as f32, relative_y as f32);
|
|
d.frame(self.serial, now);
|
|
}
|
|
}
|
|
crate::event::PointerEvent::Button {
|
|
time: _,
|
|
button,
|
|
state,
|
|
} => {
|
|
if !self.has_button {
|
|
return;
|
|
}
|
|
if let Some((d, b)) = self.button.as_mut() {
|
|
b.button(
|
|
button,
|
|
match state {
|
|
0 => ButtonState::Released,
|
|
_ => ButtonState::Press,
|
|
},
|
|
);
|
|
d.frame(self.serial, now);
|
|
}
|
|
}
|
|
crate::event::PointerEvent::Axis {
|
|
time: _,
|
|
axis,
|
|
value,
|
|
} => {
|
|
if !self.has_scroll {
|
|
return;
|
|
}
|
|
if let Some((d, s)) = self.scroll.as_mut() {
|
|
match axis {
|
|
0 => s.scroll(0., value as f32),
|
|
_ => s.scroll(value as f32, 0.),
|
|
}
|
|
d.frame(self.serial, now);
|
|
}
|
|
}
|
|
crate::event::PointerEvent::Frame {} => {}
|
|
},
|
|
Event::Keyboard(k) => match k {
|
|
crate::event::KeyboardEvent::Key {
|
|
time: _,
|
|
key,
|
|
state,
|
|
} => {
|
|
if !self.has_keyboard {
|
|
return;
|
|
}
|
|
if let Some((d, k)) = &mut self.keyboard {
|
|
k.key(
|
|
key,
|
|
match state {
|
|
0 => KeyState::Released,
|
|
_ => KeyState::Press,
|
|
},
|
|
);
|
|
d.frame(self.serial, now);
|
|
}
|
|
}
|
|
crate::event::KeyboardEvent::Modifiers { .. } => {}
|
|
},
|
|
_ => {}
|
|
}
|
|
self.context.flush().unwrap();
|
|
}
|
|
|
|
async fn dispatch(&mut self) -> Result<()> {
|
|
let event = match self.events.next().await {
|
|
Some(e) => e?,
|
|
None => return Err(anyhow!("libei connection lost")),
|
|
};
|
|
let event = match event {
|
|
PendingRequestResult::Request(result) => result,
|
|
PendingRequestResult::ParseError(e) => {
|
|
return Err(anyhow!("libei protocol violation: {e}"))
|
|
}
|
|
PendingRequestResult::InvalidObject(e) => return Err(anyhow!("invalid object {e}")),
|
|
};
|
|
match event {
|
|
ei::Event::Handshake(handshake, request) => match request {
|
|
ei::handshake::Event::HandshakeVersion { version } => {
|
|
if self.handshake {
|
|
return Ok(());
|
|
}
|
|
log::info!("libei version {}", version);
|
|
// sender means we are sending events _to_ the eis server
|
|
handshake.handshake_version(version); // FIXME
|
|
handshake.context_type(ContextType::Sender);
|
|
handshake.name("ei-demo-client");
|
|
handshake.interface_version("ei_connection", 1);
|
|
handshake.interface_version("ei_callback", 1);
|
|
handshake.interface_version("ei_pingpong", 1);
|
|
handshake.interface_version("ei_seat", 1);
|
|
handshake.interface_version("ei_device", 2);
|
|
handshake.interface_version("ei_pointer", 1);
|
|
handshake.interface_version("ei_pointer_absolute", 1);
|
|
handshake.interface_version("ei_scroll", 1);
|
|
handshake.interface_version("ei_button", 1);
|
|
handshake.interface_version("ei_keyboard", 1);
|
|
handshake.interface_version("ei_touchscreen", 1);
|
|
handshake.finish();
|
|
self.handshake = true;
|
|
}
|
|
ei::handshake::Event::InterfaceVersion { name, version } => {
|
|
log::debug!("handshake: Interface {name} @ {version}");
|
|
}
|
|
ei::handshake::Event::Connection { serial, connection } => {
|
|
connection.sync(1);
|
|
self.serial = serial;
|
|
}
|
|
_ => unreachable!(),
|
|
},
|
|
ei::Event::Connection(_connection, request) => match request {
|
|
ei::connection::Event::Seat { seat } => {
|
|
log::debug!("connected to seat: {seat:?}");
|
|
}
|
|
ei::connection::Event::Ping { ping } => {
|
|
ping.done(0);
|
|
}
|
|
ei::connection::Event::Disconnected {
|
|
last_serial: _,
|
|
reason,
|
|
explanation,
|
|
} => {
|
|
log::debug!("ei - disconnected: reason: {reason:?}: {explanation}")
|
|
}
|
|
ei::connection::Event::InvalidObject {
|
|
last_serial,
|
|
invalid_id,
|
|
} => {
|
|
return Err(anyhow!(
|
|
"invalid object: id: {invalid_id}, serial: {last_serial}"
|
|
));
|
|
}
|
|
_ => unreachable!(),
|
|
},
|
|
ei::Event::Device(device, request) => match request {
|
|
ei::device::Event::Destroyed { serial } => {
|
|
log::debug!("device destroyed: {device:?} - serial: {serial}")
|
|
}
|
|
ei::device::Event::Name { name } => {
|
|
log::debug!("device name: {name}")
|
|
}
|
|
ei::device::Event::DeviceType { device_type } => {
|
|
log::debug!("device type: {device_type:?}")
|
|
}
|
|
ei::device::Event::Dimensions { width, height } => {
|
|
log::debug!("device dimensions: {width}x{height}")
|
|
}
|
|
ei::device::Event::Region {
|
|
offset_x,
|
|
offset_y,
|
|
width,
|
|
hight,
|
|
scale,
|
|
} => log::debug!(
|
|
"device region: {width}x{hight} @ ({offset_x},{offset_y}), scale: {scale}"
|
|
),
|
|
ei::device::Event::Interface { object } => {
|
|
log::debug!("device interface: {object:?}");
|
|
if object.interface().eq("ei_pointer") {
|
|
log::debug!("GOT POINTER DEVICE");
|
|
self.pointer.replace((device, object.downcast().unwrap()));
|
|
} else if object.interface().eq("ei_button") {
|
|
log::debug!("GOT BUTTON DEVICE");
|
|
self.button.replace((device, object.downcast().unwrap()));
|
|
} else if object.interface().eq("ei_scroll") {
|
|
log::debug!("GOT SCROLL DEVICE");
|
|
self.scroll.replace((device, object.downcast().unwrap()));
|
|
} else if object.interface().eq("ei_keyboard") {
|
|
log::debug!("GOT KEYBOARD DEVICE");
|
|
self.keyboard.replace((device, object.downcast().unwrap()));
|
|
}
|
|
}
|
|
ei::device::Event::Done => {
|
|
log::debug!("device: done {device:?}");
|
|
}
|
|
ei::device::Event::Resumed { serial } => {
|
|
self.serial = serial;
|
|
device.start_emulating(serial, self.sequence);
|
|
self.sequence += 1;
|
|
log::debug!("resumed: {device:?}");
|
|
if let Some((d, _)) = &mut self.pointer {
|
|
if d == &device {
|
|
log::debug!("pointer resumed {serial}");
|
|
self.has_pointer = true;
|
|
}
|
|
}
|
|
if let Some((d, _)) = &mut self.button {
|
|
if d == &device {
|
|
log::debug!("button resumed {serial}");
|
|
self.has_button = true;
|
|
}
|
|
}
|
|
if let Some((d, _)) = &mut self.scroll {
|
|
if d == &device {
|
|
log::debug!("scroll resumed {serial}");
|
|
self.has_scroll = true;
|
|
}
|
|
}
|
|
if let Some((d, _)) = &mut self.keyboard {
|
|
if d == &device {
|
|
log::debug!("keyboard resumed {serial}");
|
|
self.has_keyboard = true;
|
|
}
|
|
}
|
|
}
|
|
ei::device::Event::Paused { serial } => {
|
|
self.has_pointer = false;
|
|
self.has_button = false;
|
|
self.serial = serial;
|
|
}
|
|
ei::device::Event::StartEmulating { serial, sequence } => {
|
|
log::debug!("start emulating {serial}, {sequence}")
|
|
}
|
|
ei::device::Event::StopEmulating { serial } => {
|
|
log::debug!("stop emulating {serial}")
|
|
}
|
|
ei::device::Event::Frame { serial, timestamp } => {
|
|
log::debug!("frame: {serial}, {timestamp}");
|
|
}
|
|
ei::device::Event::RegionMappingId { mapping_id } => {
|
|
log::debug!("RegionMappingId {mapping_id}")
|
|
}
|
|
e => log::debug!("invalid event: {e:?}"),
|
|
},
|
|
ei::Event::Seat(seat, request) => match request {
|
|
ei::seat::Event::Destroyed { serial } => {
|
|
self.serial = serial;
|
|
log::debug!("seat destroyed: {seat:?}");
|
|
}
|
|
ei::seat::Event::Name { name } => {
|
|
log::debug!("seat name: {name}");
|
|
}
|
|
ei::seat::Event::Capability { mask, interface } => {
|
|
log::debug!("seat capabilities: {mask}, interface: {interface:?}");
|
|
self.capabilities.insert(interface, mask);
|
|
self.capability_mask |= mask;
|
|
}
|
|
ei::seat::Event::Done => {
|
|
log::debug!("seat done");
|
|
log::debug!("binding capabilities: {}", self.capability_mask);
|
|
seat.bind(self.capability_mask);
|
|
}
|
|
ei::seat::Event::Device { device } => {
|
|
log::debug!("seat: new device - {device:?}");
|
|
}
|
|
_ => todo!(),
|
|
},
|
|
e => log::debug!("unhandled event: {e:?}"),
|
|
}
|
|
self.context.flush()?;
|
|
Ok(())
|
|
}
|
|
|
|
async fn notify(&mut self, _client_event: ClientEvent) {}
|
|
|
|
async fn destroy(&mut self) {}
|
|
}
|