Added pause, play, resume, skip, and stop

src/commands/audio/pause.rs

@@ -0,0 +1,43 @@
+use log::{debug, error};
+
+use serenity::prelude::*;
+use serenity::builder::CreateApplicationCommand;
+use serenity::model::application::interaction::application_command::ApplicationCommandInteraction;
+
+use super::{get_songbird, create_response, edit_response};
+
+pub async fn run(ctx: &Context, command: &ApplicationCommandInteraction) {
+  // Create the initial response
+  if let Err(why) = create_response(&ctx, &command, "Processing command...".to_string()).await {
+    error!("Failed to create response message: {}", why);
+    return;
+  }
+
+  let guild_id = match command.guild_id {
+    Some(g) => g,
+    None => {
+      if let Err(why) = edit_response(&ctx, &command, "Unable to join voice channel".to_string()).await {
+        error!("Failed to edit response message: {}", why);
+      }
+      return;
+    }
+  };
+  let manager = get_songbird(ctx).await;
+  if let Some(handler_lock) = manager.get(guild_id) {
+    let handler = handler_lock.lock().await;
+    if let Err(err) = handler.queue().pause() {
+      if let Err(why) = edit_response(&ctx, &command, format!("Failed to pause: {}", err)).await {
+        error!("Failed to edit response message: {}", why);
+      }
+    } else {
+      debug!("Paused the track");
+      if let Err(why) = edit_response(&ctx, &command, format!("Pausing the track")).await {
+        error!("Failed to edit response message: {}", why);
+      }
+    }
+  }
+}
+
+pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+  command.name("pause").description("Pause the current track")
+}

src/commands/audio/play.rs

@@ -74,7 +74,7 @@ pub async fn run(ctx: &Context, command: &ApplicationCommandInteraction) {
             }
             let mut handler = handler_lock.lock().await;
             handler.remove_all_global_events();
-            handler.add_global_event(songbird::Event::Track(songbird::TrackEvent::End), InactiveHandler { guild_id, call: manager })
+            handler.add_global_event(songbird::Event::Track(songbird::TrackEvent::End), TrackEndNotifier { guild_id, call: manager })
           }
           Err(why) => {
             warn!("Failed to add song: {}", why);
@@ -107,19 +107,19 @@ pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicatio
   })
 }
 
-struct InactiveHandler {
+struct TrackEndNotifier {
   pub call: std::sync::Arc<songbird::Songbird>,
   pub guild_id: serenity::model::id::GuildId
 }
 
 #[async_trait]
-impl EventHandler for InactiveHandler {
+impl EventHandler for TrackEndNotifier {
   async fn act(&self, ctx: &songbird::events::EventContext<'_>) -> Option<songbird::events::Event> {
-    if let songbird::EventContext::Track(track_list) = ctx {
-      if track_list.is_empty() {
-        if let Some(call) = self.call.get(self.guild_id) {
-          debug!("Track list is empty; leaving voice channel");
-          let mut handler = call.lock().await;
+    if let songbird::EventContext::Track(_track_list) = ctx {
+      if let Some(call) = self.call.get(self.guild_id) {
+        let mut handler = call.lock().await;
+        if handler.queue().is_empty() {
+          debug!("Queue is empty, leaving voice channel");
           handler.leave().await.unwrap();
         }
       }

src/commands/audio/resume.rs

@@ -0,0 +1,43 @@
+use log::{debug, error};
+
+use serenity::prelude::*;
+use serenity::builder::CreateApplicationCommand;
+use serenity::model::application::interaction::application_command::ApplicationCommandInteraction;
+
+use super::{get_songbird, create_response, edit_response};
+
+pub async fn run(ctx: &Context, command: &ApplicationCommandInteraction) {
+  // Create the initial response
+  if let Err(why) = create_response(&ctx, &command, "Processing command...".to_string()).await {
+    error!("Failed to create response message: {}", why);
+    return;
+  }
+
+  let guild_id = match command.guild_id {
+    Some(g) => g,
+    None => {
+      if let Err(why) = edit_response(&ctx, &command, "Unable to join voice channel".to_string()).await {
+        error!("Failed to edit response message: {}", why);
+      }
+      return;
+    }
+  };
+  let manager = get_songbird(ctx).await;
+  if let Some(handler_lock) = manager.get(guild_id) {
+    let handler = handler_lock.lock().await;
+    if let Err(err) = handler.queue().resume() {
+      if let Err(why) = edit_response(&ctx, &command, format!("Failed to resume: {}", err)).await {
+        error!("Failed to edit response message: {}", why);
+      }
+    } else {
+      debug!("Resumed the track");
+      if let Err(why) = edit_response(&ctx, &command, format!("Resuming the track")).await {
+        error!("Failed to edit response message: {}", why);
+      }
+    }
+  }
+}
+
+pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+  command.name("resume").description("Resume the current track")
+}

src/commands/audio/skip.rs

@@ -0,0 +1,43 @@
+use log::{debug, error};
+
+use serenity::prelude::*;
+use serenity::builder::CreateApplicationCommand;
+use serenity::model::application::interaction::application_command::ApplicationCommandInteraction;
+
+use super::{get_songbird, create_response, edit_response};
+
+pub async fn run(ctx: &Context, command: &ApplicationCommandInteraction) {
+  // Create the initial response
+  if let Err(why) = create_response(&ctx, &command, "Processing command...".to_string()).await {
+    error!("Failed to create response message: {}", why);
+    return;
+  }
+
+  let guild_id = match command.guild_id {
+    Some(g) => g,
+    None => {
+      if let Err(why) = edit_response(&ctx, &command, "Unable to join voice channel".to_string()).await {
+        error!("Failed to edit response message: {}", why);
+      }
+      return;
+    }
+  };
+  let manager = get_songbird(ctx).await;
+  if let Some(handler_lock) = manager.get(guild_id) {
+    let handler = handler_lock.lock().await;
+    if let Err(err) = handler.queue().skip() {
+      if let Err(why) = edit_response(&ctx, &command, format!("Failed to skip: {}", err)).await {
+        error!("Failed to edit response message: {}", why);
+      }
+    } else {
+      debug!("Skipped the track");
+      if let Err(why) = edit_response(&ctx, &command, format!("Skipping the track")).await {
+        error!("Failed to edit response message: {}", why);
+      }
+    }
+  }
+}
+
+pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+  command.name("skip").description("Skip the current track")
+}

src/commands/audio/stop.rs

@@ -0,0 +1,38 @@
+use log::{debug, error};
+
+use serenity::prelude::*;
+use serenity::builder::CreateApplicationCommand;
+use serenity::model::application::interaction::application_command::ApplicationCommandInteraction;
+
+use super::{get_songbird, create_response, edit_response};
+
+pub async fn run(ctx: &Context, command: &ApplicationCommandInteraction) {
+  // Create the initial response
+  if let Err(why) = create_response(&ctx, &command, "Processing command...".to_string()).await {
+    error!("Failed to create response message: {}", why);
+    return;
+  }
+
+  let guild_id = match command.guild_id {
+    Some(g) => g,
+    None => {
+      if let Err(why) = edit_response(&ctx, &command, "Unable to join voice channel".to_string()).await {
+        error!("Failed to edit response message: {}", why);
+      }
+      return;
+    }
+  };
+  let manager = get_songbird(ctx).await;
+  if let Some(handler_lock) = manager.get(guild_id) {
+    let handler = handler_lock.lock().await;
+    handler.queue().stop();
+    debug!("Stopped the track");
+    if let Err(why) = edit_response(&ctx, &command, format!("Stopping the tracks")).await {
+      error!("Failed to edit response message: {}", why);
+    }
+  }
+}
+
+pub fn register(command: &mut CreateApplicationCommand) -> &mut CreateApplicationCommand {
+  command.name("stop").description("Stop the current track and clear the queue")
+}