1pub(crate) mod artwork;
2mod persistence;
3mod playback;
4mod recording;
5mod status;
6use playback::PlaybackController;
7use recording::RecordingController;
8pub use status::{PlaybackState, RecordingState};
9
10use crate::error::{DomainError, ErrorCode};
11use crate::{
12 config::Config,
13 directory::Directory,
14 model::{Filter, Station},
15 player::{Event, Player},
16 process::{Background, MediaLock},
17 recorder::{self, Recorder},
18 store::Store,
19};
20use anyhow::{Context, Result, bail};
21use std::{
22 collections::VecDeque,
23 sync::{Arc, atomic::AtomicBool},
24 time::{Duration, Instant},
25};
26
27#[derive(Debug, Clone, PartialEq)]
28pub struct Status {
29 pub station: Option<Station>,
30 pub title: String,
31 pub message: String,
32 pub playback_state: PlaybackState,
33 pub volume: u8,
34 pub muted: bool,
35 pub recording_state: RecordingState,
36 pub recording_ms: u64,
37 pub recording_path: String,
38 pub source_url: String,
39}
40
41impl Status {
42 pub(crate) fn control_eq(&self, other: &Self) -> bool {
43 self.station == other.station
44 && self.title == other.title
45 && self.message == other.message
46 && self.playback_state == other.playback_state
47 && self.recording_state == other.recording_state
48 && self.volume == other.volume
49 && self.muted == other.muted
50 && self.recording_path == other.recording_path
51 && self.source_url == other.source_url
52 }
53 pub(crate) fn ui_eq(&self, other: &Self) -> bool {
54 self.control_eq(other) && self.recording_ms / 1000 == other.recording_ms / 1000
55 }
56 pub fn playing(&self) -> bool {
57 matches!(
58 self.playback_state,
59 PlaybackState::Playing | PlaybackState::Paused
60 )
61 }
62 pub fn paused(&self) -> bool {
63 self.playback_state == PlaybackState::Paused
64 }
65 pub fn recording(&self) -> bool {
66 matches!(
67 self.recording_state,
68 RecordingState::Probing | RecordingState::Recording
69 )
70 }
71}
72
73pub struct Engine {
74 session: Session,
75 playback: PlaybackController,
76 recording: RecordingController,
77}
78
79pub(crate) struct Session {
81 persistence: Option<persistence::Writer>,
82 pub subtitles: crate::speech::Controller,
83 pub(crate) artwork: artwork::Controller,
84 pub config: Config,
85 pub store: Store,
86 pub directory: Directory,
87 pub status: Status,
88 pub stop: Arc<AtomicBool>,
89 pub(crate) _lock: Arc<MediaLock>,
90 pub(crate) background_media: bool,
91 pub(crate) diagnostics: Option<Background<(serde_json::Value, bool)>>,
92 pub(crate) library_task: Option<Background<String>>,
93 pub playback_failed: bool,
94}
95
96impl Session {
97 pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
98 if let Some(writer) = &self.persistence {
99 writer.preference(key, value)
100 } else {
101 self.store.set_meta(key, value)
102 }
103 }
104
105 fn remember_play(&self, uuid: &str) -> Result<()> {
106 if let Some(writer) = &self.persistence {
107 writer.played(uuid)
108 } else {
109 self.store.played(uuid)?;
110 self.store.set_meta("pref_last_station", uuid)
111 }
112 }
113}
114
115impl Engine {
116 pub fn status(&self) -> &Status {
117 &self.session.status
118 }
119
120 pub fn config(&self) -> &Config {
121 &self.session.config
122 }
123
124 pub fn store(&self) -> &Store {
125 &self.session.store
126 }
127
128 pub fn subtitles(&self) -> &crate::speech::Snapshot {
129 &self.session.subtitles.snapshot
130 }
131
132 pub fn playback_failed(&self) -> bool {
133 self.session.playback_failed
134 }
135
136 pub fn change_station(
138 &mut self,
139 command: crate::service::StationCommand,
140 ) -> Result<crate::service::StationChange> {
141 crate::service::change_station(&mut self.session.store, command)
142 }
143
144 pub fn toggle_favorite(&mut self, uuid: &str) -> Result<bool> {
146 self.session.store.toggle_favorite(uuid)
147 }
148
149 pub(crate) fn save_preference(&self, key: &str, value: &str) -> Result<()> {
150 self.session.save_preference(key, value)
151 }
152
153 pub(crate) fn set_language(&mut self, language: String) {
154 crate::messages::init(Some(&language), None);
155 self.session.config.settings.language = Some(language.clone());
156 self.session.status.message = crate::t!("language_set", "language" => language);
157 }
158
159 pub(crate) fn request_artwork(&mut self, station: Option<String>) {
160 self.session.artwork.demand = station;
161 }
162
163 pub(crate) fn track_artwork(&self) -> &Option<artwork::TrackArtwork> {
164 &self.session.artwork.cover
165 }
166
167 pub(crate) fn start_diagnostics(&mut self) -> Result<()> {
168 if self.session.diagnostics.is_some() {
169 bail!(crate::t!("diagnostics_busy"));
170 }
171 let config = self.session.config.clone();
172 self.session.diagnostics = Some(Background::start("radio-doctor", move |cancel| {
173 crate::service::doctor_report(&config, &cancel)
174 })?);
175 Ok(())
176 }
177
178 pub(crate) fn poll_diagnostics(&mut self) -> Option<Result<(serde_json::Value, bool)>> {
179 let result = self.session.diagnostics.as_ref()?.poll()?;
180 self.session.diagnostics = None;
181 Some(result)
182 }
183
184 pub(crate) fn stop(&mut self) -> Result<()> {
185 self.stop_playback()?;
186 self.session.status.message = crate::t!("playback_stopped").into();
187 Ok(())
188 }
189
190 #[cfg(test)]
191 pub(crate) fn test_session(&mut self) -> &mut Session {
192 &mut self.session
193 }
194
195 pub fn bootstrap(&mut self) -> Result<usize> {
196 self.session.directory.bootstrap(&mut self.session.store)
197 }
198
199 pub fn sync(&mut self, progress: impl FnMut(usize)) -> Result<usize> {
201 self.sync_with_policy(progress, false)
202 }
203
204 pub fn sync_with_policy(
207 &mut self,
208 progress: impl FnMut(usize),
209 accept_shrink: bool,
210 ) -> Result<usize> {
211 self.session
212 .directory
213 .sync_with_policy(&mut self.session.store, progress, accept_shrink)
214 }
215
216 pub fn refresh_station(&mut self, uuid: &str) -> Result<Option<Station>> {
218 self.session.directory.refresh(uuid)
219 }
220
221 pub fn report_click(&mut self, uuid: &str) -> Result<()> {
223 self.session.directory.click(uuid)
224 }
225 pub fn new(mut config: Config, stop: Arc<AtomicBool>) -> Result<Self> {
226 let lock = MediaLock::acquire(&config.runtime_dir)?;
227 let store = Store::open(&config.data_dir.join("radio.db"))?;
228 if let Some(volume) = store
229 .meta("pref_volume")?
230 .and_then(|v| v.parse::<u8>().ok())
231 .filter(|v| *v <= 100)
232 {
233 config.settings.volume = volume;
234 }
235 let recovery_warnings = recorder::recover(&store)?;
236 let directory = Directory::new(&config, stop.clone())?;
237 let status = Status {
238 station: None,
239 title: String::new(),
240 message: if recovery_warnings.is_empty() {
241 crate::t!("status_ready").into()
242 } else {
243 recovery_warnings.join("\n")
244 },
245 playback_state: PlaybackState::Idle,
246 volume: config.settings.volume,
247 muted: false,
248 recording_state: RecordingState::Idle,
249 recording_ms: 0,
250 recording_path: String::new(),
251 source_url: String::new(),
252 };
253 Ok(Self {
254 session: Session {
255 persistence: None,
256 subtitles: crate::speech::Controller::default(),
257 artwork: artwork::Controller::default(),
258 config,
259 store,
260 directory,
261 status,
262 stop,
263 _lock: Arc::new(lock),
264 background_media: false,
265 diagnostics: None,
266 library_task: None,
267 playback_failed: false,
268 },
269 playback: PlaybackController {
270 generation: 0,
271 refresh_task: None,
272 click_task: None,
273 player: None,
274 player_start: None,
275 retiring: vec![],
276 url: String::new(),
277 candidates: VecDeque::new(),
278 tried: vec![],
279 refreshed: false,
280 confirmed: false,
281 session_started: false,
282 source_kind: playback::SourceKind::Catalog,
283 local_recording_id: None,
284 reconnect_attempts: 0,
285 reconnect_due: None,
286 reconnect_window: VecDeque::new(),
287 started: Instant::now(),
288 random_filter: None,
289 random_tried: vec![],
290 failure: None,
291 },
292 recording: RecordingController {
293 recording_probe: None,
294 retiring_probes: vec![],
295 finalizing: None,
296 recorder: None,
297 },
298 })
299 }
300
301 pub fn play(&mut self, uuid: &str) -> Result<()> {
302 let result = self
303 .playback
304 .play(&mut self.session, &mut self.recording, uuid);
305 if let Err(error) = &result
306 && !self.playback_active()
307 {
308 self.session.status.playback_state = PlaybackState::Failed {
309 reason: format!("{error:#}"),
310 };
311 }
312 result
313 }
314
315 pub fn resume_last_station(&mut self) -> Result<()> {
316 self.playback
317 .resume_last_station(&mut self.session, &mut self.recording)
318 }
319
320 pub fn play_recording(&mut self, id: &str) -> Result<()> {
321 let result = self
322 .playback
323 .play_recording(&mut self.session, &mut self.recording, id);
324 if let Err(error) = &result
325 && !self.playback_active()
326 {
327 self.session.status.playback_state = PlaybackState::Failed {
328 reason: format!("{error:#}"),
329 };
330 }
331 result
332 }
333
334 pub fn random(&mut self, filter: Filter) -> Result<()> {
335 let result = self
336 .playback
337 .random(&mut self.session, &mut self.recording, filter);
338 if let Err(error) = &result
339 && !self.playback_active()
340 {
341 self.session.status.playback_state = PlaybackState::Failed {
342 reason: format!("{error:#}"),
343 };
344 }
345 result
346 }
347
348 pub fn tick(&mut self) -> Result<()> {
349 self.poll_background()?;
350 self.playback.tick(&mut self.session, &mut self.recording)?;
351 self.recording
352 .recording_tick(&mut self.session, &mut self.playback)?;
353 self.subtitle_tick();
354 self.artwork_tick();
355 Ok(())
356 }
357
358 fn subtitle_tick(&mut self) {
359 if !self.session.background_media {
360 return;
361 }
362 if self.session.subtitles.snapshot.enabled && !self.session.artwork.quiescent() {
363 self.session.artwork.cancel();
364 return;
365 }
366 let playing = self.session.status.playback_state == PlaybackState::Playing;
367 let paused = self.session.status.paused();
368 let local = self.playback.source_kind == playback::SourceKind::Local;
369 let generation = self.playback.generation;
370 let session = &mut self.session;
371 let key = (generation, session.status.source_url.as_str());
372 session
373 .subtitles
374 .update(&session.config, key, playing, paused, local, &session.stop);
375 }
376
377 pub fn set_subtitles(&mut self, enabled: bool) {
378 self.session.subtitles.enabled(enabled);
379 }
380 pub fn retry_subtitles(&mut self) {
381 self.session.subtitles.retry();
382 }
383 pub fn clear_subtitles(&mut self) {
384 self.session.subtitles.clear();
385 }
386 pub fn set_subtitle_model(&mut self, id: String) -> Result<()> {
387 crate::speech::validate_model(&id)?;
388 let mut settings = self.session.config.settings.subtitles.clone();
389 settings.model = id;
390 settings.validate()?;
391 self.session.config.settings.subtitles = settings;
392 self.session.subtitles.retry();
393 self.session.subtitles.clear();
394 Ok(())
395 }
396
397 fn artwork_tick(&mut self) {
398 let request = (self.session.background_media
399 && !self.session.subtitles.snapshot.enabled
400 && self.session.subtitles.quiescent()
401 && self.session.config.settings.artwork == crate::config::ArtworkMode::Track
402 && self.session.status.playback_state == PlaybackState::Playing
403 && !matches!(
404 self.session.status.recording_state,
405 RecordingState::Probing | RecordingState::Recording | RecordingState::Finalizing
406 )
407 && self.playback.source_kind != playback::SourceKind::Local
408 && self.playback.retiring.is_empty()
409 && self.recording.retiring_probes.is_empty()
410 && !self.session.status.title.is_empty())
411 .then_some(self.session.status.station.as_ref())
412 .flatten()
413 .filter(|station| {
414 station.hls == 0
415 && self.session.artwork.demand.as_deref() == Some(station.stationuuid.as_str())
416 })
417 .filter(|_| crate::config::validate_url(&self.session.status.source_url).is_ok())
418 .map(|station| artwork::Request {
419 stationuuid: station.stationuuid.clone(),
420 source_url: self.session.status.source_url.clone(),
421 title: self.session.status.title.clone(),
422 });
423 let session = &mut self.session;
424 session.artwork.update(&session.config, request);
425 }
426
427 pub fn pause(&mut self) -> Result<()> {
428 self.playback.pause(&mut self.session, &mut self.recording)
429 }
430 pub fn mute(&mut self) -> Result<()> {
431 self.playback
432 .player
433 .as_mut()
434 .context(DomainError::new(ErrorCode::NotPlaying))?
435 .toggle_mute()
436 }
437
438 pub fn volume(&mut self, delta: i32) -> Result<()> {
439 self.playback
440 .volume(&mut self.session, &mut self.recording, delta)
441 }
442
443 pub fn stop_playback(&mut self) -> Result<()> {
444 self.playback
445 .stop_playback(&mut self.session, &mut self.recording)
446 }
447
448 pub fn toggle_recording(&mut self) -> Result<()> {
449 let result = self
450 .recording
451 .toggle_recording(&mut self.session, &mut self.playback);
452 if let Err(error) = &result
453 && self.recording.recorder.is_none()
454 && self.recording.recording_probe.is_none()
455 && self.recording.finalizing.is_none()
456 {
457 self.session.status.recording_state = RecordingState::Failed {
458 reason: format!("{error:#}"),
459 };
460 }
461 result
462 }
463
464 pub fn record_current(
465 &mut self,
466 duration: Option<Duration>,
467 dir: Option<&std::path::Path>,
468 ) -> Result<()> {
469 let result =
470 self.recording
471 .record_current(&mut self.session, &mut self.playback, duration, dir);
472 if let Err(error) = &result
473 && self.recording.recorder.is_none()
474 && self.recording.recording_probe.is_none()
475 && self.recording.finalizing.is_none()
476 {
477 self.session.status.recording_state = RecordingState::Failed {
478 reason: format!("{error:#}"),
479 };
480 }
481 result
482 }
483
484 pub fn standalone_record(
485 &mut self,
486 uuid: &str,
487 duration: Option<Duration>,
488 dir: Option<&std::path::Path>,
489 ) -> Result<()> {
490 let result = self.recording.standalone_record(
491 &mut self.session,
492 &mut self.playback,
493 uuid,
494 duration,
495 dir,
496 );
497 if let Err(error) = &result
498 && self.recording.recorder.is_none()
499 && self.recording.recording_probe.is_none()
500 && self.recording.finalizing.is_none()
501 {
502 self.session.status.recording_state = RecordingState::Failed {
503 reason: format!("{error:#}"),
504 };
505 }
506 result
507 }
508
509 pub fn stop_recording(&mut self, reason: Option<&str>) -> Result<()> {
510 self.recording
511 .stop_recording(&mut self.session, &mut self.playback, reason)
512 }
513
514 pub(crate) fn enable_background_media(&mut self) -> Result<()> {
515 if self.session.persistence.is_none() {
516 self.session.persistence = Some(persistence::Writer::start(
517 self.session.config.data_dir.join("radio.db"),
518 self.session._lock.clone(),
519 )?);
520 }
521 self.session.background_media = true;
522 let enabled = self.session.config.settings.subtitles.enabled;
523 self.session.subtitles.enabled(enabled);
524 Ok(())
525 }
526
527 pub fn delete_recording(&mut self, id: String, index_only: bool) -> Result<()> {
528 if self.session.library_task.is_some() {
529 bail!(DomainError::new(ErrorCode::RecordingBusy));
530 }
531 if self.playback.local_recording_id.as_deref() == Some(&id) {
532 self.stop_playback()?;
533 }
534 let path = self.session.config.data_dir.join("radio.db");
535 let lock = self.session._lock.clone();
536 self.session.library_task = Some(Background::start(
537 "radio-recording-delete",
538 move |cancel| {
539 let _lock = lock;
540 if cancel.load(std::sync::atomic::Ordering::Relaxed) {
541 bail!(DomainError::new(ErrorCode::Cancelled));
542 }
543 crate::service::delete_recording(&Store::open(&path)?, &id, index_only)?;
544 Ok(crate::t!("recording_deleted", "id" => id))
545 },
546 )?);
547 Ok(())
548 }
549
550 pub fn open_recordings(&mut self) -> Result<()> {
551 if self.session.library_task.is_some() {
552 bail!(DomainError::new(ErrorCode::RecordingBusy));
553 }
554 let dir = self.session.config.recording_dir.clone();
555 self.session.library_task =
556 Some(Background::start("radio-open-recordings", move |cancel| {
557 crate::service::open_recordings(&dir, &cancel)?;
558 Ok(crate::t!("recordings_opened", "path" => dir.display()))
559 })?);
560 Ok(())
561 }
562
563 pub fn playback_active(&self) -> bool {
564 self.playback.player.is_some()
565 || self.playback.player_start.is_some()
566 || self.playback.refresh_task.is_some()
567 || self.playback.reconnect_due.is_some()
568 }
569
570 pub fn playback_error(&self) -> Option<&DomainError> {
571 self.playback.failure.as_ref()
572 }
573
574 pub fn shutdown(&mut self) -> Result<()> {
575 self.shutdown_with_budget(Duration::from_secs(6))
576 }
577
578 fn shutdown_with_budget(&mut self, budget: Duration) -> Result<()> {
579 let mut failure = self.stop_playback().err();
580 self.session.subtitles.enabled(false);
581 self.playback.click_task = None;
582 self.session.diagnostics = None;
583 self.session.library_task = None;
584 let deadline = Instant::now() + budget;
585 if let Some(writer) = &self.session.persistence {
586 writer.close(deadline);
587 }
588 while (self.recording.finalizing.is_some()
591 || !self.playback.retiring.is_empty()
592 || !self.recording.retiring_probes.is_empty()
593 || !self.session.artwork.quiescent()
594 || !self.session.subtitles.quiescent()
595 || self
596 .session
597 .persistence
598 .as_ref()
599 .is_some_and(|writer| !writer.finished()))
600 && Instant::now() < deadline
601 {
602 if let Err(error) = self.poll_background() {
603 failure.get_or_insert(error);
604 }
605 std::thread::sleep(Duration::from_millis(10));
606 }
607 self.recording.finalizing = None;
608 if let Some(writer) = self.session.persistence.take()
609 && let Err(error) = writer.finish().context(crate::t!("session_save_failed"))
610 {
611 failure.get_or_insert(error);
612 }
613 failure.map_or(Ok(()), Err)
614 }
615
616 fn poll_background(&mut self) -> Result<()> {
617 if let Some(writer) = &self.session.persistence {
618 writer.poll().context(crate::t!("session_save_failed"))?;
619 }
620 self.session.subtitles.poll_retiring();
621 if let Some(result) = self
622 .session
623 .library_task
624 .as_ref()
625 .and_then(Background::poll)
626 {
627 self.session.library_task = None;
628 self.session.status.message = match result {
629 Ok(message) => message,
630 Err(error) => {
631 crate::t!("recording_operation_failed", "error" => format!("{error:#}"))
632 }
633 };
634 }
635 self.playback
636 .poll_background(&mut self.session, &mut self.recording)?;
637 self.recording
638 .record_poll_background(&mut self.session, &mut self.playback)
639 }
640}
641
642impl Drop for Engine {
643 fn drop(&mut self) {
644 let _ = self.shutdown();
645 }
646}
647
648#[cfg(test)]
649mod tests {
650 use super::*;
651
652 #[test]
653 fn background_media_preserves_the_lock_budget_for_catalog_writes() {
654 let dir = tempfile::tempdir().unwrap();
655 let config = crate::test_support::config(dir.path());
656 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
657 let station = crate::service::add_station(
658 &mut engine.session.store,
659 "Custom".into(),
660 "https://example.test/live".into(),
661 &[],
662 )
663 .unwrap();
664 engine.enable_background_media().unwrap();
665 for operation in 0..5 {
668 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
669 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
670 let release = std::thread::spawn(move || {
671 std::thread::sleep(Duration::from_millis(100));
672 connection.execute_batch("ROLLBACK").unwrap();
673 });
674 let result = match operation {
675 0 => engine.toggle_favorite(&station.stationuuid).map(|_| ()),
676 1 => engine
677 .change_station(crate::service::StationCommand::Backups {
678 uuid: station.stationuuid.clone(),
679 add: vec!["https://example.test/backup".into()],
680 remove: vec![],
681 })
682 .map(|_| ()),
683 2 => engine.store().upsert(&station),
684 3 => engine.store().save_recording(
685 &serde_json::from_value(serde_json::json!({
686 "id":"record", "stationuuid":station.stationuuid,
687 "station_name":station.name, "source_url_resolved":station.url,
688 "started_at":"2026-11-01T00:00:00Z", "codec":"mp3", "container":"mp3",
689 "path":"record.mp3", "size_bytes":0, "status":"recording"
690 }))
691 .unwrap(),
692 ),
693 4 => engine
694 .change_station(crate::service::StationCommand::Remove {
695 uuid: station.stationuuid.clone(),
696 keep_references: true,
697 })
698 .map(|_| ()),
699 _ => unreachable!(),
700 };
701 release.join().unwrap();
702 result.unwrap();
703 }
704 engine.shutdown().unwrap();
705 }
706
707 #[test]
708 fn background_session_writes_keep_controls_responsive_under_a_write_lock() {
709 let dir = tempfile::tempdir().unwrap();
710 let config = crate::test_support::config(dir.path());
711 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
712 let station = Station {
713 stationuuid: uuid::Uuid::new_v4().to_string(),
714 name: "Remembered".into(),
715 active: true,
716 ..Station::default()
717 };
718 engine.session.store.upsert(&station).unwrap();
719 engine.enable_background_media().unwrap();
720 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
721 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
722 let started = Instant::now();
723 for _ in 0..10 {
724 engine.volume(-1).unwrap();
725 }
726 engine.save_preference("pref_source", "favorites").unwrap();
727 engine.session.remember_play(&station.stationuuid).unwrap();
728 engine.stop_playback().unwrap();
729 engine.tick().unwrap();
730 assert!(started.elapsed() < Duration::from_millis(250));
731 assert_eq!(engine.session.status.volume, 70);
732 std::thread::sleep(Duration::from_millis(150));
734 engine.volume(-5).unwrap();
735 connection.execute_batch("ROLLBACK").unwrap();
736 engine.shutdown().unwrap();
738 assert_eq!(
739 engine.session.store.meta("pref_volume").unwrap().as_deref(),
740 Some("65")
741 );
742 assert_eq!(
743 engine.session.store.meta("pref_source").unwrap().as_deref(),
744 Some("favorites")
745 );
746 assert_eq!(
747 engine
748 .session
749 .store
750 .meta("pref_last_station")
751 .unwrap()
752 .as_deref(),
753 Some(station.stationuuid.as_str())
754 );
755 assert_eq!(
756 engine
757 .session
758 .store
759 .search_count(&Filter {
760 history: true,
761 ..Filter::default()
762 })
763 .unwrap(),
764 1
765 );
766 }
767
768 #[test]
769 fn background_session_write_failures_are_reported() {
770 let dir = tempfile::tempdir().unwrap();
771 let config = crate::test_support::config(dir.path());
772 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
773 engine
774 .session
775 .store
776 .test_connection()
777 .execute_batch(
778 "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
779 BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
780 )
781 .unwrap();
782 engine.enable_background_media().unwrap();
783 engine.volume(-1).unwrap();
784 let deadline = Instant::now() + Duration::from_secs(3);
785 loop {
786 if let Err(error) = engine.tick() {
787 assert!(format!("{error:#}").contains("preference denied"));
788 break;
789 }
790 assert!(Instant::now() < deadline);
791 std::thread::sleep(Duration::from_millis(10));
792 }
793 assert!(engine.shutdown().is_err());
794 assert!(engine.session.persistence.is_none());
795 engine.shutdown().unwrap();
796 }
797
798 #[test]
799 fn shutdown_drains_finalization_after_a_session_write_failure() {
800 let dir = tempfile::tempdir().unwrap();
801 let config = crate::test_support::config(dir.path());
802 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
803 engine
804 .store()
805 .test_connection()
806 .execute_batch(
807 "CREATE TRIGGER deny_preferences BEFORE INSERT ON meta
808 BEGIN SELECT RAISE(ABORT,'preference denied'); END;",
809 )
810 .unwrap();
811 engine.enable_background_media().unwrap();
812 engine.volume(-1).unwrap();
813 let (completed, receive) = std::sync::mpsc::channel();
814 engine.recording.finalizing = Some(
815 Background::start("test-finalization", move |_| {
816 std::thread::sleep(Duration::from_millis(150));
817 completed.send(()).unwrap();
818 bail!("finalization fixture");
819 })
820 .unwrap(),
821 );
822 let error = engine.shutdown().unwrap_err();
823 assert!(format!("{error:#}").contains("preference denied"));
824 receive
825 .try_recv()
826 .expect("finalization must finish before shutdown returns");
827 assert!(engine.recording.finalizing.is_none());
828 assert!(engine.session.persistence.is_none());
829 assert!(matches!(
830 engine.status().recording_state,
831 RecordingState::Failed { .. }
832 ));
833 engine.shutdown().unwrap();
834 }
835
836 #[test]
837 fn shutdown_stops_pending_writes_before_reporting_a_flush_timeout() {
838 let dir = tempfile::tempdir().unwrap();
839 let config = crate::test_support::config(dir.path());
840 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
841 engine.enable_background_media().unwrap();
842 let connection = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
843 connection.execute_batch("BEGIN IMMEDIATE").unwrap();
844 engine.volume(-1).unwrap();
845 let (cancelled, receive) = std::sync::mpsc::channel();
846 engine.recording.finalizing = Some(
847 Background::start("test-finalization", move |cancel| {
848 while !cancel.load(std::sync::atomic::Ordering::Relaxed) {
849 std::thread::sleep(Duration::from_millis(5));
850 }
851 cancelled.send(()).unwrap();
852 bail!("cancelled finalization fixture");
853 })
854 .unwrap(),
855 );
856 assert!(
857 engine
858 .shutdown_with_budget(Duration::from_millis(150))
859 .is_err()
860 );
861 assert!(engine.session.persistence.is_none());
862 assert!(engine.recording.finalizing.is_none());
863 receive.recv_timeout(Duration::from_secs(1)).unwrap();
864 connection.execute_batch("ROLLBACK").unwrap();
865 assert!(engine.store().meta("pref_volume").unwrap().is_none());
868 engine.shutdown().unwrap();
869 }
870
871 #[test]
872 fn invalid_subtitle_model_reports_id_without_changing_settings() {
873 let dir = tempfile::tempdir().unwrap();
874 let config = crate::test_support::config(dir.path());
875 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
876 let original = engine.session.config.settings.subtitles.model.clone();
877 for id in ["unknown", "silero-vad", "../../model"] {
878 let error = engine.set_subtitle_model(id.into()).unwrap_err();
879 let error = error.downcast_ref::<DomainError>().unwrap();
880 assert_eq!(error.code, ErrorCode::SubtitleModel);
881 assert_eq!(engine.session.config.settings.subtitles.model, original);
882 }
883 }
884
885 #[test]
886 fn device_failure_skips_backups_reconnects_refresh_and_random_fallback() {
887 use crate::test_support::{Server, fake_mpv};
888 use std::sync::atomic::{AtomicUsize, Ordering};
889 let requests = Arc::new(AtomicUsize::new(0));
890 let counter = requests.clone();
891 let server = Server::new(move |_, _| {
892 counter.fetch_add(1, Ordering::Relaxed);
893 });
894 let dir = tempfile::tempdir().unwrap();
895 let mpv = fake_mpv(dir.path());
896 for background in [false, true] {
897 let data = dir.path().join(background.to_string());
898 let mut config = crate::test_support::config_with_api(&data, &server.url);
899 config.settings.mpv = mpv.to_string_lossy().into_owned();
900 config.settings.audio_device = Some("test/fail".into());
901 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
902 engine.session.background_media = background;
903 let station = Station {
904 stationuuid: uuid::Uuid::new_v4().to_string(),
905 name: "Catalog station".into(),
906 url: format!("{}/live", server.url),
907 active: true,
908 ..Station::default()
909 };
910 engine.session.store.upsert(&station).unwrap();
911 engine
912 .session
913 .store
914 .add_backup(&station.stationuuid, &format!("{}/backup", server.url))
915 .unwrap();
916 engine.play(&station.stationuuid).unwrap();
917 engine.playback.random_filter = Some(Filter::default());
918 engine.playback.session_started = true;
919 let deadline = Instant::now() + Duration::from_secs(3);
920 while !engine.session.playback_failed {
921 engine.tick().unwrap();
922 assert!(
923 Instant::now() < deadline,
924 "{}",
925 engine.session.status.message
926 );
927 std::thread::sleep(Duration::from_millis(10));
928 }
929 let error = engine.playback_error().unwrap();
930 assert_eq!(error.code, ErrorCode::AudioDeviceFailed);
931 assert_eq!(error.params["device"], "test/fail");
932 assert_eq!(engine.playback.tried.len(), 1);
933 assert!(!engine.playback_active());
934 assert!(!engine.playback.refreshed);
935 assert!(engine.playback.reconnect_window.is_empty());
936 engine.shutdown().unwrap();
937 }
938 assert_eq!(requests.load(Ordering::Relaxed), 0);
939 let commands = std::fs::read_to_string(mpv.with_extension("commands")).unwrap();
940 assert_eq!(
941 commands
942 .lines()
943 .filter(|s| s.contains("\"loadfile\""))
944 .count(),
945 2
946 );
947 }
948
949 #[test]
950 fn background_player_startup_preserves_dependency_failure() {
951 let dir = tempfile::tempdir().unwrap();
952 let mut config = crate::test_support::config(dir.path());
953 config.settings.mpv = dir
954 .path()
955 .join("missing-mpv")
956 .to_string_lossy()
957 .into_owned();
958 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
959 engine.enable_background_media().unwrap();
960 engine.play("https://example.com/live").unwrap();
961 let deadline = Instant::now() + Duration::from_secs(3);
962 while !engine.session.playback_failed {
963 engine.tick().unwrap();
964 assert!(Instant::now() < deadline);
965 std::thread::sleep(Duration::from_millis(10));
966 }
967 assert_eq!(
968 engine.playback_error().unwrap().code,
969 ErrorCode::MissingDependency
970 );
971 assert!(!engine.playback_active());
972 }
973
974 #[test]
975 fn failed_recording_finalization_keeps_the_previous_playback_source_kind() {
976 use crate::test_support::{Server, config, fixture, response};
977 let bytes = fixture("libmp3lame", "mp3");
978 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
979 let dir = tempfile::tempdir().unwrap();
980 let mut engine = Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
981 let station = Station {
982 stationuuid: uuid::Uuid::new_v4().to_string(),
983 name: "Saved station".into(),
984 url: server.url.clone(),
985 active: true,
986 custom: true,
987 ..Station::default()
988 };
989 engine.session.store.upsert(&station).unwrap();
990 engine.session.status.station = Some(station.clone());
991 engine.session.status.playback_state = PlaybackState::Playing;
992 engine.playback.url = server.url.clone();
993 engine.record_current(None, None).unwrap();
994 let conn = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
995 conn.execute_batch("CREATE TRIGGER reject_recording_update BEFORE UPDATE ON recordings BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
996 assert!(engine.play("https://example.com/audition").is_err());
997 assert_eq!(
998 engine.session.status.station.as_ref().unwrap().stationuuid,
999 station.stationuuid
1000 );
1001 assert_eq!(engine.playback.source_kind, playback::SourceKind::Catalog);
1002 }
1003
1004 #[test]
1005 fn recording_track_is_snapshotted_before_probe_and_stays_stable() {
1006 use crate::test_support::{Server, config, fixture, response};
1007 let bytes = fixture("libmp3lame", "mp3");
1008 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
1009 for background in [false, true] {
1010 for title in [
1011 "Björk / 中文\x1b\n".to_owned(),
1012 String::new(),
1013 "曲".repeat(100),
1014 ] {
1015 let dir = tempfile::tempdir().unwrap();
1016 let mut engine =
1017 Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
1018 if background {
1019 engine.enable_background_media().unwrap();
1020 }
1021 let station = Station {
1022 stationuuid: uuid::Uuid::new_v4().to_string(),
1023 name: if title.starts_with('曲') {
1024 "台".repeat(60)
1025 } else {
1026 "Station".into()
1027 },
1028 url: server.url.clone(),
1029 custom: true,
1030 active: true,
1031 ..Station::default()
1032 };
1033 engine.session.store.upsert(&station).unwrap();
1034 engine.session.status.station = Some(station);
1035 engine.session.status.playback_state = PlaybackState::Playing;
1036 engine.session.status.title = title.clone();
1037 engine.playback.url = server.url.clone();
1038 engine
1039 .record_current(Some(Duration::from_secs(1)), None)
1040 .unwrap();
1041 engine.session.status.title = "Next track".into();
1042 let deadline = Instant::now() + Duration::from_secs(8);
1043 while engine.session.status.recording_path.is_empty() {
1044 engine.tick().unwrap();
1045 assert!(
1046 Instant::now() < deadline,
1047 "{}",
1048 engine.session.status.message
1049 );
1050 std::thread::sleep(Duration::from_millis(10));
1051 }
1052 let record = engine.session.store.recordings(1).unwrap().remove(0);
1053 let expected = crate::clean_text(&title).trim().to_owned();
1054 assert_eq!(
1055 record.track.as_deref(),
1056 (!expected.is_empty()).then_some(expected.as_str())
1057 );
1058 let final_path = record.final_path.clone().unwrap();
1059 let name = std::path::Path::new(&record.path)
1060 .file_name()
1061 .unwrap()
1062 .to_str()
1063 .unwrap();
1064 assert!(name.len() + ".json.tmp".len() <= 255);
1065 if title.starts_with("Björk") {
1066 assert!(name.contains("-Station-Björk_中文-"));
1067 }
1068 if title.is_empty() {
1069 assert!(name.contains("-Station-"));
1070 }
1071 while engine.session.status.recording()
1072 || engine.session.status.recording_state == RecordingState::Finalizing
1073 {
1074 engine.tick().unwrap();
1075 assert!(
1076 Instant::now() < deadline,
1077 "{}",
1078 engine.session.status.message
1079 );
1080 std::thread::sleep(Duration::from_millis(10));
1081 }
1082 let saved = engine.session.store.recording(&record.id).unwrap();
1083 assert_eq!(saved.status, "complete", "{:?}", saved.error);
1084 assert_eq!(saved.path, final_path);
1085 assert_eq!(saved.track, record.track);
1086 let sidecar: crate::model::Recording =
1087 serde_json::from_slice(&std::fs::read(format!("{}.json", saved.path)).unwrap())
1088 .unwrap();
1089 assert_eq!(sidecar.track, saved.track);
1090 let reopened = Store::open(&dir.path().join("radio.db")).unwrap();
1091 assert_eq!(reopened.recording(&record.id).unwrap().track, saved.track);
1092 }
1093 }
1094 }
1095
1096 #[test]
1097 fn changing_station_clears_finished_recording_status() {
1098 let dir = tempfile::tempdir().unwrap();
1099 let config = crate::test_support::config(dir.path());
1100 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1101 for state in [
1102 RecordingState::Done,
1103 RecordingState::Failed {
1104 reason: "disk".into(),
1105 },
1106 ] {
1107 engine.session.status.recording_state = state;
1108 engine.session.status.recording_path = "old.mp3".into();
1109 engine.session.status.recording_ms = 1000;
1110 assert!(
1112 engine
1113 .playback
1114 .play_source(
1115 &mut engine.session,
1116 &mut engine.recording,
1117 Station::default(),
1118 vec![],
1119 playback::SourceKind::Catalog
1120 )
1121 .is_err()
1122 );
1123 assert_eq!(engine.session.status.recording_state, RecordingState::Idle);
1124 assert!(engine.session.status.recording_path.is_empty());
1125 assert_eq!(engine.session.status.recording_ms, 0);
1126 }
1127 }
1128
1129 #[test]
1130 fn flapping_reconnects_have_a_sliding_window_limit() {
1131 let dir = tempfile::tempdir().unwrap();
1132 let config = crate::test_support::config(dir.path());
1133 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1134 engine.session.status.station = Some(Station {
1135 custom: true,
1136 ..Station::default()
1137 });
1138 engine.playback.session_started = true;
1139 engine.playback.reconnect_window = std::iter::repeat_n(Instant::now(), 6).collect();
1140 engine
1141 .playback
1142 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1143 .unwrap();
1144 assert!(engine.session.playback_failed);
1145 assert!(!engine.session.status.muted);
1146 assert_eq!(engine.playback.reconnect_attempts, 0);
1147 assert!(engine.playback.reconnect_window.is_empty());
1148 assert!(engine.playback.reconnect_due.is_none());
1149 let failed_state = engine.session.status.playback_state.clone();
1150 for _ in 0..3 {
1151 engine.tick().unwrap();
1152 assert!(engine.session.playback_failed);
1153 assert_eq!(engine.session.status.playback_state, failed_state);
1154 assert!(!engine.playback_active());
1155 }
1156 engine.playback.reconnect_window =
1157 std::iter::repeat_n(Instant::now() - Duration::from_secs(61), 6).collect();
1158 engine
1159 .playback
1160 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1161 .unwrap();
1162 assert!(engine.playback.reconnect_due.is_some());
1163 assert_eq!(engine.playback.reconnect_window.len(), 1);
1164 }
1165
1166 #[test]
1167 fn reconnect_budget_is_bounded_and_stop_cancels_it() {
1168 let dir = tempfile::tempdir().unwrap();
1169 let config = crate::test_support::config(dir.path());
1170 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
1171 engine.session.status.station = Some(Station {
1172 custom: true,
1173 name: "Test".into(),
1174 ..Station::default()
1175 });
1176 engine.session.status.muted = true;
1177 engine.playback.session_started = true;
1178 for delay in [1, 3, 7] {
1179 engine
1180 .playback
1181 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1182 .unwrap();
1183 let remaining = engine
1184 .playback
1185 .reconnect_due
1186 .unwrap()
1187 .saturating_duration_since(Instant::now());
1188 assert!(remaining <= Duration::from_secs(delay));
1189 assert!(remaining > Duration::from_millis(delay * 1000 - 100));
1190 assert!(!engine.session.playback_failed);
1191 }
1192 engine.playback.reconnect_due = None;
1193 engine
1194 .playback
1195 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1196 .unwrap();
1197 assert!(engine.session.playback_failed);
1198 assert!(!engine.session.status.muted);
1199 assert_eq!(engine.playback.reconnect_attempts, 0);
1200 assert!(engine.playback.reconnect_window.is_empty());
1201 assert!(engine.playback.reconnect_due.is_none());
1202 engine.playback.reconnect_attempts = 0;
1203 engine
1204 .playback
1205 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
1206 .unwrap();
1207 engine.session.status.muted = true;
1208 engine.stop_playback().unwrap();
1209 assert!(!engine.session.status.muted);
1210 assert_eq!(engine.playback.reconnect_attempts, 0);
1211 assert!(engine.playback.reconnect_window.is_empty());
1212 assert!(engine.playback.reconnect_due.is_none());
1213 let generation = engine.playback.generation;
1214 engine.tick().unwrap();
1215 assert_eq!(engine.playback.generation, generation);
1216 assert!(engine.playback.player.is_none() && engine.playback.player_start.is_none());
1217 }
1218}