2023-03-10 14:35:18 +00:00
|
|
|
use crate::{
|
|
|
|
database::MusicIndex,
|
|
|
|
media::{TrackId, TrackInfo},
|
|
|
|
playback::{Playback, PlaybackControl, PlaybackStatus},
|
|
|
|
scanner::MusicScanner,
|
|
|
|
Error, FatalError,
|
|
|
|
};
|
|
|
|
use flow::{ok, return_error, Flow};
|
|
|
|
use gstreamer::{format::ClockTime, prelude::*, MessageView};
|
2023-02-11 17:59:15 +00:00
|
|
|
use std::{
|
|
|
|
sync::{
|
|
|
|
mpsc::{channel, Receiver, RecvTimeoutError, Sender},
|
2023-03-10 14:35:18 +00:00
|
|
|
Arc, Mutex,
|
2023-02-11 17:59:15 +00:00
|
|
|
},
|
|
|
|
thread,
|
|
|
|
thread::JoinHandle,
|
|
|
|
time::{Duration, Instant},
|
|
|
|
};
|
|
|
|
|
2023-02-26 03:17:00 +00:00
|
|
|
fn scan_frequency() -> Duration {
|
|
|
|
Duration::from_secs(60)
|
2023-02-11 17:59:15 +00:00
|
|
|
}
|
|
|
|
|
2023-03-10 14:35:18 +00:00
|
|
|
#[derive(Clone)]
|
2023-02-11 17:59:15 +00:00
|
|
|
pub enum ControlMsg {
|
2023-03-10 14:35:18 +00:00
|
|
|
PlayTrack(TrackId),
|
2023-02-11 17:59:15 +00:00
|
|
|
Exit,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub enum TrackMsg {
|
2023-02-26 03:17:00 +00:00
|
|
|
UpdateInProgress,
|
|
|
|
UpdateComplete,
|
2023-02-11 17:59:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
pub enum PlaybackMsg {
|
|
|
|
PositionUpdate,
|
|
|
|
Playing,
|
|
|
|
Pausing,
|
|
|
|
Stopping,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct Core {
|
|
|
|
db: Arc<dyn MusicIndex>,
|
2023-03-10 14:35:18 +00:00
|
|
|
scanner: Arc<dyn MusicScanner>,
|
|
|
|
control_rx: Receiver<ControlMsg>,
|
|
|
|
|
|
|
|
playback_controller: Playback,
|
2023-02-11 17:59:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Core {
|
2023-02-26 03:17:00 +00:00
|
|
|
pub fn new(
|
|
|
|
db: Arc<dyn MusicIndex>,
|
2023-03-10 14:35:18 +00:00
|
|
|
scanner: Arc<dyn MusicScanner>,
|
|
|
|
) -> Flow<(Core, CoreAPI), FatalError, Error> {
|
2023-02-11 17:59:15 +00:00
|
|
|
let (control_tx, control_rx) = channel::<ControlMsg>();
|
2023-02-26 03:17:00 +00:00
|
|
|
let db = db;
|
2023-02-11 17:59:15 +00:00
|
|
|
|
2023-03-10 14:35:18 +00:00
|
|
|
let playback_controller = Playback::new();
|
|
|
|
|
|
|
|
ok((
|
|
|
|
Core {
|
|
|
|
db,
|
|
|
|
scanner,
|
|
|
|
control_rx,
|
|
|
|
playback_controller,
|
|
|
|
},
|
|
|
|
CoreAPI {
|
|
|
|
control_tx: Arc::new(Mutex::new(control_tx)),
|
|
|
|
},
|
|
|
|
))
|
|
|
|
}
|
|
|
|
|
|
|
|
pub fn start(&self) -> Flow<(), FatalError, Error> {
|
|
|
|
gstreamer::init();
|
|
|
|
let (scanner_tx, _scanner_rx) = channel();
|
|
|
|
let mut next_scan = Instant::now();
|
|
|
|
loop {
|
|
|
|
if Instant::now() >= next_scan {
|
|
|
|
let scan_start = Instant::now();
|
|
|
|
let _ = scanner_tx.send(TrackMsg::UpdateInProgress);
|
|
|
|
for track in self.scanner.scan() {
|
|
|
|
match track {
|
|
|
|
Ok(track) => self.db.add_track(track),
|
|
|
|
Err(_) => ok(()),
|
|
|
|
};
|
2023-02-26 03:17:00 +00:00
|
|
|
}
|
2023-03-10 14:35:18 +00:00
|
|
|
let _ = scanner_tx.send(TrackMsg::UpdateComplete);
|
|
|
|
next_scan = Instant::now() + scan_frequency();
|
|
|
|
println!("scan duration: {:?}", Instant::now() - scan_start);
|
|
|
|
}
|
|
|
|
match self.control_rx.recv_timeout(Duration::from_millis(1000)) {
|
|
|
|
Ok(ControlMsg::PlayTrack(id)) => {
|
|
|
|
let _ = self.play_track(id);
|
|
|
|
}
|
|
|
|
Ok(ControlMsg::Exit) => return ok(()),
|
|
|
|
Err(RecvTimeoutError::Timeout) => (),
|
|
|
|
Err(RecvTimeoutError::Disconnected) => return ok(()),
|
|
|
|
}
|
|
|
|
}
|
2023-02-11 17:59:15 +00:00
|
|
|
}
|
|
|
|
|
2023-02-26 03:17:00 +00:00
|
|
|
pub fn list_tracks<'a>(&'a self) -> Flow<Vec<TrackInfo>, FatalError, Error> {
|
|
|
|
self.db.list_tracks().map_err(Error::DatabaseError)
|
|
|
|
}
|
|
|
|
|
2023-03-10 14:35:18 +00:00
|
|
|
pub fn play_track<'a>(&'a self, id: TrackId) -> Flow<(), FatalError, Error> {
|
2023-02-11 17:59:15 +00:00
|
|
|
/*
|
2023-03-10 14:35:18 +00:00
|
|
|
println!("play_track: {}", id.as_ref());
|
|
|
|
let pipeline = return_error!(Flow::from(
|
|
|
|
gstreamer::parse_launch(&format!("playbin uri={}", id.as_str()))
|
|
|
|
.map_err(|err| Error::CannotPlay(err.to_string()),)
|
|
|
|
));
|
|
|
|
return_error!(Flow::from(
|
|
|
|
pipeline
|
|
|
|
.set_state(gstreamer::State::Playing)
|
|
|
|
.map_err(|err| Error::CannotPlay(err.to_string()))
|
|
|
|
));
|
|
|
|
{
|
|
|
|
let pipeline = pipeline.clone();
|
|
|
|
thread::spawn(move || {
|
|
|
|
println!("starting");
|
|
|
|
let bus = pipeline.bus().unwrap();
|
|
|
|
for msg in bus.iter_timed(gstreamer::ClockTime::NONE) {
|
|
|
|
match msg.view() {
|
|
|
|
MessageView::Eos(_) => (),
|
|
|
|
MessageView::Error(err) => {
|
|
|
|
println!(
|
|
|
|
"Error from {:?}: {} ({:?})",
|
|
|
|
err.src().map(|s| s.path_string()),
|
|
|
|
err.error(),
|
|
|
|
err.debug()
|
|
|
|
);
|
|
|
|
}
|
|
|
|
msg => println!("{:?}", msg),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
2023-02-11 17:59:15 +00:00
|
|
|
*/
|
2023-03-10 14:35:18 +00:00
|
|
|
self.playback_controller.play_track(id);
|
|
|
|
ok(())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct CoreAPI {
|
|
|
|
control_tx: Arc<Mutex<Sender<ControlMsg>>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl CoreAPI {
|
|
|
|
pub fn play_track(&self, id: TrackId) -> () {
|
|
|
|
self.control_tx
|
|
|
|
.lock()
|
|
|
|
.unwrap()
|
|
|
|
.send(ControlMsg::PlayTrack(id))
|
|
|
|
.unwrap()
|
2023-02-11 17:59:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
2023-02-26 03:17:00 +00:00
|
|
|
mod test {
|
|
|
|
use super::*;
|
2023-03-02 04:54:23 +00:00
|
|
|
use crate::{database::MemoryIndex, media::TrackId, scanner::factories::MockScanner};
|
2023-02-26 03:17:00 +00:00
|
|
|
use std::collections::HashSet;
|
|
|
|
|
|
|
|
fn with_example_index<F>(f: F)
|
|
|
|
where
|
|
|
|
F: Fn(Core),
|
|
|
|
{
|
|
|
|
let index = MemoryIndex::new();
|
|
|
|
let scanner = MockScanner::new();
|
2023-03-10 14:35:18 +00:00
|
|
|
match Core::new(Arc::new(index), Arc::new(scanner)) {
|
|
|
|
Flow::Ok((core, api)) => {
|
2023-02-26 03:17:00 +00:00
|
|
|
thread::sleep(Duration::from_millis(10));
|
|
|
|
f(core)
|
|
|
|
}
|
|
|
|
Flow::Err(error) => panic!("{:?}", error),
|
|
|
|
Flow::Fatal(error) => panic!("{:?}", error),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn it_lists_tracks() {
|
|
|
|
with_example_index(|core| match core.list_tracks() {
|
|
|
|
Flow::Ok(tracks) => {
|
|
|
|
let track_ids = tracks
|
|
|
|
.iter()
|
|
|
|
.map(|t| t.id.clone())
|
|
|
|
.collect::<HashSet<TrackId>>();
|
|
|
|
assert_eq!(track_ids.len(), 5);
|
|
|
|
assert_eq!(
|
|
|
|
track_ids,
|
|
|
|
HashSet::from([
|
|
|
|
TrackId::from("/home/savanni/Track 1.mp3".to_owned()),
|
|
|
|
TrackId::from("/home/savanni/Track 2.mp3".to_owned()),
|
|
|
|
TrackId::from("/home/savanni/Track 3.mp3".to_owned()),
|
|
|
|
TrackId::from("/home/savanni/Track 4.mp3".to_owned()),
|
|
|
|
TrackId::from("/home/savanni/Track 5.mp3".to_owned()),
|
|
|
|
])
|
|
|
|
);
|
|
|
|
}
|
|
|
|
Flow::Fatal(err) => panic!("fatal error: {:?}", err),
|
|
|
|
Flow::Err(err) => panic!("error: {:?}", err),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|