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