Expose a client voice manager

4 files changed, 107 insertions, 73 deletions

diff --git a/src/client/bridge/gateway/mod.rs b/src/client/bridge/gateway/mod.rs
index 06f5ea4..3cc6dca 100644
--- a/src/client/bridge/gateway/mod.rs
+++ b/src/client/bridge/gateway/mod.rs
@@ -60,7 +60,7 @@ pub use self::shard_manager::{ShardManager, ShardManagerOptions};
 pub use self::shard_manager_monitor::ShardManagerMonitor;
 pub use self::shard_messenger::ShardMessenger;
 pub use self::shard_queuer::ShardQueuer;
-pub use self::shard_runner::ShardRunner;
+pub use self::shard_runner::{ShardRunner, ShardRunnerOptions};
 pub use self::shard_runner_message::ShardRunnerMessage;
 
 use std::fmt::{Display, Formatter, Result as FmtResult};
diff --git a/src/client/bridge/gateway/shard_manager.rs b/src/client/bridge/gateway/shard_manager.rs
index ea3ad1e..b62ff00 100644
--- a/src/client/bridge/gateway/shard_manager.rs
+++ b/src/client/bridge/gateway/shard_manager.rs
@@ -20,6 +20,8 @@ use typemap::ShareMap;
 
 #[cfg(feature = "framework")]
 use framework::Framework;
+#[cfg(feature = "voice")]
+use client::bridge::voice::ClientVoiceManager;
 
 /// A manager for handling the status of shards by starting them, restarting
 /// them, and stopping them when required.
@@ -40,6 +42,11 @@ use framework::Framework;
 ///
 /// # use std::error::Error;
 /// #
+/// # #[cfg(feature = "voice")]
+/// # use serenity::client::bridge::voice::ClientVoiceManager;
+/// # #[cfg(feature = "voice")]
+/// # use serenity::model::id::UserId;
+/// #
 /// # #[cfg(feature = "framework")]
 /// # fn try_main() -> Result<(), Box<Error>> {
 /// #
@@ -78,6 +85,8 @@ use framework::Framework;
 ///     shard_total: 5,
 ///     token: &token,
 ///     threadpool,
+///     # #[cfg(feature = "voice")]
+///     # voice_manager: &Arc::new(Mutex::new(ClientVoiceManager::new(0, UserId(0)))),
 ///     ws_url: &gateway_url,
 /// });
 /// #     Ok(())
@@ -135,6 +144,8 @@ impl ShardManager {
             rx: shard_queue_rx,
             threadpool: opt.threadpool,
             token: Arc::clone(opt.token),
+            #[cfg(feature = "voice")]
+            voice_manager: Arc::clone(opt.voice_manager),
             ws_url: Arc::clone(opt.ws_url),
         };
 
@@ -343,5 +354,7 @@ pub struct ShardManagerOptions<'a, H: EventHandler + Send + Sync + 'static> {
     pub shard_total: u64,
     pub threadpool: ThreadPool,
     pub token: &'a Arc<Mutex<String>>,
+    #[cfg(feature = "voice")]
+    pub voice_manager: &'a Arc<Mutex<ClientVoiceManager>>,
     pub ws_url: &'a Arc<Mutex<String>>,
 }
diff --git a/src/client/bridge/gateway/shard_queuer.rs b/src/client/bridge/gateway/shard_queuer.rs
index 461fdd1..afcd4c7 100644
--- a/src/client/bridge/gateway/shard_queuer.rs
+++ b/src/client/bridge/gateway/shard_queuer.rs
@@ -13,11 +13,14 @@ use super::{
     ShardQueuerMessage,
     ShardRunner,
     ShardRunnerInfo,
+    ShardRunnerOptions,
 };
 use threadpool::ThreadPool;
 use typemap::ShareMap;
 use ::gateway::ConnectionStage;
 
+#[cfg(feature = "voice")]
+use client::bridge::voice::ClientVoiceManager;
 #[cfg(feature = "framework")]
 use framework::Framework;
 
@@ -70,6 +73,9 @@ pub struct ShardQueuer<H: EventHandler + Send + Sync + 'static> {
     pub threadpool: ThreadPool,
     /// A copy of the token to connect with.
     pub token: Arc<Mutex<String>>,
+    /// A copy of the client's voice manager.
+    #[cfg(feature = "voice")]
+    pub voice_manager: Arc<Mutex<ClientVoiceManager>>,
     /// A copy of the URI to use to connect to the gateway.
     pub ws_url: Arc<Mutex<String>>,
 }
@@ -165,24 +171,17 @@ impl<H: EventHandler + Send + Sync + 'static> ShardQueuer<H> {
             shard_info,
         )?;
 
-        let mut runner = feature_framework! {{
-            ShardRunner::new(
-                shard,
-                self.manager_tx.clone(),
-                Arc::clone(&self.framework),
-                Arc::clone(&self.data),
-                Arc::clone(&self.event_handler),
-                self.threadpool.clone(),
-            )
-        } else {
-            ShardRunner::new(
-                shard,
-                self.manager_tx.clone(),
-                self.data.clone(),
-                self.event_handler.clone(),
-                self.threadpool.clone(),
-            )
-        }};
+        let mut runner = ShardRunner::new(ShardRunnerOptions {
+            data: Arc::clone(&self.data),
+            event_handler: Arc::clone(&self.event_handler),
+            #[cfg(feature = "framework")]
+            framework: Arc::clone(&self.framework),
+            manager_tx: self.manager_tx.clone(),
+            threadpool: self.threadpool.clone(),
+            #[cfg(feature = "voice")]
+            voice_manager: Arc::clone(&self.voice_manager),
+            shard,
+        });
 
         let runner_info = ShardRunnerInfo {
             latency: None,
diff --git a/src/client/bridge/gateway/shard_runner.rs b/src/client/bridge/gateway/shard_runner.rs
index ba9e00e..bfe4214 100644
--- a/src/client/bridge/gateway/shard_runner.rs
+++ b/src/client/bridge/gateway/shard_runner.rs
@@ -17,6 +17,8 @@ use websocket::WebSocketError;
 
 #[cfg(feature = "framework")]
 use framework::Framework;
+#[cfg(feature = "voice")]
+use super::super::voice::ClientVoiceManager;
 
 /// A runner for managing a [`Shard`] and its respective WebSocket client.
 ///
@@ -33,53 +35,27 @@ pub struct ShardRunner<H: EventHandler + Send + Sync + 'static> {
     runner_tx: Sender<InterMessage>,
     shard: Shard,
     threadpool: ThreadPool,
+    #[cfg(feature = "voice")]
+    voice_manager: Arc<Mutex<ClientVoiceManager>>,
 }
 
 impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
     /// Creates a new runner for a Shard.
-    #[allow(too_many_arguments)]
-    #[cfg(feature = "framework")]
-    pub fn new(
-        shard: Shard,
-        manager_tx: Sender<ShardManagerMessage>,
-        framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
-        data: Arc<Mutex<ShareMap>>,
-        event_handler: Arc<H>,
-        threadpool: ThreadPool,
-    ) -> Self {
-        let (tx, rx) = mpsc::channel();
-
-        Self {
-            runner_rx: rx,
-            runner_tx: tx,
-            data,
-            event_handler,
-            framework,
-            manager_tx,
-            shard,
-            threadpool,
-        }
-    }
-
-    /// Creates a new runner for a Shard.
-    #[cfg(not(feature = "framework"))]
-    pub fn new(
-        shard: Shard,
-        manager_tx: Sender<ShardManagerMessage>,
-        data: Arc<Mutex<ShareMap>>,
-        event_handler: Arc<H>,
-        threadpool: ThreadPool,
-    ) -> Self {
+    pub fn new(opt: ShardRunnerOptions<H>) -> Self {
         let (tx, rx) = mpsc::channel();
 
         Self {
             runner_rx: rx,
             runner_tx: tx,
-            data,
-            event_handler,
-            manager_tx,
-            shard,
-            threadpool,
+            data: opt.data,
+            event_handler: opt.event_handler,
+            #[cfg(feature = "framework")]
+            framework: opt.framework,
+            manager_tx: opt.manager_tx,
+            shard: opt.shard,
+            threadpool: opt.threadpool,
+            #[cfg(feature = "voice")]
+            voice_manager: opt.voice_manager,
         }
     }
 
@@ -132,19 +108,8 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
                 return self.request_restart();
             }
 
-            #[cfg(feature = "voice")]
-            {
-                for message in self.shard.cycle_voice_recv() {
-                    if let Err(why) = self.shard.client.send_json(&message) {
-                        println!("Err sending from voice over WS: {:?}", why);
-                    }
-                }
-            }
-
             let pre = self.shard.stage();
-
             let (event, action, successful) = self.recv_event();
-
             let post = self.shard.stage();
 
             if post != pre {
@@ -325,6 +290,39 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
         }
     }
 
+    #[cfg(feature = "voice")]
+    fn handle_voice_event(&self, event: &Event) {
+        match *event {
+            Event::Ready(_) => {
+                self.voice_manager.lock().set(
+                    self.shard.shard_info()[0],
+                    self.runner_tx.clone(),
+                );
+            },
+            Event::VoiceServerUpdate(ref event) => {
+                if let Some(guild_id) = event.guild_id {
+                    let mut manager = self.voice_manager.lock();
+                    let mut search = manager.get_mut(guild_id);
+
+                    if let Some(handler) = search {
+                        handler.update_server(&event.endpoint, &event.token);
+                    }
+                }
+            },
+            Event::VoiceStateUpdate(ref event) => {
+                if let Some(guild_id) = event.guild_id {
+                    let mut manager = self.voice_manager.lock();
+                    let mut search = manager.get_mut(guild_id);
+
+                    if let Some(handler) = search {
+                        handler.update_state(&event.voice_state);
+                    }
+                }
+            },
+            _ => {},
+        }
+    }
+
     // Receives values over the internal shard runner rx channel and handles
     // them.
     //
@@ -431,11 +429,15 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
             },
         };
 
-        match event {
-            Ok(GatewayEvent::HeartbeatAck) => {
-                self.update_manager();
-            },
-            _ => {},
+        if let Ok(GatewayEvent::HeartbeatAck) = event {
+            self.update_manager();
+        }
+
+        #[cfg(feature = "voice")]
+        {
+            if let Ok(GatewayEvent::Dispatch(_, ref event)) = event {
+                self.handle_voice_event(&event);
+            }
         }
 
         let event = match event {
@@ -457,6 +459,11 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
         let msg = ShardManagerMessage::Restart(shard_id);
         let _ = self.manager_tx.send(msg);
 
+        #[cfg(feature = "voice")]
+        {
+            self.voice_manager.lock().manager_remove(&shard_id.0);
+        }
+
         Ok(())
     }
 
@@ -468,3 +475,18 @@ impl<H: EventHandler + Send + Sync + 'static> ShardRunner<H> {
         });
     }
 }
+
+/// Options to be passed to [`ShardRunner::new`].
+///
+/// [`ShardRunner::new`]: struct.ShardRunner.html#method.new
+pub struct ShardRunnerOptions<H: EventHandler + Send + Sync + 'static> {
+    pub data: Arc<Mutex<ShareMap>>,
+    pub event_handler: Arc<H>,
+    #[cfg(feature = "framework")]
+    pub framework: Arc<Mutex<Option<Box<Framework + Send>>>>,
+    pub manager_tx: Sender<ShardManagerMessage>,
+    pub shard: Shard,
+    pub threadpool: ThreadPool,
+    #[cfg(feature = "voice")]
+    pub voice_manager: Arc<Mutex<ClientVoiceManager>>,
+}