TheLanc3/lan-mouse
1
0
Fork 0
mirror of https://github.com/feschber/lan-mouse.git synced 2026-03-07 20:09:59 +03:00
Code Issues Packages Projects Releases Wiki Activity

rename {Capture,Emulation}Event to %Request

Browse Source
This commit is contained in:
Ferdinand Schober
2024-08-09 13:51:17 +02:00
parent e67d820ee4
commit 092d875bc2
4 changed files with 56 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
src/server.rs
View File

@@ -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<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;
}
}

14
src/server/capture_task.rs
View File

@@ -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 {
@@ -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,
}

32
src/server/emulation_task.rs
View File

@@ -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");
}
}

14
src/server/ping_task.rs
View File

@@ -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;
}
}
}