From 092d875bc2e6d3948c589751271e5e84090b89b7 Mon Sep 17 00:00:00 2001 From: Ferdinand Schober Date: Fri, 9 Aug 2024 13:51:17 +0200 Subject: [PATCH] rename {Capture,Emulation}Event to %Request --- src/server.rs | 48 +++++++++++++++++++----------------- src/server/capture_task.rs | 14 +++++------ src/server/emulation_task.rs | 32 ++++++++++++------------ src/server/ping_task.rs | 14 +++++------ 4 files changed, 56 insertions(+), 52 deletions(-) diff --git a/src/server.rs b/src/server.rs index 4c265a2..e67ec8b 100644 --- a/src/server.rs +++ b/src/server.rs @@ -1,5 +1,5 @@ -use capture_task::CaptureEvent; -use emulation_task::EmulationEvent; +use capture_task::CaptureRequest; +use emulation_task::EmulationRequest; use log; use std::{ cell::{Cell, RefCell}, @@ -306,8 +306,8 @@ impl Server { async fn handle_request( &self, - capture: &Sender, - emulate: &Sender, + capture: &Sender, + emulate: &Sender, event: FrontendRequest, ) -> bool { log::debug!("frontend: {event:?}"); @@ -372,8 +372,8 @@ impl Server { async fn deactivate_client( &self, - capture: &Sender, - emulate: &Sender, + capture: &Sender, + emulate: &Sender, handle: ClientHandle, ) { log::debug!("deactivating client {handle}"); @@ -382,15 +382,15 @@ impl Server { None => return, }; - let _ = capture.send(CaptureEvent::Destroy(handle)).await; - let _ = emulate.send(EmulationEvent::Destroy(handle)).await; + let _ = capture.send(CaptureRequest::Destroy(handle)).await; + let _ = emulate.send(EmulationRequest::Destroy(handle)).await; log::debug!("deactivating client {handle} done"); } async fn activate_client( &self, - capture: &Sender, - emulate: &Sender, + capture: &Sender, + emulate: &Sender, handle: ClientHandle, ) { log::debug!("activating client"); @@ -415,15 +415,17 @@ impl Server { }; /* notify emulation, capture and frontends */ - let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await; - let _ = emulate.send(EmulationEvent::Create(handle)).await; + let _ = capture + .send(CaptureRequest::Create(handle, pos.into())) + .await; + let _ = emulate.send(EmulationRequest::Create(handle)).await; log::debug!("activating client {handle} done"); } async fn remove_client( &self, - capture: &Sender, - emulate: &Sender, + capture: &Sender, + emulate: &Sender, handle: ClientHandle, ) { let Some(active) = self @@ -436,8 +438,8 @@ impl Server { }; if active { - let _ = capture.send(CaptureEvent::Destroy(handle)).await; - let _ = emulate.send(EmulationEvent::Destroy(handle)).await; + let _ = capture.send(CaptureRequest::Destroy(handle)).await; + let _ = emulate.send(EmulationRequest::Destroy(handle)).await; } } @@ -502,8 +504,8 @@ impl Server { async fn update_pos( &self, handle: ClientHandle, - capture: &Sender, - emulate: &Sender, + capture: &Sender, + emulate: &Sender, pos: Position, ) { let (changed, active) = { @@ -520,11 +522,13 @@ impl Server { // update state in event input emulator & input capture if changed { if active { - let _ = capture.send(CaptureEvent::Destroy(handle)).await; - let _ = emulate.send(EmulationEvent::Destroy(handle)).await; + let _ = capture.send(CaptureRequest::Destroy(handle)).await; + let _ = emulate.send(EmulationRequest::Destroy(handle)).await; } - let _ = capture.send(CaptureEvent::Create(handle, pos.into())).await; - let _ = emulate.send(EmulationEvent::Create(handle)).await; + let _ = capture + .send(CaptureRequest::Create(handle, pos.into())) + .await; + let _ = emulate.send(EmulationRequest::Create(handle)).await; } } diff --git a/src/server/capture_task.rs b/src/server/capture_task.rs index d43e9ff..85ce4ca 100644 --- a/src/server/capture_task.rs +++ b/src/server/capture_task.rs @@ -16,7 +16,7 @@ use crate::{client::ClientHandle, frontend::Status, server::State}; use super::Server; #[derive(Clone, Copy, Debug)] -pub(crate) enum CaptureEvent { +pub(crate) enum CaptureRequest { /// capture must release the mouse Release, /// add a capture client @@ -27,7 +27,7 @@ pub(crate) enum CaptureEvent { pub(crate) fn new( server: Server, - capture_rx: Receiver, + capture_rx: Receiver, udp_send: Sender<(Event, SocketAddr)>, ) -> JoinHandle<()> { let backend = server.config.capture_backend.map(|b| b.into()); @@ -38,7 +38,7 @@ async fn capture_task( server: Server, backend: Option, sender_tx: Sender<(Event, SocketAddr)>, - mut notify_rx: Receiver, + mut notify_rx: Receiver, ) { loop { if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await { @@ -64,7 +64,7 @@ async fn do_capture( backend: Option, server: &Server, sender_tx: &Sender<(Event, SocketAddr)>, - notify_rx: &mut Receiver, + notify_rx: &mut Receiver, ) -> Result<(), InputCaptureError> { /* allow cancelling capture request */ let mut capture = tokio::select! { @@ -100,12 +100,12 @@ async fn do_capture( log::debug!("input capture notify rx: {e:?}"); match e { Some(e) => match e { - CaptureEvent::Release => { + CaptureRequest::Release => { capture.release().await?; server.state.replace(State::Receiving); } - CaptureEvent::Create(h, p) => capture.create(h, p).await?, - CaptureEvent::Destroy(h) => capture.destroy(h).await?, + CaptureRequest::Create(h, p) => capture.create(h, p).await?, + CaptureRequest::Destroy(h) => capture.destroy(h).await?, }, None => break, } diff --git a/src/server/emulation_task.rs b/src/server/emulation_task.rs index 30c9ea3..311c9f8 100644 --- a/src/server/emulation_task.rs +++ b/src/server/emulation_task.rs @@ -13,10 +13,10 @@ use crate::{ use input_emulation::{self, EmulationError, EmulationHandle, InputEmulation, InputEmulationError}; use input_event::Event; -use super::{network_task::NetworkError, CaptureEvent, Server}; +use super::{network_task::NetworkError, CaptureRequest, Server}; #[derive(Clone, Debug)] -pub(crate) enum EmulationEvent { +pub(crate) enum EmulationRequest { /// create a new client Create(EmulationHandle), /// destroy a client @@ -27,10 +27,10 @@ pub(crate) enum EmulationEvent { pub(crate) fn new( server: Server, - emulation_rx: Receiver, + emulation_rx: Receiver, udp_rx: Receiver>, sender_tx: Sender<(Event, SocketAddr)>, - capture_tx: Sender, + capture_tx: Sender, ) -> JoinHandle<()> { let emulation_task = emulation_task(server, emulation_rx, udp_rx, sender_tx, capture_tx); tokio::task::spawn_local(emulation_task) @@ -38,10 +38,10 @@ pub(crate) fn new( async fn emulation_task( server: Server, - mut rx: Receiver, + mut rx: Receiver, mut udp_rx: Receiver>, sender_tx: Sender<(Event, SocketAddr)>, - capture_tx: Sender, + capture_tx: Sender, ) { loop { if let Err(e) = do_emulation(&server, &mut rx, &mut udp_rx, &sender_tx, &capture_tx).await { @@ -65,10 +65,10 @@ async fn emulation_task( async fn do_emulation( server: &Server, - rx: &mut Receiver, + rx: &mut Receiver, udp_rx: &mut Receiver>, sender_tx: &Sender<(Event, SocketAddr)>, - capture_tx: &Sender, + capture_tx: &Sender, ) -> Result<(), InputEmulationError> { let backend = server.config.emulation_backend.map(|b| b.into()); log::info!("creating input emulation..."); @@ -92,10 +92,10 @@ async fn do_emulation( async fn do_emulation_session( server: &Server, emulation: &mut InputEmulation, - rx: &mut Receiver, + rx: &mut Receiver, udp_rx: &mut Receiver>, sender_tx: &Sender<(Event, SocketAddr)>, - capture_tx: &Sender, + capture_tx: &Sender, ) -> Result<(), InputEmulationError> { let mut last_ignored = None; @@ -113,9 +113,9 @@ async fn do_emulation_session( } emulate_event = rx.recv() => { match emulate_event.expect("channel closed") { - EmulationEvent::Create(h) => { let _ = emulation.create(h).await; }, - EmulationEvent::Destroy(h) => emulation.destroy(h).await, - EmulationEvent::ReleaseKeys(c) => emulation.release_keys(c).await?, + EmulationRequest::Create(h) => { let _ = emulation.create(h).await; }, + EmulationRequest::Destroy(h) => emulation.destroy(h).await, + EmulationRequest::ReleaseKeys(c) => emulation.release_keys(c).await?, } } _ = server.notifies.cancel.cancelled() => break Ok(()), @@ -125,7 +125,7 @@ async fn do_emulation_session( async fn handle_udp_rx( server: &Server, - capture_tx: &Sender, + capture_tx: &Sender, emulate: &mut InputEmulation, sender_tx: &Sender<(Event, SocketAddr)>, last_ignored: &mut Option, @@ -162,7 +162,7 @@ async fn handle_udp_rx( } else { // upon receiving any event, we go back to receiving mode server.state.replace(State::Receiving); - let _ = capture_tx.send(CaptureEvent::Release).await; + let _ = capture_tx.send(CaptureRequest::Release).await; log::trace!("STATE ===> Receiving"); } } @@ -189,7 +189,7 @@ async fn handle_udp_rx( // event should still be possible if let Event::Enter() = event { server.state.replace(State::Receiving); - let _ = capture_tx.send(CaptureEvent::Release).await; + let _ = capture_tx.send(CaptureRequest::Release).await; log::trace!("STATE ===> Receiving"); } } diff --git a/src/server/ping_task.rs b/src/server/ping_task.rs index 195725e..3a89fe6 100644 --- a/src/server/ping_task.rs +++ b/src/server/ping_task.rs @@ -6,15 +6,15 @@ use input_event::Event; use crate::client::ClientHandle; -use super::{capture_task::CaptureEvent, emulation_task::EmulationEvent, Server, State}; +use super::{capture_task::CaptureRequest, emulation_task::EmulationRequest, Server, State}; const MAX_RESPONSE_TIME: Duration = Duration::from_millis(500); pub(crate) fn new( server: Server, sender_ch: Sender<(Event, SocketAddr)>, - emulate_notify: Sender, - capture_notify: Sender, + emulate_notify: Sender, + capture_notify: Sender, ) -> JoinHandle<()> { // timer task tokio::task::spawn_local(async move { @@ -28,8 +28,8 @@ pub(crate) fn new( async fn ping_task( server: &Server, sender_ch: Sender<(Event, SocketAddr)>, - emulate_notify: Sender, - capture_notify: Sender, + emulate_notify: Sender, + capture_notify: Sender, ) { loop { // wait for wake up signal @@ -123,14 +123,14 @@ async fn ping_task( if receiving { for h in unresponsive_clients { log::warn!("device not responding, releasing keys!"); - let _ = emulate_notify.send(EmulationEvent::ReleaseKeys(h)).await; + let _ = emulate_notify.send(EmulationRequest::ReleaseKeys(h)).await; } } else { // release pointer if the active client has not responded if !unresponsive_clients.is_empty() { log::warn!("client not responding, releasing pointer!"); server.state.replace(State::Receiving); - let _ = capture_notify.send(CaptureEvent::Release).await; + let _ = capture_notify.send(CaptureRequest::Release).await; } } }