Add status to name and change volume range to 0..1

2 files changed, 84 insertions, 30 deletions

diff --git a/src/main.rs b/src/main.rs
index e00ae9f..7b674b9 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,6 @@
-use std::str::FromStr;
 use std::io::Read;
 use std::path::PathBuf;
+use std::str::FromStr;
 
 use futures::{
     compat::Future01CompatExt,
@@ -79,23 +79,23 @@ async fn async_main() {
         .log_udp_packets(args.verbose >= 3);
 
     //let (disconnect_send, disconnect_recv) = mpsc::unbounded();
-    let con = Connection::new(con_config).compat().await.unwrap();
+    let conn = Connection::new(con_config).compat().await.unwrap();
 
-    let mut state = State::new(con.clone());
+    let mut state = State::new(conn.clone());
     {
-        let packet = con.lock().server.set_subscribed(true);
-        con.send_packet(packet).compat().await;
+        let packet = conn.lock().server.set_subscribed(true);
+        conn.send_packet(packet).compat().await;
     }
     //con.add_on_disconnect(Box::new( || {
     //disconnect_send.unbounded_send(()).unwrap()
     //}));
     let inner_state = state.clone();
-    con.add_event_listener(
+    conn.add_event_listener(
         String::from("listener"),
         Box::new(move |e| {
-            if let ConEvents(con, events) = e {
+            if let ConEvents(conn, events) = e {
                 for event in *events {
-                    handle_event(&inner_state, &con, event);
+                    handle_event(&inner_state, &conn, event);
                 }
             }
         }),
@@ -110,7 +110,7 @@ async fn async_main() {
     //let ctrlc_fut = ctrl_c.into_future().compat().fuse();
     //ctrlc_fut.await.map_err(|(e, _)| e).unwrap();
 
-    con.disconnect(DisconnectOptions::new())
+    conn.disconnect(DisconnectOptions::new())
         .compat()
         .await
         .unwrap();
@@ -119,7 +119,7 @@ async fn async_main() {
     std::process::exit(0);
 }
 
-fn handle_event<'a>(state: &State, con: &ConnectionLock<'a>, event: &Event) {
+fn handle_event<'a>(state: &State, conn: &ConnectionLock<'a>, event: &Event) {
     match event {
         Event::Message {
             from: target,
@@ -127,21 +127,25 @@ fn handle_event<'a>(state: &State, con: &ConnectionLock<'a>, event: &Event) {
             message: msg,
         } => {
             if let MessageTarget::Poke(who) = target {
-                let channel = con.clients.get(&who).expect("can find poke sender").channel;
+                let channel = conn
+                    .clients
+                    .get(&who)
+                    .expect("can find poke sender")
+                    .channel;
                 tokio::spawn(
-                    con.to_mut()
-                        .get_client(&con.own_client)
+                    conn.to_mut()
+                        .get_client(&conn.own_client)
                         .expect("can get myself")
                         .set_channel(channel)
                         .map_err(|e| error!("Failed to switch channel: {}", e)),
                 );
-            } else if sender.id != con.own_client {
+            } else if sender.id != conn.own_client {
                 if msg.starts_with("!") {
                     let tokens = msg[1..].split_whitespace().collect::<Vec<_>>();
                     match tokens.get(0).map(|t| *t) {
                         Some("test") => {
                             tokio::spawn(
-                                con.to_mut()
+                                conn.to_mut()
                                     .send_message(*target, "works :)")
                                     .map_err(|_| ()),
                             );
@@ -150,6 +154,9 @@ fn handle_event<'a>(state: &State, con: &ConnectionLock<'a>, event: &Event) {
                             let mut invalid = false;
                             if let Some(url) = &tokens.get(1) {
                                 if url.len() > 11 {
+                                    tokio::spawn(
+                                        conn.to_mut().set_name("PokeBot - Loading").map_err(|_| ()),
+                                    );
                                     let trimmed = url[5..url.len() - 6].to_owned();
                                     state.add_audio(trimmed);
                                 } else {
@@ -160,7 +167,7 @@ fn handle_event<'a>(state: &State, con: &ConnectionLock<'a>, event: &Event) {
                             }
                             if invalid {
                                 tokio::spawn(
-                                    con.to_mut()
+                                    conn.to_mut()
                                         .send_message(MessageTarget::Channel, "Invalid Url")
                                         .map_err(|_| ()),
                                 );
@@ -168,7 +175,7 @@ fn handle_event<'a>(state: &State, con: &ConnectionLock<'a>, event: &Event) {
                         }
                         Some("volume") => {
                             if let Ok(volume) = f64::from_str(tokens[1]) {
-                                state.volume(volume / 100.0);
+                                state.volume(volume);
                             }
                         }
                         Some("play") => {
diff --git a/src/state.rs b/src/state.rs
index b10dc15..00bfa54 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -92,6 +92,8 @@ impl State {
                 let opus_enc = gst::ElementFactory::make("opusenc", Some("opus-encoder")).unwrap();
                 let sink = gst::ElementFactory::make("appsink", Some("app-sink")).unwrap();
 
+                sink.set_property("async", &false);
+
                 volume.set_property("volume", &0.2);
 
                 {
@@ -138,13 +140,13 @@ impl State {
                                 },
                             );
 
-                            tokio::run(
-                                inner_conn
-                                    .get_packet_sink()
-                                    .send(packet)
-                                    .map(|_| ())
-                                    .map_err(|e| (println!("Failed to send voice packet."))),
-                            );
+                            let send_packet = inner_conn
+                                .get_packet_sink()
+                                .send(packet)
+                                .map(|_| ())
+                                .map_err(|e| println!("Failed to send voice packet"));
+
+                            tokio::run(send_packet);
 
                             Ok(gst::FlowSuccess::Ok)
                         })
@@ -167,7 +169,15 @@ impl State {
     }
 
     pub fn add_audio<'a>(&self, uri: String) {
-        let ytdl_args = ["-f", "bestaudio/best", "-g", &uri, "-o", "-"];
+        let ytdl_args = [
+            "--no-playlist",
+            "-f",
+            "bestaudio/best",
+            "-g",
+            &uri,
+            "-o",
+            "-",
+        ];
 
         let ytdl_output = Command::new("youtube-dl")
             .args(&ytdl_args)
@@ -195,6 +205,14 @@ impl State {
         self.pipeline
             .set_state(gst::State::Playing)
             .expect("Can set state to playing");
+
+        tokio::spawn(
+            self.conn
+                .lock()
+                .to_mut()
+                .set_name("PokeBot - Playing")
+                .map_err(|_| println!("Failed to change name")),
+        );
     }
 
     pub async fn poll(&self) {
@@ -224,6 +242,14 @@ impl State {
             };
         }
 
+        tokio::spawn(
+            self.conn
+                .lock()
+                .to_mut()
+                .set_name("PokeBot")
+                .map_err(|_| println!("Failed to change name")),
+        );
+
         self.pipeline
             .set_state(gst::State::Null)
             .expect("Can set state to null");
@@ -231,31 +257,52 @@ impl State {
 
     pub fn volume(&self, volume: f64) {
         self.pipeline
-            .set_state(gst::State::Paused)
-            .expect("Can set state to null");
-        self
-            .pipeline
             .get_by_name("volume")
             .expect("Volume filter should be registered")
-            .set_property("volume", &volume);
+            .set_property("volume", &volume)
+            .expect("can change volume");
     }
 
     pub fn play(&self) {
         self.pipeline
             .set_state(gst::State::Playing)
             .expect("can play");
+
+        tokio::spawn(
+            self.conn
+                .lock()
+                .to_mut()
+                .set_name("PokeBot - Playing")
+                .map_err(|_| println!("Failed to change name")),
+        );
     }
 
     pub fn pause(&self) {
         self.pipeline
             .set_state(gst::State::Paused)
             .expect("can pause");
+
+        tokio::spawn(
+            self.conn
+                .lock()
+                .to_mut()
+                .set_name("PokeBot - Paused")
+                .map_err(|_| println!("Failed to change name")),
+        );
     }
 
     pub fn stop(&self) {
         self.pipeline
             .set_state(gst::State::Ready)
             .expect("can stop");
+
+        tokio::spawn(
+            self.conn
+                .lock()
+                .to_mut()
+                .set_name("PokeBot - Stopped")
+                .map_err(|_| println!("Failed to change name")),
+        );
     }
 
     pub async fn disconnect(&self) {