1pub(crate) mod artwork;
2mod persistence;
3mod playback;
4mod queue;
5mod recording;
6mod status;
7use playback::PlaybackController;
8use recording::RecordingController;
9pub use status::{PlaybackState, RecordingState};
10
11use crate::error::{DomainError, ErrorCode};
12use crate::{
13 config::Config,
14 directory::Directory,
15 model::{Filter, Station},
16 player::{Event, Player},
17 process::{Background, MediaLock},
18 recorder::{self, Recorder},
19 store::Store,
20};
21use anyhow::{Context, Result, bail};
22use std::{
23 collections::VecDeque,
24 sync::{Arc, atomic::AtomicBool},
25 time::{Duration, Instant},
26};
27
28#[derive(Debug, Clone, PartialEq)]
29pub struct Status {
30 pub sleep_remaining: Option<u64>,
31 pub podcast_auto_next: bool,
32 pub skip_back: u32,
33 pub skip_forward: u32,
34 pub episode: Option<crate::podcast::Episode>,
35 pub seekable: bool,
36 pub speed: f64,
37 pub station: Option<Station>,
38 pub title: String,
39 pub message: String,
40 pub playback_state: PlaybackState,
41 pub volume: u8,
42 pub muted: bool,
43 pub recording_state: RecordingState,
44 pub recording_ms: u64,
45 pub recording_path: String,
46 pub source_url: String,
47}
48
49impl Status {
50 pub(crate) fn control_eq(&self, other: &Self) -> bool {
51 self.episode
52 .as_ref()
53 .map(|e| (&e.id, e.completed, e.observed_duration_ms))
54 == other
55 .episode
56 .as_ref()
57 .map(|e| (&e.id, e.completed, e.observed_duration_ms))
58 && self.seekable == other.seekable
59 && self.sleep_remaining == other.sleep_remaining
60 && self.podcast_auto_next == other.podcast_auto_next
61 && self.skip_back == other.skip_back
62 && self.skip_forward == other.skip_forward
63 && self.speed == other.speed
64 && self.station == other.station
65 && self.title == other.title
66 && self.message == other.message
67 && self.playback_state == other.playback_state
68 && self.recording_state == other.recording_state
69 && self.volume == other.volume
70 && self.muted == other.muted
71 && self.recording_path == other.recording_path
72 && self.source_url == other.source_url
73 }
74 pub(crate) fn ui_eq(&self, other: &Self) -> bool {
75 self.control_eq(other)
76 && self.recording_ms / 1000 == other.recording_ms / 1000
77 && self.episode.as_ref().map(|e| e.position_ms / 1000)
78 == other.episode.as_ref().map(|e| e.position_ms / 1000)
79 }
80 pub fn playing(&self) -> bool {
81 matches!(
82 self.playback_state,
83 PlaybackState::Playing | PlaybackState::Paused
84 )
85 }
86 pub fn paused(&self) -> bool {
87 self.playback_state == PlaybackState::Paused
88 }
89 pub fn recording(&self) -> bool {
90 matches!(
91 self.recording_state,
92 RecordingState::Probing | RecordingState::Recording
93 )
94 }
95}
96
97pub struct Engine {
98 podcast_runtime: crate::podcast::Runtime,
99 session: Session,
100 playback: PlaybackController,
101 recording: RecordingController,
102}
103
104pub(crate) struct Session {
106 persistence: Option<persistence::Writer>,
107 pub subtitles: crate::speech::Controller,
108 pub(crate) artwork: artwork::Controller,
109 pub config: Config,
110 pub store: Store,
111 pub directory: Directory,
112 pub status: Status,
113 pub podcast_speed: f64,
115 pub podcast_auto_next: bool,
116 pub stop: Arc<AtomicBool>,
117 pub(crate) _lock: Arc<MediaLock>,
118 pub(crate) background_media: bool,
119 pub(crate) diagnostics: Option<Background<(serde_json::Value, bool)>>,
120 pub(crate) library_task: Option<Background<String>>,
121 pub playback_failed: bool,
122}
123
124impl Session {
125 pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
126 if let Some(writer) = &self.persistence {
127 writer.preference(key, value)
128 } else {
129 if let Some(id) = key.strip_prefix("podcast_progress:") {
130 self.store
131 .podcast_save_progress(id, &serde_json::from_str(value)?)
132 } else if let Some(id) = key.strip_prefix("podcast_played:") {
133 self.store.podcast_played(id)
134 } else {
135 self.store.set_meta(key, value)
136 }
137 }
138 }
139
140 fn remember_play(&self, uuid: &str) -> Result<()> {
141 if let Some(writer) = &self.persistence {
142 writer.played(uuid)?;
143 writer.preference("pref_last_media", "station")
144 } else {
145 self.store.played(uuid)?;
146 self.store.set_meta("pref_last_media", "station")?;
147 self.store.set_meta("pref_last_station", uuid)
148 }
149 }
150}
151
152impl Engine {
153 pub fn status(&self) -> &Status {
154 &self.session.status
155 }
156
157 pub fn config(&self) -> &Config {
158 &self.session.config
159 }
160
161 pub fn store(&self) -> &Store {
162 &self.session.store
163 }
164
165 #[cfg(test)]
166 pub(crate) fn test_store_mut(&mut self) -> &mut Store {
167 &mut self.session.store
168 }
169
170 pub fn subtitles(&self) -> &crate::speech::Snapshot {
171 &self.session.subtitles.snapshot
172 }
173
174 pub fn playback_failed(&self) -> bool {
175 self.session.playback_failed
176 }
177
178 pub fn change_station(
180 &mut self,
181 command: crate::service::StationCommand,
182 ) -> Result<crate::service::StationChange> {
183 crate::service::change_station(&mut self.session.store, command)
184 }
185
186 pub fn toggle_favorite(&mut self, uuid: &str) -> Result<bool> {
188 self.session.store.toggle_favorite(uuid)
189 }
190
191 pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
192 self.session.save_preference(key, value)
193 }
194
195 pub(crate) fn set_language(&mut self, language: String) {
196 crate::messages::init(Some(&language), None);
197 self.session.config.settings.language = Some(language.clone());
198 self.session.status.message = crate::t!("language_set", "language" => language);
199 }
200
201 pub(crate) fn request_artwork(&mut self, station: Option<String>) {
202 self.session.artwork.demand = station;
203 }
204
205 pub(crate) fn track_artwork(&self) -> &Option<artwork::TrackArtwork> {
206 &self.session.artwork.cover
207 }
208
209 pub(crate) fn start_diagnostics(&mut self) -> Result<()> {
210 if self.session.diagnostics.is_some() {
211 bail!(crate::t!("diagnostics_busy"));
212 }
213 let config = self.session.config.clone();
214 self.session.diagnostics = Some(Background::start("radio-doctor", move |cancel| {
215 crate::service::doctor_report(&config, &cancel)
216 })?);
217 Ok(())
218 }
219
220 pub(crate) fn poll_diagnostics(&mut self) -> Option<Result<(serde_json::Value, bool)>> {
221 let result = self.session.diagnostics.as_ref()?.poll()?;
222 self.session.diagnostics = None;
223 Some(result)
224 }
225
226 pub(crate) fn stop(&mut self) -> Result<()> {
227 self.stop_playback()?;
228 self.session.status.message = crate::t!("playback_stopped").into();
229 Ok(())
230 }
231
232 #[cfg(test)]
233 pub(crate) fn test_session(&mut self) -> &mut Session {
234 &mut self.session
235 }
236
237 pub fn bootstrap(&mut self) -> Result<usize> {
238 self.session.directory.bootstrap(&mut self.session.store)
239 }
240
241 pub fn sync(&mut self, progress: impl FnMut(usize)) -> Result<usize> {
243 self.sync_with_policy(progress, false)
244 }
245
246 pub fn sync_with_policy(
249 &mut self,
250 progress: impl FnMut(usize),
251 accept_shrink: bool,
252 ) -> Result<usize> {
253 self.session
254 .directory
255 .sync_with_policy(&mut self.session.store, progress, accept_shrink)
256 }
257
258 pub fn refresh_station(&mut self, uuid: &str) -> Result<Option<Station>> {
260 self.session.directory.refresh(uuid)
261 }
262
263 pub fn report_click(&mut self, uuid: &str) -> Result<()> {
265 self.session.directory.click(uuid)
266 }
267 pub fn new(mut config: Config, stop: Arc<AtomicBool>) -> Result<Self> {
268 let lock = MediaLock::acquire(&config.runtime_dir)?;
269 let store = Store::open(&config.data_dir.join("radio.db"))?;
270 if let Some(volume) = store
271 .meta("pref_volume")?
272 .and_then(|v| v.parse::<u8>().ok())
273 .filter(|v| *v <= 100)
274 {
275 config.settings.volume = volume;
276 }
277 let podcast_speed = store
278 .meta("podcast_speed")?
279 .and_then(|v| v.parse().ok())
280 .unwrap_or(1.);
281 let podcast_auto_next = store.meta("podcast_auto_next")?.as_deref() == Some("on");
282 let recovery_warnings = recorder::recover(&store)?;
283 let directory = Directory::new(&config, stop.clone())?;
284 let status = Status {
285 sleep_remaining: None,
286 podcast_auto_next: false,
287 skip_back: 15,
288 skip_forward: 15,
289 episode: None,
290 seekable: false,
291 speed: 1.,
292 station: None,
293 title: String::new(),
294 message: if recovery_warnings.is_empty() {
295 crate::t!("status_ready").into()
296 } else {
297 recovery_warnings.join("\n")
298 },
299 playback_state: PlaybackState::Idle,
300 volume: config.settings.volume,
301 muted: false,
302 recording_state: RecordingState::Idle,
303 recording_ms: 0,
304 recording_path: String::new(),
305 source_url: String::new(),
306 };
307 Ok(Self {
308 podcast_runtime: Default::default(),
309 session: Session {
310 persistence: None,
311 subtitles: crate::speech::Controller::default(),
312 artwork: artwork::Controller::default(),
313 config,
314 store,
315 directory,
316 status,
317 podcast_speed,
318 podcast_auto_next,
319 stop,
320 _lock: Arc::new(lock),
321 background_media: false,
322 diagnostics: None,
323 library_task: None,
324 playback_failed: false,
325 },
326 playback: PlaybackController {
327 sleep_deadline: None,
328 sleep_end: false,
329 show_settings: Default::default(),
330 episode: None,
331 progress: Default::default(),
332 seek_request: None,
333 loaded: false,
334 resume_pending: false,
335 resume_blocked: false,
336 last_save: Instant::now(),
337 queue_mode: false,
338 auto_next: false,
339 queue_completions: Default::default(),
340 generation: 0,
341 refresh_task: None,
342 click_task: None,
343 player: None,
344 player_start: None,
345 retiring: vec![],
346 url: String::new(),
347 candidates: VecDeque::new(),
348 tried: vec![],
349 refreshed: false,
350 confirmed: false,
351 session_started: false,
352 source_kind: playback::SourceKind::Catalog,
353 local_recording_id: None,
354 reconnect_attempts: 0,
355 reconnect_due: None,
356 reconnect_window: VecDeque::new(),
357 started: Instant::now(),
358 random_filter: None,
359 random_tried: vec![],
360 failure: None,
361 },
362 recording: RecordingController {
363 recording_probe: None,
364 retiring_probes: vec![],
365 finalizing: None,
366 recorder: None,
367 },
368 })
369 }
370
371 pub fn play_episode(&mut self, id: &str, from_start: bool, speed: Option<f64>) -> Result<()> {
372 if self.podcast_runtime.cleaning(id) {
373 anyhow::bail!(crate::t!("podcast_download_busy"));
374 }
375 self.playback.play_episode(
376 &mut self.session,
377 &mut self.recording,
378 id,
379 from_start,
380 speed,
381 )
382 }
383 pub fn play_podcast_queue(&mut self, auto_next: bool) -> Result<()> {
384 let id = self
385 .store()
386 .podcast_queue()?
387 .first()
388 .map(|e| e.id.clone())
389 .context(crate::t!("podcast_empty_queue"))?;
390 self.play_episode(&id, false, None)?;
391 self.playback.queue_mode = true;
392 self.playback.auto_next = auto_next;
393 Ok(())
394 }
395 pub fn seek_episode(&mut self, position: u64) -> Result<()> {
396 self.playback.seek_episode(&mut self.session, position)
397 }
398 pub fn podcast_speed(&mut self, rate: f64) -> Result<()> {
399 crate::podcast::valid_speed(rate)?;
400 if let Some(p) = self.playback.player.as_mut()
401 && self.playback.episode.is_some()
402 {
403 p.request(serde_json::json!(["set_property", "speed", rate]))?;
404 }
405 self.session.podcast_speed = rate;
406 self.session.status.speed = rate;
407 self.session
408 .save_preference("podcast_speed", &rate.to_string())
409 }
410 pub fn podcast_auto_next(&mut self, on: bool) -> Result<()> {
411 self.session.status.podcast_auto_next = on;
412 self.session.podcast_auto_next = on;
413 self.playback.auto_next = on;
414 self.session
415 .save_preference("podcast_auto_next", if on { "on" } else { "off" })
416 }
417 pub fn play(&mut self, uuid: &str) -> Result<()> {
418 let result = self
419 .playback
420 .play(&mut self.session, &mut self.recording, uuid);
421 if let Err(error) = &result
422 && !self.playback_active()
423 {
424 self.session.status.playback_state = PlaybackState::Failed {
425 reason: format!("{error:#}"),
426 };
427 }
428 result
429 }
430
431 pub fn resume_last_station(&mut self) -> Result<()> {
432 self.playback
433 .resume_last_station(&mut self.session, &mut self.recording)
434 }
435
436 pub fn play_recording(&mut self, id: &str) -> Result<()> {
437 let result = self
438 .playback
439 .play_recording(&mut self.session, &mut self.recording, id);
440 if let Err(error) = &result
441 && !self.playback_active()
442 {
443 self.session.status.playback_state = PlaybackState::Failed {
444 reason: format!("{error:#}"),
445 };
446 }
447 result
448 }
449
450 pub fn random(&mut self, filter: Filter) -> Result<()> {
451 let result = self
452 .playback
453 .random(&mut self.session, &mut self.recording, filter);
454 if let Err(error) = &result
455 && !self.playback_active()
456 {
457 self.session.status.playback_state = PlaybackState::Failed {
458 reason: format!("{error:#}"),
459 };
460 }
461 result
462 }
463
464 pub(crate) fn current_podcast_action(
465 &mut self,
466 mut action: crate::podcast::Action,
467 ) -> Result<()> {
468 let episode = self
469 .session
470 .status
471 .episode
472 .as_ref()
473 .filter(|_| self.session.status.playing())
474 .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
475 let id = action
476 .episode_id_mut()
477 .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
478 *id = episode.id.clone();
479 self.podcast_action(action)
480 }
481
482 pub fn podcast_action(&mut self, mut action: crate::podcast::Action) -> Result<()> {
483 use crate::podcast::{Action, DownloadAction, QueueAction};
484 if let Some(id) = action.episode_id_mut() {
485 *id = self.store().podcast_episode_id(id)?;
486 }
487 if let Action::Queue {
488 action: QueueAction::Next { after, .. },
489 } = &mut action
490 {
491 *after = self
492 .playback
493 .queue_mode
494 .then(|| self.playback.episode.as_ref().map(|e| e.id.clone()))
495 .flatten();
496 }
497 self.podcast_runtime
498 .follow_captions(self.session.status.episode.as_ref());
499 let show = matches!(&action, Action::Subtitles { id, .. } if self.status().playing() && self.status().episode.as_ref().is_some_and(|e| e.id == *id));
500 let result = match action {
501 Action::Sleep { value } => self.playback.set_sleep(&mut self.session, &value),
502 Action::Jump { id, time } => {
503 let target = crate::podcast::parse_time(&time)?;
504 if self.status().episode.as_ref().is_some_and(|e| e.id == id) {
505 self.seek_episode(target)
506 } else {
507 self.play_episode(&id, false, None)?;
508 self.playback.episode.as_mut().unwrap().position_ms = target;
509 self.playback.resume_pending = target > 0;
510 Ok(())
511 }
512 }
513 Action::Bookmark {
514 id,
515 time: None,
516 note,
517 } => {
518 let episode = self
519 .status()
520 .episode
521 .as_ref()
522 .filter(|e| e.id == id)
523 .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
524 self.store()
525 .podcast_add_bookmark(&id, episode.position_ms, ¬e)?;
526 Ok(())
527 }
528 Action::Resume => {
529 let id = self
530 .store()
531 .meta("pref_last_episode")?
532 .ok_or_else(|| crate::podcast::error(crate::t!("podcast_current_required")))?;
533 self.play_episode(&id, false, None)
534 }
535 Action::Relative { seconds } => {
536 if !seconds.is_finite() || seconds.abs() > 86400. {
537 anyhow::bail!(crate::t!("podcast_invalid_time"));
538 }
539 self.playback.seek_relative(&mut self.session, seconds)
540 }
541 Action::Play {
542 id,
543 from_start,
544 speed,
545 } => self.play_episode(&id, from_start, speed),
546 Action::Queue {
547 action: QueueAction::Start { id, auto_next },
548 } => {
549 if !self.store().podcast_queue()?.iter().any(|e| e.id == id) {
550 anyhow::bail!(crate::t!("podcast_not_found"));
551 }
552 self.play_episode(&id, false, None)?;
553 self.playback.queue_mode = true;
554 self.playback.auto_next = auto_next || self.session.podcast_auto_next;
555 Ok(())
556 }
557 Action::Queue {
558 action: QueueAction::Play { auto_next },
559 } => self.play_podcast_queue(auto_next || self.session.podcast_auto_next),
560 Action::Seek { time } => self.seek_episode(crate::podcast::parse_time(&time)?),
561 Action::Speed { rate } => self.podcast_speed(rate),
562 Action::MarkBatch { ids, unplayed } => {
563 let mut episodes = ids
565 .iter()
566 .map(|id| self.store().podcast_episode(id))
567 .collect::<Result<Vec<_>>>()?;
568 let ids = episodes.iter().map(|e| e.id.clone()).collect::<Vec<_>>();
569 if self
570 .playback
571 .episode
572 .as_ref()
573 .is_some_and(|e| ids.contains(&e.id))
574 {
575 self.stop_playback()?;
576 self.playback.episode = None;
577 }
578 let mut rows = Vec::new();
579 for e in &mut episodes {
580 e.completed = !unplayed;
581 e.position_ms = if unplayed {
582 0
583 } else {
584 e.observed_duration_ms
585 .or(e.duration_ms)
586 .unwrap_or(e.position_ms)
587 };
588 self.playback.progress.insert(e.id.clone(), e.clone());
589 if self.status().episode.as_ref().is_some_and(|p| p.id == e.id) {
590 self.session.status.episode = Some(e.clone());
591 }
592 rows.push((e.id.clone(), e.progress()));
593 }
594 if let Some(writer) = &self.session.persistence {
595 let updates = rows
596 .iter()
597 .map(|(id, progress)| {
598 Ok((
599 format!("podcast_progress:{id}"),
600 serde_json::to_string(progress)?,
601 ))
602 })
603 .collect::<Result<Vec<_>>>()?;
604 writer.preferences(updates)
605 } else {
606 let tx = rusqlite::Transaction::new_unchecked(
607 &self.store().conn,
608 rusqlite::TransactionBehavior::Immediate,
609 )?;
610 for (id, progress) in rows {
611 Store::write_podcast_progress(&tx, &id, &progress)?;
612 }
613 tx.commit()?;
614 Ok(())
615 }
616 }
617 Action::Mark { id, state } => {
618 let mut e = self.session.store.podcast_episode(&id)?;
619 if self.playback.episode.as_ref().is_some_and(|e| e.id == id) {
620 self.stop_playback()?;
621 self.playback.episode = None;
622 }
623 e.completed = state == "played";
624 e.position_ms = if e.completed {
625 e.observed_duration_ms.unwrap_or(e.position_ms)
626 } else {
627 0
628 };
629 self.playback.progress.insert(id.clone(), e.clone());
630 if self
631 .session
632 .status
633 .episode
634 .as_ref()
635 .is_some_and(|p| p.id == id)
636 {
637 self.session.status.episode = Some(e.clone());
638 }
639 self.session.save_preference(
640 &format!("podcast_progress:{id}"),
641 &serde_json::to_string(&e.progress())?,
642 )
643 }
644 Action::AutoNext { state } => self.podcast_auto_next(state == "on"),
645 Action::Downloads {
646 action: DownloadAction::Remove { ref id },
647 } if self.podcast_runtime.download_active(id) => {
648 Err(crate::podcast::error(crate::t!("podcast_download_busy")))
649 }
650 Action::Downloads {
651 action: DownloadAction::Remove { ref id },
652 } if self.playback_active()
653 && self
654 .store()
655 .podcast_download(id)?
656 .is_some_and(|d| !d.path.is_empty() && d.path == self.playback.url) =>
657 {
658 Err(crate::podcast::error(crate::t!("podcast_download_in_use")))
659 }
660 action => self.podcast_runtime.action(
661 &self.session.config,
662 action,
663 self.session._lock.clone(),
664 ),
665 };
666 if result.is_ok() && show {
667 self.set_subtitles(true);
668 }
669 result
670 }
671 pub(crate) fn show_podcast_subtitles(&mut self, id: &str) -> Result<()> {
672 if !self.playback_active() || self.playback.episode.as_ref().is_none_or(|e| e.id != id) {
675 self.play_episode(id, false, None)?;
676 }
677 self.set_subtitles(true);
678 Ok(())
679 }
680 pub(crate) fn subtitle_progress(&self) -> Option<u64> {
681 self.podcast_runtime.subtitle_progress()
682 }
683 pub fn podcast_tasks(&self) -> (usize, bool) {
684 self.podcast_runtime.tasks()
685 }
686 pub(crate) fn poll_podcast_browse(&mut self) -> Option<Result<serde_json::Value>> {
687 self.podcast_runtime.poll_browse()
688 }
689 pub fn poll_podcast(&mut self) -> Option<Result<serde_json::Value>> {
690 self.podcast_runtime
691 .poll_browse()
692 .or_else(|| self.podcast_runtime.poll())
693 }
694 pub(crate) fn poll_podcast_operation(&mut self) -> Option<Result<serde_json::Value>> {
695 self.podcast_runtime.poll()
696 }
697 pub(crate) fn poll_podcast_subtitles(&mut self) -> Option<Result<serde_json::Value>> {
698 let current = self
699 .session
700 .status
701 .episode
702 .as_ref()
703 .is_some_and(|e| self.podcast_runtime.subtitle_target() == Some(e.id.as_str()));
704 let result = self.podcast_runtime.poll_subtitles()?;
705 if current {
706 self.session.subtitles.retry();
707 }
708 Some(result)
709 }
710 pub(crate) fn cancel_podcast_subtitles(&mut self) {
711 self.podcast_runtime.cancel_subtitles();
712 self.session.subtitles.retry();
713 }
714 pub(crate) fn cancel_podcast_subtitles_for(&mut self, id: &str) -> Result<()> {
715 self.podcast_runtime.cancel_subtitles_for(id)?;
716 self.session.subtitles.retry();
717 Ok(())
718 }
719 pub(crate) fn cancel_podcast_browse(&mut self) {
720 self.podcast_runtime.cancel_browse();
721 }
722 pub fn cancel_podcast(&mut self) -> bool {
723 let cancelled = self.podcast_runtime.cancel();
724 if cancelled {
725 self.session.subtitles.retry();
726 }
727 cancelled
728 }
729 pub fn tick(&mut self) -> Result<()> {
730 if self.session.background_media {
731 self.podcast_runtime
732 .follow_captions(self.session.status.episode.as_ref());
733 self.podcast_runtime
734 .tick(&self.session.config, self.session._lock.clone())?;
735 }
736 self.playback
737 .sleep_tick(&mut self.session, Instant::now())?;
738 self.poll_background()?;
739 self.playback.tick(&mut self.session, &mut self.recording)?;
740 self.recording
741 .recording_tick(&mut self.session, &mut self.playback)?;
742 self.subtitle_tick();
743 self.artwork_tick();
744 Ok(())
745 }
746
747 fn subtitle_tick(&mut self) {
748 if !self.session.background_media {
749 return;
750 }
751 if self.session.subtitles.snapshot.enabled && !self.session.artwork.quiescent() {
752 self.session.artwork.cancel();
753 return;
754 }
755 let playing = self.session.status.playback_state == PlaybackState::Playing;
756 let paused = self.session.status.paused();
757 let local = self.playback.source_kind == playback::SourceKind::Local;
758 let generation = self.playback.generation;
759 if let Some(episode) = &self.session.status.episode {
760 self.podcast_runtime.follow_captions(Some(episode));
761 self.session.subtitles.update_episode(
762 &self.session.config,
763 generation,
764 episode,
765 playing || paused,
766 );
767 let reset = !self
768 .session
769 .subtitles
770 .incremental_episode(generation, episode);
771 if self.session.subtitles.snapshot.enabled
772 && let Some(update) = self.podcast_runtime.caption_update(episode, reset)
773 {
774 self.session
775 .subtitles
776 .publish_episode(generation, episode, update);
777 }
778 return;
779 }
780 let session = &mut self.session;
781 let key = (generation, session.status.source_url.as_str());
782 session
783 .subtitles
784 .update(&session.config, key, playing, paused, local, &session.stop);
785 }
786
787 pub fn set_subtitles(&mut self, enabled: bool) {
788 self.session.subtitles.enabled(enabled);
789 }
790 pub fn retry_subtitles(&mut self) {
791 self.session.subtitles.retry();
792 }
793 pub fn clear_subtitles(&mut self) {
794 self.session.subtitles.clear();
795 }
796 pub fn set_subtitle_model(&mut self, id: String) -> Result<()> {
797 crate::speech::validate_model(&id)?;
798 let mut settings = self.session.config.settings.subtitles.clone();
799 settings.model = id;
800 settings.validate()?;
801 self.session.config.settings.subtitles = settings;
802 self.session.subtitles.retry();
803 self.session.subtitles.clear();
804 Ok(())
805 }
806
807 fn artwork_tick(&mut self) {
808 let request = (self.session.background_media
809 && !self.session.subtitles.snapshot.enabled
810 && self.session.subtitles.quiescent()
811 && self.session.config.settings.artwork == crate::config::ArtworkMode::Track
812 && self.session.status.playback_state == PlaybackState::Playing
813 && !matches!(
814 self.session.status.recording_state,
815 RecordingState::Probing | RecordingState::Recording | RecordingState::Finalizing
816 )
817 && self.playback.source_kind != playback::SourceKind::Local
818 && self.playback.retiring.is_empty()
819 && self.recording.retiring_probes.is_empty()
820 && !self.session.status.title.is_empty())
821 .then_some(self.session.status.station.as_ref())
822 .flatten()
823 .filter(|station| {
824 station.hls == 0
825 && self.session.artwork.demand.as_deref() == Some(station.stationuuid.as_str())
826 })
827 .filter(|_| crate::config::validate_url(&self.session.status.source_url).is_ok())
828 .map(|station| artwork::Request {
829 stationuuid: station.stationuuid.clone(),
830 source_url: self.session.status.source_url.clone(),
831 title: self.session.status.title.clone(),
832 });
833 let session = &mut self.session;
834 session.artwork.update(&session.config, request);
835 }
836
837 pub fn pause(&mut self) -> Result<()> {
838 self.playback.pause(&mut self.session, &mut self.recording)
839 }
840 pub fn mute(&mut self) -> Result<()> {
841 self.playback
842 .player
843 .as_mut()
844 .context(DomainError::new(ErrorCode::NotPlaying))?
845 .toggle_mute()
846 }
847
848 pub fn volume(&mut self, delta: i32) -> Result<()> {
849 self.playback
850 .volume(&mut self.session, &mut self.recording, delta)
851 }
852
853 pub fn stop_playback(&mut self) -> Result<()> {
854 self.playback
855 .stop_playback(&mut self.session, &mut self.recording)
856 }
857
858 pub fn toggle_recording(&mut self) -> Result<()> {
859 let result = self
860 .recording
861 .toggle_recording(&mut self.session, &mut self.playback);
862 if let Err(error) = &result
863 && self.recording.recorder.is_none()
864 && self.recording.recording_probe.is_none()
865 && self.recording.finalizing.is_none()
866 {
867 self.session.status.recording_state = RecordingState::Failed {
868 reason: format!("{error:#}"),
869 };
870 }
871 result
872 }
873
874 pub fn record_current(
875 &mut self,
876 duration: Option<Duration>,
877 dir: Option<&std::path::Path>,
878 ) -> Result<()> {
879 let result =
880 self.recording
881 .record_current(&mut self.session, &mut self.playback, duration, dir);
882 if let Err(error) = &result
883 && self.recording.recorder.is_none()
884 && self.recording.recording_probe.is_none()
885 && self.recording.finalizing.is_none()
886 {
887 self.session.status.recording_state = RecordingState::Failed {
888 reason: format!("{error:#}"),
889 };
890 }
891 result
892 }
893
894 pub fn standalone_record(
895 &mut self,
896 uuid: &str,
897 duration: Option<Duration>,
898 dir: Option<&std::path::Path>,
899 ) -> Result<()> {
900 let result = self.recording.standalone_record(
901 &mut self.session,
902 &mut self.playback,
903 uuid,
904 duration,
905 dir,
906 );
907 if let Err(error) = &result
908 && self.recording.recorder.is_none()
909 && self.recording.recording_probe.is_none()
910 && self.recording.finalizing.is_none()
911 {
912 self.session.status.recording_state = RecordingState::Failed {
913 reason: format!("{error:#}"),
914 };
915 }
916 result
917 }
918
919 pub fn stop_recording(&mut self, reason: Option<&str>) -> Result<()> {
920 self.recording
921 .stop_recording(&mut self.session, &mut self.playback, reason)
922 }
923
924 pub(crate) fn enable_background_media(&mut self) -> Result<()> {
925 if self.session.persistence.is_none() {
926 self.session.persistence = Some(persistence::Writer::start(
927 self.session.config.data_dir.join("radio.db"),
928 self.session._lock.clone(),
929 )?);
930 }
931 self.session.background_media = true;
932 let enabled = self.session.config.settings.subtitles.enabled;
933 self.session.subtitles.enabled(enabled);
934 Ok(())
935 }
936
937 pub fn delete_recording(&mut self, id: String, index_only: bool) -> Result<()> {
938 if self.session.library_task.is_some() {
939 bail!(DomainError::new(ErrorCode::RecordingBusy));
940 }
941 if self.playback.local_recording_id.as_deref() == Some(&id) {
942 self.stop_playback()?;
943 }
944 let path = self.session.config.data_dir.join("radio.db");
945 let lock = self.session._lock.clone();
946 self.session.library_task = Some(Background::start(
947 "radio-recording-delete",
948 move |cancel| {
949 let _lock = lock;
950 if cancel.load(std::sync::atomic::Ordering::Relaxed) {
951 bail!(DomainError::new(ErrorCode::Cancelled));
952 }
953 crate::service::delete_recording(&Store::open(&path)?, &id, index_only)?;
954 Ok(crate::t!("recording_deleted", "id" => id))
955 },
956 )?);
957 Ok(())
958 }
959
960 pub fn open_recordings(&mut self) -> Result<()> {
961 if self.session.library_task.is_some() {
962 bail!(DomainError::new(ErrorCode::RecordingBusy));
963 }
964 let dir = self.session.config.recording_dir.clone();
965 self.session.library_task =
966 Some(Background::start("radio-open-recordings", move |cancel| {
967 crate::service::open_recordings(&dir, &cancel)?;
968 Ok(crate::t!("recordings_opened", "path" => dir.display()))
969 })?);
970 Ok(())
971 }
972
973 pub fn playback_active(&self) -> bool {
974 self.playback.player.is_some()
975 || self.playback.player_start.is_some()
976 || self.playback.refresh_task.is_some()
977 || self.playback.reconnect_due.is_some()
978 || self
979 .playback
980 .queue_completions
981 .active(self.playback.generation)
982 }
983
984 pub fn playback_error(&self) -> Option<&DomainError> {
985 self.playback.failure.as_ref()
986 }
987
988 pub fn shutdown(&mut self) -> Result<()> {
989 self.shutdown_with_budget(Duration::from_secs(6))
990 }
991
992 fn shutdown_with_budget(&mut self, budget: Duration) -> Result<()> {
993 self.podcast_runtime = Default::default();
994 let mut failure = self.stop_playback().err();
995 self.session.subtitles.enabled(false);
996 self.playback.click_task = None;
997 self.session.diagnostics = None;
998 self.session.library_task = None;
999 let deadline = Instant::now() + budget;
1000 if let Some(writer) = &self.session.persistence {
1001 writer.close(deadline);
1002 }
1003 while (self.recording.finalizing.is_some()
1006 || !self.playback.queue_completions.is_empty()
1007 || !self.playback.retiring.is_empty()
1008 || !self.recording.retiring_probes.is_empty()
1009 || !self.session.artwork.quiescent()
1010 || !self.session.subtitles.quiescent()
1011 || self
1012 .session
1013 .persistence
1014 .as_ref()
1015 .is_some_and(|writer| !writer.finished()))
1016 && Instant::now() < deadline
1017 {
1018 if let Err(error) = self.poll_background() {
1019 failure.get_or_insert(error);
1020 }
1021 std::thread::sleep(Duration::from_millis(10));
1022 }
1023 self.recording.finalizing = None;
1024 if !self.playback.queue_completions.is_empty() {
1025 failure.get_or_insert_with(|| anyhow::anyhow!(crate::t!("session_save_failed")));
1026 }
1027 if let Some(writer) = self.session.persistence.take()
1028 && let Err(error) = writer.finish().context(crate::t!("session_save_failed"))
1029 {
1030 failure.get_or_insert(error);
1031 }
1032 failure.map_or(Ok(()), Err)
1033 }
1034
1035 fn poll_background(&mut self) -> Result<()> {
1036 if let Some(writer) = &self.session.persistence {
1037 writer.poll().context(crate::t!("session_save_failed"))?;
1038 }
1039 self.session.subtitles.poll_retiring();
1040 if let Some(result) = self
1041 .session
1042 .library_task
1043 .as_ref()
1044 .and_then(Background::poll)
1045 {
1046 self.session.library_task = None;
1047 self.session.status.message = match result {
1048 Ok(message) => message,
1049 Err(error) => {
1050 crate::t!("recording_operation_failed", "error" => format!("{error:#}"))
1051 }
1052 };
1053 }
1054 self.playback
1055 .poll_background(&mut self.session, &mut self.recording)?;
1056 self.recording
1057 .record_poll_background(&mut self.session, &mut self.playback)
1058 }
1059}
1060
1061impl Drop for Engine {
1062 fn drop(&mut self) {
1063 let _ = self.shutdown();
1064 }
1065}
1066
1067#[cfg(test)]
1068mod tests {
1069 use super::*;
1070
1071 #[test]
1072 fn cached_episode_captions_follow_mpv_resume_pause_seek_and_speed() {
1073 use crate::podcast::{Action, Download, Episode, Feed, Preview};
1074 let dir = tempfile::tempdir().unwrap();
1075 let mut config = crate::test_support::config(dir.path());
1076 config.settings.mpv = std::env::var("RADIO_TEST_MPV").unwrap_or_else(|_| "mpv".into());
1077 config.settings.audio_device = Some("null".into());
1078 config.settings.podcasts.refresh_hours = 0;
1079 if std::process::Command::new(&config.settings.mpv)
1080 .arg("--version")
1081 .output()
1082 .is_err()
1083 {
1084 return;
1085 }
1086 let audio = dir.path().join("audio.wav");
1087 std::fs::write(&audio, crate::test_support::fixture("pcm_s16le", "wav")).unwrap();
1088 let file = dir.path().join("captions.vtt");
1089 std::fs::write(&file, "WEBVTT\n\n00:00.000 --> 00:01.000\nfirst\n\n00:01.000 --> 00:02.000\nsecond\n\n00:02.000 --> 00:05.000\nthird").unwrap();
1090 let stop = Arc::new(AtomicBool::new(false));
1091 let mut engine = Engine::new(config.clone(), stop.clone()).unwrap();
1092 let p = Preview {
1093 feed: Feed {
1094 url: "https://example.test/feed".into(),
1095 title: "show".into(),
1096 ..Default::default()
1097 },
1098 episodes: vec![Episode {
1099 url: "https://example.test/audio".into(),
1100 title: "episode".into(),
1101 ..Default::default()
1102 }],
1103 };
1104 let feed = engine.store().podcast_subscribe(&p, &p.feed.url).unwrap();
1105 let episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1106 engine
1107 .store()
1108 .podcast_save_download(&Download {
1109 episode_id: episode.id.clone(),
1110 url: episode.url.clone(),
1111 media: Some(episode.media()),
1112 path: audio.to_string_lossy().into(),
1113 state: "complete".into(),
1114 ..Default::default()
1115 })
1116 .unwrap();
1117 crate::podcast::manage(
1118 &config,
1119 engine.store(),
1120 Action::Subtitles {
1121 id: episode.id.clone(),
1122 file: Some(file),
1123 transcribe: false,
1124 },
1125 &stop,
1126 )
1127 .unwrap();
1128 engine
1129 .store()
1130 .podcast_progress(&episode, 1200, None, false)
1131 .unwrap();
1132 engine.session.background_media = true;
1133 engine.set_subtitles(true);
1134 engine.play_episode(&episode.id, false, None).unwrap();
1135 let deadline = Instant::now() + Duration::from_secs(10);
1136 let wait = |engine: &mut Engine, expected: usize| {
1137 loop {
1138 engine.tick().unwrap();
1139 if engine.subtitles().current == [expected] {
1140 break;
1141 }
1142 assert!(
1143 Instant::now() < deadline,
1144 "{:?} {:?}",
1145 engine.status(),
1146 engine.subtitles()
1147 );
1148 std::thread::sleep(Duration::from_millis(10));
1149 }
1150 };
1151 wait(&mut engine, 1);
1152 while engine.status().playback_state != PlaybackState::Playing
1153 || !engine.playback.session_started
1154 || engine.status().episode.as_ref().unwrap().position_ms <= 1200
1155 {
1156 engine.tick().unwrap();
1157 assert!(Instant::now() < deadline);
1158 std::thread::sleep(Duration::from_millis(10));
1159 }
1160 assert!(engine.subtitles().timed);
1161 engine.pause().unwrap();
1162 while !engine.status().paused() {
1163 engine.tick().unwrap();
1164 assert!(Instant::now() < deadline, "{:?}", engine.status());
1165 std::thread::sleep(Duration::from_millis(10));
1166 }
1167 engine.seek_episode(2500).unwrap();
1168 engine.podcast_speed(2.).unwrap();
1169 wait(&mut engine, 2);
1170 assert!(engine.status().paused());
1171 assert_eq!(engine.status().speed, 2.);
1172 let generation = engine.playback.generation;
1173 let position = engine.status().episode.as_ref().unwrap().position_ms;
1174 engine.show_podcast_subtitles(&episode.id).unwrap();
1175 assert!(engine.subtitles().enabled);
1176 assert_eq!(engine.playback.generation, generation);
1177 assert_eq!(
1178 engine.status().episode.as_ref().unwrap().position_ms,
1179 position
1180 );
1181 assert!(engine.status().paused());
1182 assert_eq!(engine.status().speed, 2.);
1183 let revision = engine.subtitles().revision;
1184 for _ in 0..3 {
1185 engine.tick().unwrap();
1186 }
1187 assert_eq!(engine.subtitles().revision, revision);
1188 engine.seek_episode(250).unwrap();
1189 wait(&mut engine, 0);
1190 engine.pause().unwrap();
1191 wait(&mut engine, 1);
1192 assert_eq!(engine.status().speed, 2.);
1193 engine.set_subtitles(false);
1194 let error = engine
1195 .show_podcast_subtitles("missing-episode")
1196 .unwrap_err();
1197 assert!(!error.to_string().is_empty());
1198 assert!(!engine.subtitles().enabled);
1199 assert_eq!(engine.status().episode.as_ref().unwrap().id, episode.id);
1200 engine.shutdown().unwrap();
1201 }
1202
1203 #[test]
1204 fn queue_completion_refreshes_candidates_after_concurrent_edits() {
1205 use crate::podcast::{Episode, Feed, Preview, QueueAction};
1206 for edit in ["clear", "remove", "move", "readd"] {
1207 let dir = tempfile::tempdir().unwrap();
1208 let mut config = crate::test_support::config(dir.path());
1209 config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1210 .to_string_lossy()
1211 .into_owned();
1212 let path = config.data_dir.join("radio.db");
1213 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1214 let preview = Preview {
1215 feed: Feed {
1216 url: "https://example.test/feed".into(),
1217 ..Default::default()
1218 },
1219 episodes: ["episode-eof", "second", "third"]
1220 .into_iter()
1221 .map(|name| Episode {
1222 guid: Some(name.into()),
1223 url: format!("https://example.test/{name}"),
1224 ..Default::default()
1225 })
1226 .collect(),
1227 };
1228 let feed = engine
1229 .store()
1230 .podcast_subscribe(&preview, &preview.feed.url)
1231 .unwrap();
1232 let episodes = engine.store().podcast_episodes(&feed.id).unwrap();
1233 let ids: Vec<_> = ["episode-eof", "second", "third"]
1234 .into_iter()
1235 .map(|name| {
1236 episodes
1237 .iter()
1238 .find(|e| e.guid.as_deref() == Some(name))
1239 .unwrap()
1240 .id
1241 .clone()
1242 })
1243 .collect();
1244 engine.store().podcast_queue_set(&ids).unwrap();
1245 engine.enable_background_media().unwrap();
1246 engine.play_podcast_queue(true).unwrap();
1247 let deadline = Instant::now() + Duration::from_secs(3);
1248 while engine.playback.queue_completions.is_empty() {
1249 engine.tick().unwrap();
1250 assert!(Instant::now() < deadline);
1251 std::thread::sleep(Duration::from_millis(5));
1252 }
1253 engine.poll_background().unwrap();
1255 let external = Store::open(&path).unwrap();
1256 while external.podcast_queue().unwrap().len() != 2 {
1257 assert!(Instant::now() < deadline);
1258 std::thread::sleep(Duration::from_millis(5));
1259 }
1260 let action = match edit {
1261 "clear" => QueueAction::Clear,
1262 "remove" => QueueAction::Remove { id: ids[1].clone() },
1263 "move" => QueueAction::Move {
1264 id: ids[2].clone(),
1265 position: 1,
1266 },
1267 "readd" => QueueAction::Add { id: ids[0].clone() },
1268 _ => unreachable!(),
1269 };
1270 external.podcast_queue_update(action).unwrap();
1271 let deadline = Instant::now() + Duration::from_secs(3);
1272 while !engine.playback.queue_completions.is_empty() {
1273 engine.tick().unwrap();
1274 assert!(Instant::now() < deadline);
1275 std::thread::sleep(Duration::from_millis(5));
1276 }
1277 match edit {
1278 "clear" => {
1279 assert!(!engine.playback_active());
1280 assert_eq!(engine.status().playback_state, PlaybackState::Idle);
1281 }
1282 "remove" | "move" => {
1283 assert_eq!(engine.status().episode.as_ref().unwrap().id, ids[2])
1284 }
1285 "readd" => {
1286 assert_eq!(engine.status().episode.as_ref().unwrap().id, ids[1]);
1287 assert!(
1288 external
1289 .podcast_queue()
1290 .unwrap()
1291 .iter()
1292 .any(|e| e.id == ids[0])
1293 );
1294 }
1295 _ => unreachable!(),
1296 }
1297 engine.shutdown().unwrap();
1298 }
1299 }
1300
1301 #[test]
1302 fn queue_completion_retries_without_blocking_or_overriding_controls() {
1303 use crate::podcast::{Episode, Feed, Preview};
1304 for control in ["advance", "stop", "switch", "off", "shutdown"] {
1305 let dir = tempfile::tempdir().unwrap();
1306 let mut config = crate::test_support::config(dir.path());
1307 config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1308 .to_string_lossy()
1309 .into_owned();
1310 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1311 let preview = Preview {
1312 feed: Feed {
1313 url: "https://example.test/feed".into(),
1314 ..Default::default()
1315 },
1316 episodes: ["episode-eof", "audio"]
1317 .into_iter()
1318 .map(|name| Episode {
1319 guid: Some(name.into()),
1320 url: format!("https://example.test/{name}"),
1321 ..Default::default()
1322 })
1323 .collect(),
1324 };
1325 let feed = engine
1326 .store()
1327 .podcast_subscribe(&preview, &preview.feed.url)
1328 .unwrap();
1329 let episodes = engine.store().podcast_episodes(&feed.id).unwrap();
1330 let first = episodes
1331 .iter()
1332 .find(|e| e.guid.as_deref() == Some("episode-eof"))
1333 .unwrap();
1334 let next = episodes
1335 .iter()
1336 .find(|e| e.guid.as_deref() == Some("audio"))
1337 .unwrap();
1338 engine
1339 .store()
1340 .podcast_queue_set(&[first.id.clone(), next.id.clone()])
1341 .unwrap();
1342 engine.enable_background_media().unwrap();
1343 engine.play_podcast_queue(true).unwrap();
1344 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1345 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1346 let deadline = Instant::now() + Duration::from_secs(3);
1347 while engine.playback.queue_completions.is_empty() {
1348 let started = Instant::now();
1349 engine.tick().unwrap();
1350 assert!(
1351 started.elapsed() < Duration::from_millis(250),
1352 "EOF blocked controls"
1353 );
1354 assert!(Instant::now() < deadline);
1355 std::thread::sleep(Duration::from_millis(5));
1356 }
1357 let deadline = Instant::now() + Duration::from_millis(350);
1358 while Instant::now() < deadline {
1359 let started = Instant::now();
1360 engine.tick().unwrap();
1361 engine.volume(-1).unwrap();
1362 assert!(
1363 started.elapsed() < Duration::from_millis(250),
1364 "queue retry blocked controls"
1365 );
1366 std::thread::sleep(Duration::from_millis(5));
1367 }
1368 assert_eq!(engine.store().podcast_queue().unwrap().len(), 2);
1369 assert!(!engine.playback.queue_completions.is_empty());
1370 if control == "shutdown" {
1371 let release = std::thread::spawn(move || {
1372 std::thread::sleep(Duration::from_millis(200));
1373 connection.execute_batch("ROLLBACK").unwrap();
1374 });
1375 engine.shutdown().unwrap();
1376 release.join().unwrap();
1377 assert!(engine.playback.queue_completions.is_empty());
1378 assert_eq!(engine.status().playback_state, PlaybackState::Idle);
1379 assert_eq!(engine.store().podcast_queue().unwrap()[0].id, next.id);
1380 assert!(engine.store().podcast_episode(&first.id).unwrap().completed);
1381 continue;
1382 }
1383 match control {
1384 "stop" => {
1385 engine.stop_playback().unwrap();
1386 assert!(!engine.playback_active());
1387 }
1388 "switch" => {
1389 engine.play("https://example.test/live").unwrap();
1390 }
1391 "off" => engine.podcast_auto_next(false).unwrap(),
1392 _ => assert!(engine.playback_active()),
1393 }
1394 connection.execute_batch("ROLLBACK").unwrap();
1395 let deadline = Instant::now() + Duration::from_secs(3);
1396 loop {
1397 engine.tick().unwrap();
1398 if engine.playback.queue_completions.is_empty()
1399 && (matches!(control, "stop" | "off")
1400 || engine.status().playback_state == PlaybackState::Playing)
1401 {
1402 break;
1403 }
1404 assert!(
1405 Instant::now() < deadline,
1406 "{control}: {:?}",
1407 engine.status()
1408 );
1409 std::thread::sleep(Duration::from_millis(5));
1410 }
1411 assert_eq!(
1412 engine
1413 .store()
1414 .podcast_queue()
1415 .unwrap()
1416 .iter()
1417 .map(|e| &e.id)
1418 .collect::<Vec<_>>(),
1419 vec![&next.id]
1420 );
1421 match control {
1422 "advance" => assert_eq!(engine.status().episode.as_ref().unwrap().id, next.id),
1423 "stop" | "off" => assert_eq!(engine.status().playback_state, PlaybackState::Idle),
1424 "switch" => {
1425 assert!(engine.status().episode.is_none());
1426 assert_eq!(engine.status().source_url, "https://example.test/live");
1427 }
1428 _ => unreachable!(),
1429 }
1430 engine.shutdown().unwrap();
1431 assert!(engine.store().podcast_episode(&first.id).unwrap().completed);
1432 }
1433 }
1434
1435 #[test]
1436 fn podcast_preferences_apply_before_the_background_write_finishes() {
1437 use crate::podcast::{Action, Episode, Feed, Preview, QueueAction};
1438 for (old_speed, old_auto_next, speed, auto_next) in
1439 [(1., false, 1.5, true), (1.5, true, 1.25, false)]
1440 {
1441 let dir = tempfile::tempdir().unwrap();
1442 let mut config = crate::test_support::config(dir.path());
1443 let mpv = crate::test_support::fake_mpv(dir.path());
1444 config.settings.mpv = mpv.to_string_lossy().into_owned();
1445 let store = Store::open(&config.data_dir.join("radio.db")).unwrap();
1446 store
1447 .set_meta("podcast_speed", &old_speed.to_string())
1448 .unwrap();
1449 store
1450 .set_meta(
1451 "podcast_auto_next",
1452 if old_auto_next { "on" } else { "off" },
1453 )
1454 .unwrap();
1455 let preview = Preview {
1456 feed: Feed {
1457 url: "https://example.test/feed".into(),
1458 ..Default::default()
1459 },
1460 episodes: vec![Episode {
1461 url: "https://example.test/audio".into(),
1462 ..Default::default()
1463 }],
1464 };
1465 let feed = store
1466 .podcast_subscribe(&preview, &preview.feed.url)
1467 .unwrap();
1468 let id = store.podcast_episodes(&feed.id).unwrap().remove(0).id;
1469 store.podcast_queue_set(std::slice::from_ref(&id)).unwrap();
1470 let mut engine = Engine::new(config.clone(), Arc::new(AtomicBool::new(false))).unwrap();
1471 engine.enable_background_media().unwrap();
1472 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1473 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1474 engine
1475 .podcast_action(Action::Speed { rate: speed })
1476 .unwrap();
1477 engine
1478 .podcast_action(Action::AutoNext {
1479 state: if auto_next { "on" } else { "off" }.into(),
1480 })
1481 .unwrap();
1482 assert_eq!(
1483 store.meta("podcast_speed").unwrap(),
1484 Some(old_speed.to_string())
1485 );
1486 assert_eq!(
1487 store.meta("podcast_auto_next").unwrap().as_deref(),
1488 Some(if old_auto_next { "on" } else { "off" })
1489 );
1490 engine
1491 .podcast_action(Action::Queue {
1492 action: QueueAction::Play { auto_next: false },
1493 })
1494 .unwrap();
1495 assert_eq!(engine.status().speed, speed);
1496 assert_eq!(engine.playback.auto_next, auto_next);
1497 let deadline = Instant::now() + Duration::from_secs(3);
1498 loop {
1499 engine.tick().unwrap();
1500 let commands =
1501 std::fs::read_to_string(mpv.with_extension("commands")).unwrap_or_default();
1502 let speed_sent = commands
1503 .lines()
1504 .filter_map(|line| serde_json::from_str::<serde_json::Value>(line).ok())
1505 .any(|value| {
1506 value["command"] == serde_json::json!(["set_property", "speed", speed])
1507 });
1508 if speed_sent && engine.status().playback_state == PlaybackState::Playing {
1509 break;
1510 }
1511 assert!(Instant::now() < deadline, "{:?}", engine.status());
1512 std::thread::sleep(Duration::from_millis(5));
1513 }
1514 engine.play("https://example.test/live").unwrap();
1515 assert_eq!(engine.status().speed, 1.);
1516 engine.play_episode(&id, false, Some(2.)).unwrap();
1517 assert_eq!(engine.status().speed, 2.);
1518 assert!(engine.podcast_speed(f64::NAN).is_err());
1519 engine.play_episode(&id, false, None).unwrap();
1520 assert_eq!(engine.status().speed, speed);
1521 engine
1522 .podcast_action(Action::Queue {
1523 action: QueueAction::Play { auto_next: true },
1524 })
1525 .unwrap();
1526 assert!(engine.playback.auto_next);
1527 connection.execute_batch("ROLLBACK").unwrap();
1528 engine.shutdown().unwrap();
1529 let lock = Arc::downgrade(&engine.session._lock);
1530 drop(engine);
1531 let deadline = Instant::now() + Duration::from_secs(3);
1533 while lock.strong_count() > 0 {
1534 assert!(Instant::now() < deadline);
1535 std::thread::sleep(Duration::from_millis(5));
1536 }
1537 let mut restored = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1538 restored.play_episode(&id, false, None).unwrap();
1539 assert_eq!(restored.status().speed, speed);
1540 assert_eq!(restored.playback.auto_next, auto_next);
1541 restored.shutdown().unwrap();
1542 }
1543 }
1544
1545 #[test]
1546 fn podcast_marks_apply_before_the_background_write_finishes() {
1547 use crate::podcast::{Action, Episode, Feed, Preview};
1548 for active in [false, true] {
1549 for state in ["unplayed", "played"] {
1550 let dir = tempfile::tempdir().unwrap();
1551 let mut config = crate::test_support::config(dir.path());
1552 config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1553 .to_string_lossy()
1554 .into_owned();
1555 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1556 let preview = Preview {
1557 feed: Feed {
1558 url: "https://example.test/feed".into(),
1559 ..Default::default()
1560 },
1561 episodes: vec![Episode {
1562 url: "https://example.test/audio".into(),
1563 ..Default::default()
1564 }],
1565 };
1566 let feed = engine
1567 .store()
1568 .podcast_subscribe(&preview, &preview.feed.url)
1569 .unwrap();
1570 let episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1571 let id = episode.id.clone();
1572 engine
1573 .store()
1574 .podcast_progress(&episode, 15000, Some(20000), false)
1575 .unwrap();
1576 engine.enable_background_media().unwrap();
1577 if active {
1578 engine.play_episode(&id, false, None).unwrap();
1579 }
1580 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1581 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1582 engine
1583 .podcast_action(Action::Mark {
1584 id: id.clone(),
1585 state: state.into(),
1586 })
1587 .unwrap();
1588 let stored = engine.store().podcast_episode(&id).unwrap();
1589 assert_eq!(stored.position_ms, 15000);
1590 assert!(!stored.completed);
1591 engine.play_episode(&id, false, None).unwrap();
1592 let playing = engine.status().episode.as_ref().unwrap();
1593 assert_eq!(playing.position_ms, 0, "{state}, active={active}");
1594 assert!(!playing.completed);
1595 connection.execute_batch("ROLLBACK").unwrap();
1596 engine.shutdown().unwrap();
1597 assert_eq!(engine.store().podcast_episode(&id).unwrap().position_ms, 0);
1598 }
1599 }
1600 }
1601
1602 #[test]
1603 fn replay_preserves_uncommitted_progress_for_unchanged_media() {
1604 use crate::podcast::{Episode, Feed, Preview};
1605 let dir = tempfile::tempdir().unwrap();
1606 let mut config = crate::test_support::config(dir.path());
1607 config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1608 .to_string_lossy()
1609 .into_owned();
1610 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1611 let preview = Preview {
1612 feed: Feed {
1613 url: "https://example.test/feed".into(),
1614 ..Default::default()
1615 },
1616 episodes: vec![Episode {
1617 url: "https://example.test/audio".into(),
1618 duration_ms: Some(20000),
1619 ..Default::default()
1620 }],
1621 };
1622 let feed = engine
1623 .store()
1624 .podcast_subscribe(&preview, &preview.feed.url)
1625 .unwrap();
1626 let mut episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1627 let id = episode.id.clone();
1628 engine.enable_background_media().unwrap();
1629 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1630 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1631 episode.position_ms = 8000;
1632 engine.playback.episode = Some(episode);
1633 engine
1634 .playback
1635 .save_episode(&mut engine.session, false)
1636 .unwrap();
1637 engine.playback.episode = None;
1638 assert_eq!(engine.store().podcast_episode(&id).unwrap().position_ms, 0);
1639 engine.play_episode(&id, false, None).unwrap();
1640 assert_eq!(engine.status().episode.as_ref().unwrap().position_ms, 8000);
1641 connection.execute_batch("ROLLBACK").unwrap();
1642 engine.shutdown().unwrap();
1643 assert_eq!(
1644 engine.store().podcast_episode(&id).unwrap().position_ms,
1645 8000
1646 );
1647 }
1648
1649 #[test]
1650 fn download_removal_checks_the_active_input_instead_of_the_saved_episode() {
1651 use crate::podcast::{self, Action, Episode, Feed, Preview};
1652 for streaming in [false, true] {
1653 for background in [false, true] {
1654 let dir = tempfile::tempdir().unwrap();
1655 let mut config = crate::test_support::config(dir.path());
1656 config.settings.mpv = crate::test_support::fake_mpv(dir.path())
1657 .to_string_lossy()
1658 .into_owned();
1659 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1660 if background {
1661 engine.enable_background_media().unwrap();
1662 }
1663 let p = Preview {
1664 feed: Feed {
1665 url: "https://example.test/rss".into(),
1666 ..Default::default()
1667 },
1668 episodes: vec![Episode {
1669 guid: Some("episode".into()),
1670 url: "https://example.test/audio".into(),
1671 ..Default::default()
1672 }],
1673 };
1674 let feed = engine.store().podcast_subscribe(&p, &p.feed.url).unwrap();
1675 let episode = engine.store().podcast_episodes(&feed.id).unwrap().remove(0);
1676 let path = podcast::download_path(engine.config(), &episode.id);
1677 std::fs::create_dir_all(path.parent().unwrap()).unwrap();
1678 std::fs::write(&path, b"fixture").unwrap();
1679 let download = podcast::Download {
1680 episode_id: episode.id.clone(),
1681 url: episode.url.clone(),
1682 media: Some(episode.media()),
1683 state: "complete".into(),
1684 path: path.to_string_lossy().into_owned(),
1685 bytes: 7,
1686 ..Default::default()
1687 };
1688 if !streaming {
1690 engine.store().podcast_save_download(&download).unwrap();
1691 }
1692 engine.play_episode(&episode.id, false, None).unwrap();
1693 if streaming {
1694 engine.store().podcast_save_download(&download).unwrap();
1695 }
1696 assert!(engine.playback_active());
1697 let remove = Action::Downloads {
1698 action: podcast::DownloadAction::Remove {
1699 id: episode.id.clone(),
1700 },
1701 };
1702 if !streaming {
1703 assert!(engine.podcast_action(remove.clone()).is_err());
1704 assert!(path.exists());
1705 engine.stop_playback().unwrap();
1706 assert!(!engine.playback_active());
1707 assert_eq!(engine.status().episode.as_ref().unwrap().id, episode.id);
1708 }
1709 engine.podcast_action(remove).unwrap();
1710 let deadline = Instant::now() + Duration::from_secs(3);
1711 let result = loop {
1712 if let Some(result) = engine.poll_podcast() {
1713 break result.unwrap();
1714 }
1715 assert!(Instant::now() < deadline);
1716 std::thread::sleep(Duration::from_millis(10));
1717 };
1718 assert_eq!(result["state"], "removed");
1719 assert!(!path.exists());
1720 if streaming {
1721 assert!(engine.playback_active());
1722 }
1723 engine.shutdown().unwrap();
1724 }
1725 }
1726 }
1727
1728 #[test]
1729 fn background_media_preserves_the_lock_budget_for_catalog_writes() {
1730 let dir = tempfile::tempdir().unwrap();
1731 let config = crate::test_support::config(dir.path());
1732 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1733 let station = crate::service::add_station(
1734 &mut engine.session.store,
1735 "Custom".into(),
1736 "https://example.test/live".into(),
1737 &[],
1738 )
1739 .unwrap();
1740 engine.enable_background_media().unwrap();
1741 for operation in 0..5 {
1744 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1745 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1746 let release = std::thread::spawn(move || {
1747 std::thread::sleep(Duration::from_millis(100));
1748 connection.execute_batch("ROLLBACK").unwrap();
1749 });
1750 let result = match operation {
1751 0 => engine.toggle_favorite(&station.stationuuid).map(|_| ()),
1752 1 => engine
1753 .change_station(crate::service::StationCommand::Backups {
1754 uuid: station.stationuuid.clone(),
1755 add: vec!["https://example.test/backup".into()],
1756 remove: vec![],
1757 })
1758 .map(|_| ()),
1759 2 => engine.store().upsert(&station),
1760 3 => engine.store().save_recording(
1761 &serde_json::from_value(serde_json::json!({
1762 "id":"record", "stationuuid":station.stationuuid,
1763 "station_name":station.name, "source_url_resolved":station.url,
1764 "started_at":"2026-11-01T00:00:00Z", "codec":"mp3", "container":"mp3",
1765 "path":"record.mp3", "size_bytes":0, "status":"recording"
1766 }))
1767 .unwrap(),
1768 ),
1769 4 => engine
1770 .change_station(crate::service::StationCommand::Remove {
1771 uuid: station.stationuuid.clone(),
1772 keep_references: true,
1773 })
1774 .map(|_| ()),
1775 _ => unreachable!(),
1776 };
1777 release.join().unwrap();
1778 result.unwrap();
1779 }
1780 engine.shutdown().unwrap();
1781 }
1782
1783 #[test]
1784 fn background_session_writes_keep_controls_responsive_under_a_write_lock() {
1785 let dir = tempfile::tempdir().unwrap();
1786 let config = crate::test_support::config(dir.path());
1787 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1788 let station = Station {
1789 stationuuid: uuid::Uuid::new_v4().to_string(),
1790 name: "Remembered".into(),
1791 active: true,
1792 ..Station::default()
1793 };
1794 engine.session.store.upsert(&station).unwrap();
1795 engine.enable_background_media().unwrap();
1796 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1797 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1798 let started = Instant::now();
1799 for _ in 0..10 {
1800 engine.volume(-1).unwrap();
1801 }
1802 engine.save_preference("pref_source", "favorites").unwrap();
1803 engine.session.remember_play(&station.stationuuid).unwrap();
1804 engine.stop_playback().unwrap();
1805 engine.tick().unwrap();
1806 assert!(started.elapsed() < Duration::from_millis(250));
1807 assert_eq!(engine.session.status.volume, 70);
1808 std::thread::sleep(Duration::from_millis(150));
1810 engine.volume(-5).unwrap();
1811 connection.execute_batch("ROLLBACK").unwrap();
1812 engine.shutdown().unwrap();
1814 assert_eq!(
1815 engine.session.store.meta("pref_volume").unwrap().as_deref(),
1816 Some("65")
1817 );
1818 assert_eq!(
1819 engine.session.store.meta("pref_source").unwrap().as_deref(),
1820 Some("favorites")
1821 );
1822 assert_eq!(
1823 engine
1824 .session
1825 .store
1826 .meta("pref_last_station")
1827 .unwrap()
1828 .as_deref(),
1829 Some(station.stationuuid.as_str())
1830 );
1831 assert_eq!(
1832 engine
1833 .session
1834 .store
1835 .search_count(&Filter {
1836 history: true,
1837 ..Filter::default()
1838 })
1839 .unwrap(),
1840 1
1841 );
1842 }
1843
1844 #[test]
1845 fn background_session_write_failures_are_reported() {
1846 let dir = tempfile::tempdir().unwrap();
1847 let config = crate::test_support::config(dir.path());
1848 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1849 engine
1850 .session
1851 .store
1852 .test_connection()
1853 .execute_batch(
1854 "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
1855 BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
1856 )
1857 .unwrap();
1858 engine.enable_background_media().unwrap();
1859 engine.volume(-1).unwrap();
1860 let deadline = Instant::now() + Duration::from_secs(3);
1861 loop {
1862 if let Err(error) = engine.tick() {
1863 assert!(format!("{error:#}").contains("preference denied"));
1864 break;
1865 }
1866 assert!(Instant::now() < deadline);
1867 std::thread::sleep(Duration::from_millis(10));
1868 }
1869 assert!(engine.shutdown().is_err());
1870 assert!(engine.session.persistence.is_none());
1871 engine.shutdown().unwrap();
1872 }
1873
1874 #[test]
1875 fn shutdown_drains_finalization_after_a_session_write_failure() {
1876 let dir = tempfile::tempdir().unwrap();
1877 let config = crate::test_support::config(dir.path());
1878 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1879 engine
1880 .store()
1881 .test_connection()
1882 .execute_batch(
1883 "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
1884 BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
1885 )
1886 .unwrap();
1887 engine.enable_background_media().unwrap();
1888 engine.volume(-1).unwrap();
1889 let (completed, receive) = std::sync::mpsc::channel();
1890 engine.recording.finalizing = Some(
1891 Background::start("test-finalization", move |_| {
1892 std::thread::sleep(Duration::from_millis(150));
1893 completed.send(()).unwrap();
1894 bail!("finalization fixture");
1895 })
1896 .unwrap(),
1897 );
1898 let error = engine.shutdown().unwrap_err();
1899 assert!(format!("{error:#}").contains("preference denied"));
1900 receive
1901 .try_recv()
1902 .expect("finalization must finish before shutdown returns");
1903 assert!(engine.recording.finalizing.is_none());
1904 assert!(engine.session.persistence.is_none());
1905 assert!(matches!(
1906 engine.status().recording_state,
1907 RecordingState::Failed { .. }
1908 ));
1909 engine.shutdown().unwrap();
1910 }
1911
1912 #[test]
1913 fn shutdown_stops_pending_writes_before_reporting_a_flush_timeout() {
1914 let dir = tempfile::tempdir().unwrap();
1915 let config = crate::test_support::config(dir.path());
1916 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1917 engine.enable_background_media().unwrap();
1918 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
1919 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
1920 engine.volume(-1).unwrap();
1921 let (cancelled, receive) = std::sync::mpsc::channel();
1922 engine.recording.finalizing = Some(
1923 Background::start("test-finalization", move |cancel| {
1924 while !cancel.load(std::sync::atomic::Ordering::Relaxed) {
1925 std::thread::sleep(Duration::from_millis(5));
1926 }
1927 cancelled.send(()).unwrap();
1928 bail!("cancelled finalization fixture");
1929 })
1930 .unwrap(),
1931 );
1932 assert!(
1933 engine
1934 .shutdown_with_budget(Duration::from_millis(150))
1935 .is_err()
1936 );
1937 assert!(engine.session.persistence.is_none());
1938 assert!(engine.recording.finalizing.is_none());
1939 receive.recv_timeout(Duration::from_secs(1)).unwrap();
1940 connection.execute_batch("ROLLBACK").unwrap();
1941 assert!(engine.store().meta("pref_volume").unwrap().is_none());
1944 engine.shutdown().unwrap();
1945 }
1946
1947 #[test]
1948 fn invalid_subtitle_model_reports_id_without_changing_settings() {
1949 let dir = tempfile::tempdir().unwrap();
1950 let config = crate::test_support::config(dir.path());
1951 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1952 let original = engine.session.config.settings.subtitles.model.clone();
1953 for id in ["unknown", "silero-vad", "../../model"] {
1954 let error = engine.set_subtitle_model(id.into()).unwrap_err();
1955 let error = error.downcast_ref::<DomainError>().unwrap();
1956 assert_eq!(error.code, ErrorCode::SubtitleModel);
1957 assert_eq!(engine.session.config.settings.subtitles.model, original);
1958 }
1959 }
1960
1961 #[test]
1962 fn device_failure_skips_backups_reconnects_refresh_and_random_fallback() {
1963 use crate::test_support::{Server, fake_mpv};
1964 use std::sync::atomic::{AtomicUsize, Ordering};
1965 let requests = Arc::new(AtomicUsize::new(0));
1966 let counter = requests.clone();
1967 let server = Server::new(move |_, _| {
1968 counter.fetch_add(1, Ordering::Relaxed);
1969 });
1970 let dir = tempfile::tempdir().unwrap();
1971 let mpv = fake_mpv(dir.path());
1972 for background in [false, true] {
1973 let data = dir.path().join(background.to_string());
1974 let mut config = crate::test_support::config_with_api(&data, &server.url);
1975 config.settings.mpv = mpv.to_string_lossy().into_owned();
1976 config.settings.audio_device = Some("test/fail".into());
1977 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1978 engine.session.background_media = background;
1979 let station = Station {
1980 stationuuid: uuid::Uuid::new_v4().to_string(),
1981 name: "Catalog station".into(),
1982 url: format!("{}/live", server.url),
1983 active: true,
1984 ..Station::default()
1985 };
1986 engine.session.store.upsert(&station).unwrap();
1987 engine
1988 .session
1989 .store
1990 .add_backup(&station.stationuuid, &format!("{}/backup", server.url))
1991 .unwrap();
1992 engine.play(&station.stationuuid).unwrap();
1993 engine.playback.random_filter = Some(Filter::default());
1994 engine.playback.session_started = true;
1995 let deadline = Instant::now() + Duration::from_secs(3);
1996 while !engine.session.playback_failed {
1997 engine.tick().unwrap();
1998 assert!(
1999 Instant::now() < deadline,
2000 "{}",
2001 engine.session.status.message
2002 );
2003 std::thread::sleep(Duration::from_millis(10));
2004 }
2005 let error = engine.playback_error().unwrap();
2006 assert_eq!(error.code, ErrorCode::AudioDeviceFailed);
2007 assert_eq!(error.params["device"], "test/fail");
2008 assert_eq!(engine.playback.tried.len(), 1);
2009 assert!(!engine.playback_active());
2010 assert!(!engine.playback.refreshed);
2011 assert!(engine.playback.reconnect_window.is_empty());
2012 engine.shutdown().unwrap();
2013 }
2014 assert_eq!(requests.load(Ordering::Relaxed), 0);
2015 let commands = std::fs::read_to_string(mpv.with_extension("commands")).unwrap();
2016 assert_eq!(
2017 commands
2018 .lines()
2019 .filter(|s| s.contains("\"loadfile\""))
2020 .count(),
2021 2
2022 );
2023 }
2024
2025 #[test]
2026 fn background_player_startup_preserves_dependency_failure() {
2027 let dir = tempfile::tempdir().unwrap();
2028 let mut config = crate::test_support::config(dir.path());
2029 config.settings.mpv = dir
2030 .path()
2031 .join("missing-mpv")
2032 .to_string_lossy()
2033 .into_owned();
2034 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2035 engine.enable_background_media().unwrap();
2036 engine.play("https://example.com/live").unwrap();
2037 let deadline = Instant::now() + Duration::from_secs(3);
2038 while !engine.session.playback_failed {
2039 engine.tick().unwrap();
2040 assert!(Instant::now() < deadline);
2041 std::thread::sleep(Duration::from_millis(10));
2042 }
2043 assert_eq!(
2044 engine.playback_error().unwrap().code,
2045 ErrorCode::MissingDependency
2046 );
2047 assert!(!engine.playback_active());
2048 }
2049
2050 #[test]
2051 fn failed_recording_finalization_keeps_the_previous_playback_source_kind() {
2052 use crate::test_support::{Server, config, fixture, response};
2053 let bytes = fixture("libmp3lame", "mp3");
2054 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
2055 let dir = tempfile::tempdir().unwrap();
2056 let mut engine = Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
2057 let station = Station {
2058 stationuuid: uuid::Uuid::new_v4().to_string(),
2059 name: "Saved station".into(),
2060 url: server.url.clone(),
2061 active: true,
2062 custom: true,
2063 ..Station::default()
2064 };
2065 engine.session.store.upsert(&station).unwrap();
2066 engine.session.status.station = Some(station.clone());
2067 engine.session.status.playback_state = PlaybackState::Playing;
2068 engine.playback.url = server.url.clone();
2069 engine.record_current(None, None).unwrap();
2070 let conn = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
2071 conn.execute_batch("CREATE TRIGGER reject_recording_update BEFORE UPDATE ON recordings BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
2072 assert!(engine.play("https://example.com/audition").is_err());
2073 assert_eq!(
2074 engine.session.status.station.as_ref().unwrap().stationuuid,
2075 station.stationuuid
2076 );
2077 assert_eq!(engine.playback.source_kind, playback::SourceKind::Catalog);
2078 }
2079
2080 #[test]
2081 fn recording_track_is_snapshotted_before_probe_and_stays_stable() {
2082 use crate::test_support::{Server, config, fixture, response};
2083 let bytes = fixture("libmp3lame", "mp3");
2084 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
2085 for background in [false, true] {
2086 for title in [
2087 "Björk / 中文\x1b\n".to_owned(),
2088 String::new(),
2089 "曲".repeat(100),
2090 ] {
2091 let dir = tempfile::tempdir().unwrap();
2092 let mut engine =
2093 Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
2094 if background {
2095 engine.enable_background_media().unwrap();
2096 }
2097 let station = Station {
2098 stationuuid: uuid::Uuid::new_v4().to_string(),
2099 name: if title.starts_with('曲') {
2100 "台".repeat(60)
2101 } else {
2102 "Station".into()
2103 },
2104 url: server.url.clone(),
2105 custom: true,
2106 active: true,
2107 ..Station::default()
2108 };
2109 engine.session.store.upsert(&station).unwrap();
2110 engine.session.status.station = Some(station);
2111 engine.session.status.playback_state = PlaybackState::Playing;
2112 engine.session.status.title = title.clone();
2113 engine.playback.url = server.url.clone();
2114 engine
2115 .record_current(Some(Duration::from_secs(1)), None)
2116 .unwrap();
2117 engine.session.status.title = "Next track".into();
2118 let deadline = Instant::now() + Duration::from_secs(8);
2119 while engine.session.status.recording_path.is_empty() {
2120 engine.tick().unwrap();
2121 assert!(
2122 Instant::now() < deadline,
2123 "{}",
2124 engine.session.status.message
2125 );
2126 std::thread::sleep(Duration::from_millis(10));
2127 }
2128 let record = engine.session.store.recordings(1).unwrap().remove(0);
2129 let expected = crate::clean_text(&title).trim().to_owned();
2130 assert_eq!(
2131 record.track.as_deref(),
2132 (!expected.is_empty()).then_some(expected.as_str())
2133 );
2134 let final_path = record.final_path.clone().unwrap();
2135 let name = std::path::Path::new(&record.path)
2136 .file_name()
2137 .unwrap()
2138 .to_str()
2139 .unwrap();
2140 assert!(name.len() + ".json.tmp".len() <= 255);
2141 if title.starts_with("Björk") {
2142 assert!(name.contains("-Station-Björk_中文-"));
2143 }
2144 if title.is_empty() {
2145 assert!(name.contains("-Station-"));
2146 }
2147 while engine.session.status.recording()
2148 || engine.session.status.recording_state == RecordingState::Finalizing
2149 {
2150 engine.tick().unwrap();
2151 assert!(
2152 Instant::now() < deadline,
2153 "{}",
2154 engine.session.status.message
2155 );
2156 std::thread::sleep(Duration::from_millis(10));
2157 }
2158 let saved = engine.session.store.recording(&record.id).unwrap();
2159 assert_eq!(saved.status, "complete", "{:?}", saved.error);
2160 assert_eq!(saved.path, final_path);
2161 assert_eq!(saved.track, record.track);
2162 let sidecar: crate::model::Recording =
2163 serde_json::from_slice(&std::fs::read(format!("{}.json", saved.path)).unwrap())
2164 .unwrap();
2165 assert_eq!(sidecar.track, saved.track);
2166 let reopened = Store::open(&dir.path().join("radio.db")).unwrap();
2167 assert_eq!(reopened.recording(&record.id).unwrap().track, saved.track);
2168 }
2169 }
2170 }
2171
2172 #[test]
2173 fn changing_station_clears_finished_recording_status() {
2174 let dir = tempfile::tempdir().unwrap();
2175 let config = crate::test_support::config(dir.path());
2176 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2177 for state in [
2178 RecordingState::Done,
2179 RecordingState::Failed {
2180 reason: "disk".into(),
2181 },
2182 ] {
2183 engine.session.status.recording_state = state;
2184 engine.session.status.recording_path = "old.mp3".into();
2185 engine.session.status.recording_ms = 1000;
2186 assert!(
2188 engine
2189 .playback
2190 .play_source(
2191 &mut engine.session,
2192 &mut engine.recording,
2193 Station::default(),
2194 vec![],
2195 playback::SourceKind::Catalog
2196 )
2197 .is_err()
2198 );
2199 assert_eq!(engine.session.status.recording_state, RecordingState::Idle);
2200 assert!(engine.session.status.recording_path.is_empty());
2201 assert_eq!(engine.session.status.recording_ms, 0);
2202 }
2203 }
2204
2205 #[test]
2206 fn flapping_reconnects_have_a_sliding_window_limit() {
2207 let dir = tempfile::tempdir().unwrap();
2208 let config = crate::test_support::config(dir.path());
2209 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2210 engine.session.status.station = Some(Station {
2211 custom: true,
2212 ..Station::default()
2213 });
2214 engine.playback.session_started = true;
2215 engine.playback.reconnect_window = std::iter::repeat_n(Instant::now(), 6).collect();
2216 engine
2217 .playback
2218 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2219 .unwrap();
2220 assert!(engine.session.playback_failed);
2221 assert!(!engine.session.status.muted);
2222 assert_eq!(engine.playback.reconnect_attempts, 0);
2223 assert!(engine.playback.reconnect_window.is_empty());
2224 assert!(engine.playback.reconnect_due.is_none());
2225 let failed_state = engine.session.status.playback_state.clone();
2226 for _ in 0..3 {
2227 engine.tick().unwrap();
2228 assert!(engine.session.playback_failed);
2229 assert_eq!(engine.session.status.playback_state, failed_state);
2230 assert!(!engine.playback_active());
2231 }
2232 engine.playback.reconnect_window =
2233 std::iter::repeat_n(Instant::now() - Duration::from_secs(61), 6).collect();
2234 engine
2235 .playback
2236 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2237 .unwrap();
2238 assert!(engine.playback.reconnect_due.is_some());
2239 assert_eq!(engine.playback.reconnect_window.len(), 1);
2240 }
2241
2242 #[test]
2243 fn reconnect_budget_is_bounded_and_stop_cancels_it() {
2244 let dir = tempfile::tempdir().unwrap();
2245 let config = crate::test_support::config(dir.path());
2246 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
2247 engine.session.status.station = Some(Station {
2248 custom: true,
2249 name: "Test".into(),
2250 ..Station::default()
2251 });
2252 engine.session.status.muted = true;
2253 engine.playback.session_started = true;
2254 for delay in [1, 3, 7] {
2255 engine
2256 .playback
2257 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2258 .unwrap();
2259 let remaining = engine
2260 .playback
2261 .reconnect_due
2262 .unwrap()
2263 .saturating_duration_since(Instant::now());
2264 assert!(remaining <= Duration::from_secs(delay));
2265 assert!(remaining > Duration::from_millis(delay * 1000 - 100));
2266 assert!(!engine.session.playback_failed);
2267 }
2268 engine.playback.reconnect_due = None;
2269 engine
2270 .playback
2271 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2272 .unwrap();
2273 assert!(engine.session.playback_failed);
2274 assert!(!engine.session.status.muted);
2275 assert_eq!(engine.playback.reconnect_attempts, 0);
2276 assert!(engine.playback.reconnect_window.is_empty());
2277 assert!(engine.playback.reconnect_due.is_none());
2278 engine.playback.reconnect_attempts = 0;
2279 engine
2280 .playback
2281 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
2282 .unwrap();
2283 engine.session.status.muted = true;
2284 engine.stop_playback().unwrap();
2285 assert!(!engine.session.status.muted);
2286 assert_eq!(engine.playback.reconnect_attempts, 0);
2287 assert!(engine.playback.reconnect_window.is_empty());
2288 assert!(engine.playback.reconnect_due.is_none());
2289 let generation = engine.playback.generation;
2290 engine.tick().unwrap();
2291 assert_eq!(engine.playback.generation, generation);
2292 assert!(engine.playback.player.is_none() && engine.playback.player_start.is_none());
2293 }
2294}