Add exclude current clearing for the server

crabidy-core/crabidy/v1/crabidy.proto

@@ -14,11 +14,11 @@ service CrabidyService {
   rpc Append(AppendRequest) returns (AppendResponse);
   rpc Remove(RemoveRequest) returns (RemoveResponse);
   rpc Insert(InsertRequest) returns (InsertResponse);
+  rpc ClearQueue(ClearQueueRequest) returns (ClearQueueResponse);
   rpc SetCurrent(SetCurrentRequest) returns (SetCurrentResponse);
   rpc ToggleShuffle(ToggleShuffleRequest) returns (ToggleShuffleResponse);
   rpc ToggleRepeat(ToggleRepeatRequest) returns (ToggleRepeatResponse);
   rpc GetUpdateStream(GetUpdateStreamRequest) returns (stream GetUpdateStreamResponse);
-  rpc ClearQueue(ClearQueueRequest) returns (ClearQueueResponse);
   rpc SaveQueue(SaveQueueRequest) returns (SaveQueueResponse);
 
   // Playback

crabidy-server/src/lib.rs

@@ -219,6 +219,20 @@ impl QueueManager {
             self.shuffle_behind(self.current_offset);
         }
     }
+
+    pub fn clear(&mut self, exclude_current: bool) -> bool {
+        let current_track = self.current_track();
+        self.current_offset = 0;
+        self.tracks.clear();
+
+        if exclude_current {
+            if let Some(track) = current_track {
+                self.tracks.push(track);
+            }
+        }
+
+        !exclude_current
+    }
 }
 
 #[cfg(test)]

crabidy-server/src/main.rs

@@ -170,6 +170,10 @@ pub enum PlaybackMessage {
         uuids: Vec<String>,
         span: Span,
     },
+    Clear {
+        exclude_current: bool,
+        span: Span,
+    },
     SetCurrent {
         position: u32,
         span: Span,

crabidy-server/src/playback.rs

@@ -225,6 +225,27 @@ impl Playback {
                         debug!("queue lock released");
                     }
 
+                    PlaybackMessage::Clear {
+                        exclude_current,
+                        span,
+                    } => {
+                        let _e = span.enter();
+                        debug!("clearing");
+                        let should_stop = {
+                            let mut queue = self.queue.lock().unwrap();
+                            debug!("got queue lock");
+                            let should_stop = queue.clear(exclude_current);
+                            let queue_update_tx = self.update_tx.clone();
+                            let update = StreamUpdate::Queue(queue.clone().into());
+                            queue_update_tx.send(update).unwrap();
+                            should_stop
+                        };
+                        debug!("queue lock released");
+                        if should_stop {
+                            self.player.stop().in_current_span().await;
+                        }
+                    }
+
                     PlaybackMessage::SetCurrent {
                         position: queue_position,
                         span,

crabidy-server/src/rpc.rs

@@ -201,6 +201,28 @@ impl CrabidyService for RpcService {
         Ok(Response::new(reply))
     }
 
+    #[instrument(skip(self, request), fields(exclude_current))]
+    async fn clear_queue(
+        &self,
+        request: tonic::Request<ClearQueueRequest>,
+    ) -> std::result::Result<tonic::Response<ClearQueueResponse>, tonic::Status> {
+        let exclude_current = request.into_inner().exclude_current;
+        Span::current().record("exclude_current", exclude_current);
+        debug!("Received clear_queue request");
+        let playback_tx = self.playback_tx.clone();
+        let span = debug_span!("play-chan");
+        playback_tx
+            .send_async(PlaybackMessage::Clear {
+                exclude_current,
+                span,
+            })
+            .in_current_span()
+            .await
+            .map_err(|_| Status::internal("Failed to send request via channel"))?;
+        let reply = ClearQueueResponse {};
+        Ok(Response::new(reply))
+    }
+
     #[instrument(skip(self, request), fields(position))]
     async fn set_current(
         &self,
@@ -279,24 +301,6 @@ impl CrabidyService for RpcService {
         Ok(Response::new(Box::pin(output_stream)))
     }
 
-    #[instrument(skip(self, _request))]
-    async fn clear_queue(
-        &self,
-        _request: tonic::Request<ClearQueueRequest>,
-    ) -> std::result::Result<tonic::Response<ClearQueueResponse>, tonic::Status> {
-        debug!("Received clear_queue request");
-        let playback_tx = self.playback_tx.clone();
-        let span = debug_span!("play-chan");
-        let uuids = Vec::new();
-        playback_tx
-            .send_async(PlaybackMessage::Replace { uuids, span })
-            .in_current_span()
-            .await
-            .map_err(|_| Status::internal("Failed to send request via channel"))?;
-        let reply = ClearQueueResponse {};
-        Ok(Response::new(reply))
-    }
-
     #[instrument(skip(self, _request))]
     async fn save_queue(
         &self,