Refactor to use ConnectConfig for opting in to SetQueue events

Author: ralph

CHANGELOG.md

@@ -10,7 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - [connect] Add method `add_to_queue` to `Spirc` to add tracks, episodes, albums and playlists to the queue
-- [playback] Add `SetQueue` player event (opt-in), emitting when the queue changes (context loaded, track added to queue, or queue set via Spotify Connect)
+- [playback] Add `SetQueue` player event, emitting when the queue changes (context loaded, track added to queue, or queue set via Spotify Connect). Gated behind `ConnectConfig::emit_set_queue_events`
 
 ### Changed
 

connect/src/spirc.rs

@@ -95,6 +95,8 @@ struct SpircTask {
 
     context_resolver: ContextResolver,
 
+    emit_set_queue_events: bool,
+
     shutdown: bool,
     session: Session,
 
@@ -173,6 +175,7 @@ impl Spirc {
         let spirc_id = SPIRC_COUNTER.fetch_add(1, Ordering::AcqRel);
         debug!("new Spirc[{spirc_id}]");
 
+        let emit_set_queue_events = config.emit_set_queue_events;
         let connect_state = ConnectState::new(config, &session);
 
         let connection_id_update = session
@@ -249,6 +252,8 @@ impl Spirc {
 
             context_resolver: ContextResolver::new(session.clone()),
 
+            emit_set_queue_events,
+
             shutdown: false,
             session,
 
@@ -647,6 +652,10 @@ impl SpircTask {
 
     /// Emit set queue event via PlayerEvent
     fn emit_set_queue_event(&self) {
+        if !self.emit_set_queue_events {
+            return;
+        }
+
         let context_uri = self.connect_state.context_uri().clone();
         let state_player = self.connect_state.player();
 

connect/src/state.rs

@@ -90,6 +90,8 @@ pub struct ConnectConfig {
     pub disable_volume: bool,
     /// Number of incremental steps (default: 64)
     pub volume_steps: u16,
+    /// Emit `SetQueue` player events when the queue changes (default: false)
+    pub emit_set_queue_events: bool,
 }
 
 impl Default for ConnectConfig {
@@ -101,6 +103,7 @@ impl Default for ConnectConfig {
             initial_volume: u16::MAX / 2,
             disable_volume: false,
             volume_steps: 64,
+            emit_set_queue_events: false,
         }
     }
 }

playback/src/player.rs

@@ -80,7 +80,7 @@ struct PlayerInternal {
     sink_status: SinkStatus,
     sink_event_callback: Option<SinkEventCallback>,
     volume_getter: Box<dyn VolumeGetter + Send>,
-    event_senders: Vec<EventSubscriber>,
+    event_senders: Vec<mpsc::UnboundedSender<PlayerEvent>>,
     converter: Converter,
 
     normalisation_integrators: [f64; 2],
@@ -113,10 +113,7 @@ enum PlayerCommand {
     Stop,
     Seek(u32),
     SetSession(Session),
-    AddEventSender {
-        sender: mpsc::UnboundedSender<PlayerEvent>,
-        opt_in_events: OptInPlayerEvents,
-    },
+    AddEventSender(mpsc::UnboundedSender<PlayerEvent>),
     SetSinkEventCallback(Option<SinkEventCallback>),
     EmitVolumeChangedEvent(u16),
     SetAutoNormaliseAsAlbum(bool),
@@ -156,20 +153,6 @@ pub struct QueueTrack {
     pub provider: String,
 }
 
-/// Opt-in player events that are not delivered to subscribers by default.
-///
-/// Use [`Player::get_player_event_channel_with`] to subscribe to these.
-#[derive(Clone, Copy, Debug, Default)]
-pub struct OptInPlayerEvents {
-    /// Subscribe to [`PlayerEvent::SetQueue`] events.
-    pub set_queue: bool,
-}
-
-struct EventSubscriber {
-    sender: mpsc::UnboundedSender<PlayerEvent>,
-    opt_in_events: OptInPlayerEvents,
-}
-
 #[derive(Debug, Clone)]
 pub enum PlayerEvent {
     // Play request id changed
@@ -321,14 +304,6 @@ impl PlayerEvent {
             _ => None,
         }
     }
-
-    /// Whether this event should be sent to a subscriber with the given opt-in events.
-    fn should_send(&self, opt_in: &OptInPlayerEvents) -> bool {
-        match self {
-            PlayerEvent::SetQueue { .. } => opt_in.set_queue,
-            _ => true,
-        }
-    }
 }
 
 pub type PlayerEventChannel = mpsc::UnboundedReceiver<PlayerEvent>;
@@ -619,18 +594,8 @@ impl Player {
     }
 
     pub fn get_player_event_channel(&self) -> PlayerEventChannel {
-        self.get_player_event_channel_with(OptInPlayerEvents::default())
-    }
-
-    pub fn get_player_event_channel_with(
-        &self,
-        opt_in_events: OptInPlayerEvents,
-    ) -> PlayerEventChannel {
         let (event_sender, event_receiver) = mpsc::unbounded_channel();
-        self.command(PlayerCommand::AddEventSender {
-            sender: event_sender,
-            opt_in_events,
-        });
+        self.command(PlayerCommand::AddEventSender(event_sender));
         event_receiver
     }
 
@@ -2353,15 +2318,7 @@ impl PlayerInternal {
 
             PlayerCommand::SetSession(session) => self.session = session,
 
-            PlayerCommand::AddEventSender {
-                sender,
-                opt_in_events,
-            } => {
-                self.event_senders.push(EventSubscriber {
-                    sender,
-                    opt_in_events,
-                });
-            }
+            PlayerCommand::AddEventSender(sender) => self.event_senders.push(sender),
 
             PlayerCommand::SetSinkEventCallback(callback) => self.sink_event_callback = callback,
 
@@ -2462,12 +2419,8 @@ impl PlayerInternal {
     }
 
     fn send_event(&mut self, event: PlayerEvent) {
-        self.event_senders.retain(|sub| {
-            if !event.should_send(&sub.opt_in_events) {
-                return true; // keep subscriber, skip this event
-            }
-            sub.sender.send(event.clone()).is_ok()
-        });
+        self.event_senders
+            .retain(|sender| sender.send(event.clone()).is_ok());
     }
 
     fn load_track(
@@ -2573,7 +2526,7 @@ impl fmt::Debug for PlayerCommand {
             PlayerCommand::Stop => f.debug_tuple("Stop").finish(),
             PlayerCommand::Seek(position) => f.debug_tuple("Seek").field(&position).finish(),
             PlayerCommand::SetSession(_) => f.debug_tuple("SetSession").finish(),
-            PlayerCommand::AddEventSender { .. } => f.debug_tuple("AddEventSender").finish(),
+            PlayerCommand::AddEventSender(_) => f.debug_tuple("AddEventSender").finish(),
             PlayerCommand::SetSinkEventCallback(_) => {
                 f.debug_tuple("SetSinkEventCallback").finish()
             }

src/main.rs

@@ -16,7 +16,7 @@ use librespot::{
         },
         dither,
         mixer::{self, MixerConfig, MixerFn},
-        player::{OptInPlayerEvents, Player, coefficient_to_duration, duration_to_coefficient},
+        player::{Player, coefficient_to_duration, duration_to_coefficient},
     },
 };
 use librespot_oauth::OAuthClientBuilder;
@@ -1534,6 +1534,7 @@ async fn get_setup() -> Setup {
             initial_volume,
             disable_volume,
             volume_steps,
+            ..ConnectConfig::default()
         }
     };
 
@@ -1994,9 +1995,8 @@ async fn main() {
     });
 
     if let Some(player_event_program) = setup.player_event_program.clone() {
-        let opt_in_events = OptInPlayerEvents { set_queue: true };
         _event_handler = Some(EventHandler::new(
-            player.get_player_event_channel_with(opt_in_events),
+            player.get_player_event_channel(),
             &player_event_program,
         ));