#[macro_use] extern crate clap;#[macro_use] extern crate log;#[macro_use] extern crate serde_derive;#[macro_use] extern crate failure;#[macro_use] mod util;mod discovery;use std::time::Duration;use std::net::IpAddr;use sonos::Speaker;use failure::Fallible;use crate::discovery::find_speaker_by_name;fn argparse<'a, 'b>() -> clap::App<'a, 'b> {use clap::{App, AppSettings, Arg, SubCommand};App::new("sonos").version(crate_version!()).author("Jordan Doyle <jordan@doyle.la>").about("Control your Sonos using the command line").setting(AppSettings::SubcommandRequired).arg(Arg::with_name("controller").help("Set the controller to run operation on").short("c").required_unless("rooms").value_name("IP or Room Name").takes_value(true)).arg(Arg::with_name("json").help("Return back JSON serialised responses for programmatic use of the CLI")).subcommand(SubCommand::with_name("info").about("Shows information about the speaker")).subcommand(SubCommand::with_name("track").about("Commands to manipulate the tracklist").subcommand(SubCommand::with_name("next").about("Skip to the next track")).subcommand(SubCommand::with_name("prev").about("Go back to the last track")).subcommand(SubCommand::with_name("list").about("Get the list of tracks in the queue")).subcommand(SubCommand::with_name("play").about("Play a given track").subcommand(SubCommand::with_name("tv").about("Set the current speaker's input to the SPDIF")).subcommand(SubCommand::with_name("line-in").about("Set the current speaker's input to the line-in")).arg(Arg::with_name("uri").help("Queue position to skip to or a Sonos URI to play").index(1).conflicts_with_all(&["tv", "line-in"])))).subcommand(SubCommand::with_name("group").about("Group this speaker with the given master").arg(Arg::with_name("MASTER").help("Name of the speaker to group with").required(true).index(1))).subcommand(SubCommand::with_name("ungroup").about("Ungroup this speaker from the master")).subcommand(SubCommand::with_name("seek").about("Seek to a specific timestamp on the current track").arg(Arg::with_name("TIMESTAMP").help("hh:mm:ss/mm:ss").required(true).index(1))).subcommand(SubCommand::with_name("volume").about("Get or set the volume of the speaker").arg(Arg::with_name("VOLUME").help("Percent volume to set speaker to 0-100").index(1))).subcommand(SubCommand::with_name("rooms").about("List all of your speakers").arg(Arg::with_name("invalidate").help("Detect new speakers and room arrangements")))}#[tokio::main]async fn main() -> Fallible<()> {let args = argparse().get_matches();util::setup_logger()?;let controller = args.value_of("controller").expect("controller");let speaker = match controller.parse::<IpAddr>() {Ok(ip) => Speaker::from_ip(ip).await?,Err(_) => discovery::find_speaker_by_name(controller).await?,};match args.subcommand() {("track", Some(subargs)) => {match subargs.subcommand() {("next", _) => speaker.queue().next().await?,("prev", _) => speaker.queue().previous().await?,("list", _) => print_struct!(args, &TrackList::new(&speaker).await?),("play", Some(play_subargs)) => match play_subargs.subcommand_name() {Some("tv") => speaker.play_tv().await?,Some("line-in") => speaker.play_line_in().await?,_ => {let uri = play_subargs.value_of("uri").filter(|s| !s.is_empty()).ok_or_else(|| format_err!("Must pass [tv], [line-in] or a URI to the play command"))?;if let Ok(pos) = uri.parse::<u64>() {speaker.queue().skip_to(&pos).await?} else {speaker.play_track(uri).await?}},},_ => print_struct!(args, &Track::new(&speaker).await?)}},("group", Some(sub)) => {let master = sub.value_of("MASTER").expect("master");speaker.group(&match master.parse::<IpAddr>() {Ok(ip) => Speaker::from_ip(ip).await?,Err(_) => discovery::find_speaker_by_name(master).await?,}).await?},("ungroup", _) => speaker.ungroup().await?,("info", _) => print_struct!(args, &Info::new(&speaker)),("volume", Some(sub)) => match sub.value_of("VOLUME") {Some(volume) => speaker.set_volume(volume.parse()?).await?,None => print_struct!(args, &Volume::new(&speaker).await?),},("seek", Some(sub)) => {let a = sub.value_of("TIMESTAMP").expect("timestamp");let mut multiplier = 1;let secs = a.split(":").collect::<Vec<&str>>().iter().rfold(0, |curr, iter_val| {let section_value = iter_val.parse::<u64>().expect("can't parse int") * multiplier;multiplier *= 60;curr + section_value});let duration = Duration::new(secs, 0);speaker.seek(&duration).await?;},("rooms", Some(sub)) => {let devices = discovery::discover(true, sub.is_present("invalidate")).await?;let mut rooms = std::collections::HashMap::new();for device in devices {let coordinator = device.coordinator().await?;let mut room = rooms.entry(coordinator).or_insert(Vec::new());room.push(device);}for (key, value) in rooms {info!("Controller: {}", key);for device in value {info!("d: {}", device.name);}}},_ => {panic!();}}Ok(())}#[derive(Serialize, Deserialize, Debug)]struct TrackListItem {pub position: u64,pub title: String,pub artist: String,pub album: String,pub duration: Duration}#[derive(Serialize, Deserialize, Debug)]struct TrackList(Vec<TrackListItem>);impl TrackList {pub async fn new(speaker: &Speaker) -> Fallible<Self> {Ok(Self(speaker.queue().list().await?.into_iter().map(|v| TrackListItem {position: v.position,title: v.title,artist: v.artist,album: v.album,duration: v.duration}).collect()))}}impl std::fmt::Display for TrackList {fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {Ok(for item in &self.0 {writeln!(f, "{}: {} - {} ({})",item.position,item.artist,item.title,util::duration_to_hms(item.duration))?})}}#[derive(Serialize, Deserialize, Debug)]struct Track {pub title: String,pub artist: String,pub album: Option<String>,pub running_time: Duration,pub duration: Duration}impl Track {pub async fn new(speaker: &Speaker) -> Fallible<Track> {let track = speaker.track().await?;Ok(Self {title: track.title,artist: track.artist,album: track.album,running_time: track.running_time,duration: track.duration})}}impl std::fmt::Display for Track {fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {writeln!(f, "\u{1F3A4} {}", self.artist)?;writeln!(f, "\u{1F3B5} {}", self.title)?;if let Some(album) = &self.album {writeln!(f, "\u{1F4BF} {}", album)?;}let running_time = util::duration_to_hms(self.running_time);let duration = util::duration_to_hms(self.duration);write!(f, "\u{23F1}\u{FE0F} {}/{}", running_time, duration)?;const PROG_BAR_LEN: usize = 25;let percent_played = ((self.running_time.as_secs() as f64 / self.duration.as_secs() as f64) * PROG_BAR_LEN as f64) as usize;write!(f, " [{}{}]", "\u{2587}".repeat(percent_played), "-".repeat(PROG_BAR_LEN - percent_played))}}#[derive(Serialize, Deserialize, Debug)]struct Volume {volume: u8,muted: bool,}impl Volume {pub async fn new(speaker: &Speaker) -> Result<Volume, failure::Error> {Ok(Self {volume: speaker.volume().await?,muted: speaker.muted().await?,})}}impl std::fmt::Display for Volume {fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {const MAX_VOLUME: usize = 100;const PROG_BAR_LEN: usize = 25;let pictogram = if self.muted {"\u{1F507}"} else {"\u{1F50A}"};write!(f, "{} {}/{}", pictogram, self.volume, MAX_VOLUME)?;let percent = (self.volume as usize * PROG_BAR_LEN) / MAX_VOLUME;write!(f, " [{}{}]", "\u{2587}".repeat(percent), "-".repeat(PROG_BAR_LEN - percent))}}#[derive(Serialize, Deserialize, Debug)]struct Info {pub ip: IpAddr,pub model: String,pub model_number: String,pub software_version: String,pub hardware_version: String,pub serial_number: String,pub name: String,pub uuid: String,}impl Info {pub fn new(speaker: &Speaker) -> Info {Info {ip: speaker.ip.clone(),model: speaker.model.clone(),model_number: speaker.model_number.clone(),software_version: speaker.software_version.clone(),hardware_version: speaker.hardware_version.clone(),serial_number: speaker.serial_number.clone(),name: speaker.name.clone(),uuid: speaker.uuid.clone(),}}}impl std::fmt::Display for Info {fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {writeln!(f, "\u{1F508} {}", self.name)?;writeln!(f, "{}", "=".repeat(self.name.len() + 3))?;writeln!(f, "Model: {} ({})", self.model, self.model_number)?;writeln!(f, "Versions: Software {}, Hardware {}", self.software_version, self.hardware_version)?;writeln!(f, "Serial number: {}", self.serial_number)?;writeln!(f, "UUID: {}", self.uuid)}}