Persist, and toggle with a dbus service

Seems to have some issues at present.

src/toggle_dbus.rs

@@ -0,0 +1,67 @@
+use cosmic::iced::{self, futures::StreamExt, subscription};
+use futures_channel::mpsc;
+use std::{fmt::Debug, hash::Hash};
+use zbus::{dbus_interface, Connection, ConnectionBuilder};
+
+pub fn subscription() -> iced::Subscription<Event> {
+    subscription::unfold("workspaces-dbus", State::Ready, move |state| {
+        start_listening(state)
+    })
+}
+
+#[derive(Debug)]
+enum State {
+    Ready,
+    Waiting(Connection, mpsc::UnboundedReceiver<Event>),
+    Finished,
+}
+
+async fn start_listening(state: State) -> (Option<Event>, State) {
+    match state {
+        State::Ready => {
+            let (tx, rx) = mpsc::unbounded();
+            if let Some(conn) = ConnectionBuilder::session()
+                .ok()
+                .and_then(|conn| conn.name("com.system76.CosmicWorkspaces").ok())
+                .and_then(|conn| {
+                    conn.serve_at(
+                        "/com/system76/CosmicWorkspaces",
+                        CosmicWorkspacesServer { tx },
+                    )
+                    .ok()
+                })
+                .map(|conn| conn.build())
+            {
+                if let Ok(conn) = conn.await {
+                    return (None, State::Waiting(conn, rx));
+                }
+            }
+            return (None, State::Finished);
+        }
+        State::Waiting(conn, mut rx) => {
+            if let Some(Event::Toggle) = rx.next().await {
+                (Some(Event::Toggle), State::Waiting(conn, rx))
+            } else {
+                (None, State::Finished)
+            }
+        }
+        State::Finished => iced::futures::future::pending().await,
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum Event {
+    Toggle,
+}
+
+#[derive(Debug)]
+struct CosmicWorkspacesServer {
+    tx: mpsc::UnboundedSender<Event>,
+}
+
+#[dbus_interface(name = "com.system76.CosmicWorkspaces")]
+impl CosmicWorkspacesServer {
+    async fn toggle(&self) {
+        self.tx.unbounded_send(Event::Toggle).unwrap();
+    }
+}