cleanup capture task

src/server.rs

@@ -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
     }
 
@@ -563,6 +563,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

@@ -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,
             }
         }
@@ -123,68 +123,38 @@ async fn handle_capture_event(
     sender_tx: &Sender<(Event, SocketAddr)>,
     event: (CaptureHandle, Event),
 ) -> Result<(), CaptureError> {
-    let (handle, mut e) = event;
+    let (handle, event) = event;
-    log::trace!("({handle}) {e:?}");
+    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);
+        server.set_state(State::Receiving);
-        e = Event::Disconnect();
     }
 
-    let info = {
+    if let Some(addr) = server.active_addr(handle) {
-        let mut enter = false;
+        let event = match server.get_state() {
-        let mut start_timer = false;
+            State::Sending => event,
-
+            /* send additional enter events until acknowleged */
-        // get client state for handle
+            State::AwaitingLeave => Event::Enter(),
-        let mut client_manager = server.client_manager.borrow_mut();
+            /* released capture */
-        let client_state = client_manager.get_mut(handle).map(|(_, s)| s);
+            State::Receiving => Event::Disconnect(),
-        if let Some(client_state) = client_state {
+        };
-            // if we just entered the client we want to send additional enter events until
+        sender_tx.send((event, addr)).await.expect("sender closed");
-            // 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;
     }
     Ok(())
 }