rename {Capture,Emulation}Event to %Request

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},
@@ -253,7 +253,7 @@ impl Server {
         self.notifies.capture.notify_waiters()
     }
 
-    async fn capture_notified(&self) {
+    async fn capture_enabled(&self) {
         self.notifies.capture.notified().await
     }
 
@@ -306,8 +306,8 @@ impl Server {
 
     async fn handle_request(
         &self,
-        capture: &Sender<CaptureEvent>,
-        emulate: &Sender<EmulationEvent>,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
         event: FrontendRequest,
     ) -> bool {
         log::debug!("frontend: {event:?}");
@@ -372,8 +372,8 @@ impl Server {
 
     async fn deactivate_client(
         &self,
-        capture: &Sender<CaptureEvent>,
-        emulate: &Sender<EmulationEvent>,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
         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<CaptureEvent>,
-        emulate: &Sender<EmulationEvent>,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
         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<CaptureEvent>,
-        emulate: &Sender<EmulationEvent>,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
         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<CaptureEvent>,
-        emulate: &Sender<EmulationEvent>,
+        capture: &Sender<CaptureRequest>,
+        emulate: &Sender<EmulationRequest>,
         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;
         }
     }
 
@@ -563,6 +567,27 @@ impl Server {
             .get_mut(handle)
             .and_then(|(c, _)| c.hostname.clone())
     }
+
+    fn get_state(&self) -> State {
+        self.state.get()
+    }
+
+    fn set_state(&self, state: State) {
+        log::debug!("state => {state:?}");
+        self.state.replace(state);
+    }
+
+    fn set_active(&self, handle: Option<u64>) {
+        log::debug!("active client => {handle:?}");
+        self.active_client.replace(handle);
+    }
+
+    fn active_addr(&self, handle: u64) -> Option<SocketAddr> {
+        self.client_manager
+            .borrow()
+            .get(handle)
+            .and_then(|(_, s)| s.active_addr)
+    }
 }
 
 async fn listen_frontend(

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<CaptureEvent>,
+    capture_rx: Receiver<CaptureRequest>,
     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<input_capture::Backend>,
     sender_tx: Sender<(Event, SocketAddr)>,
-    mut notify_rx: Receiver<CaptureEvent>,
+    mut notify_rx: Receiver<CaptureRequest>,
 ) {
     loop {
         if let Err(e) = do_capture(backend, &server, &sender_tx, &mut notify_rx).await {
@@ -53,7 +53,7 @@ async fn capture_task(
         loop {
             tokio::select! {
                 _ = notify_rx.recv() => continue, /* need to ignore requests here! */
-                _ = server.capture_notified() => break,
+                _ = server.capture_enabled() => break,
                 _ = server.cancelled() => return,
             }
         }
@@ -64,7 +64,7 @@ async fn do_capture(
     backend: Option<input_capture::Backend>,
     server: &Server,
     sender_tx: &Sender<(Event, SocketAddr)>,
-    notify_rx: &mut Receiver<CaptureEvent>,
+    notify_rx: &mut Receiver<CaptureRequest>,
 ) -> 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,
                 }
@@ -123,68 +123,38 @@ async fn handle_capture_event(
     sender_tx: &Sender<(Event, SocketAddr)>,
     event: (CaptureHandle, Event),
 ) -> Result<(), CaptureError> {
-    let (handle, mut e) = event;
-    log::trace!("({handle}) {e:?}");
+    let (handle, event) = event;
+    log::trace!("({handle}) {event:?}");
+
+    // capture started
+    if event == Event::Enter() {
+        server.set_state(State::AwaitingLeave);
+        server.set_active(Some(handle));
+        server.restart_ping_timer();
+        spawn_hook_command(server, handle);
+    }
+
+    // release capture if emulation set state to Receiveing
+    if server.get_state() == State::Receiving {
+        capture.release().await?;
+        return Ok(());
+    }
 
     // check release bind
     if capture.keys_pressed(&server.release_bind) {
         capture.release().await?;
-        server.state.replace(State::Receiving);
-        e = Event::Disconnect();
+        server.set_state(State::Receiving);
     }
 
-    let info = {
-        let mut enter = false;
-        let mut start_timer = false;
-
-        // get client state for handle
-        let mut client_manager = server.client_manager.borrow_mut();
-        let client_state = client_manager.get_mut(handle).map(|(_, s)| s);
-        if let Some(client_state) = client_state {
-            // if we just entered the client we want to send additional enter events until
-            // we get a leave event
-            if let Event::Enter() = e {
-                server.state.replace(State::AwaitingLeave);
-                server.active_client.replace(Some(handle));
-                log::trace!("Active client => {}", handle);
-                start_timer = true;
-                log::trace!("STATE ===> AwaitingLeave");
-                enter = true;
-            } else {
-                // ignore any potential events in receiving mode
-                if server.state.get() == State::Receiving && e != Event::Disconnect() {
-                    return Ok(());
-                }
-            }
-            Some((client_state.active_addr, enter, start_timer))
-        } else {
-            None
-        }
-    };
-
-    let (addr, enter, start_timer) = match info {
-        Some(i) => i,
-        None => {
-            // should not happen
-            log::warn!("unknown client!");
-            capture.release().await?;
-            server.state.replace(State::Receiving);
-            log::trace!("STATE ===> Receiving");
-            return Ok(());
-        }
-    };
-
-    if start_timer {
-        server.restart_ping_timer();
-    }
-    if enter {
-        spawn_hook_command(server, handle);
-    }
-    if let Some(addr) = addr {
-        if enter {
-            let _ = sender_tx.send((Event::Enter(), addr)).await;
-        }
-        let _ = sender_tx.send((e, addr)).await;
+    if let Some(addr) = server.active_addr(handle) {
+        let event = match server.get_state() {
+            State::Sending => event,
+            /* send additional enter events until acknowleged */
+            State::AwaitingLeave => Event::Enter(),
+            /* released capture */
+            State::Receiving => Event::Disconnect(),
+        };
+        sender_tx.send((event, addr)).await.expect("sender closed");
     }
     Ok(())
 }

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<EmulationEvent>,
+    emulation_rx: Receiver<EmulationRequest>,
     udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: Sender<(Event, SocketAddr)>,
-    capture_tx: Sender<CaptureEvent>,
+    capture_tx: Sender<CaptureRequest>,
 ) -> 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<EmulationEvent>,
+    mut rx: Receiver<EmulationRequest>,
     mut udp_rx: Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: Sender<(Event, SocketAddr)>,
-    capture_tx: Sender<CaptureEvent>,
+    capture_tx: Sender<CaptureRequest>,
 ) {
     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<EmulationEvent>,
+    rx: &mut Receiver<EmulationRequest>,
     udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: &Sender<(Event, SocketAddr)>,
-    capture_tx: &Sender<CaptureEvent>,
+    capture_tx: &Sender<CaptureRequest>,
 ) -> 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<EmulationEvent>,
+    rx: &mut Receiver<EmulationRequest>,
     udp_rx: &mut Receiver<Result<(Event, SocketAddr), NetworkError>>,
     sender_tx: &Sender<(Event, SocketAddr)>,
-    capture_tx: &Sender<CaptureEvent>,
+    capture_tx: &Sender<CaptureRequest>,
 ) -> 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<CaptureEvent>,
+    capture_tx: &Sender<CaptureRequest>,
     emulate: &mut InputEmulation,
     sender_tx: &Sender<(Event, SocketAddr)>,
     last_ignored: &mut Option<SocketAddr>,
@@ -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");
                     }
                 }

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<EmulationEvent>,
-    capture_notify: Sender<CaptureEvent>,
+    emulate_notify: Sender<EmulationRequest>,
+    capture_notify: Sender<CaptureRequest>,
 ) -> 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<EmulationEvent>,
-    capture_notify: Sender<CaptureEvent>,
+    emulate_notify: Sender<EmulationRequest>,
+    capture_notify: Sender<CaptureRequest>,
 ) {
     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;
                 }
             }
         }