arabianq/pipewire-soundpad
1
0
Fork 0
mirror of https://github.com/arabianq/pipewire-soundpad.git synced 2026-04-28 14:31:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: first attemp to support playing multiple tracks in parallel

Browse Source
This commit is contained in:
Tarasov Aleksandr
2026-01-24 22:18:42 +03:00
parent c1c8deb1b3
commit 3e6a8b6e79
12 changed files with 673 additions and 351 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/utils/gui.rs
+24 -42
View File
@@ -1,6 +1,6 @@
use crate::{
types::{
audio_player::PlayerState,
audio_player::{PlayerState, TrackInfo},
config::GuiConfig,
gui::AudioPlayerState,
socket::{Request, Response},
@@ -50,56 +50,47 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
wait_for_daemon().await.ok();
let state_req = Request::get_state();
let file_path_req = Request::get_current_file_path();
let tracks_req = Request::get_tracks();
let is_paused_req = Request::get_is_paused();
let volume_req = Request::get_volume();
let position_req = Request::get_position();
let duration_req = Request::get_duration();
let current_input_req = Request::get_input();
let all_inputs_req = Request::get_inputs();
let looped_req = Request::get_loop();
let (
state_res,
file_path_res,
tracks_res,
is_paused_res,
volume_res,
position_res,
duration_res,
current_input_res,
all_inputs_res,
looped_res,
) = tokio::join!(
make_request(state_req),
make_request(file_path_req),
make_request(tracks_req),
make_request(is_paused_req),
make_request(volume_req),
make_request(position_req),
make_request(duration_req),
make_request(current_input_req),
make_request(all_inputs_req),
make_request(looped_req),
);
let state_res = state_res.unwrap_or_default();
let file_path_res = file_path_res.unwrap_or_default();
let tracks_res = tracks_res.unwrap_or_default();
let is_paused_res = is_paused_res.unwrap_or_default();
let volume_res = volume_res.unwrap_or_default();
let position_res = position_res.unwrap_or_default();
let duration_res = duration_res.unwrap_or_default();
let current_input_res = current_input_res.unwrap_or_default();
let all_inputs_res = all_inputs_res.unwrap_or_default();
let looped_res = looped_res.unwrap_or_default();
let state = match state_res.status {
true => serde_json::from_str::<PlayerState>(&state_res.message).unwrap(),
false => PlayerState::default(),
};
let file_path = match file_path_res.status {
true => PathBuf::from(file_path_res.message),
false => PathBuf::new(),
let tracks = match tracks_res.status {
true => {
serde_json::from_str::<Vec<TrackInfo>>(&tracks_res.message).unwrap_or_default()
}
false => vec![],
};
let is_paused = match is_paused_res.status {
true => is_paused_res.message == "true",
false => false,
@@ -108,14 +99,6 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
true => volume_res.message.parse::<f32>().unwrap(),
false => 0.0,
};
let position = match position_res.status {
true => position_res.message.parse::<f32>().unwrap(),
false => 0.0,
};
let duration = match duration_res.status {
true => duration_res.message.parse::<f32>().unwrap(),
false => 0.0,
};
let current_input = match current_input_res.status {
true => current_input_res
.message
@@ -144,10 +127,6 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
.collect::<HashMap<String, String>>(),
false => HashMap::new(),
};
let looped = match looped_res.status {
true => looped_res.message.parse::<bool>().unwrap_or_default(),
false => false,
};
{
let mut guard = audio_player_state_shared.lock().unwrap();
@@ -159,7 +138,19 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
}
None => state,
};
guard.current_file_path = file_path;
guard.tracks = tracks.clone();
if let Some(last_track) = tracks.last() {
guard.current_file_path = last_track.path.clone();
guard.position = last_track.position;
guard.duration = last_track.duration.unwrap_or(1.0);
guard.looped = last_track.looped;
} else {
guard.current_file_path = PathBuf::new();
guard.position = 0.0;
guard.duration = 1.0;
guard.looped = false;
}
guard.is_paused = is_paused;
guard.volume = match guard.new_volume {
Some(new_volume) => {
@@ -168,17 +159,8 @@ pub fn start_app_state_thread(audio_player_state_shared: Arc<Mutex<AudioPlayerSt
}
None => volume,
};
guard.position = match guard.new_position {
Some(new_position) => {
guard.new_position = None;
new_position
}
None => position,
};
guard.duration = if duration > 0.0 { duration } else { 1.0 };
guard.current_input = current_input;
guard.all_inputs = all_inputs;
guard.looped = looped;
}
sleep(sleep_duration).await;