Make WayVR IPC independent of the built-in Wayland server

- Rename state -> wayland_state
- Move WayVR IPC server outside "wayvr" (wayland server) feature
- WayVR IPC server is now available without "wayvr" (wayland server) feature
- Remove run_compositor_at_start (run wayland server instantly)

wlx-overlay-s/src/ipc/events.rs

@@ -0,0 +1,189 @@
+use std::{cell::RefCell, rc::Rc};
+
+use crate::ipc::ipc_server;
+use wayvr_ipc::packet_server;
+
+#[cfg(feature = "wayvr")]
+use crate::{
+    backend::wayvr, config_wayvr, overlays::wayvr::OverlayToCreate, overlays::wayvr::WayVRData,
+};
+
+use crate::{
+    backend::{
+        self,
+        task::{OverlayTask, TaskType},
+    },
+    ipc::signal::WayVRSignal,
+    overlays::{self},
+    state::AppState,
+    windowing::{OverlaySelector, manager::OverlayWindowManager},
+};
+
+#[cfg(feature = "wayvr")]
+fn process_tick_tasks(
+    app: &mut AppState,
+    tick_tasks: Vec<backend::wayvr::TickTask>,
+    r_wayvr: &Rc<RefCell<WayVRData>>,
+) -> anyhow::Result<()> {
+    for tick_task in tick_tasks {
+        match tick_task {
+            backend::wayvr::TickTask::NewExternalProcess(request) => {
+                let config = &app.session.wayvr_config;
+
+                let disp_name = request.env.display_name.map_or_else(
+                    || {
+                        config
+                            .get_default_display()
+                            .map(|(display_name, _)| display_name)
+                    },
+                    |display_name| {
+                        config
+                            .get_display(display_name.as_str())
+                            .map(|_| display_name)
+                    },
+                );
+
+                if let Some(disp_name) = disp_name {
+                    let mut wayvr = r_wayvr.borrow_mut();
+
+                    log::info!("Registering external process with PID {}", request.pid);
+
+                    let disp_handle = overlays::wayvr::get_or_create_display_by_name(
+                        app, &mut wayvr, &disp_name,
+                    )?;
+
+                    wayvr
+                        .data
+                        .state
+                        .add_external_process(disp_handle, request.pid);
+
+                    wayvr
+                        .data
+                        .state
+                        .manager
+                        .add_client(wayvr::client::WayVRClient {
+                            client: request.client,
+                            display_handle: disp_handle,
+                            pid: request.pid,
+                        });
+                }
+            }
+            wayvr::TickTask::NewDisplay(cpar, disp_handle) => {
+                log::info!("Creating new display with name \"{}\"", cpar.name);
+
+                let mut wayvr = r_wayvr.borrow_mut();
+
+                let unique_name = wayvr.get_unique_display_name(cpar.name);
+
+                let disp_handle = match disp_handle {
+                    Some(d) => d,
+                    None => wayvr.data.state.create_display(
+                        cpar.width,
+                        cpar.height,
+                        &unique_name,
+                        false,
+                    )?,
+                };
+
+                wayvr.overlays_to_create.push(OverlayToCreate {
+                    disp_handle,
+                    conf_display: config_wayvr::WayVRDisplay {
+                        attach_to: Some(config_wayvr::AttachTo::from_packet(&cpar.attach_to)),
+                        width: cpar.width,
+                        height: cpar.height,
+                        pos: None,
+                        primary: None,
+                        rotation: None,
+                        scale: cpar.scale,
+                    },
+                });
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[allow(clippy::too_many_lines)]
+pub fn tick_events<O>(
+    app: &mut AppState,
+    overlays: &mut OverlayWindowManager<O>,
+) -> anyhow::Result<()>
+where
+    O: Default,
+{
+    #[cfg(feature = "wayvr")]
+    let r_wayvr = app.wayvr.clone();
+    #[cfg(feature = "wayvr")]
+    let mut wayvr = r_wayvr.borrow_mut();
+
+    while let Some(signal) = app.wayvr_signals.read() {
+        match signal {
+            #[cfg(feature = "wayvr")]
+            WayVRSignal::DisplayVisibility(display_handle, visible) => {
+                if let Some(overlay_id) = wayvr.display_handle_map.get(&display_handle) {
+                    let overlay_id = *overlay_id;
+                    wayvr
+                        .data
+                        .state
+                        .set_display_visible(display_handle, visible);
+                    app.tasks.enqueue(TaskType::Overlay(OverlayTask::Modify(
+                        OverlaySelector::Id(overlay_id),
+                        Box::new(move |app, o| {
+                            if visible == o.is_active() {
+                                return;
+                            }
+                            if visible {
+                                o.activate(app);
+                            } else {
+                                o.deactivate();
+                            }
+                        }),
+                    )));
+                }
+            }
+            #[cfg(feature = "wayvr")]
+            WayVRSignal::DisplayWindowLayout(display_handle, layout) => {
+                wayvr.data.state.set_display_layout(display_handle, layout);
+            }
+            #[cfg(feature = "wayvr")]
+            WayVRSignal::BroadcastStateChanged(packet) => {
+                app.ipc_server
+                    .broadcast(packet_server::PacketServer::WvrStateChanged(packet));
+            }
+            #[cfg(feature = "wayvr")]
+            WayVRSignal::Haptics(haptics) => {
+                wayvr.pending_haptics = Some(haptics);
+            }
+            WayVRSignal::DropOverlay(overlay_id) => {
+                app.tasks
+                    .enqueue(TaskType::Overlay(OverlayTask::Drop(OverlaySelector::Id(
+                        overlay_id,
+                    ))));
+            }
+            WayVRSignal::CustomTask(custom_task) => {
+                app.tasks
+                    .enqueue(TaskType::Overlay(OverlayTask::ModifyPanel(custom_task)));
+            }
+        }
+    }
+
+    #[cfg(feature = "wayvr")]
+    {
+        let tick_tasks = wayvr.data.tick_events(app)?;
+        process_tick_tasks(app, tick_tasks, &r_wayvr)?;
+    }
+
+    #[cfg(not(feature = "wayvr"))]
+    {
+        app.ipc_server.tick(&mut ipc_server::TickParams {
+            input_state: &app.input_state,
+            signals: &app.wayvr_signals,
+        });
+    }
+
+    #[cfg(feature = "wayvr")]
+    overlays::wayvr::create_queued_displays(app, &mut wayvr, overlays)?;
+
+    Ok(())
+}