100 lines
2.9 KiB
Rust
100 lines
2.9 KiB
Rust
use covers::create_cover_server;
|
|
use database::{establish_connection, initialize_database};
|
|
use library::LibraryService;
|
|
use music::player::AudioPlayer;
|
|
use player::PlayerService;
|
|
use proto::library::library_server::LibraryServer;
|
|
use proto::player::player_server::PlayerServer;
|
|
use proto::settings::settings_server::SettingsServer;
|
|
use rodio::{OutputStream, Sink};
|
|
use state::{GrooveState, GrooveStateData};
|
|
use std::sync::Arc;
|
|
use tokio::sync::Mutex;
|
|
use tonic::transport::Server;
|
|
|
|
pub mod checksum;
|
|
pub mod covers;
|
|
pub mod database;
|
|
pub mod library;
|
|
pub mod music;
|
|
pub mod player;
|
|
pub mod settings;
|
|
pub mod state;
|
|
|
|
use settings::SettingsService;
|
|
|
|
pub mod proto {
|
|
pub mod settings {
|
|
tonic::include_proto!("settings");
|
|
}
|
|
pub mod library {
|
|
tonic::include_proto!("library");
|
|
}
|
|
pub mod player {
|
|
tonic::include_proto!("player");
|
|
}
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
let pool = &mut establish_connection();
|
|
|
|
let connection = pool.get().unwrap();
|
|
|
|
initialize_database(&connection).expect("Error initializing database");
|
|
|
|
let address = "[::1]:39993".parse()?;
|
|
|
|
let (_stream, stream_handle) =
|
|
OutputStream::try_default().expect("Error getting audio output stream");
|
|
let sink = Sink::try_new(&stream_handle).expect("Error getting audio sink");
|
|
|
|
let player = Arc::new(Mutex::new(AudioPlayer::new(sink)));
|
|
let c_player = player.clone();
|
|
|
|
let (watch_handle, mut rx) = player.lock().await.start_watching();
|
|
|
|
let player_rx_handle = tokio::spawn(async move {
|
|
while let Some(next) = rx.recv().await {
|
|
let mut player = player.lock().await;
|
|
match next {
|
|
Some(queued_track) => {
|
|
let _ = player
|
|
.play_track(queued_track.track, queued_track.path, false)
|
|
.await;
|
|
}
|
|
None => {
|
|
player.clear().await;
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
let state = GrooveState::new(Mutex::new(GrooveStateData::new(c_player)));
|
|
|
|
let settings = SettingsService::new(state.clone(), pool.clone());
|
|
let library = LibraryService::new(state.clone(), pool.clone());
|
|
let player_service = PlayerService::new(state, pool.clone());
|
|
|
|
let cover_server_handle = tokio::spawn(async move {
|
|
create_cover_server()
|
|
.await
|
|
.expect("Error creating cover server");
|
|
});
|
|
|
|
Server::builder()
|
|
.accept_http1(true)
|
|
.layer(tower_http::cors::CorsLayer::permissive())
|
|
.add_service(tonic_web::enable(SettingsServer::new(settings)))
|
|
.add_service(tonic_web::enable(LibraryServer::new(library)))
|
|
.add_service(tonic_web::enable(PlayerServer::new(player_service)))
|
|
.serve(address)
|
|
.await?;
|
|
|
|
let _ = cover_server_handle.await;
|
|
let _ = watch_handle.await;
|
|
let _ = player_rx_handle.await;
|
|
|
|
Ok(())
|
|
}
|