From cf31b2204a53533d1a22dc44c7eb49278f1f6db0 Mon Sep 17 00:00:00 2001
From: Henrik Friedrichsen <henrik@affekt.org>
Date: Mon, 11 Mar 2019 01:07:21 +0100
Subject: [PATCH] trigger redraw every 400ms while playing to keep statusbar in
 sync

---
 Cargo.toml     |  1 +
 src/main.rs    |  1 +
 src/spotify.rs | 35 ++++++++++++++++++++++++++++++++---
 3 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index f5c1ee5..4b62e05 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -23,6 +23,7 @@ serde = "1.0"
 serde_derive = "1.0"
 toml = "0.4"
 tokio-core = "0.1"
+tokio-timer = "0.2"
 unicode-width = "0.1.5"
 
 [dependencies.librespot]
diff --git a/src/main.rs b/src/main.rs
index d102a69..9077710 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -5,6 +5,7 @@ extern crate futures;
 extern crate librespot;
 extern crate rspotify;
 extern crate tokio_core;
+extern crate tokio_timer;
 extern crate unicode_width;
 
 #[macro_use]
diff --git a/src/spotify.rs b/src/spotify.rs
index 9bda928..1fff69e 100644
--- a/src/spotify.rs
+++ b/src/spotify.rs
@@ -23,6 +23,7 @@ use futures::Async;
 use futures::Future;
 use futures::Stream;
 use tokio_core::reactor::Core;
+use tokio_timer;
 
 use std::sync::RwLock;
 use std::thread;
@@ -60,6 +61,8 @@ struct Worker {
     commands: mpsc::UnboundedReceiver<WorkerCommand>,
     player: Player,
     play_task: Box<futures::Future<Item = (), Error = oneshot::Canceled>>,
+    refresh_task: Box<futures::Stream<Item = (), Error = tokio_timer::Error>>,
+    active: bool,
 }
 
 impl Worker {
@@ -73,10 +76,23 @@ impl Worker {
             commands: commands,
             player: player,
             play_task: Box::new(futures::empty()),
+            refresh_task: Box::new(futures::stream::empty()),
+            active: false,
         }
     }
 }
 
+impl Worker {
+    fn create_refresh(&self) -> Box<futures::Stream<Item = (), Error = tokio_timer::Error>> {
+        let ev = self.events.clone();
+        let future =
+            tokio_timer::Interval::new_interval(Duration::from_millis(400)).map(move |_| {
+                ev.trigger();
+            });
+        Box::new(future)
+    }
+}
+
 impl futures::Future for Worker {
     type Item = ();
     type Error = ();
@@ -85,7 +101,6 @@ impl futures::Future for Worker {
         loop {
             let mut progress = false;
 
-            trace!("Worker is polling");
             if let Async::Ready(Some(cmd)) = self.commands.poll().unwrap() {
                 progress = true;
                 debug!("message received!");
@@ -97,14 +112,18 @@ impl futures::Future for Worker {
                     WorkerCommand::Play => {
                         self.player.play();
                         self.events.send(Event::Player(PlayerEvent::Playing));
+                        self.refresh_task = self.create_refresh();
+                        self.active = true;
                     }
                     WorkerCommand::Pause => {
                         self.player.pause();
                         self.events.send(Event::Player(PlayerEvent::Paused));
+                        self.active = false;
                     }
                     WorkerCommand::Stop => {
                         self.player.stop();
                         self.events.send(Event::Player(PlayerEvent::Stopped));
+                        self.active = false;
                     }
                 }
             }
@@ -120,10 +139,20 @@ impl futures::Future for Worker {
                     self.play_task = Box::new(futures::empty());
                 }
             }
+            match self.refresh_task.poll() {
+                Ok(Async::Ready(_)) => {
+                    self.refresh_task = match self.active {
+                        true => {
+                            progress = true;
+                            self.create_refresh()
+                        }
+                        false => Box::new(futures::stream::empty()),
+                    };
+                }
+                _ => (),
+            }
 
-            info!("worker done");
             if !progress {
-                trace!("handing executor to other tasks");
                 return Ok(Async::NotReady);
             }
         }