Merge pull request #36 from qxb3/forward-backward-action

forward(), backward() action improvements

src/action.rs

@@ -35,8 +35,8 @@ pub enum Action {
     LoopTrack,
     LoopCycle,
 
-    Forward(u64),
-    Backward(u64),
+    Forward(i64),
+    Backward(i64),
 }
 
 impl<'de> Deserialize<'de> for Action {
@@ -46,8 +46,8 @@ impl<'de> Deserialize<'de> for Action {
     {
         let action_str: &str = Deserialize::deserialize(deserializer)?;
 
-        let forward_re = Regex::new(r"forward\((\d+)\)").unwrap();
-        let backward_re = Regex::new(r"backward\((\d+)\)").unwrap();
+        let forward_re = Regex::new(r"forward\((-?\d+)\)").unwrap();
+        let backward_re = Regex::new(r"backward\((-?\d+)\)").unwrap();
 
         match action_str {
             "quit()"            => Ok(Action::Quit),
@@ -71,27 +71,31 @@ impl<'de> Deserialize<'de> for Action {
 
             a if forward_re.is_match(a) => {
                 if let Some(captures) = forward_re.captures(a) {
-                    match captures[1].parse::<u64>() {
+                    match captures[1].parse::<i64>() {
                         Ok(offset) => return Ok(Action::Forward(offset)),
-                        Err(_) => return Err(de::Error::custom("Invalid forward offset format"))
+                        Err(_) => return Err(de::Error::custom("Invalid forward() offset format"))
                     }
                 }
 
-                Err(de::Error::custom("Invalid forward format"))
+                Err(de::Error::custom("Invalid forward() format"))
             },
 
             a if backward_re.is_match(a) => {
                 if let Some(captures) = backward_re.captures(a) {
-                    match captures[1].parse::<u64>() {
+                    match captures[1].parse::<i64>() {
                         Ok(offset) => return Ok(Action::Backward(offset)),
-                        Err(_) => return Err(de::Error::custom("Invalid backward offset format"))
+                        Err(_) => return Err(de::Error::custom("Invalid backward() offset format"))
                     }
                 }
 
-                Err(de::Error::custom("Invalid backward format"))
+                Err(de::Error::custom("Invalid backward() format"))
             },
 
-            _ => Err(serde::de::Error::custom(format!("Unknown action: {}", action_str)))
+            // Error if forward() / backward() has no value inside
+            "forward()" => Err(de::Error::custom(format!("Invalid forward() format, needs value inside"))),
+            "backward()" => Err(de::Error::custom(format!("Invalid backward() format, needs value inside"))),
+
+            _ => Err(de::Error::custom(format!("Unknown action: {}", action_str)))
         }
     }
 }
@@ -128,8 +132,30 @@ impl Action {
                 }
             },
 
-            Action::Forward(offset)     => if_player!(&fum.player, |player: &Player| player.seek_forwards(&Duration::from_millis(*offset))),
-            Action::Backward(offset)    => if_player!(&fum.player, |player: &Player| player.seek_backwards(&Duration::from_millis(*offset)))
+            Action::Forward(offset)     => if_player!(&fum.player, |player: &Player| {
+                fum.redraw = true;
+
+                if let Some(track_id) = &fum.meta.track_id {
+                    match offset {
+                        -1  => return player.set_position(track_id.clone(), &fum.meta.length),
+                        _   => return player.seek_forwards(&Duration::from_millis(*offset as u64))
+                    }
+                }
+
+                unreachable!()
+            }),
+            Action::Backward(offset)     => if_player!(&fum.player, |player: &Player| {
+                fum.redraw = true;
+
+                if let Some(track_id) = &fum.meta.track_id {
+                    match offset {
+                        -1   => return player.set_position(track_id.clone(), &Duration::from_secs(0)),
+                        _   => return player.seek_backwards(&Duration::from_millis(*offset as u64))
+                    }
+                }
+
+                unreachable!()
+            })
         }
 
         Ok(())

src/meta.rs

@@ -2,7 +2,7 @@ use std::{fs, io::{self, Cursor}, str::FromStr, time::Duration};
 
 use base64::{prelude::BASE64_STANDARD, Engine};
 use image::ImageReader;
-use mpris::{Metadata, MetadataValue, PlaybackStatus, Player, PlayerFinder};
+use mpris::{Metadata, MetadataValue, PlaybackStatus, Player, PlayerFinder, TrackID};
 use ratatui_image::{picker::Picker, protocol::StatefulProtocol};
 use reqwest::{header::RANGE, Url};
 
@@ -17,6 +17,7 @@ pub struct CoverArt {
 #[derive(Clone)]
 pub struct Meta<'a> {
     pub metadata: Metadata,
+    pub track_id: Option<TrackID>,
     pub title: String,
     pub artists: Vec<String>,
     pub album: String,
@@ -32,6 +33,7 @@ impl<'a> Default for Meta<'a> {
     fn default() -> Self {
         Self {
             metadata: Metadata::default(),
+            track_id: None,
             title: "No Music".to_string(),
             artists: vec!["Artist".to_string()],
             album: "Album".to_string(),
@@ -48,6 +50,7 @@ impl<'a> Default for Meta<'a> {
 impl<'a> Meta<'a> {
     pub fn fetch(player: &Player, picker: &Picker, current: Option<&Self>) -> FumResult<Self> {
         let metadata = Meta::get_metadata(player)?;
+        let track_id = Meta::get_trackid(&metadata)?;
         let title = Meta::get_title(&metadata)?;
         let artists = Meta::get_artists(&metadata)?;
         let album = Meta::get_album(&metadata)?;
@@ -71,6 +74,7 @@ impl<'a> Meta<'a> {
 
         Ok(Self {
             metadata,
+            track_id: Some(track_id),
             title,
             artists,
             album,
@@ -124,6 +128,13 @@ impl<'a> Meta<'a> {
         Ok(metadata)
     }
 
+    pub fn get_trackid(metadata: &Metadata) -> FumResult<TrackID> {
+        let trackid = metadata.track_id()
+            .ok_or("Failed to get track_id")?;
+
+        Ok(trackid)
+    }
+
     pub fn get_title(metadata: &Metadata) -> FumResult<String> {
         let title = metadata
             .title()