Add repeat and shuffle mode

Author: Ross

.github/workflows/build.yaml

@@ -87,6 +87,7 @@ jobs:
       - name: Install Rust toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
+          toolchain: stable
           targets: ${{ matrix.target }}
 
       - name: Add Dependency
@@ -119,9 +120,7 @@ jobs:
           echo "TARBALL_NAME=${TARBALL_NAME}" >> $GITHUB_ENV
 
       - name: Upload release asset
-        uses: softprops/action-gh-release@v2
-        with:
-          files: ${{ env.TARBALL_NAME }}
-          generate_release_notes: true
+        run: |
+          gh release upload ${{ github.ref_name }} ${{env.TARBALL_NAME}} --clobber
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

src/app.rs

@@ -68,6 +68,17 @@ pub enum VolumeDirection {
     Down,
 }
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RepeatMode {
+    None,
+    One,
+    All,
+}
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ShuffleMode {
+    Off,
+    On,
+}
 pub struct TabSelection<T> {
     pub index: usize,
     pub state: ListState,
@@ -182,6 +193,11 @@ pub struct App {
     pub widget_notification: Option<(String, std::time::Instant)>,
     pub w_notification_duration: std::time::Duration,
     pub last_search_keystroke: Option<std::time::Instant>,
+    // Shuffle and repeat
+    pub on_repeat: RepeatMode,
+    pub shuffle_mode: ShuffleMode,
+    pub shuffle_order: Vec<usize>,
+    pub shuffle_position: usize,
     // TabSelection
     pub queue_tab: TabSelection<Track>,
     pub tracks_tab: TabSelection<Track>,
@@ -197,10 +213,6 @@ pub struct App {
     pub search_query: String,
     pub search_engine: SearchEngine,
     pub is_searching: bool,
-    // player status
-    pub on_repeat: bool,
-    // Need to work on the logic to allow shuffling
-    pub _on_shuffle: bool,
     pub cover_art_protocol: Option<StatefulProtocol>,
 }
 
@@ -301,8 +313,10 @@ impl App {
             search_query: String::new(),
             search_engine,
             is_searching: false,
-            on_repeat: false,
-            _on_shuffle: false,
+            on_repeat: RepeatMode::None,
+            shuffle_mode: ShuffleMode::Off,
+            shuffle_order: Vec::new(),
+            shuffle_position: 0,
             cover_art_protocol: None,
         };
 

src/app/playback.rs

@@ -1,9 +1,10 @@
 use anyhow::Result;
 use futures::future;
 use mpris_server::{Metadata, Property};
+use rand::seq::SliceRandom;
 
 use crate::{
-    app::{ActiveSection, ActiveTab, AppError, Track, VolumeDirection},
+    app::{ActiveSection, ActiveTab, AppError, RepeatMode, ShuffleMode, Track, VolumeDirection},
     mpris_handler::track_to_metadata,
 };
 
@@ -59,14 +60,61 @@ impl App {
         self.subsonic_client.scrobble(&track, false).await?;
         Ok(())
     }
+    pub fn enable_shuffle(&mut self) {
+        if self.queue_tab.data.is_empty() {
+            return;
+        }
+        let mut rng = rand::thread_rng();
+        let mut indices: Vec<usize> = (0..self.queue_tab.len()).collect();
+        indices.shuffle(&mut rng);
+        // Put current_track as first track
+        if let Some(pos) = indices.iter().position(|&i| i == self.playing_index) {
+            indices.swap(0, pos)
+        };
+        self.shuffle_order = indices;
+        self.shuffle_position = 0;
+        self.shuffle_mode = ShuffleMode::On;
+    }
+    pub fn disable_shuffle(&mut self) {
+        self.shuffle_mode = ShuffleMode::Off;
+        self.shuffle_order.clear();
+    }
+    pub fn toggle_shuffle(&mut self) {
+        match self.shuffle_mode {
+            ShuffleMode::Off => self.enable_shuffle(),
+            ShuffleMode::On => self.disable_shuffle(),
+        }
+    }
+    pub fn toggle_repeat(&mut self) {
+        self.on_repeat = match self.on_repeat {
+            RepeatMode::None => RepeatMode::One,
+            RepeatMode::One => RepeatMode::All,
+            RepeatMode::All => RepeatMode::None,
+        }
+    }
     pub async fn play_next(&mut self) -> Result<(), AppError> {
         if self.current_track.is_none() {
             return Err(AppError::NoTrackLoaded);
         }
+        if self.shuffle_mode == ShuffleMode::On && !self.shuffle_order.is_empty() {
+            self.shuffle_position = (self.shuffle_position + 1) % self.shuffle_order.len();
+            let idx = self.shuffle_order[self.shuffle_position];
+            self.play_from_queue(idx).await?;
+            return Ok(());
+        }
         if self.queue_tab.data.is_empty() {
             return Err(AppError::EmptyQueue);
         } else if self.playing_index < self.queue_tab.data.len() - 1 {
-            self.play_from_queue(self.playing_index + 1).await?;
+            match self.on_repeat {
+                RepeatMode::One => {
+                    self.play_selected(self.playing_index).await?;
+                }
+                RepeatMode::None => {
+                    self.playing_index += 1;
+                    self.play_from_queue(self.playing_index).await?;
+                }
+                RepeatMode::All => {}
+            }
         } else {
             self.player.lock().await.stop()?;
             self.is_playing = false;
@@ -156,15 +204,24 @@ impl App {
         self.subsonic_client
             .scrobble(self.current_track.as_ref().unwrap(), true)
             .await?;
-        if self.on_repeat {
-            self.play_selected(self.playing_index).await?;
-        } else if self.playing_index < self.queue_tab.data.len().saturating_sub(1) {
-            self.play_next().await?;
-        } else {
-            self.is_playing = false;
-            self.current_track = None;
-            self.metadata = Metadata::default();
-            self.sync_mpris().await;
+        match self.on_repeat {
+            RepeatMode::One => {
+                self.play_selected(self.playing_index).await?;
+            }
+            RepeatMode::All => {
+                let next = (self.playing_index + 1) % self.queue_tab.len();
+                self.play_from_queue(next).await?;
+            }
+            RepeatMode::None => {
+                if self.playing_index < self.queue_tab.data.len().saturating_sub(1) {
+                    self.play_next().await?;
+                } else {
+                    self.is_playing = false;
+                    self.current_track = None;
+                    self.metadata = Metadata::default();
+                    self.sync_mpris().await;
+                }
+            }
         }
         Ok(())
     }

src/main.rs

@@ -73,8 +73,12 @@ async fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> Result
                     KeyCode::Char('j') | KeyCode::Down => app.next_item_in_tab(),
                     KeyCode::Enter => app.play_selected(app.find_selected()).await?,
                     KeyCode::Left => app.seek_backward().await?,
+                    KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => {
+                        app.refresh_library().await?
+                    }
+                    KeyCode::Char('r') => app.toggle_repeat(),
+                    KeyCode::Char('S') => app.toggle_shuffle(),
                     KeyCode::Right => app.seek_forward().await?,
-                    KeyCode::Char('r') => app.refresh_library().await?,
                     KeyCode::Char('a') => app._add_to_queue().await?,
                     KeyCode::Char('+') => app.adjust_volume(app::VolumeDirection::Up).await?,
                     KeyCode::Char('-') => app.adjust_volume(app::VolumeDirection::Down).await?,

src/ui.rs

@@ -1,5 +1,5 @@
 use crate::{
-    app::{ActiveSection, ActiveTab, App, InputMode, Track},
+    app::{ActiveSection, ActiveTab, App, InputMode, RepeatMode, ShuffleMode, Track},
     theme::ResolvedTheme,
 };
 use ratatui::{
@@ -198,15 +198,15 @@ fn draw_track_info(f: &mut Frame, app: &App, track: &Track, area: Rect, theme: &
     } else {
         Color::LightYellow
     };
-    let repeat_indicator = if app.on_repeat {
-        Span::styled("repeat: on", Style::default().fg(theme.accent))
-    } else {
-        Span::styled("repeat: off", Style::default().fg(theme.muted_color))
+    let repeat_indicator = match app.on_repeat {
+        RepeatMode::None => Span::styled("repeat: off", Style::default().fg(theme.accent)),
+        RepeatMode::One =>
+        Span::styled("repeat: one", Style::default().fg(theme.muted_color)),
+        RepeatMode::All => Span::styled("repeat: all", Style::default().fg(theme.muted_color))
     };
-    let shuffle_indicator = if app._on_shuffle {
-        Span::styled("shuffle: on", Style::default().fg(theme.accent))
-    } else {
-        Span::styled("shuffle: off", Style::default().fg(theme.muted_color))
+    let shuffle_indicator = match app.shuffle_mode {
+        ShuffleMode::On => Span::styled("shuffle: on", Style::default().fg(theme.accent)),
+            ShuffleMode::Off =>Span::styled("shuffle: off", Style::default().fg(theme.muted_color))
     };
     let info_lines = vec![
         Line::from(vec![