main: cli: play: --poll-events-every & --poll-events-every-while-paused

Allow user to decide how often events are polled. This helps reduce
resource consumption while still providing smooth playback and user
decides which one they prefer.

src/app.rs

···
     frame_rx: Receiver<minimp3::Frame>,
     /// [`OsMediaControls`].
     os_media_controls: Option<OsMediaControls>,
+    /// Poll for events every specified [`Duration`].
+    ///
+    /// Allows user to decide the trade off between computational
+    /// resource comsumption, animation smoothness and how responsive
+    /// the application. Smaller durations lead to more resource
+    /// consumption but smoother animations and better responsiveness.
+    poll_events_every: Duration,
+    /// [`Self::poll_events_every`] but when player is paused.
+    ///
+    /// This should generally be larger than
+    /// [`Self::poll_events_every`].
+    poll_events_every_while_paused: Duration,
 }
 
 impl App {
···
         frame_rx: Receiver<minimp3::Frame>,
         mode: CurrentDisplayMode,
         os_media_controls: Option<OsMediaControls>,
+        poll_events_every: Duration,
+        poll_events_every_while_paused: Duration,
     ) -> Self {
         let graph = GraphConfig {
             axis_color: Color::DarkGray,
···
             channels: source.channels as u8,
             frame_rx,
             os_media_controls,
+            poll_events_every,
+            poll_events_every_while_paused,
         }
     }
 }
···
             }
 
             let timeout_duration = if self.graph.pause {
-                // reduce checks to only every 100 milliseconds (~10
-                // times a second). This helps reduce spinning of the
-                // thread and thus consuming a lot of resources while
-                // allowing for event handling at a decent rate.
-                Duration::from_millis(100)
+                self.poll_events_every_while_paused
             } else {
-                Duration::from_millis(0)
+                self.poll_events_every
             };
 
             while event::poll(timeout_duration).unwrap() {

src/main.rs

···
+use std::time::Duration;
+
 use anyhow::Error;
 use app::CurrentDisplayMode;
 use clap::{arg, builder::ValueParser, Command};
···
                 .arg(arg!(<station> "The station to play"))
                 .arg(arg!(--volume "Set the initial volume (as a percent)").default_value("100"))
                 .arg(clap::Arg::new("display-mode").long("display-mode").help("Set the display mode to start with").default_value("Spectroscope"))
-                .arg(clap::Arg::new("enable-os-media-controls").long("enable-os-media-controls").help("Should enable OS media controls?").default_value("true").value_parser(ValueParser::bool())),
+                .arg(clap::Arg::new("enable-os-media-controls").long("enable-os-media-controls").help("Should enable OS media controls?").default_value("true").value_parser(ValueParser::bool()))
+                .arg(clap::Arg::new("poll-events-every").long("poll-events-every").help("Poll for events every specified milliseconds.").default_value("16"))
+                .arg(clap::Arg::new("poll-events-every-while-paused").long("poll-events-every-while-paused").help("Poll for events every specified milliseconds while player is paused.").default_value("100")),
         )
         .subcommand(
             Command::new("browse")
···
                 .parse::<CurrentDisplayMode>()
                 .unwrap();
             let enable_os_media_controls = args.get_one("enable-os-media-controls").unwrap();
+            let poll_events_every =
+                Duration::from_millis(args.value_of("poll-events-every").unwrap().parse().unwrap());
+            let poll_events_every_while_paused = Duration::from_millis(
+                args.value_of("poll-events-every-while-paused")
+                    .unwrap()
+                    .parse()
+                    .unwrap(),
+            );
             play::exec(
                 station,
                 provider,
                 volume,
                 display_mode,
                 *enable_os_media_controls,
+                poll_events_every,
+                poll_events_every_while_paused,
             )
             .await?;
         }

src/play.rs

···
     volume: f32,
     display_mode: CurrentDisplayMode,
     enable_os_media_controls: bool,
+    poll_events_every: Duration,
+    poll_events_every_while_paused: Duration,
 ) -> Result<(), Error> {
     let _provider = provider;
     let provider: Box<dyn Provider> = match provider {
···
         None
     };
 
-    let mut app = App::new(&ui, &opts, frame_rx, display_mode, os_media_controls);
+    let mut app = App::new(
+        &ui,
+        &opts,
+        frame_rx,
+        display_mode,
+        os_media_controls,
+        poll_events_every,
+        poll_events_every_while_paused,
+    );
     let station_name = station.name.clone();
 
     thread::spawn(move || {