endorphin-tessera-gui/src/events.rs

//! Native input transport. Frame/mount identities and optional logical pointer positions cross to the VM worker.
use serde::{Deserialize, Serialize};
use std::{
    io::{Read, Write},
    net::TcpStream,
    sync::mpsc::{SyncSender, sync_channel},
    thread,
    time::Duration,
};
use winit::event_loop::EventLoopProxy;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TabDrop {
    pub window: u64,
    pub layout_version: u64,
    pub index: usize,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Input {
    #[serde(default = "default_window")]
    pub window: u64,
    pub session: u64,
    pub layout_version: u64,
    pub mount: u64,
    pub kind: String,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub point: Option<[f32; 2]>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub press_point: Option<[f32; 2]>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub delta: Option<[f32; 2]>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub tab_drop: Option<TabDrop>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub screen_position: Option<[i32; 2]>,
}

fn default_window() -> u64 {
    crate::window::MAIN_WINDOW
}

impl Input {
    pub fn validate(&self) -> Result<(), &'static str> {
        if self.window == 0 {
            return Err("window identity must be nonzero");
        }
        if self.kind == "tab-drop" {
            let Some(target) = &self.tab_drop else {
                return Err("tab-drop requires target metadata");
            };
            if target.window == 0
                || target.index > crate::ui_bridge::MAX_PAGES
                || self.point.is_some()
                || self.press_point.is_some()
                || self.delta.is_some()
                || self.screen_position.is_some()
            {
                return Err("invalid tab drop metadata");
            }
            return Ok(());
        }
        if self.tab_drop.is_some() {
            return Err("tab_drop is only accepted for tab-drop");
        }
        if let Some(position) = self.screen_position
            && (self.kind != "tab-detach"
                || !position
                    .iter()
                    .all(|value| (-1_000_000..=1_000_000).contains(value)))
        {
            return Err("screen_position is only accepted for tab-detach with bounded coordinates");
        }
        if self.kind == "scroll" {
            return match (self.point, self.press_point, self.delta) {
                (Some(point), None, Some(delta))
                    if point
                        .iter()
                        .all(|v| v.is_finite() && (0.0..=1_000_000.0).contains(v))
                        && delta
                            .iter()
                            .all(|v| v.is_finite() && v.abs() <= 1_000_000.0) =>
                {
                    Ok(())
                }
                _ => Err("scroll requires point and finite delta, with no press_point"),
            };
        }
        if self.delta.is_some() {
            return Err("delta is only accepted for scroll input");
        }
        match (self.point, self.press_point) {
            (None, None) => Ok(()),
            (Some(point), Some(press))
                if self.kind == "click"
                    && point
                        .into_iter()
                        .chain(press)
                        .all(|value| value.is_finite() && (0.0..=1_000_000.0).contains(&value)) =>
            {
                Ok(())
            }
            _ => Err("pointer click requires finite press/release coordinates"),
        }
    }
}

pub struct Client(SyncSender<Input>);
impl Client {
    pub fn new(proxy: EventLoopProxy<crate::app::AppEvent>) -> anyhow::Result<Self> {
        let (sender, receiver) = sync_channel::<Input>(8);
        thread::Builder::new()
            .name("tessera-native-events".into())
            .spawn(move || {
                for input in receiver {
                    if let Err(error) = send(&input) {
                        let _ = proxy.send_event(crate::app::AppEvent::RuntimeFailed {
                            message: error.to_string(),
                        });
                    }
                }
            })?;
        Ok(Self(sender))
    }
    pub fn send(&self, input: Input) -> bool {
        self.0.try_send(input).is_ok()
    }
}

fn send(input: &Input) -> anyhow::Result<()> {
    let body = serde_json::to_string(input)?;
    let mut stream =
        TcpStream::connect_timeout(&crate::api::API_ADDRESS.parse()?, Duration::from_secs(2))?;
    stream.set_read_timeout(Some(Duration::from_secs(10)))?;
    stream.set_write_timeout(Some(Duration::from_secs(2)))?;
    write!(
        stream,
        "POST /v1/namespaces/app.main/events HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n{}",
        body.len(),
        body
    )?;
    let mut response = String::new();
    stream.take(32768).read_to_string(&mut response)?;
    let status = response.split_whitespace().nth(1).unwrap_or("");
    // An old frame's event is deliberately discarded, with no automatic retry.
    if status == "409" {
        return Ok(());
    }
    if status != "200" {
        let body = response
            .split_once("\r\n\r\n")
            .map(|(_, body)| body)
            .unwrap_or(&response);
        anyhow::bail!(
            "Native event failed: {}",
            body.chars().take(1024).collect::<String>()
        );
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn drop_metadata_is_scoped_to_its_event_kind_and_bounded() {
        let mut input:Input=serde_json::from_str(r#"{"window":1,"session":1,"layout_version":2,"mount":3,"kind":"tab-drop","tab_drop":{"window":2,"layout_version":4,"index":1}}"#).unwrap();
        assert!(input.validate().is_ok());
        input.kind = "click".into();
        assert!(input.validate().is_err());
        input.kind = "tab-drop".into();
        input.tab_drop.as_mut().unwrap().index = 65;
        assert!(input.validate().is_err());
        input.kind = "tab-detach".into();
        input.tab_drop = None;
        input.screen_position = Some([-400, 200]);
        assert!(input.validate().is_ok());
        input.screen_position = Some([i32::MIN, 0]);
        assert!(input.validate().is_err());
    }

    #[test]
    fn legacy_event_window_defaults_but_zero_is_never_a_resource() {
        let mut input: Input =
            serde_json::from_str(r#"{"session":1,"layout_version":2,"mount":3,"kind":"focus"}"#)
                .unwrap();
        assert_eq!(input.window, crate::window::MAIN_WINDOW);
        assert!(input.validate().is_ok());
        input.window = 0;
        assert!(input.validate().is_err());
    }
}