Make SetQueue an opt-in event

Other expensive events might be added to `OptInPlayerEvents` in the
future.

Author: Ralph von der Heyden

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, emitting when the queue changes (context loaded, track added to queue, or queue set via Spotify Connect)
+- [playback] Add `SetQueue` player event (opt-in), emitting when the queue changes (context loaded, track added to queue, or queue set via Spotify Connect)
 
 ### Changed
 

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<mpsc::UnboundedSender<PlayerEvent>>,
+    event_senders: Vec<EventSubscriber>,
     converter: Converter,
 
     normalisation_integrators: [f64; 2],
@@ -113,7 +113,10 @@ enum PlayerCommand {
     Stop,
     Seek(u32),
     SetSession(Session),
-    AddEventSender(mpsc::UnboundedSender<PlayerEvent>),
+    AddEventSender {
+        sender: mpsc::UnboundedSender<PlayerEvent>,
+        opt_in_events: OptInPlayerEvents,
+    },
     SetSinkEventCallback(Option<SinkEventCallback>),
     EmitVolumeChangedEvent(u16),
     SetAutoNormaliseAsAlbum(bool),
@@ -153,6 +156,20 @@ 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
@@ -304,6 +321,14 @@ 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>;
@@ -594,8 +619,18 @@ 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(event_sender));
+        self.command(PlayerCommand::AddEventSender {
+            sender: event_sender,
+            opt_in_events,
+        });
         event_receiver
     }
 
@@ -2318,7 +2353,15 @@ impl PlayerInternal {
 
             PlayerCommand::SetSession(session) => self.session = session,
 
-            PlayerCommand::AddEventSender(sender) => self.event_senders.push(sender),
+            PlayerCommand::AddEventSender {
+                sender,
+                opt_in_events,
+            } => {
+                self.event_senders.push(EventSubscriber {
+                    sender,
+                    opt_in_events,
+                });
+            }
 
             PlayerCommand::SetSinkEventCallback(callback) => self.sink_event_callback = callback,
 
@@ -2419,8 +2462,12 @@ impl PlayerInternal {
     }
 
     fn send_event(&mut self, event: PlayerEvent) {
-        self.event_senders
-            .retain(|sender| sender.send(event.clone()).is_ok());
+        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()
+        });
     }
 
     fn load_track(
@@ -2526,7 +2573,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::{Player, coefficient_to_duration, duration_to_coefficient},
+        player::{OptInPlayerEvents, Player, coefficient_to_duration, duration_to_coefficient},
     },
 };
 use librespot_oauth::OAuthClientBuilder;
@@ -1994,8 +1994,9 @@ 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(),
+            player.get_player_event_channel_with(opt_in_events),
             &player_event_program,
         ));