refactor: move various clients to own folder

src/clients/wayland/client.rs

@@ -0,0 +1,129 @@
+use super::toplevel::{ToplevelEvent, ToplevelInfo};
+use super::toplevel_manager::listen_for_toplevels;
+use super::ToplevelChange;
+use super::{Env, ToplevelHandler};
+use color_eyre::Report;
+use indexmap::IndexMap;
+use smithay_client_toolkit::environment::Environment;
+use smithay_client_toolkit::output::{with_output_info, OutputInfo};
+use smithay_client_toolkit::reexports::calloop;
+use smithay_client_toolkit::{new_default_environment, WaylandSource};
+use std::sync::{Arc, RwLock};
+use std::time::Duration;
+use tokio::sync::{broadcast, oneshot};
+use tokio::task::spawn_blocking;
+use tracing::{error, trace};
+use wayland_client::protocol::wl_seat::WlSeat;
+use wayland_protocols::wlr::unstable::foreign_toplevel::v1::client::{
+    zwlr_foreign_toplevel_handle_v1::ZwlrForeignToplevelHandleV1,
+    zwlr_foreign_toplevel_manager_v1::ZwlrForeignToplevelManagerV1,
+};
+
+pub struct WaylandClient {
+    pub outputs: Vec<OutputInfo>,
+    pub seats: Vec<WlSeat>,
+    pub toplevels: Arc<RwLock<IndexMap<usize, (ToplevelInfo, ZwlrForeignToplevelHandleV1)>>>,
+    toplevel_tx: broadcast::Sender<ToplevelEvent>,
+    _toplevel_rx: broadcast::Receiver<ToplevelEvent>,
+}
+
+impl WaylandClient {
+    pub(super) async fn new() -> Self {
+        let (output_tx, output_rx) = oneshot::channel();
+        let (seat_tx, seat_rx) = oneshot::channel();
+
+        let (toplevel_tx, toplevel_rx) = broadcast::channel(32);
+
+        let toplevel_tx2 = toplevel_tx.clone();
+
+        let toplevels = Arc::new(RwLock::new(IndexMap::new()));
+        let toplevels2 = toplevels.clone();
+
+        // `queue` is not send so we need to handle everything inside the task
+        spawn_blocking(move || {
+            let (env, _display, queue) =
+                new_default_environment!(Env, fields = [toplevel: ToplevelHandler::init()])
+                    .expect("Failed to connect to Wayland compositor");
+
+            let outputs = Self::get_outputs(&env);
+            output_tx
+                .send(outputs)
+                .expect("Failed to send outputs out of task");
+
+            let seats = env.get_all_seats();
+            seat_tx
+                .send(
+                    seats
+                        .into_iter()
+                        .map(|seat| seat.detach())
+                        .collect::<Vec<WlSeat>>(),
+                )
+                .expect("Failed to send seats out of task");
+
+            let _toplevel_manager = env.require_global::<ZwlrForeignToplevelManagerV1>();
+
+            let _listener = listen_for_toplevels(env, move |handle, event, _ddata| {
+                trace!("Received toplevel event: {:?}", event);
+
+                if event.change == ToplevelChange::Close {
+                    toplevels2
+                        .write()
+                        .expect("Failed to get write lock on toplevels")
+                        .remove(&event.toplevel.id);
+                } else {
+                    toplevels2
+                        .write()
+                        .expect("Failed to get write lock on toplevels")
+                        .insert(event.toplevel.id, (event.toplevel.clone(), handle));
+                }
+
+                toplevel_tx2
+                    .send(event)
+                    .expect("Failed to send toplevel event");
+            });
+
+            let mut event_loop =
+                calloop::EventLoop::<()>::try_new().expect("Failed to create new event loop");
+            WaylandSource::new(queue)
+                .quick_insert(event_loop.handle())
+                .expect("Failed to insert event loop into wayland event queue");
+
+            loop {
+                // TODO: Avoid need for duration here - can we force some event when sending requests?
+                if let Err(err) = event_loop.dispatch(Duration::from_millis(50), &mut ()) {
+                    error!(
+                        "{:?}",
+                        Report::new(err).wrap_err("Failed to dispatch pending wayland events")
+                    );
+                }
+            }
+        });
+
+        let outputs = output_rx
+            .await
+            .expect("Failed to receive outputs from task");
+
+        let seats = seat_rx.await.expect("Failed to receive seats from task");
+
+        Self {
+            outputs,
+            seats,
+            toplevels,
+            toplevel_tx,
+            _toplevel_rx: toplevel_rx,
+        }
+    }
+
+    pub fn subscribe_toplevels(&self) -> broadcast::Receiver<ToplevelEvent> {
+        self.toplevel_tx.subscribe()
+    }
+
+    fn get_outputs(env: &Environment<Env>) -> Vec<OutputInfo> {
+        let outputs = env.get_all_outputs();
+
+        outputs
+            .iter()
+            .filter_map(|output| with_output_info(output, Clone::clone))
+            .collect()
+    }
+}