Skip to main content

sonos_cli/cli/
run.rs

1use std::io::IsTerminal;
2
3use sonos_sdk::{SeekTarget, SonosSystem};
4
5use super::{
6    format_duration_human, format_time_ms, parse_duration, playback_icon, playback_label,
7    require_speaker_only, resolve_group, resolve_speaker, validate_seek_time, Commands,
8    GlobalFlags, OnOff, QueueAction,
9};
10use crate::config::Config;
11use crate::diagnostics;
12use crate::errors::CliError;
13
14pub fn run_command(
15    cmd: Commands,
16    system: &SonosSystem,
17    config: &Config,
18    global: &GlobalFlags,
19) -> Result<String, CliError> {
20    let spk = || resolve_speaker(system, config, global);
21
22    match cmd {
23        Commands::Speakers => cmd_speakers(system),
24        Commands::Groups => cmd_groups(system),
25        Commands::Status => cmd_status(system, config, global),
26        Commands::Join => cmd_join(system, global),
27        Commands::Leave => cmd_leave(system, global),
28        Commands::Bass { level } => cmd_bass(system, global, level),
29        Commands::Treble { level } => cmd_treble(system, global, level),
30        Commands::Loudness { state } => cmd_loudness(system, global, state),
31        Commands::Sleep { duration } => cmd_sleep(system, config, global, &duration),
32        Commands::Queue { action } => cmd_queue(system, config, global, action),
33
34        Commands::Play => {
35            let s = spk()?;
36            s.play()?;
37            Ok(format!("Playing ({})", s.name))
38        }
39        Commands::Pause => {
40            let s = spk()?;
41            s.pause()?;
42            Ok(format!("Paused ({})", s.name))
43        }
44        Commands::Stop => {
45            let s = spk()?;
46            s.stop()?;
47            Ok(format!("Stopped ({})", s.name))
48        }
49        Commands::Next => {
50            let s = spk()?;
51            s.next()?;
52            Ok(format!("Next track ({})", s.name))
53        }
54        Commands::Previous => {
55            let s = spk()?;
56            s.previous()?;
57            Ok(format!("Previous track ({})", s.name))
58        }
59        Commands::Seek { position } => {
60            validate_seek_time(&position)?;
61            let s = spk()?;
62            s.seek(SeekTarget::Time(position.clone()))?;
63            Ok(format!("Seeked to {} ({})", position, s.name))
64        }
65        Commands::Mode { mode } => {
66            let s = spk()?;
67            s.set_play_mode(mode.to_sdk())?;
68            Ok(format!("Mode set to {:?} ({})", mode, s.name))
69        }
70        Commands::Volume { level } => cmd_volume(system, config, global, level),
71        Commands::Mute => cmd_mute(system, config, global, true),
72        Commands::Unmute => cmd_mute(system, config, global, false),
73    }
74}
75
76// -- Command handlers ---------------------------------------------------------
77
78fn cmd_speakers(system: &SonosSystem) -> Result<String, CliError> {
79    let speakers = system.speakers();
80    if speakers.is_empty() {
81        eprintln!("{}", diagnostics::discovery_hint());
82        return Ok("No speakers found".to_string());
83    }
84    let lines: Vec<String> = speakers
85        .iter()
86        .map(|s| {
87            let state = s.playback_state.fetch().ok();
88            let vol = s.volume.fetch().ok();
89            let group_name = s
90                .group()
91                .and_then(|g| g.coordinator().map(|c| c.name))
92                .unwrap_or_default();
93
94            let state_str = state
95                .as_ref()
96                .map(|st| format!("{} {}", playback_icon(st), playback_label(st)))
97                .unwrap_or_default();
98            let vol_str = vol.map(|v| format!("vol:{}", v.0)).unwrap_or_default();
99
100            let mut parts = vec![s.name.clone()];
101            if !state_str.is_empty() {
102                parts.push(state_str);
103            }
104            if !vol_str.is_empty() {
105                parts.push(vol_str);
106            }
107            if !group_name.is_empty() {
108                parts.push(format!("({group_name})"));
109            }
110            parts.join("   ")
111        })
112        .collect();
113    Ok(lines.join("\n"))
114}
115
116fn cmd_groups(system: &SonosSystem) -> Result<String, CliError> {
117    let groups = system.groups();
118    if groups.is_empty() {
119        eprintln!("{}", diagnostics::discovery_hint());
120        return Ok("No groups found".to_string());
121    }
122    let lines: Vec<String> = groups
123        .iter()
124        .map(|g| {
125            let coord = g.coordinator();
126            let coord_name = coord
127                .as_ref()
128                .map(|c| c.name.clone())
129                .unwrap_or_else(|| "unknown".to_string());
130
131            let state = coord.as_ref().and_then(|c| c.playback_state.fetch().ok());
132            let track = coord.as_ref().and_then(|c| c.current_track.fetch().ok());
133            let vol = g.volume.fetch().ok();
134
135            let state_str = state
136                .as_ref()
137                .map(|st| format!("{} {}", playback_icon(st), playback_label(st)))
138                .unwrap_or_default();
139            let track_str = track
140                .as_ref()
141                .map(|t| {
142                    let d = t.display();
143                    if d == "Unknown" {
144                        t.uri
145                            .as_deref()
146                            .filter(|u| !u.is_empty() && !u.starts_with("x-rincon:"))
147                            .map(|_| "Playing (no metadata)".to_string())
148                            .unwrap_or(d)
149                    } else {
150                        d
151                    }
152                })
153                .unwrap_or_default();
154            let vol_str = vol.map(|v| format!("vol:{}", v.0)).unwrap_or_default();
155
156            let mut parts = vec![coord_name];
157            if !state_str.is_empty() {
158                parts.push(state_str);
159            }
160            if !track_str.is_empty() {
161                parts.push(track_str);
162            }
163            if !vol_str.is_empty() {
164                parts.push(vol_str);
165            }
166            parts.join("   ")
167        })
168        .collect();
169    Ok(lines.join("\n"))
170}
171
172fn cmd_volume(
173    system: &SonosSystem,
174    config: &Config,
175    global: &GlobalFlags,
176    level: u8,
177) -> Result<String, CliError> {
178    // Explicit --speaker (without --group) → Speaker.set_volume(u8)
179    if global.speaker.is_some() && global.group.is_none() {
180        let s = resolve_speaker(system, config, global)?;
181        s.set_volume(level)?;
182        return Ok(format!("Volume set to {} ({})", level, s.name));
183    }
184    // Otherwise → Group.set_volume(u16) via GroupRenderingControl
185    let g = resolve_group(system, config, global)?;
186    let name = g
187        .coordinator()
188        .map(|c| c.name)
189        .unwrap_or_else(|| "unknown".to_string());
190    g.set_volume(level as u16)?;
191    Ok(format!("Volume set to {level} ({name})"))
192}
193
194fn cmd_mute(
195    system: &SonosSystem,
196    config: &Config,
197    global: &GlobalFlags,
198    muted: bool,
199) -> Result<String, CliError> {
200    let label = if muted { "Muted" } else { "Unmuted" };
201    // Explicit --speaker (without --group) → Speaker.set_mute(bool)
202    if global.speaker.is_some() && global.group.is_none() {
203        let s = resolve_speaker(system, config, global)?;
204        s.set_mute(muted)?;
205        return Ok(format!("{} ({})", label, s.name));
206    }
207    // Otherwise → Group.set_mute(bool) via GroupRenderingControl
208    let g = resolve_group(system, config, global)?;
209    let name = g
210        .coordinator()
211        .map(|c| c.name)
212        .unwrap_or_else(|| "unknown".to_string());
213    g.set_mute(muted)?;
214    Ok(format!("{label} ({name})"))
215}
216
217fn cmd_status(
218    system: &SonosSystem,
219    config: &Config,
220    global: &GlobalFlags,
221) -> Result<String, CliError> {
222    let spk = resolve_speaker(system, config, global)?;
223    let state = spk.playback_state.fetch().ok();
224    let track = spk.current_track.fetch().ok();
225    let pos = spk.position.fetch().ok();
226    let vol = spk.volume.fetch().ok();
227
228    let state_str = state
229        .as_ref()
230        .map(|st| format!("{} {}", playback_icon(st), playback_label(st)))
231        .unwrap_or_else(|| "unknown".to_string());
232    let track_str = track
233        .as_ref()
234        .map(|t| {
235            let d = t.display();
236            if d == "Unknown" {
237                t.uri
238                    .as_deref()
239                    .filter(|u| !u.is_empty() && !u.starts_with("x-rincon:"))
240                    .map(|_| "Playing (no metadata)".to_string())
241                    .unwrap_or(d)
242            } else {
243                d
244            }
245        })
246        .unwrap_or_default();
247    let pos_str = pos
248        .as_ref()
249        .map(|p| {
250            format!(
251                "{}/{}",
252                format_time_ms(p.position_ms),
253                format_time_ms(p.duration_ms)
254            )
255        })
256        .unwrap_or_default();
257    let vol_str = vol.map(|v| format!("vol:{}", v.0)).unwrap_or_default();
258
259    let mut parts = vec![spk.name.clone(), state_str];
260    if !track_str.is_empty() {
261        parts.push(track_str);
262    }
263    if !pos_str.is_empty() {
264        parts.push(pos_str);
265    }
266    if !vol_str.is_empty() {
267        parts.push(vol_str);
268    }
269    Ok(parts.join("  "))
270}
271
272fn cmd_join(system: &SonosSystem, global: &GlobalFlags) -> Result<String, CliError> {
273    let speaker_name = global
274        .speaker
275        .as_deref()
276        .ok_or_else(|| CliError::Validation("--speaker is required for join".into()))?;
277    let group_name = global
278        .group
279        .as_deref()
280        .ok_or_else(|| CliError::Validation("--group is required for join".into()))?;
281    let spk = system
282        .speaker(speaker_name)
283        .ok_or_else(|| CliError::SpeakerNotFound(speaker_name.into()))?;
284    let grp = system
285        .group(group_name)
286        .ok_or_else(|| CliError::GroupNotFound(group_name.into()))?;
287    grp.add_speaker(&spk)?;
288    Ok(format!("{speaker_name} joined {group_name}"))
289}
290
291fn cmd_leave(system: &SonosSystem, global: &GlobalFlags) -> Result<String, CliError> {
292    let speaker_name = global
293        .speaker
294        .as_deref()
295        .ok_or_else(|| CliError::Validation("--speaker is required for leave".into()))?;
296    let spk = system
297        .speaker(speaker_name)
298        .ok_or_else(|| CliError::SpeakerNotFound(speaker_name.into()))?;
299    let group_name = spk
300        .group()
301        .and_then(|g| g.coordinator().map(|c| c.name))
302        .unwrap_or_else(|| "its group".into());
303    spk.leave_group()?;
304    Ok(format!("{speaker_name} left {group_name}"))
305}
306
307fn cmd_bass(system: &SonosSystem, global: &GlobalFlags, level: i8) -> Result<String, CliError> {
308    let spk = require_speaker_only(system, global, "bass")?;
309    spk.set_bass(level)?;
310    Ok(format!("Bass set to {} ({})", level, spk.name))
311}
312
313fn cmd_treble(system: &SonosSystem, global: &GlobalFlags, level: i8) -> Result<String, CliError> {
314    let spk = require_speaker_only(system, global, "treble")?;
315    spk.set_treble(level)?;
316    Ok(format!("Treble set to {} ({})", level, spk.name))
317}
318
319fn cmd_loudness(
320    system: &SonosSystem,
321    global: &GlobalFlags,
322    state: OnOff,
323) -> Result<String, CliError> {
324    let spk = require_speaker_only(system, global, "loudness")?;
325    let enabled = matches!(state, OnOff::On);
326    spk.set_loudness(enabled)?;
327    if enabled {
328        Ok(format!("Loudness enabled ({})", spk.name))
329    } else {
330        Ok(format!("Loudness disabled ({})", spk.name))
331    }
332}
333
334fn cmd_sleep(
335    system: &SonosSystem,
336    config: &Config,
337    global: &GlobalFlags,
338    duration: &str,
339) -> Result<String, CliError> {
340    let spk = resolve_speaker(system, config, global)?;
341    if duration == "cancel" {
342        spk.cancel_sleep_timer()?;
343        Ok(format!("Sleep timer cancelled ({})", spk.name))
344    } else {
345        let hh_mm_ss = parse_duration(duration)?;
346        let human = format_duration_human(duration);
347        spk.configure_sleep_timer(&hh_mm_ss)?;
348        Ok(format!("Sleep timer set for {} ({})", human, spk.name))
349    }
350}
351
352fn cmd_queue(
353    system: &SonosSystem,
354    config: &Config,
355    global: &GlobalFlags,
356    action: Option<QueueAction>,
357) -> Result<String, CliError> {
358    let spk = resolve_speaker(system, config, global)?;
359    match action {
360        None => {
361            let info = spk.get_media_info()?;
362            if info.nr_tracks == 0 {
363                return Ok(format!("queue is empty ({})", spk.name));
364            }
365            Ok(format!("{} — {} tracks", spk.name, info.nr_tracks))
366        }
367        Some(QueueAction::Add { uri }) => {
368            spk.add_uri_to_queue(&uri, "", 0, false)?;
369            Ok(format!("Added to queue ({})", spk.name))
370        }
371        Some(QueueAction::Clear) => {
372            if std::io::stdin().is_terminal() && !global.no_input {
373                eprint!("Clear queue for {}? [y/N] ", spk.name);
374                let mut input = String::new();
375                std::io::stdin()
376                    .read_line(&mut input)
377                    .map_err(|e| CliError::Validation(e.to_string()))?;
378                if !input.trim().eq_ignore_ascii_case("y") {
379                    return Ok("Cancelled".into());
380                }
381            }
382            spk.remove_all_tracks_from_queue()?;
383            Ok(format!("Queue cleared ({})", spk.name))
384        }
385    }
386}