1pub(crate) mod artwork;
2mod playback;
3mod recording;
4mod status;
5use playback::PlaybackController;
6use recording::RecordingController;
7pub use status::{PlaybackState, RecordingState};
8
9use crate::error::{DomainError, ErrorCode};
10use crate::{
11 config::Config,
12 directory::Directory,
13 model::{Filter, Station},
14 player::{Event, Player},
15 process::{Background, MediaLock},
16 recorder::{self, Recorder},
17 store::Store,
18};
19use anyhow::{Context, Result, bail};
20use std::{
21 collections::VecDeque,
22 sync::{Arc, atomic::AtomicBool},
23 time::{Duration, Instant},
24};
25
26#[derive(Debug, Clone, PartialEq, Eq)]
27pub struct Status {
28 pub station: Option<Station>,
29 pub title: String,
30 pub message: String,
31 pub playback_state: PlaybackState,
32 pub volume: u8,
33 pub muted: bool,
34 pub recording_state: RecordingState,
35 pub recording_ms: u64,
36 pub recording_path: String,
37 pub source_url: String,
38}
39
40impl Status {
41 pub(crate) fn control_eq(&self, other: &Self) -> bool {
42 self.station == other.station
43 && self.title == other.title
44 && self.message == other.message
45 && self.playback_state == other.playback_state
46 && self.recording_state == other.recording_state
47 && self.volume == other.volume
48 && self.muted == other.muted
49 && self.recording_path == other.recording_path
50 && self.source_url == other.source_url
51 }
52 pub(crate) fn ui_eq(&self, other: &Self) -> bool {
53 self.control_eq(other) && self.recording_ms / 1000 == other.recording_ms / 1000
54 }
55 pub fn playing(&self) -> bool {
56 matches!(
57 self.playback_state,
58 PlaybackState::Playing | PlaybackState::Paused
59 )
60 }
61 pub fn paused(&self) -> bool {
62 self.playback_state == PlaybackState::Paused
63 }
64 pub fn recording(&self) -> bool {
65 matches!(
66 self.recording_state,
67 RecordingState::Probing | RecordingState::Recording
68 )
69 }
70}
71
72pub struct Engine {
73 session: Session,
74 playback: PlaybackController,
75 recording: RecordingController,
76}
77
78pub struct Session {
80 pub(crate) artwork: artwork::Controller,
81 pub config: Config,
82 pub store: Store,
83 pub directory: Directory,
84 pub status: Status,
85 pub stop: Arc<AtomicBool>,
86 pub(crate) _lock: Arc<MediaLock>,
87 pub(crate) background_media: bool,
88 pub(crate) diagnostics: Option<Background<(serde_json::Value, bool)>>,
89 pub(crate) library_task: Option<Background<String>>,
90 pub playback_failed: bool,
91}
92
93impl std::ops::Deref for Engine {
94 type Target = Session;
95 fn deref(&self) -> &Session {
96 &self.session
97 }
98}
99impl std::ops::DerefMut for Engine {
100 fn deref_mut(&mut self) -> &mut Session {
101 &mut self.session
102 }
103}
104
105impl Engine {
106 pub fn bootstrap(&mut self) -> Result<usize> {
107 self.session.directory.bootstrap(&mut self.session.store)
108 }
109 pub fn new(mut config: Config, stop: Arc<AtomicBool>) -> Result<Self> {
110 let lock = MediaLock::acquire(&config.runtime_dir)?;
111 let store = Store::open(&config.data_dir.join("radio.db"))?;
112 if let Some(volume) = store
113 .meta("pref_volume")?
114 .and_then(|v| v.parse::<u8>().ok())
115 .filter(|v| *v <= 100)
116 {
117 config.settings.volume = volume;
118 }
119 let recovery_warnings = recorder::recover(&store)?;
120 let directory = Directory::new(&config, stop.clone())?;
121 let status = Status {
122 station: None,
123 title: String::new(),
124 message: if recovery_warnings.is_empty() {
125 crate::t!("status_ready").into()
126 } else {
127 recovery_warnings.join("\n")
128 },
129 playback_state: PlaybackState::Idle,
130 volume: config.settings.volume,
131 muted: false,
132 recording_state: RecordingState::Idle,
133 recording_ms: 0,
134 recording_path: String::new(),
135 source_url: String::new(),
136 };
137 Ok(Self {
138 session: Session {
139 artwork: artwork::Controller::default(),
140 config,
141 store,
142 directory,
143 status,
144 stop,
145 _lock: Arc::new(lock),
146 background_media: false,
147 diagnostics: None,
148 library_task: None,
149 playback_failed: false,
150 },
151 playback: PlaybackController {
152 generation: 0,
153 refresh_task: None,
154 click_task: None,
155 player: None,
156 player_start: None,
157 retiring: vec![],
158 url: String::new(),
159 candidates: VecDeque::new(),
160 tried: vec![],
161 refreshed: false,
162 confirmed: false,
163 session_started: false,
164 source_kind: playback::SourceKind::Catalog,
165 local_recording_id: None,
166 reconnect_attempts: 0,
167 reconnect_due: None,
168 reconnect_window: VecDeque::new(),
169 started: Instant::now(),
170 random_filter: None,
171 random_tried: vec![],
172 failure: None,
173 },
174 recording: RecordingController {
175 recording_probe: None,
176 retiring_probes: vec![],
177 finalizing: None,
178 recorder: None,
179 },
180 })
181 }
182
183 pub fn play(&mut self, uuid: &str) -> Result<()> {
184 let result = self
185 .playback
186 .play(&mut self.session, &mut self.recording, uuid);
187 if let Err(error) = &result
188 && !self.playback_active()
189 {
190 self.status.playback_state = PlaybackState::Failed {
191 reason: format!("{error:#}"),
192 };
193 }
194 result
195 }
196
197 pub fn resume_last_station(&mut self) -> Result<()> {
198 self.playback
199 .resume_last_station(&mut self.session, &mut self.recording)
200 }
201
202 pub fn play_recording(&mut self, id: &str) -> Result<()> {
203 let result = self
204 .playback
205 .play_recording(&mut self.session, &mut self.recording, id);
206 if let Err(error) = &result
207 && !self.playback_active()
208 {
209 self.status.playback_state = PlaybackState::Failed {
210 reason: format!("{error:#}"),
211 };
212 }
213 result
214 }
215
216 pub fn random(&mut self, filter: Filter) -> Result<()> {
217 let result = self
218 .playback
219 .random(&mut self.session, &mut self.recording, filter);
220 if let Err(error) = &result
221 && !self.playback_active()
222 {
223 self.status.playback_state = PlaybackState::Failed {
224 reason: format!("{error:#}"),
225 };
226 }
227 result
228 }
229
230 pub fn tick(&mut self) -> Result<()> {
231 self.poll_background()?;
232 self.playback.tick(&mut self.session, &mut self.recording)?;
233 self.recording
234 .recording_tick(&mut self.session, &mut self.playback)?;
235 self.artwork_tick();
236 Ok(())
237 }
238
239 fn artwork_tick(&mut self) {
240 let request = (self.background_media
241 && self.config.settings.artwork == crate::config::ArtworkMode::Track
242 && self.status.playback_state == PlaybackState::Playing
243 && !matches!(
244 self.status.recording_state,
245 RecordingState::Probing | RecordingState::Recording | RecordingState::Finalizing
246 )
247 && self.playback.source_kind != playback::SourceKind::Local
248 && self.playback.retiring.is_empty()
249 && self.recording.retiring_probes.is_empty()
250 && !self.status.title.is_empty())
251 .then(|| self.status.station.as_ref())
252 .flatten()
253 .filter(|station| {
254 station.hls == 0 && self.artwork.demand.as_deref() == Some(station.stationuuid.as_str())
255 })
256 .filter(|_| crate::config::validate_url(&self.status.source_url).is_ok())
257 .map(|station| artwork::Request {
258 stationuuid: station.stationuuid.clone(),
259 source_url: self.status.source_url.clone(),
260 title: self.status.title.clone(),
261 });
262 let session = &mut self.session;
263 session.artwork.update(&session.config, request);
264 }
265
266 pub fn pause(&mut self) -> Result<()> {
267 self.playback.pause(&mut self.session, &mut self.recording)
268 }
269 pub fn mute(&mut self) -> Result<()> {
270 self.playback
271 .player
272 .as_mut()
273 .context(DomainError::new(ErrorCode::NotPlaying))?
274 .toggle_mute()
275 }
276
277 pub fn volume(&mut self, delta: i32) -> Result<()> {
278 self.playback
279 .volume(&mut self.session, &mut self.recording, delta)
280 }
281
282 pub fn stop_playback(&mut self) -> Result<()> {
283 self.playback
284 .stop_playback(&mut self.session, &mut self.recording)
285 }
286
287 pub fn toggle_recording(&mut self) -> Result<()> {
288 let result = self
289 .recording
290 .toggle_recording(&mut self.session, &mut self.playback);
291 if let Err(error) = &result
292 && self.recording.recorder.is_none()
293 && self.recording.recording_probe.is_none()
294 && self.recording.finalizing.is_none()
295 {
296 self.status.recording_state = RecordingState::Failed {
297 reason: format!("{error:#}"),
298 };
299 }
300 result
301 }
302
303 pub fn record_current(
304 &mut self,
305 duration: Option<Duration>,
306 dir: Option<&std::path::Path>,
307 ) -> Result<()> {
308 let result =
309 self.recording
310 .record_current(&mut self.session, &mut self.playback, duration, dir);
311 if let Err(error) = &result
312 && self.recording.recorder.is_none()
313 && self.recording.recording_probe.is_none()
314 && self.recording.finalizing.is_none()
315 {
316 self.status.recording_state = RecordingState::Failed {
317 reason: format!("{error:#}"),
318 };
319 }
320 result
321 }
322
323 pub fn standalone_record(
324 &mut self,
325 uuid: &str,
326 duration: Option<Duration>,
327 dir: Option<&std::path::Path>,
328 ) -> Result<()> {
329 let result = self.recording.standalone_record(
330 &mut self.session,
331 &mut self.playback,
332 uuid,
333 duration,
334 dir,
335 );
336 if let Err(error) = &result
337 && self.recording.recorder.is_none()
338 && self.recording.recording_probe.is_none()
339 && self.recording.finalizing.is_none()
340 {
341 self.status.recording_state = RecordingState::Failed {
342 reason: format!("{error:#}"),
343 };
344 }
345 result
346 }
347
348 pub fn stop_recording(&mut self, reason: Option<&str>) -> Result<()> {
349 self.recording
350 .stop_recording(&mut self.session, &mut self.playback, reason)
351 }
352
353 pub(crate) fn enable_background_media(&mut self) {
354 self.background_media = true;
355 }
356
357 pub fn delete_recording(&mut self, id: String, index_only: bool) -> Result<()> {
358 if self.library_task.is_some() {
359 bail!(DomainError::new(ErrorCode::RecordingBusy));
360 }
361 if self.playback.local_recording_id.as_deref() == Some(&id) {
362 self.stop_playback()?;
363 }
364 let path = self.config.data_dir.join("radio.db");
365 let lock = self._lock.clone();
366 self.library_task = Some(Background::start(
367 "radio-recording-delete",
368 move |cancel| {
369 let _lock = lock;
370 if cancel.load(std::sync::atomic::Ordering::Relaxed) {
371 bail!(DomainError::new(ErrorCode::Cancelled));
372 }
373 crate::service::delete_recording(&Store::open(&path)?, &id, index_only)?;
374 Ok(crate::t!("recording_deleted", "id" => id))
375 },
376 )?);
377 Ok(())
378 }
379
380 pub fn open_recordings(&mut self) -> Result<()> {
381 if self.library_task.is_some() {
382 bail!(DomainError::new(ErrorCode::RecordingBusy));
383 }
384 let dir = self.config.recording_dir.clone();
385 self.library_task = Some(Background::start("radio-open-recordings", move |cancel| {
386 crate::service::open_recordings(&dir, &cancel)?;
387 Ok(crate::t!("recordings_opened", "path" => dir.display()))
388 })?);
389 Ok(())
390 }
391
392 pub fn playback_active(&self) -> bool {
393 self.playback.player.is_some()
394 || self.playback.player_start.is_some()
395 || self.playback.refresh_task.is_some()
396 || self.playback.reconnect_due.is_some()
397 }
398
399 pub fn playback_error(&self) -> Option<&DomainError> {
400 self.playback.failure.as_ref()
401 }
402
403 pub fn shutdown(&mut self) -> Result<()> {
404 self.stop_playback()?;
405 self.playback.click_task = None;
406 self.diagnostics = None;
407 let deadline = Instant::now() + Duration::from_secs(6);
410 while (self.recording.finalizing.is_some()
411 || !self.playback.retiring.is_empty()
412 || !self.recording.retiring_probes.is_empty()
413 || !self.artwork.quiescent())
414 && Instant::now() < deadline
415 {
416 self.poll_background()?;
417 std::thread::sleep(Duration::from_millis(10));
418 }
419 self.recording.finalizing = None;
420 Ok(())
421 }
422
423 fn poll_background(&mut self) -> Result<()> {
424 if let Some(result) = self.library_task.as_ref().and_then(Background::poll) {
425 self.library_task = None;
426 self.status.message = match result {
427 Ok(message) => message,
428 Err(error) => {
429 crate::t!("recording_operation_failed", "error" => format!("{error:#}"))
430 }
431 };
432 }
433 self.playback
434 .poll_background(&mut self.session, &mut self.recording)?;
435 self.recording
436 .record_poll_background(&mut self.session, &mut self.playback)
437 }
438}
439
440impl Drop for Engine {
441 fn drop(&mut self) {
442 let _ = self.shutdown();
443 }
444}
445
446#[cfg(test)]
447mod tests {
448 use super::*;
449
450 #[test]
451 fn device_failure_skips_backups_reconnects_refresh_and_random_fallback() {
452 use crate::test_support::{Server, fake_mpv};
453 use std::sync::atomic::{AtomicUsize, Ordering};
454 let requests = Arc::new(AtomicUsize::new(0));
455 let counter = requests.clone();
456 let server = Server::new(move |_, _| {
457 counter.fetch_add(1, Ordering::Relaxed);
458 });
459 let dir = tempfile::tempdir().unwrap();
460 let mpv = fake_mpv(dir.path());
461 for background in [false, true] {
462 let data = dir.path().join(background.to_string());
463 let mut config = Config::load(None, Some(&data), Some(&server.url)).unwrap();
464 config.prepare().unwrap();
465 config.settings.mpv = mpv.to_string_lossy().into_owned();
466 config.settings.audio_device = Some("test/fail".into());
467 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
468 engine.session.background_media = background;
469 let station = Station {
470 stationuuid: uuid::Uuid::new_v4().to_string(),
471 name: "Catalog station".into(),
472 url: format!("{}/live", server.url),
473 active: true,
474 ..Station::default()
475 };
476 engine.store.upsert(&station).unwrap();
477 engine
478 .store
479 .add_backup(&station.stationuuid, &format!("{}/backup", server.url))
480 .unwrap();
481 engine.play(&station.stationuuid).unwrap();
482 engine.playback.random_filter = Some(Filter::default());
483 engine.playback.session_started = true;
484 let deadline = Instant::now() + Duration::from_secs(3);
485 while !engine.playback_failed {
486 engine.tick().unwrap();
487 assert!(Instant::now() < deadline, "{}", engine.status.message);
488 std::thread::sleep(Duration::from_millis(10));
489 }
490 let error = engine.playback_error().unwrap();
491 assert_eq!(error.code, ErrorCode::AudioDeviceFailed);
492 assert_eq!(error.params["device"], "test/fail");
493 assert_eq!(engine.playback.tried.len(), 1);
494 assert!(!engine.playback_active());
495 assert!(!engine.playback.refreshed);
496 assert!(engine.playback.reconnect_window.is_empty());
497 engine.shutdown().unwrap();
498 }
499 assert_eq!(requests.load(Ordering::Relaxed), 0);
500 let commands = std::fs::read_to_string(mpv.with_extension("commands")).unwrap();
501 assert_eq!(
502 commands
503 .lines()
504 .filter(|s| s.contains("\"loadfile\""))
505 .count(),
506 2
507 );
508 }
509
510 #[test]
511 fn background_player_startup_preserves_dependency_failure() {
512 let dir = tempfile::tempdir().unwrap();
513 let mut config = crate::test_support::config(dir.path());
514 config.settings.mpv = dir
515 .path()
516 .join("missing-mpv")
517 .to_string_lossy()
518 .into_owned();
519 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
520 engine.enable_background_media();
521 engine.play("https://example.com/live").unwrap();
522 let deadline = Instant::now() + Duration::from_secs(3);
523 while !engine.playback_failed {
524 engine.tick().unwrap();
525 assert!(Instant::now() < deadline);
526 std::thread::sleep(Duration::from_millis(10));
527 }
528 assert_eq!(
529 engine.playback_error().unwrap().code,
530 ErrorCode::MissingDependency
531 );
532 assert!(!engine.playback_active());
533 }
534
535 #[test]
536 fn failed_recording_finalization_keeps_the_previous_playback_source_kind() {
537 use crate::test_support::{Server, config, fixture, response};
538 let bytes = fixture("libmp3lame", "mp3");
539 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
540 let dir = tempfile::tempdir().unwrap();
541 let mut engine = Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
542 let station = Station {
543 stationuuid: uuid::Uuid::new_v4().to_string(),
544 name: "Saved station".into(),
545 url: server.url.clone(),
546 active: true,
547 custom: true,
548 ..Station::default()
549 };
550 engine.store.upsert(&station).unwrap();
551 engine.status.station = Some(station.clone());
552 engine.status.playback_state = PlaybackState::Playing;
553 engine.playback.url = server.url.clone();
554 engine.record_current(None, None).unwrap();
555 let conn = rusqlite::Connection::open(dir.path().join("radio.db")).unwrap();
556 conn.execute_batch("CREATE TRIGGER reject_recording_update BEFORE UPDATE ON recordings BEGIN SELECT RAISE(ABORT, 'test failure'); END;").unwrap();
557 assert!(engine.play("https://example.com/audition").is_err());
558 assert_eq!(
559 engine.status.station.as_ref().unwrap().stationuuid,
560 station.stationuuid
561 );
562 assert_eq!(engine.playback.source_kind, playback::SourceKind::Catalog);
563 }
564
565 #[test]
566 fn recording_track_is_snapshotted_before_probe_and_stays_stable() {
567 use crate::test_support::{Server, config, fixture, response};
568 let bytes = fixture("libmp3lame", "mp3");
569 let server = Server::new(move |_, stream| response(stream, 200, "audio/mpeg", &bytes));
570 for background in [false, true] {
571 for title in [
572 "Björk / 中文\x1b\n".to_owned(),
573 String::new(),
574 "曲".repeat(100),
575 ] {
576 let dir = tempfile::tempdir().unwrap();
577 let mut engine =
578 Engine::new(config(dir.path()), Arc::new(AtomicBool::new(false))).unwrap();
579 if background {
580 engine.enable_background_media();
581 }
582 let station = Station {
583 stationuuid: uuid::Uuid::new_v4().to_string(),
584 name: if title.starts_with('曲') {
585 "台".repeat(60)
586 } else {
587 "Station".into()
588 },
589 url: server.url.clone(),
590 custom: true,
591 active: true,
592 ..Station::default()
593 };
594 engine.store.upsert(&station).unwrap();
595 engine.status.station = Some(station);
596 engine.status.playback_state = PlaybackState::Playing;
597 engine.status.title = title.clone();
598 engine.playback.url = server.url.clone();
599 engine
600 .record_current(Some(Duration::from_secs(1)), None)
601 .unwrap();
602 engine.status.title = "Next track".into();
603 let deadline = Instant::now() + Duration::from_secs(8);
604 while engine.status.recording_path.is_empty() {
605 engine.tick().unwrap();
606 assert!(Instant::now() < deadline, "{}", engine.status.message);
607 std::thread::sleep(Duration::from_millis(10));
608 }
609 let record = engine.store.recordings(1).unwrap().remove(0);
610 let expected = crate::clean_text(&title).trim().to_owned();
611 assert_eq!(
612 record.track.as_deref(),
613 (!expected.is_empty()).then_some(expected.as_str())
614 );
615 let final_path = record.final_path.clone().unwrap();
616 let name = std::path::Path::new(&record.path)
617 .file_name()
618 .unwrap()
619 .to_str()
620 .unwrap();
621 assert!(name.len() + ".json.tmp".len() <= 255);
622 if title.starts_with("Björk") {
623 assert!(name.contains("-Station-Björk_中文-"));
624 }
625 if title.is_empty() {
626 assert!(name.contains("-Station-"));
627 }
628 while engine.status.recording()
629 || engine.status.recording_state == RecordingState::Finalizing
630 {
631 engine.tick().unwrap();
632 assert!(Instant::now() < deadline, "{}", engine.status.message);
633 std::thread::sleep(Duration::from_millis(10));
634 }
635 let saved = engine.store.recording(&record.id).unwrap();
636 assert_eq!(saved.status, "complete", "{:?}", saved.error);
637 assert_eq!(saved.path, final_path);
638 assert_eq!(saved.track, record.track);
639 let sidecar: crate::model::Recording =
640 serde_json::from_slice(&std::fs::read(format!("{}.json", saved.path)).unwrap())
641 .unwrap();
642 assert_eq!(sidecar.track, saved.track);
643 let reopened = Store::open(&dir.path().join("radio.db")).unwrap();
644 assert_eq!(reopened.recording(&record.id).unwrap().track, saved.track);
645 }
646 }
647 }
648
649 #[test]
650 fn changing_station_clears_finished_recording_status() {
651 let dir = tempfile::tempdir().unwrap();
652 let config = Config::load(None, Some(dir.path()), Some("http://127.0.0.1:1")).unwrap();
653 config.prepare().unwrap();
654 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
655 for state in [
656 RecordingState::Done,
657 RecordingState::Failed {
658 reason: "disk".into(),
659 },
660 ] {
661 engine.status.recording_state = state;
662 engine.status.recording_path = "old.mp3".into();
663 engine.status.recording_ms = 1000;
664 assert!(
666 engine
667 .playback
668 .play_source(
669 &mut engine.session,
670 &mut engine.recording,
671 Station::default(),
672 vec![],
673 playback::SourceKind::Catalog
674 )
675 .is_err()
676 );
677 assert_eq!(engine.status.recording_state, RecordingState::Idle);
678 assert!(engine.status.recording_path.is_empty());
679 assert_eq!(engine.status.recording_ms, 0);
680 }
681 }
682
683 #[test]
684 fn flapping_reconnects_have_a_sliding_window_limit() {
685 let dir = tempfile::tempdir().unwrap();
686 let config = Config::load(None, Some(dir.path()), Some("http://127.0.0.1:1")).unwrap();
687 config.prepare().unwrap();
688 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
689 engine.status.station = Some(Station {
690 custom: true,
691 ..Station::default()
692 });
693 engine.playback.session_started = true;
694 engine.playback.reconnect_window = std::iter::repeat_n(Instant::now(), 6).collect();
695 engine
696 .playback
697 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
698 .unwrap();
699 assert!(engine.playback_failed);
700 assert!(!engine.status.muted);
701 assert_eq!(engine.playback.reconnect_attempts, 0);
702 assert!(engine.playback.reconnect_window.is_empty());
703 assert!(engine.playback.reconnect_due.is_none());
704 let failed_state = engine.status.playback_state.clone();
705 for _ in 0..3 {
706 engine.tick().unwrap();
707 assert!(engine.playback_failed);
708 assert_eq!(engine.status.playback_state, failed_state);
709 assert!(!engine.playback_active());
710 }
711 engine.playback.reconnect_window =
712 std::iter::repeat_n(Instant::now() - Duration::from_secs(61), 6).collect();
713 engine
714 .playback
715 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
716 .unwrap();
717 assert!(engine.playback.reconnect_due.is_some());
718 assert_eq!(engine.playback.reconnect_window.len(), 1);
719 }
720
721 #[test]
722 fn reconnect_budget_is_bounded_and_stop_cancels_it() {
723 let dir = tempfile::tempdir().unwrap();
724 let config = Config::load(None, Some(dir.path()), Some("http://127.0.0.1:1")).unwrap();
725 config.prepare().unwrap();
726 let mut engine = Engine::new(config, Arc::new(AtomicBool::new(false))).unwrap();
727 engine.status.station = Some(Station {
728 custom: true,
729 name: "Test".into(),
730 ..Station::default()
731 });
732 engine.status.muted = true;
733 engine.playback.session_started = true;
734 for delay in [1, 3, 7] {
735 engine
736 .playback
737 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
738 .unwrap();
739 let remaining = engine
740 .playback
741 .reconnect_due
742 .unwrap()
743 .saturating_duration_since(Instant::now());
744 assert!(remaining <= Duration::from_secs(delay));
745 assert!(remaining > Duration::from_millis(delay * 1000 - 100));
746 assert!(!engine.playback_failed);
747 }
748 engine.playback.reconnect_due = None;
749 engine
750 .playback
751 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
752 .unwrap();
753 assert!(engine.playback_failed);
754 assert!(!engine.status.muted);
755 assert_eq!(engine.playback.reconnect_attempts, 0);
756 assert!(engine.playback.reconnect_window.is_empty());
757 assert!(engine.playback.reconnect_due.is_none());
758 engine.playback.reconnect_attempts = 0;
759 engine
760 .playback
761 .stream_failed(&mut engine.session, &mut engine.recording, "EOF")
762 .unwrap();
763 engine.status.muted = true;
764 engine.stop_playback().unwrap();
765 assert!(!engine.status.muted);
766 assert_eq!(engine.playback.reconnect_attempts, 0);
767 assert!(engine.playback.reconnect_window.is_empty());
768 assert!(engine.playback.reconnect_due.is_none());
769 let generation = engine.playback.generation;
770 engine.tick().unwrap();
771 assert_eq!(engine.playback.generation, generation);
772 assert!(engine.playback.player.is_none() && engine.playback.player_start.is_none());
773 }
774}