feat: make everything configurable via climain

1 files changed, 90 insertions, 41 deletions

diff --git a/src/main.rs b/src/main.rs
index 5d4ea54..abe53e4 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -4,17 +4,19 @@ use std::{
 };
 
 use clap::Parser;
-use mpris::{DBusError, FindingError, PlaybackStatus, Player, PlayerFinder};
+use mpris::{DBusError, PlaybackStatus, Player, PlayerFinder};
 use unwrap_retry::{RetryableOptionFn, RetryableResultFn};
 
-const PLAYER_IDENTITY: &str = "Aonsoku";
-const BROWSER_IDENTITY: &str = "Mozilla zen";
+// Defaults
+const DEFAULT_PLAYER_IDENTITY: &str = "Spotify";
+const DEFAULT_BROWSER_IDENTITY: &str = "Mozilla zen";
 
-// config
 // percentages
-const LOWER_VOLUME: u8 = 45;
-const NORMAL_VOLUME: u8 = 80;
-const VOLUME_TRANSITION: Duration = Duration::from_millis(300);
+const DEFAULT_LOWER_VOLUME: u8 = 45;
+const DEFAULT_NORMAL_VOLUME: u8 = 80;
+const DEFAULT_VOLUME_TRANSITION: u64 = 300;
+
+const DEFAULT_LOOP_DELAY: u64 = 1000;
 
 #[derive(Parser)]
 struct Args {
@@ -23,6 +25,11 @@ struct Args {
     )]
     daemon: bool,
 
+    #[arg(long, default_value_t = DEFAULT_LOOP_DELAY)]
+    /// For --daemon
+    /// in ms
+    loop_delay: u64,
+
     #[arg(
         short, long
     )]
@@ -32,14 +39,38 @@ struct Args {
         short, long
     )]
     normal: bool,
+
+    #[arg(long, default_value_t = DEFAULT_LOWER_VOLUME)]
+    lower_volume: u8,
+
+    #[arg(long, default_value_t = DEFAULT_NORMAL_VOLUME)]
+    normal_volume: u8,
+
+    #[arg(short, long, default_value_t = DEFAULT_VOLUME_TRANSITION)]
+    /// in ms
+    volume_transition_delay: u64,
+
+    #[arg(
+        short,
+        long,
+        default_value_t = DEFAULT_PLAYER_IDENTITY.to_string()
+    )]
+    player: String,
+
+    #[arg(
+        short,
+        long,
+        default_value_t = DEFAULT_BROWSER_IDENTITY.to_string()
+    )]
+    browser: String,
 }
 
-fn get_player() -> Option<Player> {
-    find_player(PLAYER_IDENTITY)
+fn get_player(id: &str) -> Option<Player> {
+    find_player(id)
 }
 
-fn get_browser() -> Option<Player> {
-    find_player(BROWSER_IDENTITY)
+fn get_browser(id: &str) -> Option<Player> {
+    find_player(id)
 }
 
 fn find_player(name: &str) -> Option<Player> {
@@ -57,7 +88,7 @@ fn denormal_volume(volume: u8) -> f64 {
     volume as f64 / 100.0
 }
 
-fn set_volume(player: &Player, volume: u8) -> Vec<Result<(), DBusError>> {
+fn _set_volume(player: &Player, volume: u8, transition: &Duration) -> Vec<Result<(), DBusError>> {
     let mut res = Vec::new();
     let current_volume = normalize_volume((|| player.get_volume()).unwrap_blocking());
 
@@ -65,7 +96,7 @@ fn set_volume(player: &Player, volume: u8) -> Vec<Result<(), DBusError>> {
         return res;
     }
 
-    let mut intervel = VOLUME_TRANSITION
+    let mut intervel = *transition
         / current_volume
             .abs_diff(volume)
             .into();
@@ -73,7 +104,7 @@ fn set_volume(player: &Player, volume: u8) -> Vec<Result<(), DBusError>> {
     let range: Box<dyn Iterator<Item = u8>> = if current_volume > volume {
         Box::new((volume..=current_volume).rev())
     } else {
-        Box::new(current_volume..volume)
+        Box::new(current_volume..=volume)
     };
 
     for v in range {
@@ -94,52 +125,49 @@ fn is_playing(player: &Player) -> bool {
         .unwrap_or(false)
 }
 
-fn daemon() -> ! {
+fn daemon(browser: &str, player: &str, normal: u8, lower: u8, transition: &Duration, loop_delay: &Duration) -> ! {
     let mut had_browser = false;
     loop {
-        let player = match get_player() {
+        let player = match get_player(player) {
             Some(p) => p,
             None => {
                 sleep(Duration::from_secs(5));
                 continue;
             }
         };
-        match get_browser() {
+
+        match get_browser(browser) {
             Some(browser) => {
-                let is_playing = is_playing(&browser);
-                if !had_browser && is_playing {
-                    set_lower(&player);
+                let browser_playing = is_playing(&browser);
+                if !had_browser && browser_playing {
+                    set_volume(
+                        &player, lower, transition,
+                    );
                     had_browser = true;
-                } else if had_browser && !is_playing {
-                    set_normal(&player);
+                } else if had_browser && !browser_playing {
+                    set_volume(
+                        &player, normal, transition,
+                    );
                     had_browser = false;
                 }
             }
             None => {
                 if had_browser {
-                    set_normal(&player);
+                    set_volume(
+                        &player, normal, transition,
+                    );
                     had_browser = false;
                 }
             }
         }
 
-        sleep(Duration::from_secs(1));
+        sleep(*loop_delay);
     }
 }
 
-fn set_lower(player: &Player) {
-    set_volume(
-        player,
-        LOWER_VOLUME,
-    )
-    .into_iter()
-    .for_each(|r| r.unwrap_or_else(|e| eprintln!("Failed to set volume: {e} for player {player:#?}")));
-}
-
-fn set_normal(player: &Player) {
-    set_volume(
-        player,
-        NORMAL_VOLUME,
+fn set_volume(player: &Player, volume: u8, transition: &Duration) {
+    _set_volume(
+        player, volume, transition,
     )
     .into_iter()
     .for_each(|r| r.unwrap_or_else(|e| eprintln!("Failed to set volume: {e} for player {player:#?}")));
@@ -147,18 +175,39 @@ fn set_normal(player: &Player) {
 
 fn main() {
     let args = Args::parse();
+    let transition_delay = Duration::from_millis(args.volume_transition_delay);
+    let daemon = || {
+        daemon(
+            &args.browser,
+            &args.player,
+            args.normal_volume,
+            args.lower_volume,
+            &transition_delay,
+            &Duration::from_millis(args.loop_delay),
+        )
+    };
 
     if args.daemon {
         daemon()
     }
 
-    let player = (|| get_player()).unwrap_blocking();
+    let player = (|| get_player(&args.player)).unwrap_blocking();
 
     if args.lower {
-        set_lower(&player);
+        set_volume(
+            &player,
+            args.lower_volume,
+            &transition_delay,
+        );
         return;
-    } else if args.normal {
-        set_normal(&player);
+    }
+
+    if args.normal {
+        set_volume(
+            &player,
+            args.normal_volume,
+            &transition_delay,
+        );
         return;
     }