use crate::debug_log::{self, log};
-use crate::mpd_handler::{InfoFromShared, MPDHandler, MPDHandlerState};
+use crate::mpd_handler::{InfoFromShared, MPDHandler, MPDHandlerState, MPDPlayState};
use crate::Opt;
use ggez::event::{self, EventHandler};
use ggez::graphics::{
text_bg_mesh: Option<Mesh>,
hide_text: bool,
tried_album_art_in_dir: bool,
+ mpd_play_state: MPDPlayState,
}
impl MPDDisplay {
text_bg_mesh: None,
hide_text: false,
tried_album_art_in_dir: false,
+ mpd_play_state: MPDPlayState::Playing,
}
}
.mpd_handler
.as_ref()
.unwrap()
- .get_current_song_info()
+ .get_mpd_handler_shared_state()
.ok();
if let Some(shared) = &self.shared {
if self.notice_text.contents() != shared.error_text {
self.notice_text = Text::new(TextFragment::new(shared.error_text.clone()));
}
- if !shared.title.is_empty() {
- self.title_text = Text::new(shared.title.clone());
- } else {
- self.dirty_flag
- .as_ref()
- .unwrap()
- .store(true, Ordering::Relaxed);
- }
- if !shared.artist.is_empty() {
- self.artist_text = Text::new(shared.artist.clone());
- } else {
- self.dirty_flag
- .as_ref()
- .unwrap()
- .store(true, Ordering::Relaxed);
- }
- if !shared.filename.is_empty() {
- if self.filename_text.contents() != shared.filename {
+ if shared.mpd_play_state != MPDPlayState::Playing {
+ if shared.mpd_play_state == MPDPlayState::Stopped {
+ self.title_text = Text::new("");
+ self.artist_text = Text::new("");
+ self.filename_text = Text::new("");
+ self.timer = 0.0;
+ self.length = 0.0;
self.album_art = None;
- self.tried_album_art_in_dir = false;
}
- self.filename_text = Text::new(shared.filename.clone());
+ self.mpd_play_state = shared.mpd_play_state;
} else {
- self.dirty_flag
- .as_ref()
- .unwrap()
- .store(true, Ordering::Relaxed);
+ self.mpd_play_state = MPDPlayState::Playing;
+ if !shared.title.is_empty() {
+ self.title_text = Text::new(shared.title.clone());
+ } else {
+ self.dirty_flag
+ .as_ref()
+ .unwrap()
+ .store(true, Ordering::Relaxed);
+ }
+ if !shared.artist.is_empty() {
+ self.artist_text = Text::new(shared.artist.clone());
+ } else {
+ self.dirty_flag
+ .as_ref()
+ .unwrap()
+ .store(true, Ordering::Relaxed);
+ }
+ if !shared.filename.is_empty() {
+ if self.filename_text.contents() != shared.filename {
+ self.album_art = None;
+ self.tried_album_art_in_dir = false;
+ }
+ self.filename_text = Text::new(shared.filename.clone());
+ } else {
+ self.dirty_flag
+ .as_ref()
+ .unwrap()
+ .store(true, Ordering::Relaxed);
+ }
+ self.timer = shared.pos;
+ self.length = shared.length;
+ self.refresh_text_transforms(ctx)?;
}
- self.timer = shared.pos;
- self.length = shared.length;
- self.refresh_text_transforms(ctx)?;
} else {
log(
"Failed to acquire read lock for getting shared data",
fn draw(&mut self, ctx: &mut ggez::Context) -> Result<(), GameError> {
graphics::clear(ctx, Color::BLACK);
- if self.album_art.is_some() && self.album_art_draw_transform.is_some() {
+ if self.mpd_play_state != MPDPlayState::Stopped
+ && self.album_art.is_some()
+ && self.album_art_draw_transform.is_some()
+ {
self.album_art.as_ref().unwrap().draw(
ctx,
DrawParam {
if !self.hide_text {
self.notice_text.draw(ctx, DrawParam::default())?;
- if self.is_valid && self.is_initialized {
+ if self.mpd_play_state != MPDPlayState::Stopped && self.is_valid && self.is_initialized
+ {
if let Some(mesh) = &self.text_bg_mesh {
mesh.draw(ctx, DrawParam::default())?;
}
)?;
}
- self.timer_text.draw(
- ctx,
- DrawParam {
- trans: self.timer_transform,
- ..Default::default()
- },
- )?;
+ if self.mpd_play_state == MPDPlayState::Playing {
+ self.timer_text.draw(
+ ctx,
+ DrawParam {
+ trans: self.timer_transform,
+ ..Default::default()
+ },
+ )?;
+ }
}
}
const POLL_DURATION: Duration = Duration::from_secs(5);
const BUF_SIZE: usize = 1024 * 4;
-#[derive(Debug, PartialEq, Copy, Clone)]
+#[derive(Debug, PartialEq, Eq, Copy, Clone)]
enum PollState {
None,
Password,
ReadPictureInDir,
}
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum MPDPlayState {
+ Playing,
+ Paused,
+ Stopped,
+}
+
#[derive(Debug, Clone)]
pub struct InfoFromShared {
pub filename: String,
pub length: f64,
pub pos: f64,
pub error_text: String,
+ pub mpd_play_state: MPDPlayState,
}
#[derive(Clone)]
dirty_flag: Arc<AtomicBool>,
pub stop_flag: Arc<AtomicBool>,
log_level: LogLevel,
+ mpd_play_state: MPDPlayState,
}
fn check_next_chars(
dirty_flag: Arc::new(AtomicBool::new(true)),
stop_flag: Arc::new(AtomicBool::new(false)),
log_level,
+ mpd_play_state: MPDPlayState::Stopped,
})),
};
Ok(s)
}
- pub fn get_current_song_info(&self) -> Result<InfoFromShared, ()> {
+ pub fn get_mpd_handler_shared_state(&self) -> Result<InfoFromShared, ()> {
if let Ok(read_lock) = self.state.try_read() {
return Ok(InfoFromShared {
filename: read_lock.current_song_filename.clone(),
pos: read_lock.current_song_position
+ read_lock.song_pos_get_time.elapsed().as_secs_f64(),
error_text: read_lock.error_text.clone(),
+ mpd_play_state: read_lock.mpd_play_state,
});
}
}
let mut buf_vec: Vec<u8> = Vec::from(&buf[0..read_amount]);
+ let mut got_mpd_state: MPDPlayState = MPDPlayState::Playing;
+
'handle_buf: loop {
if write_handle.current_binary_size > 0 {
if write_handle.current_binary_size <= buf_vec.len() {
_ => (),
}
write_handle.poll_state = PollState::None;
+ } else if line.starts_with("state: ") {
+ let remaining = line.split_off(7);
+ let remaining = remaining.trim();
+ if remaining == "stop" {
+ write_handle.current_song_filename.clear();
+ write_handle.art_data.clear();
+ write_handle.art_data_size = 0;
+ write_handle.art_data_type.clear();
+ write_handle.can_get_album_art = true;
+ write_handle.can_get_album_art_in_dir = true;
+ write_handle.current_song_title.clear();
+ write_handle.current_song_artist.clear();
+ write_handle.current_song_length = 0.0;
+ write_handle.current_song_position = 0.0;
+ write_handle.did_check_overtime = false;
+ write_handle.force_get_status = true;
+ }
+ if remaining == "stop" || remaining == "pause" {
+ got_mpd_state = if remaining == "stop" {
+ MPDPlayState::Stopped
+ } else {
+ MPDPlayState::Paused
+ };
+ write_handle.error_text.clear();
+ write_handle
+ .error_text
+ .push_str(&format!("MPD has {:?}", got_mpd_state));
+ log(
+ format!("MPD is {:?}", got_mpd_state),
+ LogState::Warning,
+ write_handle.log_level,
+ );
+ break 'handle_buf;
+ }
} else if line.starts_with("file: ") {
let song_file = line.split_off(6);
if song_file != write_handle.current_song_filename {
}
} // 'handle_buf: loop
+ if got_mpd_state != write_handle.mpd_play_state {
+ write_handle.dirty_flag.store(true, Ordering::Relaxed);
+ if got_mpd_state == MPDPlayState::Playing {
+ write_handle.error_text.clear();
+ }
+ }
+ write_handle.mpd_play_state = got_mpd_state;
+ if got_mpd_state != MPDPlayState::Playing {
+ write_handle.poll_state = PollState::None;
+ write_handle.song_pos_get_time = Instant::now();
+ write_handle.current_song_length = 30.0;
+ write_handle.current_song_position = 0.0;
+ }
+
Ok(())
}
} else if write_handle.can_get_status
&& (write_handle.song_title_get_time.elapsed() > POLL_DURATION
|| write_handle.force_get_current_song)
+ && write_handle.mpd_play_state == MPDPlayState::Playing
{
write_handle.force_get_current_song = false;
let write_result = write_handle.stream.write(b"currentsong\n");
projects / mpd_info_screen / commitdiff