Use QueueTrack struct instead of (String, String)

Author: Ralph von der Heyden

connect/src/spirc.rs

@@ -14,7 +14,7 @@ use crate::{
     model::{LoadRequest, PlayingTrack, SpircPlayStatus},
     playback::{
         mixer::Mixer,
-        player::{Player, PlayerEvent, PlayerEventChannel},
+        player::{Player, PlayerEvent, PlayerEventChannel, QueueTrack},
     },
     protocol::{
         connect::{Cluster, ClusterUpdate, LogoutCommand, SetVolumeCommand},
@@ -650,21 +650,27 @@ impl SpircTask {
         let context_uri = self.connect_state.context_uri().clone();
         let state_player = self.connect_state.player();
 
-        let current_track = state_player
-            .track
-            .as_ref()
-            .map(|t| (t.uri.clone(), t.provider.clone()));
+        let current_track = state_player.track.as_ref().map(|t| QueueTrack {
+            uri: t.uri.clone(),
+            provider: t.provider.clone(),
+        });
 
         let next_tracks: Vec<_> = state_player
             .next_tracks
             .iter()
-            .map(|t| (t.uri.clone(), t.provider.clone()))
+            .map(|t| QueueTrack {
+                uri: t.uri.clone(),
+                provider: t.provider.clone(),
+            })
             .collect();
 
         let prev_tracks: Vec<_> = state_player
             .prev_tracks
             .iter()
-            .map(|t| (t.uri.clone(), t.provider.clone()))
+            .map(|t| QueueTrack {
+                uri: t.uri.clone(),
+                provider: t.provider.clone(),
+            })
             .collect();
 
         self.player

playback/src/player.rs

@@ -140,12 +140,19 @@ enum PlayerCommand {
     EmitAutoPlayChangedEvent(bool),
     EmitSetQueueEvent {
         context_uri: String,
-        current_track: Option<(String, String)>, // (uri, provider)
-        next_tracks: Vec<(String, String)>,      // (uri, provider)
-        prev_tracks: Vec<(String, String)>,      // (uri, provider)
+        current_track: Option<QueueTrack>,
+        next_tracks: Vec<QueueTrack>,
+        prev_tracks: Vec<QueueTrack>,
     },
 }
 
+/// Represents a track in the queue with its URI and provider.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct QueueTrack {
+    pub uri: String,
+    pub provider: String,
+}
+
 #[derive(Debug, Clone)]
 pub enum PlayerEvent {
     // Play request id changed
@@ -257,9 +264,9 @@ pub enum PlayerEvent {
     /// Fired when the queue is set or context is loaded with its track list.
     SetQueue {
         context_uri: String,
-        current_track: Option<(String, String)>, // (uri, provider)
-        next_tracks: Vec<(String, String)>,      // (uri, provider)
-        prev_tracks: Vec<(String, String)>,      // (uri, provider)
+        current_track: Option<QueueTrack>,
+        next_tracks: Vec<QueueTrack>,
+        prev_tracks: Vec<QueueTrack>,
     },
 }
 
@@ -664,9 +671,9 @@ impl Player {
     pub fn emit_set_queue_event(
         &self,
         context_uri: String,
-        current_track: Option<(String, String)>,
-        next_tracks: Vec<(String, String)>,
-        prev_tracks: Vec<(String, String)>,
+        current_track: Option<QueueTrack>,
+        next_tracks: Vec<QueueTrack>,
+        prev_tracks: Vec<QueueTrack>,
     ) {
         self.command(PlayerCommand::EmitSetQueueEvent {
             context_uri,

src/player_event_handler.rs

@@ -238,22 +238,25 @@ impl EventHandler {
                             } => {
                                 env_vars.insert("PLAYER_EVENT", "set_queue".to_string());
                                 env_vars.insert("CONTEXT_URI", context_uri);
-                                if let Some((uri, provider)) = current_track {
-                                    env_vars.insert("CURRENT_TRACK", format!("{uri}\t{provider}"));
+                                if let Some(track) = current_track {
+                                    env_vars.insert(
+                                        "CURRENT_TRACK",
+                                        format!("{}\t{}", track.uri, track.provider),
+                                    );
                                 }
                                 env_vars.insert(
                                     "NEXT_TRACKS",
                                     next_tracks
                                         .into_iter()
-                                        .map(|(uri, provider)| format!("{uri}\t{provider}"))
+                                        .map(|t| format!("{}\t{}", t.uri, t.provider))
                                         .collect::<Vec<String>>()
                                         .join("\n"),
                                 );
                                 env_vars.insert(
                                     "PREV_TRACKS",
                                     prev_tracks
                                         .into_iter()
-                                        .map(|(uri, provider)| format!("{uri}\t{provider}"))
+                                        .map(|t| format!("{}\t{}", t.uri, t.provider))
                                         .collect::<Vec<String>>()
                                         .join("\n"),
                                 );