dnet 0.1.4

Message passing infrastructure.
Documentation
#![cfg(not(target_arch = "wasm32"))]

use std::time::Duration;

use anyhow::Result;
use device_query::{DeviceQuery, DeviceState};
use dnet::{codecs::BincodeCodec, udp::UdpTransport, utils::number};
use futures::{pin_mut, FutureExt};
use serde::{Deserialize, Serialize};
use tokio::{net::UdpSocket, select, signal::ctrl_c, time::interval};
use tracing::{info, Level};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Message {
    pub mouse_x: i32,
    pub mouse_y: i32,
}

pub async fn run(address: &str) -> Result<()> {
    tracing_subscriber::fmt().with_max_level(Level::INFO).init();

    info!("Server running!");

    let udp_socket = UdpSocket::bind("0.0.0.0:4321").await?;
    udp_socket.set_broadcast(true)?;
    let mut transport =
        UdpTransport::<_, _, number::Wrapper<u128, ()>, number::Wrapper<u128, Message>>::new(
            udp_socket,
            BincodeCodec::default(),
        );

    let device_state = DeviceState::new();

    let mut interval = interval(Duration::from_millis(50));
    let break_signal = ctrl_c().fuse();
    pin_mut!(break_signal);
    let mut message_number = 0;
    loop {
        select! {
            _tick = interval.tick() => {
                let mouse_state = device_state.get_mouse();
                let (x, y) = mouse_state.coords;
                let message = Message { mouse_x: x, mouse_y: y };
                let message = number::Wrapper {
                    number: message_number,
                    wrapped: message,
                };
                transport.send_to(message, address).await?;
                message_number = message_number.wrapping_add(1);
            },
            break_result = &mut break_signal => {
                break_result.expect("failed to listen for event");
                break;
            }
        }
    }
    info!("Shutting down...");

    Ok(())
}