Allow input capture & emulation being disabled (#158)

* Input capture and emulation can now be disabled and will prompt the user to enable again.

* Improved error handling to deliver more useful error messages

src/server/network_task.rs

@@ -7,71 +7,57 @@ use tokio::{
     task::JoinHandle,
 };
 
-use crate::frontend::FrontendEvent;
 use input_event::{Event, ProtocolError};
 
 use super::Server;
 
-pub async fn new(
+pub(crate) async fn new(
     server: Server,
-    frontend_notify_tx: Sender<FrontendEvent>,
-) -> io::Result<(
-    JoinHandle<()>,
-    Sender<(Event, SocketAddr)>,
-    Receiver<Result<(Event, SocketAddr), NetworkError>>,
-    Sender<u16>,
-)> {
+    udp_recv_tx: Sender<Result<(Event, SocketAddr), NetworkError>>,
+    udp_send_rx: Receiver<(Event, SocketAddr)>,
+) -> io::Result<JoinHandle<()>> {
     // bind the udp socket
     let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), server.port.get());
     let mut socket = UdpSocket::bind(listen_addr).await?;
-    let (receiver_tx, receiver_rx) = tokio::sync::mpsc::channel(32);
-    let (sender_tx, sender_rx) = tokio::sync::mpsc::channel(32);
-    let (port_tx, mut port_rx) = tokio::sync::mpsc::channel(32);
 
-    let udp_task = tokio::task::spawn_local(async move {
-        let mut sender_rx = sender_rx;
+    Ok(tokio::task::spawn_local(async move {
+        let mut sender_rx = udp_send_rx;
         loop {
-            let udp_receiver = udp_receiver(&socket, &receiver_tx);
+            let udp_receiver = udp_receiver(&socket, &udp_recv_tx);
             let udp_sender = udp_sender(&socket, &mut sender_rx);
             tokio::select! {
                 _ = udp_receiver => break, /* channel closed */
                 _ = udp_sender => break, /* channel closed */
-                port = port_rx.recv() => match port {
-                    Some(port) => update_port(&server, &frontend_notify_tx, &mut socket, port).await,
-                    _ => break,
-                }
+                _ = server.notifies.port_changed.notified() => update_port(&server, &mut socket).await,
+                _ = server.cancelled() => break, /* cancellation requested */
             }
         }
-    });
-    Ok((udp_task, sender_tx, receiver_rx, port_tx))
+    }))
 }
 
-async fn update_port(
-    server: &Server,
-    frontend_chan: &Sender<FrontendEvent>,
-    socket: &mut UdpSocket,
-    port: u16,
-) {
+async fn update_port(server: &Server, socket: &mut UdpSocket) {
+    let new_port = server.port.get();
+    let current_port = socket.local_addr().expect("socket not bound").port();
+
     // if port is the same, we dont need to change it
-    if socket.local_addr().unwrap().port() == port {
+    if current_port == new_port {
         return;
     }
 
-    // create new socket
-    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), port);
-    let frontend_event = match UdpSocket::bind(listen_addr).await {
+    // bind new socket
+    let listen_addr = SocketAddr::new("0.0.0.0".parse().unwrap(), new_port);
+    let new_socket = UdpSocket::bind(listen_addr).await;
+    let err = match new_socket {
         Ok(new_socket) => {
             *socket = new_socket;
-            server.port.replace(port);
-            FrontendEvent::PortChanged(port, None)
-        }
-        Err(e) => {
-            log::warn!("could not change port: {e}");
-            let port = socket.local_addr().unwrap().port();
-            FrontendEvent::PortChanged(port, Some(format!("could not change port: {e}")))
+            None
         }
+        Err(e) => Some(e.to_string()),
     };
-    let _ = frontend_chan.send(frontend_event).await;
+
+    // notify frontend of the actual port
+    let port = socket.local_addr().expect("socket not bound").port();
+    server.notify_port_changed(port, err);
 }
 
 async fn udp_receiver(
@@ -80,18 +66,13 @@ async fn udp_receiver(
 ) {
     loop {
         let event = receive_event(socket).await;
-        if receiver_tx.send(event).await.is_err() {
-            break;
-        }
+        receiver_tx.send(event).await.expect("channel closed");
     }
 }
 
 async fn udp_sender(socket: &UdpSocket, rx: &mut Receiver<(Event, SocketAddr)>) {
     loop {
-        let (event, addr) = match rx.recv().await {
-            Some(e) => e,
-            None => return,
-        };
+        let (event, addr) = rx.recv().await.expect("channel closed");
         if let Err(e) = send_event(socket, event, addr) {
             log::warn!("udp send failed: {e}");
         };