mirror of
https://github.com/marcoallegretti/WEFT_OS.git
synced 2026-11-22 08:13:59 +00:00
The browser-facing WebSocket accepted requests from any local page, so a page could launch or terminate apps and inject messages into any session. Every connection now completes the upgrade and sends HELLO within five seconds. The system role authenticates with a token appd writes to $XDG_RUNTIME_DIR/weft/appd.systoken (mode 0600) and may manage sessions, but never sees or sends application messages. The app role authenticates with a per-session bridge token passed to weft-app-shell in WEFT_BRIDGE_TOKEN and exchanges APP_MESSAGE envelopes with its own session only; it is disconnected when that session stops. weft-servo-shell hands the system endpoint only to the system UI document and denies navigation away from it. weft-app-shell installs the bridge only in top-level documents inside the application's UI directory and denies navigation outside it. The launcher renders package names as text. tests/frame/check_counter.py drives the Counter demo end to end through the compositor, appd, the Wasm runtime and the app shell.
666 lines
24 KiB
Rust
666 lines
24 KiB
Rust
use std::num::NonZeroU32;
|
|
use std::path::{Path, PathBuf};
|
|
use std::rc::Rc;
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use servo::{
|
|
DeviceIntRect, DeviceIntSize, DevicePoint, EventLoopWaker, InputEvent,
|
|
MouseButton as ServoMouseButton, MouseButtonAction, MouseButtonEvent, MouseMoveEvent,
|
|
NavigationRequest, RenderingContext, RgbaImage, ServoBuilder, ServoDelegate, ServoUrl,
|
|
UserContentManager, UserScript, WebViewBuilder, WebViewDelegate,
|
|
};
|
|
use winit::{
|
|
application::ApplicationHandler,
|
|
dpi::PhysicalSize,
|
|
event::{ElementState, MouseButton, WindowEvent},
|
|
event_loop::{ActiveEventLoop, EventLoop, EventLoopProxy},
|
|
keyboard::ModifiersState,
|
|
raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawDisplayHandle, RawWindowHandle},
|
|
window::{Window, WindowAttributes, WindowId},
|
|
};
|
|
|
|
// ── Event loop waker ──────────────────────────────────────────────────────────
|
|
|
|
#[derive(Clone)]
|
|
struct WeftEventLoopWaker {
|
|
proxy: Arc<Mutex<EventLoopProxy<ServoWake>>>,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct ServoWake;
|
|
|
|
impl EventLoopWaker for WeftEventLoopWaker {
|
|
fn clone_box(&self) -> Box<dyn EventLoopWaker> {
|
|
Box::new(self.clone())
|
|
}
|
|
|
|
fn wake(&self) {
|
|
let _ = self
|
|
.proxy
|
|
.lock()
|
|
.unwrap_or_else(|p| p.into_inner())
|
|
.send_event(ServoWake);
|
|
}
|
|
}
|
|
|
|
// ── Servo delegate ────────────────────────────────────────────────────────────
|
|
|
|
struct WeftServoDelegate;
|
|
|
|
impl ServoDelegate for WeftServoDelegate {
|
|
fn notify_error(&self, error: servo::ServoError) {
|
|
tracing::error!(?error, "Servo error");
|
|
}
|
|
}
|
|
|
|
// ── WebView delegate ──────────────────────────────────────────────────────────
|
|
|
|
/// Frame and load progress reported by Servo, shared with the event loop.
|
|
#[derive(Default)]
|
|
struct FrameSignals {
|
|
/// A new frame is waiting to be painted.
|
|
redraw: AtomicBool,
|
|
/// Servo has requested at least one repaint.
|
|
content: AtomicBool,
|
|
}
|
|
|
|
struct WeftWebViewDelegate {
|
|
signals: Arc<FrameSignals>,
|
|
/// The system UI document; the only one the webview may show.
|
|
document: String,
|
|
}
|
|
|
|
impl WebViewDelegate for WeftWebViewDelegate {
|
|
fn notify_new_frame_ready(&self, _webview: servo::WebView) {
|
|
self.signals.content.store(true, Ordering::Relaxed);
|
|
self.signals.redraw.store(true, Ordering::Relaxed);
|
|
}
|
|
|
|
/// The system UI holds appd's system credential, so its webview never
|
|
/// leaves the system UI document.
|
|
fn request_navigation(&self, _webview: servo::WebView, request: NavigationRequest) {
|
|
if same_document(request.url.as_str(), &self.document) {
|
|
request.allow();
|
|
} else {
|
|
tracing::warn!(url = %request.url, "navigation away from the system UI denied");
|
|
request.deny();
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Whether two URLs name the same document, ignoring any fragment.
|
|
fn same_document(a: &str, b: &str) -> bool {
|
|
fn document(url: &str) -> &str {
|
|
url.split_once('#').map_or(url, |(document, _)| document)
|
|
}
|
|
document(a) == document(b)
|
|
}
|
|
|
|
/// `value` as a single-quoted JavaScript string literal.
|
|
fn js_string(value: &str) -> String {
|
|
let mut literal = String::with_capacity(value.len() + 2);
|
|
literal.push('\'');
|
|
for c in value.chars() {
|
|
match c {
|
|
' '..='~' if c != '\'' && c != '\\' => literal.push(c),
|
|
_ => literal.push_str(&format!("\\u{{{:x}}}", u32::from(c))),
|
|
}
|
|
}
|
|
literal.push('\'');
|
|
literal
|
|
}
|
|
|
|
/// Servo preferences shared by the WEFT hosts.
|
|
fn host_preferences() -> servo::Preferences {
|
|
servo::Preferences {
|
|
// The system UI and application pages lay out with CSS Grid, which
|
|
// Servo disables by default.
|
|
layout_grid_enabled: true,
|
|
..Default::default()
|
|
}
|
|
}
|
|
|
|
// ── Rendering ───────────────────────────────────────────────────────────────
|
|
|
|
type BlitSurface = softbuffer::Surface<Arc<Window>, Arc<Window>>;
|
|
|
|
enum RenderingCtx {
|
|
/// Servo renders offscreen; each frame is read back and copied to the window.
|
|
Software {
|
|
context: Rc<servo::SoftwareRenderingContext>,
|
|
surface: BlitSurface,
|
|
},
|
|
/// Servo renders directly to the window's EGL surface.
|
|
Egl(Rc<servo::WindowRenderingContext>),
|
|
}
|
|
|
|
impl RenderingCtx {
|
|
fn as_dyn(&self) -> Rc<dyn RenderingContext> {
|
|
match self {
|
|
Self::Software { context, .. } => Rc::clone(context) as Rc<dyn RenderingContext>,
|
|
Self::Egl(context) => Rc::clone(context) as Rc<dyn RenderingContext>,
|
|
}
|
|
}
|
|
|
|
/// Paints the webview into this context and presents the frame on the window.
|
|
fn paint_and_present(&mut self, webview: &servo::WebView) -> Result<(), String> {
|
|
match self {
|
|
Self::Software { context, surface } => {
|
|
context
|
|
.make_current()
|
|
.map_err(|e| format!("make_current: {e:?}"))?;
|
|
webview.paint();
|
|
let size = context.size();
|
|
let rect = DeviceIntRect::from_size(DeviceIntSize::new(
|
|
size.width as i32,
|
|
size.height as i32,
|
|
));
|
|
let image = context.read_to_image(rect);
|
|
context.present();
|
|
let image = image.ok_or("frame readback failed")?;
|
|
blit(surface, &image)
|
|
}
|
|
Self::Egl(context) => {
|
|
context
|
|
.make_current()
|
|
.map_err(|e| format!("make_current: {e:?}"))?;
|
|
webview.paint();
|
|
context.present();
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Copies an RGBA frame into the window's software surface and presents it.
|
|
fn blit(surface: &mut BlitSurface, image: &RgbaImage) -> Result<(), String> {
|
|
let (width, height) = image.dimensions();
|
|
let (Some(w), Some(h)) = (NonZeroU32::new(width), NonZeroU32::new(height)) else {
|
|
return Ok(());
|
|
};
|
|
surface.resize(w, h).map_err(|e| format!("resize: {e}"))?;
|
|
let mut buffer = surface.buffer_mut().map_err(|e| format!("buffer: {e}"))?;
|
|
for (dst, src) in buffer.iter_mut().zip(image.as_raw().chunks_exact(4)) {
|
|
*dst = u32::from(src[0]) << 16 | u32::from(src[1]) << 8 | u32::from(src[2]);
|
|
}
|
|
buffer.present().map_err(|e| format!("present: {e}"))
|
|
}
|
|
|
|
/// Returns winit's `wl_display` and `wl_surface` pointers when running on Wayland.
|
|
fn wayland_handles(
|
|
event_loop: &ActiveEventLoop,
|
|
window: &Window,
|
|
) -> Option<(*mut std::ffi::c_void, *mut std::ffi::c_void)> {
|
|
let RawDisplayHandle::Wayland(display) = event_loop.display_handle().ok()?.as_raw() else {
|
|
return None;
|
|
};
|
|
let RawWindowHandle::Wayland(surface) = window.window_handle().ok()?.as_raw() else {
|
|
return None;
|
|
};
|
|
Some((display.display.as_ptr(), surface.surface.as_ptr()))
|
|
}
|
|
|
|
// ── Application state ─────────────────────────────────────────────────────────
|
|
|
|
struct App {
|
|
url: ServoUrl,
|
|
ws_port: u16,
|
|
window: Option<Arc<Window>>,
|
|
servo: Option<servo::Servo>,
|
|
webview: Option<servo::WebView>,
|
|
rendering_context: Option<RenderingCtx>,
|
|
signals: Arc<FrameSignals>,
|
|
waker: WeftEventLoopWaker,
|
|
shutting_down: bool,
|
|
modifiers: ModifiersState,
|
|
cursor_pos: DevicePoint,
|
|
shell_client: Option<crate::shell_client::ShellClient>,
|
|
gesture_thread: Option<std::thread::JoinHandle<()>>,
|
|
/// weft-appd's WebSocket port and system token, once both are available.
|
|
endpoint: Option<AppdEndpoint>,
|
|
next_endpoint_check: std::time::Instant,
|
|
}
|
|
|
|
/// How the system UI reaches weft-appd.
|
|
#[derive(Clone, PartialEq)]
|
|
struct AppdEndpoint {
|
|
port: u16,
|
|
token: String,
|
|
}
|
|
|
|
/// How often the shell rereads weft-appd's port and token files, which change
|
|
/// when weft-appd restarts.
|
|
const ENDPOINT_CHECK_INTERVAL: std::time::Duration = std::time::Duration::from_secs(2);
|
|
|
|
/// Reads weft-appd's port (`WEFT_APPD_WS_PORT`, then `appd.wsport`, then
|
|
/// `default_port`) and its system token from `appd.systoken`. Only a token of
|
|
/// 32 lowercase hex characters is accepted, so it can be placed in a script.
|
|
fn appd_endpoint(default_port: u16) -> Option<AppdEndpoint> {
|
|
let dir = PathBuf::from(std::env::var("XDG_RUNTIME_DIR").ok()?).join("weft");
|
|
let token = std::fs::read_to_string(dir.join("appd.systoken")).ok()?;
|
|
let token = token.trim();
|
|
if token.len() != 32
|
|
|| !token
|
|
.bytes()
|
|
.all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b))
|
|
{
|
|
return None;
|
|
}
|
|
let port = std::env::var("WEFT_APPD_WS_PORT")
|
|
.ok()
|
|
.and_then(|p| p.trim().parse().ok())
|
|
.or_else(|| {
|
|
std::fs::read_to_string(dir.join("appd.wsport"))
|
|
.ok()
|
|
.and_then(|p| p.trim().parse().ok())
|
|
})
|
|
.unwrap_or(default_port);
|
|
Some(AppdEndpoint {
|
|
port,
|
|
token: token.to_owned(),
|
|
})
|
|
}
|
|
|
|
impl App {
|
|
fn new(url: ServoUrl, waker: WeftEventLoopWaker, ws_port: u16) -> Self {
|
|
Self {
|
|
url,
|
|
ws_port,
|
|
window: None,
|
|
servo: None,
|
|
webview: None,
|
|
rendering_context: None,
|
|
signals: Arc::default(),
|
|
waker,
|
|
shutting_down: false,
|
|
modifiers: ModifiersState::default(),
|
|
cursor_pos: DevicePoint::origin(),
|
|
shell_client: None,
|
|
gesture_thread: None,
|
|
endpoint: None,
|
|
next_endpoint_check: std::time::Instant::now(),
|
|
}
|
|
}
|
|
|
|
/// Rereads the appd endpoint and hands it to the system UI. The page's
|
|
/// `weftAppdEndpoint` reconnects only when the endpoint changed, so
|
|
/// repeating the call also covers page reloads.
|
|
fn deliver_endpoint(&mut self, event_loop: &ActiveEventLoop) {
|
|
let now = std::time::Instant::now();
|
|
if now < self.next_endpoint_check {
|
|
return;
|
|
}
|
|
self.next_endpoint_check = now + ENDPOINT_CHECK_INTERVAL;
|
|
event_loop.set_control_flow(winit::event_loop::ControlFlow::WaitUntil(
|
|
self.next_endpoint_check,
|
|
));
|
|
self.endpoint = appd_endpoint(self.ws_port);
|
|
let (Some(endpoint), Some(webview)) = (&self.endpoint, &self.webview) else {
|
|
return;
|
|
};
|
|
// The credential goes only to the system UI document. Navigation away
|
|
// from it is denied; the script checks the document again because a
|
|
// load can still be under way when it runs.
|
|
if !webview
|
|
.url()
|
|
.is_some_and(|url| same_document(url.as_str(), self.url.as_str()))
|
|
{
|
|
return;
|
|
}
|
|
let document = js_string(self.url.as_str().split('#').next().unwrap_or_default());
|
|
webview.evaluate_javascript(
|
|
format!(
|
|
"window === window.top && \
|
|
location.href.split('#')[0] === {document} && \
|
|
typeof window.weftAppdEndpoint === 'function' && \
|
|
window.weftAppdEndpoint({}, '{}')",
|
|
endpoint.port, endpoint.token
|
|
),
|
|
|_| {},
|
|
);
|
|
}
|
|
|
|
/// Paints and presents once Servo has requested its first repaint.
|
|
///
|
|
/// Nothing is presented before that request; the first frames can still be
|
|
/// blank or unstyled while the document loads.
|
|
fn render_frame(&mut self) {
|
|
if !self.signals.content.load(Ordering::Relaxed) {
|
|
return;
|
|
}
|
|
let (Some(webview), Some(context)) = (&self.webview, &mut self.rendering_context) else {
|
|
return;
|
|
};
|
|
if let Err(e) = context.paint_and_present(webview) {
|
|
tracing::warn!("frame not presented: {e}");
|
|
}
|
|
}
|
|
|
|
/// Drops the webview and Servo; dropping the last `Servo` handle shuts it down.
|
|
fn shut_down(&mut self) {
|
|
self.shutting_down = true;
|
|
self.webview = None;
|
|
self.servo = None;
|
|
}
|
|
}
|
|
|
|
impl ApplicationHandler<ServoWake> for App {
|
|
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
|
|
if self.window.is_some() {
|
|
return;
|
|
}
|
|
|
|
let attrs = WindowAttributes::default().with_title("WEFT Shell");
|
|
let window = match event_loop.create_window(attrs) {
|
|
Ok(w) => Arc::new(w),
|
|
Err(e) => {
|
|
tracing::error!(error = %e, "failed to create shell window; exiting");
|
|
event_loop.exit();
|
|
return;
|
|
}
|
|
};
|
|
let size = window.inner_size();
|
|
self.window = Some(Arc::clone(&window));
|
|
|
|
if self.shell_client.is_none()
|
|
&& let Some((disp, surf)) = wayland_handles(event_loop, &window)
|
|
{
|
|
match crate::shell_client::ShellClient::connect_with_display(disp, surf) {
|
|
Ok(sc) => self.shell_client = Some(sc),
|
|
Err(e) => tracing::warn!(error = %e, "shell protocol unavailable"),
|
|
}
|
|
}
|
|
|
|
let servo = ServoBuilder::default()
|
|
.preferences(host_preferences())
|
|
.event_loop_waker(Box::new(self.waker.clone()))
|
|
.build();
|
|
|
|
servo.set_delegate(Rc::new(WeftServoDelegate));
|
|
|
|
let Some(rendering_context) = build_rendering_ctx(event_loop, &window, size) else {
|
|
tracing::error!("no rendering context available; shell cannot start");
|
|
event_loop.exit();
|
|
return;
|
|
};
|
|
|
|
let user_content_manager = Rc::new(UserContentManager::new(&servo));
|
|
if let Some(kit_js) = load_ui_kit_script() {
|
|
user_content_manager.add_script(Rc::new(UserScript::new(kit_js, None)));
|
|
}
|
|
|
|
let webview = WebViewBuilder::new(&servo, rendering_context.as_dyn())
|
|
.delegate(Rc::new(WeftWebViewDelegate {
|
|
signals: Arc::clone(&self.signals),
|
|
document: self.url.as_str().to_owned(),
|
|
}))
|
|
.user_content_manager(Rc::clone(&user_content_manager))
|
|
.url(self.url.clone().into_url())
|
|
.build();
|
|
|
|
self.servo = Some(servo);
|
|
self.webview = Some(webview);
|
|
self.rendering_context = Some(rendering_context);
|
|
}
|
|
|
|
fn user_event(&mut self, _event_loop: &ActiveEventLoop, _event: ServoWake) {
|
|
if let Some(servo) = &self.servo {
|
|
servo.spin_event_loop();
|
|
}
|
|
}
|
|
|
|
fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
|
|
if self.shutting_down {
|
|
event_loop.exit();
|
|
return;
|
|
}
|
|
let mut compositor_closed = false;
|
|
if let Some(sc) = &mut self.shell_client {
|
|
match sc.dispatch_pending() {
|
|
Ok(false) => compositor_closed = true,
|
|
Err(e) => tracing::warn!("shell client dispatch error: {e}"),
|
|
Ok(true) => {}
|
|
}
|
|
let gestures = sc.take_pending_gestures();
|
|
if !gestures.is_empty() {
|
|
let prev_done = self
|
|
.gesture_thread
|
|
.as_ref()
|
|
.map(|h| h.is_finished())
|
|
.unwrap_or(true);
|
|
if let (true, Some(endpoint)) = (prev_done, self.endpoint.clone()) {
|
|
self.gesture_thread = Some(std::thread::spawn(move || {
|
|
forward_gestures_to_appd(&endpoint, &gestures);
|
|
}));
|
|
} else if !prev_done {
|
|
tracing::debug!(
|
|
count = gestures.len(),
|
|
"gesture forwarding in progress; dropping batch"
|
|
);
|
|
} else {
|
|
tracing::debug!(
|
|
count = gestures.len(),
|
|
"weft-appd endpoint unknown; dropping gestures"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
if compositor_closed {
|
|
self.shut_down();
|
|
event_loop.exit();
|
|
return;
|
|
}
|
|
self.deliver_endpoint(event_loop);
|
|
if let Some(servo) = &self.servo {
|
|
servo.spin_event_loop();
|
|
}
|
|
if self.signals.redraw.swap(false, Ordering::Relaxed)
|
|
&& let Some(w) = &self.window
|
|
{
|
|
w.request_redraw();
|
|
}
|
|
}
|
|
|
|
fn window_event(
|
|
&mut self,
|
|
event_loop: &ActiveEventLoop,
|
|
_window_id: WindowId,
|
|
event: WindowEvent,
|
|
) {
|
|
match event {
|
|
WindowEvent::RedrawRequested => self.render_frame(),
|
|
WindowEvent::Resized(new_size) => {
|
|
if new_size.width == 0 || new_size.height == 0 {
|
|
return;
|
|
}
|
|
if let Some(wv) = &self.webview {
|
|
wv.resize(new_size);
|
|
}
|
|
}
|
|
WindowEvent::ModifiersChanged(mods) => {
|
|
self.modifiers = mods.state();
|
|
}
|
|
WindowEvent::KeyboardInput { event, .. } => {
|
|
if let Some(wv) = &self.webview {
|
|
let ev = super::keyutils::keyboard_event_from_winit(&event, self.modifiers);
|
|
let _ = wv.notify_input_event(InputEvent::Keyboard(ev));
|
|
}
|
|
}
|
|
WindowEvent::CursorMoved { position, .. } => {
|
|
let pt = DevicePoint::new(position.x as f32, position.y as f32);
|
|
self.cursor_pos = pt;
|
|
if let Some(wv) = &self.webview {
|
|
let _ = wv
|
|
.notify_input_event(InputEvent::MouseMove(MouseMoveEvent::new(pt.into())));
|
|
}
|
|
}
|
|
WindowEvent::MouseInput { state, button, .. } => {
|
|
let btn = match button {
|
|
MouseButton::Left => ServoMouseButton::Left,
|
|
MouseButton::Right => ServoMouseButton::Right,
|
|
MouseButton::Middle => ServoMouseButton::Middle,
|
|
_ => return,
|
|
};
|
|
let action = match state {
|
|
ElementState::Pressed => MouseButtonAction::Down,
|
|
ElementState::Released => MouseButtonAction::Up,
|
|
};
|
|
if let Some(wv) = &self.webview {
|
|
let _ = wv.notify_input_event(InputEvent::MouseButton(MouseButtonEvent::new(
|
|
action,
|
|
btn,
|
|
self.cursor_pos.into(),
|
|
)));
|
|
}
|
|
}
|
|
WindowEvent::CloseRequested => {
|
|
self.shut_down();
|
|
event_loop.exit();
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ── Rendering context factory ─────────────────────────────────────────────────
|
|
|
|
fn build_rendering_ctx(
|
|
event_loop: &ActiveEventLoop,
|
|
window: &Arc<Window>,
|
|
size: PhysicalSize<u32>,
|
|
) -> Option<RenderingCtx> {
|
|
if std::env::var_os("WEFT_EGL_RENDERING").is_some() {
|
|
let display_handle = event_loop.display_handle();
|
|
let window_handle = window.window_handle();
|
|
if let (Ok(dh), Ok(wh)) = (display_handle, window_handle) {
|
|
match servo::WindowRenderingContext::new(dh, wh, size) {
|
|
Ok(rc) => {
|
|
tracing::info!("using EGL rendering context");
|
|
return Some(RenderingCtx::Egl(Rc::new(rc)));
|
|
}
|
|
Err(e) => {
|
|
tracing::warn!(
|
|
"EGL rendering context failed ({e:?}), falling back to software"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
let context = match servo::SoftwareRenderingContext::new(size) {
|
|
Ok(rc) => Rc::new(rc),
|
|
Err(e) => {
|
|
tracing::error!("SoftwareRenderingContext failed: {e:?}");
|
|
return None;
|
|
}
|
|
};
|
|
let surface = softbuffer::Context::new(Arc::clone(window))
|
|
.and_then(|display| softbuffer::Surface::new(&display, Arc::clone(window)));
|
|
match surface {
|
|
Ok(surface) => Some(RenderingCtx::Software { context, surface }),
|
|
Err(e) => {
|
|
tracing::error!("software presentation surface failed: {e}");
|
|
None
|
|
}
|
|
}
|
|
}
|
|
|
|
// ── Public entry point ────────────────────────────────────────────────────────
|
|
|
|
fn resolve_weft_app_url(url: &ServoUrl) -> Option<ServoUrl> {
|
|
if url.scheme() != "weft-app" {
|
|
return None;
|
|
}
|
|
let app_id = url.host_str()?;
|
|
let rel = url.path().trim_start_matches('/');
|
|
let file_path = app_store_roots()
|
|
.into_iter()
|
|
.map(|r| r.join(app_id).join("ui").join(rel))
|
|
.find(|p| p.exists())?;
|
|
let s = format!("file://{}", file_path.display());
|
|
ServoUrl::parse(&s).ok()
|
|
}
|
|
|
|
fn load_ui_kit_script() -> Option<String> {
|
|
let path = std::env::var("WEFT_UI_KIT_JS")
|
|
.map(std::path::PathBuf::from)
|
|
.unwrap_or_else(|_| std::path::PathBuf::from("/usr/share/weft/system/weft-ui-kit.js"));
|
|
std::fs::read_to_string(path).ok()
|
|
}
|
|
|
|
fn app_store_roots() -> Vec<PathBuf> {
|
|
if let Ok(v) = std::env::var("WEFT_APP_STORE") {
|
|
return vec![PathBuf::from(v)];
|
|
}
|
|
let mut roots = Vec::new();
|
|
if let Ok(home) = std::env::var("HOME") {
|
|
roots.push(
|
|
PathBuf::from(home)
|
|
.join(".local")
|
|
.join("share")
|
|
.join("weft")
|
|
.join("apps"),
|
|
);
|
|
}
|
|
roots.push(PathBuf::from("/usr/share/weft/apps"));
|
|
roots
|
|
}
|
|
|
|
pub fn run(html_path: &Path, ws_port: u16) -> anyhow::Result<()> {
|
|
let url_str = format!("file://{}", html_path.display());
|
|
let raw_url =
|
|
ServoUrl::parse(&url_str).map_err(|e| anyhow::anyhow!("invalid URL {url_str}: {e}"))?;
|
|
let url = resolve_weft_app_url(&raw_url).unwrap_or(raw_url);
|
|
|
|
let event_loop = EventLoop::<ServoWake>::with_user_event()
|
|
.build()
|
|
.map_err(|e| anyhow::anyhow!("event loop: {e}"))?;
|
|
|
|
let waker = WeftEventLoopWaker {
|
|
proxy: Arc::new(Mutex::new(event_loop.create_proxy())),
|
|
};
|
|
|
|
let mut app = App::new(url, waker, ws_port);
|
|
event_loop
|
|
.run_app(&mut app)
|
|
.map_err(|e| anyhow::anyhow!("event loop run: {e}"))
|
|
}
|
|
|
|
fn forward_gestures_to_appd(
|
|
endpoint: &AppdEndpoint,
|
|
gestures: &[crate::shell_client::PendingGesture],
|
|
) {
|
|
use std::net::TcpStream;
|
|
let addr = format!("127.0.0.1:{}", endpoint.port);
|
|
let stream = match TcpStream::connect(&addr) {
|
|
Ok(s) => s,
|
|
Err(e) => {
|
|
tracing::warn!("gesture forward: connect to {addr} failed: {e}");
|
|
return;
|
|
}
|
|
};
|
|
let url = format!("ws://{addr}/");
|
|
let (mut ws, _) = match tungstenite::client::client(url, stream) {
|
|
Ok(pair) => pair,
|
|
Err(e) => {
|
|
tracing::warn!("gesture forward: WebSocket handshake failed: {e}");
|
|
return;
|
|
}
|
|
};
|
|
let hello = serde_json::json!({ "type": "HELLO", "role": "system", "token": endpoint.token });
|
|
if let Err(e) = ws.send(tungstenite::Message::Text(hello.to_string())) {
|
|
tracing::warn!("gesture forward: authentication failed: {e}");
|
|
return;
|
|
}
|
|
for g in gestures {
|
|
let json = format!(
|
|
r#"{{"type":"PANEL_GESTURE","gesture_type":{},"fingers":{},"dx":{},"dy":{}}}"#,
|
|
g.gesture_type, g.fingers, g.dx, g.dy
|
|
);
|
|
if let Err(e) = ws.send(tungstenite::Message::Text(json)) {
|
|
tracing::warn!("gesture forward: send failed: {e}");
|
|
break;
|
|
}
|
|
}
|
|
let _ = ws.close(None);
|
|
}
|