1 files changed, 72 insertions, 0 deletions
diff --git a/src/bin/next.rs b/src/bin/next.rs
new file mode 100644
index 0000000..108432c
--- /dev/null
+++ b/src/bin/next.rs
@@ -0,0 +1,72 @@
+use std::sync::Arc;
+
+use futures_util::StreamExt;
+use i3blocks::{
+    color_listener,
+    dbus::{player::PlayerProxy, playerctld::PlayerctldProxy},
+    i3bar::Block,
+    player_listener, Error,
+};
+use tokio::{
+    sync::{mpsc::Sender, Mutex},
+    task::JoinSet,
+};
+use zbus::Connection;
+
+#[tokio::main]
+async fn main() -> Result<(), main_error::MainError> {
+    let mut join_set = JoinSet::new();
+
+    let (tx_player, mut rx_player) = tokio::sync::mpsc::channel(128);
+    let (tx_status, mut rx_status) = tokio::sync::mpsc::channel(128);
+    let (tx_value, mut rx_value) = tokio::sync::mpsc::channel(128);
+
+    let conn = Connection::session().await?;
+    let proxy = PlayerctldProxy::builder(&conn).build().await?;
+
+    tokio::spawn(player_listener(tx_player, proxy));
+
+    let status: Arc<Mutex<Block>> = Default::default();
+
+    loop {
+        tokio::select! {
+            Some(name) = rx_player.recv() => {
+                join_set.shutdown().await;
+                if name.is_empty() {
+                    let mut status = status.lock().await;
+                    status.full_text = Default::default();
+                } else {
+                    let proxy = PlayerProxy::builder(&conn)
+                        .destination(name)?
+                        .build()
+                        .await?;
+                    join_set.spawn(color_listener(tx_status.clone(), proxy.clone()));
+                    join_set.spawn(value_listener(tx_value.clone(), proxy));
+                }
+            }
+            Some((color, background)) = rx_status.recv() => {
+                let mut status = status.lock().await;
+                status.color = color;
+                status.background = background;
+            }
+            Some(value) = rx_value.recv() => {
+                let mut status = status.lock().await;
+                status.full_text = value.then_some(  " 󰒭  ".into()).unwrap_or_default()
+            }
+        }
+
+        let s = status.lock().await;
+        s.write_stdout()?;
+    }
+}
+
+pub async fn value_listener(tx: Sender<bool>, proxy: PlayerProxy<'_>) -> Result<(), Error> {
+    tx.send(proxy.can_go_next().await?).await?;
+    let mut stream = proxy.receive_can_go_next_changed().await;
+    while let Some(signal) = stream.next().await {
+        if let Ok(value) = signal.get().await {
+            tx.send(value).await?;
+        }
+    }
+    Ok(())
+}