Draft: add playerctl support

Cargo.toml

@@ -41,3 +41,4 @@ nix = "0.26.2"
 blight = "0.7.0"
 anyhow = "1.0.75"
 thiserror = "1.0.49"
+mpris = "2.0.1"

data/swayosd.gresource.xml

@@ -18,5 +18,13 @@
     <file>icons/scalable/status/source-volume-medium-symbolic.svg</file>
     <file>icons/scalable/status/source-volume-low-symbolic.svg</file>
     <file>icons/scalable/status/source-volume-muted-symbolic.svg</file>
+
+    <file>icons/scalable/status/pause-large-symbolic.svg</file>
+    <file>icons/scalable/status/play-large-symbolic.svg</file>
+    <file>icons/scalable/status/seek-backward-large-symbolic.svg</file>
+    <file>icons/scalable/status/seek-forward-large-symbolic.svg</file>
+    <file>icons/scalable/status/playlist-consecutive-symbolic.svg</file>
+    <file>icons/scalable/status/playlist-shuffle-symbolic.svg</file>
+    <file>icons/scalable/status/stop-large-symbolic.svg</file>
   </gresource>
 </gresources>

src/argtypes.rs

@@ -8,6 +8,7 @@ pub enum ArgTypes {
 	TopMargin = isize::MIN + 1,
 	MaxVolume = isize::MIN + 2,
 	CustomIcon = isize::MIN + 3,
+	Player = isize::MIN + 4,
 	// Other
 	None = 0,
 	CapsLock = 1,
@@ -23,6 +24,7 @@ pub enum ArgTypes {
 	NumLock = 10,
 	ScrollLock = 11,
 	CustomMessage = 13,
+	Playerctl = 14,
 }
 
 impl fmt::Display for ArgTypes {
@@ -46,6 +48,8 @@ impl fmt::Display for ArgTypes {
 			ArgTypes::TopMargin => "TOP-MARGIN",
 			ArgTypes::CustomMessage => "CUSTOM-MESSAGE",
 			ArgTypes::CustomIcon => "CUSTOM-ICON",
+			ArgTypes::Playerctl => "PLAYERCTL",
+			ArgTypes::Player => "PLAYER",
 		};
 		return write!(f, "{}", string);
 	}
@@ -73,6 +77,8 @@ impl str::FromStr for ArgTypes {
 			"TOP-MARGIN" => ArgTypes::TopMargin,
 			"CUSTOM-MESSAGE" => ArgTypes::CustomMessage,
 			"CUSTOM-ICON" => ArgTypes::CustomIcon,
+			"PLAYERCTL" => ArgTypes::Playerctl,
+			"PLAYER" => ArgTypes::Player,
 			other_type => return Err(other_type.to_owned()),
 		};
 		Ok(result)

src/client/main.rs

@@ -156,6 +156,16 @@ fn main() -> Result<(), glib::Error> {
 		"Shows brightness osd and raises or loweres all available sources of brightness device",
 		Some("raise|lower|(±)number"),
 	);
+
+	// Control players cmdline arg
+	app.add_main_option(
+		"playerctl",
+		glib::Char::from(0),
+		OptionFlags::NONE,
+		OptionArg::String,
+		"Shows Playerctl osd and runs the playerctl command",
+		Some("play-pause|play|pause|stop|next|prev|shuffle"),
+	);
 	app.add_main_option(
 		"max-volume",
 		glib::Char::from(0),
@@ -172,6 +182,14 @@ fn main() -> Result<(), glib::Error> {
 		"For which device to increase/decrease audio",
 		Some("Pulseaudio device name (pactl list short sinks|sources)"),
 	);
+	app.add_main_option(
+		"player",
+		glib::Char::from(0),
+		OptionFlags::NONE,
+		OptionArg::String,
+		"For which player to run the playerctl commands",
+		Some("auto|all|(playerctl -l)"),
+	);
 
 	app.add_main_option(
 		"custom-message",

src/global_utils.rs

@@ -95,6 +95,18 @@
 					}
 				}
 			}
+			"playerctl" => {
+				let value = child.value().str().unwrap_or("");
+				match value {
+					"play-pause" | "play" | "pause" | "next" |"prev" | "previous" | "shuffle" | "stop" => (),
+					x => {
+						eprintln!("Unknown Playerctl command: \"{}\"!...", x);
+						return (HandleLocalStatus::FAILURE, actions)
+					}
+				}
+
+				(ArgTypes::Playerctl, Some(value.to_string()))
+			},
 			"device" => {
 				let value = match child.value().str() {
 					Some(v) => v.to_string(),
@@ -125,6 +137,16 @@
 				};
 				(ArgTypes::CustomIcon, Some(value))
 			}
+			"player" => {
+				let value = match child.value().str() {
+					Some(v) => v.to_string(),
+					None => {
+						eprintln!("--player found but no name given");
+						return (HandleLocalStatus::FAILURE, actions);
+					}
+				};
+				(ArgTypes::Player, Some(value))
+			}
 			"top-margin" => {
 				let value = child.value().str().unwrap_or("").trim();
 				match value.parse::<f32>() {

src/mpris-backend/mod.rs

@@ -0,0 +1,164 @@
+use mpris::{
+    PlayerFinder,
+    Player,
+    PlaybackStatus,
+};
+
+use std::error::Error;
+use crate::utils::get_player;
+
+pub enum PlayerctlAction {
+    PlayPause,
+    Play,
+    Pause,
+    Stop,
+    Next,
+    Prev,
+    Shuffle,
+}
+
+#[derive(Clone, Debug)]
+pub enum PlayerctlDeviceRaw {
+    None,
+    All,
+    Some(String),
+}
+
+pub enum PlayerctlDevice {
+    All(Vec<Player>),
+    Some(Player),
+}
+
+pub struct Playerctl {
+    player: PlayerctlDevice,
+    action: PlayerctlAction,
+    pub icon: Option<String>,
+    pub label: Option<String>,
+}
+
+impl Playerctl {
+    pub fn new(action: PlayerctlAction) -> Result<Playerctl, Box<dyn Error>> {
+        let playerfinder = PlayerFinder::new()?;
+        let player = get_player();
+        let player = match player {
+            PlayerctlDeviceRaw::None => PlayerctlDevice::Some(playerfinder.find_active()?),
+            PlayerctlDeviceRaw::Some(name) => {
+                PlayerctlDevice::Some(playerfinder.find_by_name(name.as_str())?)
+            },
+            PlayerctlDeviceRaw::All => PlayerctlDevice::All(playerfinder.find_all()?),
+        };
+        Ok(Self {
+            player,
+            action,
+            icon: None,
+            label: None,
+        })
+    }
+    pub fn run(&mut self) -> Result<(), Box<dyn Error>> {
+        use PlayerctlAction::*;
+        use PlaybackStatus::*;
+        let run_single = |player: &Player| -> Result<&str, Box<dyn Error>> {
+            let out = match self.action {
+                PlayPause => {
+                    match player.get_playback_status()? {
+                        Playing => {player.pause()?; "pause-large -symbolic"},
+                        Paused | Stopped => {player.play()?;"play-large-symbolic"}
+                    }
+                },
+                Shuffle => {
+                    let shuffle = player.get_shuffle()?;
+                    player.set_shuffle(!shuffle)?;
+                    if shuffle {
+                        "playlist-consecutive-symbolic"
+                    } else {
+                        "playlist-shuffle-symbolic"
+                    }
+                },
+                Play => {player.play()?; "play-large-symbolic"},
+                Pause => {player.pause()?; "pause-large-symbolic"},
+                Stop => {player.stop()?; "stop-large-symbolic"},
+                Next => {player.next()?; "media-seek-forward-symbolic"},
+                Prev => {player.previous()?; "media-seek-backward-symbolic"},
+            };
+            Ok(out)
+        };
+        let mut metadata = Err("some errro");
+        let icon = match &self.player {
+            PlayerctlDevice::Some(player) => {
+                metadata = player.get_metadata().or_else(|_| Err(""));
+                run_single(player)?
+            },
+            PlayerctlDevice::All(players) => {
+                let mut icon = Err("couldn't change any players!");
+                for player in players {
+                    let icon_new = run_single(player);
+                    if let Ok(icon_new) = icon_new {
+                        if icon.is_err() {
+                            icon = Ok(icon_new);
+                        }
+                    };
+                    if let Err(_) = metadata {
+                        metadata = player.get_metadata().or_else(|_| Err(""));
+                    }
+                }
+                icon?
+            },
+        };
+
+        self.icon = Some(icon.to_string());
+        let label = if let Ok(metadata) = metadata {
+            let artist = metadata.artists().and_then(|x| {
+                if x.len() != 0 {
+                    Some(x[0].to_string())
+                } else {
+                    None
+                }
+            });
+            let title = metadata.title().and_then(|x| Some(x.to_string()));
+            if title.is_none() {
+                if artist.is_none() {
+                    None
+                } else {
+                    artist
+                }
+            } else {
+                if artist.is_none() {
+                    title
+                } else {
+                    Some(format!("{} - {}", title.unwrap(), artist.unwrap()))
+                }
+            }
+        } else {
+            None
+        };
+        self.label = label;
+        Ok(())
+    }
+}
+
+impl PlayerctlAction {
+    pub fn from(action: &str) -> Result<Self, String> {
+        use PlayerctlAction::*;
+        match action {
+            "play-pause" => Ok(PlayPause),
+            "play" => Ok(Play),
+            "pause" => Ok(Pause),
+            "stop" => Ok(Stop),
+            "next" => Ok(Next),
+            "prev" | "previous" => Ok(Prev),
+            "shuffle" => Ok(Shuffle),
+            x => Err(x.to_string())
+        }
+    }
+}
+
+impl PlayerctlDeviceRaw {
+    pub fn from(player: String) -> Result<Self, ()> {
+        use PlayerctlDeviceRaw::*;
+        match player.as_str() {
+            "auto" | "" => Ok(None),
+            "all" => Ok(All),
+            _ => Ok(Some(player))
+        }
+    }
+}

src/server/application.rs

@@ -339,6 +339,32 @@ impl SwayOSDApplication {
 				};
 				set_max_volume(volume)
 			}
+			(ArgTypes::Player, name) => {
+				set_player(name.unwrap_or("".to_string()))
+			}
+			(ArgTypes::Playerctl, value) => {
+				use crate::playerctl::*;
+				let value = &value.unwrap_or("".to_string());
+
+				let action = PlayerctlAction::from(value).unwrap();
+				if let Ok(mut player) = Playerctl::new(action) {
+					match player.run() {
+						Ok(_) => {
+							let (icon, label) = (player.icon.unwrap(), player.label.unwrap());
+							for window in osd_app.windows.borrow().to_owned() {
+								window.changed_player(&icon, &label)
+							}
+						},
+						Err(x) => {
+							eprintln!("couldn't run player change: \"{:?}\"!", x)
+						},
+					}
+				} else {
+					eprintln!("Unable to get players! are any opened?")
+				}
+
+				reset_player();
+			}
 			(ArgTypes::DeviceName, name) => {
 				set_device_name(name.unwrap_or(DEVICE_NAME_DEFAULT.to_string()))
 			}

src/server/main.rs

@@ -12,6 +12,9 @@ mod global_utils;
 #[path = "../brightness_backend/mod.rs"]
 mod brightness_backend;
 
+#[path = "../mpris-backend/mod.rs"]
+mod playerctl;
+
 #[macro_use]
 extern crate shrinkwraprs;
 

src/server/osd_window.rs

@@ -135,6 +135,18 @@ impl SwayosdWindow {
 		self.run_timeout();
 	}
 
+	pub fn changed_player(&self, icon: &str, label: &str) {
+		self.clear_osd();
+
+		let icon = self.build_icon_widget(&icon);
+		let label = self.build_text_widget(Some(&label));
+
+		self.container.add(&icon);
+		self.container.add(&label);
+
+		self.run_timeout();
+	}
+
 	pub fn changed_keylock(&self, key: KeysLocks, state: bool) {
 		self.clear_osd();