-use crate::debug_log::log;
+use crate::debug_log::{self, log};
use crate::mpd_handler::{InfoFromShared, MPDHandler};
use crate::Opt;
use ggez::event::{self, EventHandler};
mpd_handler: Option<Arc<RwLock<MPDHandler>>>,
is_valid: bool,
is_initialized: bool,
+ is_authenticated: bool,
notice_text: Text,
poll_instant: Instant,
shared: Option<InfoFromShared>,
mpd_handler: None,
is_valid: true,
is_initialized: false,
+ is_authenticated: false,
notice_text: Text::new(""),
poll_instant: Instant::now() - POLL_TIME,
shared: None,
self.opts.host,
self.opts.port,
self.opts.password.clone().map_or(String::new(), |s| s),
+ self.opts.log_level,
)
.map_or_else(|_| None, |v| Some(v));
if self.mpd_handler.is_some() {
thread::sleep(POLL_TIME);
}
}
- log("Successfully initialized MPDHandler");
+ log(
+ "Successfully initialized MPDHandler",
+ debug_log::LogState::DEBUG,
+ self.opts.log_level,
+ );
} else {
self.is_valid = false;
- log("Failed to initialize MPDHandler");
+ log(
+ "Failed to initialize MPDHandler",
+ debug_log::LogState::DEBUG,
+ self.opts.log_level,
+ );
}
}
&mut self.timer_y,
);
} else {
- log("filename text is empty");
+ log(
+ "filename text is empty",
+ debug_log::LogState::WARNING,
+ self.opts.log_level,
+ );
}
if !self.artist_text.contents().is_empty() && !self.opts.disable_show_artist {
&mut self.timer_y,
);
} else {
- log("artist text is empty");
+ log(
+ "artist text is empty",
+ debug_log::LogState::WARNING,
+ self.opts.log_level,
+ );
}
if !self.title_text.contents().is_empty() && !self.opts.disable_show_title {
&mut self.timer_y,
);
} else {
- log("title text is empty");
+ log(
+ "title text is empty",
+ debug_log::LogState::WARNING,
+ self.opts.log_level,
+ );
}
set_transform(
} else {
self.init_mpd_handler();
}
+ } else if self.password_entered {
+ 'check_state: loop {
+ let result = MPDHandler::is_authenticated(self.mpd_handler.clone().unwrap());
+ if let Ok(true) = result {
+ self.is_authenticated = true;
+ break;
+ } else if let Err(()) = result {
+ continue;
+ } else {
+ loop {
+ let check_fail_result =
+ MPDHandler::failed_to_authenticate(self.mpd_handler.clone().unwrap());
+ if let Ok(true) = check_fail_result {
+ {
+ let mpd_handler = self.mpd_handler.clone().unwrap();
+ loop {
+ let write_handle_result = mpd_handler.try_write();
+ if let Ok(write_handle) = write_handle_result {
+ write_handle.stop_flag.store(true, Ordering::Relaxed);
+ break;
+ }
+ }
+ }
+ self.notice_text = Text::new(TextFragment::new("password: "));
+ self.opts.password = Some(String::new());
+ self.password_entered = false;
+ self.is_initialized = false;
+ break 'check_state;
+ } else if let Err(()) = check_fail_result {
+ continue;
+ } else {
+ break 'check_state;
+ }
+ }
+ }
+ }
}
if self.is_valid && self.is_initialized && self.poll_instant.elapsed() > POLL_TIME {
.unwrap()
.swap(false, Ordering::Relaxed)
{
- log("dirty_flag cleared, acquiring shared data...");
+ log(
+ "dirty_flag cleared, acquiring shared data...",
+ debug_log::LogState::DEBUG,
+ self.opts.log_level,
+ );
self.shared = MPDHandler::get_current_song_info(self.mpd_handler.clone().unwrap())
.map_or(None, |f| Some(f));
if let Some(shared) = &self.shared {
self.length = shared.length;
self.refresh_text_transforms(ctx)?;
} else {
- log("Failed to acquire read lock for getting shared data");
+ log(
+ "Failed to acquire read lock for getting shared data",
+ debug_log::LogState::DEBUG,
+ self.opts.log_level,
+ );
}
if self.album_art.is_none() {
let result = self.get_image_from_data(ctx);
if let Err(e) = result {
- log(e);
+ log(e, debug_log::LogState::DEBUG, self.opts.log_level);
self.album_art = None;
self.album_art_draw_transform = None;
} else {
graphics::clear(ctx, Color::BLACK);
if self.album_art.is_some() && self.album_art_draw_transform.is_some() {
- log("Drawing album_art");
self.album_art.as_ref().unwrap().draw(
ctx,
DrawParam {
}
} else if keycode == event::KeyCode::Return {
self.password_entered = true;
- //log(format!("Entered \"{}\"", self.opts.password.as_ref().unwrap_or(&String::new())));
}
} else {
if keycode == event::KeyCode::H {
-use crate::debug_log::log;
+use crate::debug_log::{log, LogState};
use std::io::{self, Read, Write};
use std::net::{IpAddr, Ipv4Addr, SocketAddr, TcpStream};
use std::str::FromStr;
self_thread: Option<Arc<Mutex<thread::JoinHandle<Result<(), String>>>>>,
dirty_flag: Arc<AtomicBool>,
pub stop_flag: Arc<AtomicBool>,
+ log_level: LogState,
}
fn check_next_chars(
}
impl MPDHandler {
- pub fn new(host: Ipv4Addr, port: u16, password: String) -> Result<Arc<RwLock<Self>>, String> {
+ pub fn new(
+ host: Ipv4Addr,
+ port: u16,
+ password: String,
+ log_level: LogState,
+ ) -> Result<Arc<RwLock<Self>>, String> {
let stream = TcpStream::connect_timeout(
&SocketAddr::new(IpAddr::V4(host), port),
Duration::from_secs(5),
self_thread: None,
dirty_flag: Arc::new(AtomicBool::new(true)),
stop_flag: Arc::new(AtomicBool::new(false)),
+ log_level,
}));
let s_clone = s.clone();
&self.art_data
}
+ pub fn is_authenticated(h: Arc<RwLock<Self>>) -> Result<bool, ()> {
+ let read_handle = h.try_read().map_err(|_| ())?;
+ Ok(read_handle.is_authenticated)
+ }
+
+ pub fn failed_to_authenticate(h: Arc<RwLock<Self>>) -> Result<bool, ()> {
+ let read_handle = h.try_read().map_err(|_| ())?;
+ Ok(!read_handle.can_authenticate)
+ }
+
fn handler_loop(h: Arc<RwLock<Self>>) -> Result<(), String> {
+ let log_level = h.read().expect("Failed to get log_level").log_level;
let mut buf: [u8; BUF_SIZE] = [0; BUF_SIZE];
let mut saved: Vec<u8> = Vec::new();
let mut saved_str: String = String::new();
if let Ok(write_handle) = h.try_write() {
if write_handle.self_thread.is_none() {
// main thread failed to store handle to this thread
- println!("MPDHandle thread stopping due to failed handle storage");
+ log(
+ "MPDHandle thread stopping due to failed handle storage",
+ LogState::ERROR,
+ write_handle.log_level,
+ );
break 'main;
}
}
if let Err(err_string) =
Self::handler_read_block(h.clone(), &mut buf, &mut saved, &mut saved_str)
{
- println!("WARNING: read_block error: {}", err_string);
+ log(
+ format!("read_block error: {}", err_string),
+ LogState::WARNING,
+ log_level,
+ );
} else if let Err(err_string) = Self::handler_write_block(h.clone()) {
- println!("WARNING: write_block error: {}", err_string);
+ log(
+ format!("write_block error: {}", err_string),
+ LogState::WARNING,
+ log_level,
+ );
}
if let Ok(read_handle) = h.try_read() {
io::stdout().flush().unwrap();
}
- log("MPDHandler thread entering exit loop");
+ log(
+ "MPDHandler thread entering exit loop",
+ LogState::DEBUG,
+ log_level,
+ );
'exit: loop {
if let Ok(mut write_handle) = h.try_write() {
write_handle.self_thread = None;
buf_vec = buf_vec.split_off(count + 1);
write_handle.current_binary_size = 0;
write_handle.poll_state = PollState::None;
- log(format!(
- "Album art recv progress: {}/{}",
- write_handle.art_data.len(),
- write_handle.art_data_size
- ));
+ log(
+ format!(
+ "Album art recv progress: {}/{}",
+ write_handle.art_data.len(),
+ write_handle.art_data_size
+ ),
+ LogState::DEBUG,
+ write_handle.log_level,
+ );
if write_handle.art_data.len() == write_handle.art_data_size {
write_handle.dirty_flag.store(true, Ordering::Relaxed);
}
} else {
write_handle.art_data.extend_from_slice(&buf_vec);
write_handle.current_binary_size -= buf_vec.len();
- log(format!(
- "Album art recv progress: {}/{}",
- write_handle.art_data.len(),
- write_handle.art_data_size
- ));
+ log(
+ format!(
+ "Album art recv progress: {}/{}",
+ write_handle.art_data.len(),
+ write_handle.art_data_size
+ ),
+ LogState::DEBUG,
+ write_handle.log_level,
+ );
if write_handle.art_data.len() == write_handle.art_data_size {
write_handle.dirty_flag.store(true, Ordering::Relaxed);
}
if write_handle.is_init {
if line.starts_with("OK MPD ") {
write_handle.is_init = false;
- println!("Got initial \"OK\" from MPD");
+ log(
+ "Got initial \"OK\" from MPD",
+ LogState::DEBUG,
+ write_handle.log_level,
+ );
write_handle.poll_state = PollState::None;
break 'handle_buf;
} else {
} // write_handle.is_init
if line.starts_with("OK") {
- log(format!(
- "Got OK when poll state is {:?}",
- write_handle.poll_state
- ));
+ log(
+ format!("Got OK when poll state is {:?}", write_handle.poll_state),
+ LogState::DEBUG,
+ write_handle.log_level,
+ );
match write_handle.poll_state {
PollState::Password => write_handle.is_authenticated = true,
PollState::ReadPicture => {
if write_handle.art_data.is_empty() {
write_handle.can_get_album_art = false;
write_handle.dirty_flag.store(true, Ordering::Relaxed);
- println!("No embedded album art");
+ log(
+ "No embedded album art",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
}
}
PollState::ReadPictureInDir => {
if write_handle.art_data.is_empty() {
write_handle.can_get_album_art_in_dir = false;
write_handle.dirty_flag.store(true, Ordering::Relaxed);
- println!("No album art in dir");
+ log(
+ "No album art in dir",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
}
}
_ => (),
write_handle.poll_state = PollState::None;
break 'handle_buf;
} else if line.starts_with("ACK") {
- println!("ERROR: {}", line);
+ log(line, LogState::WARNING, write_handle.log_level);
match write_handle.poll_state {
PollState::Password => {
write_handle.can_authenticate = false;
PollState::ReadPicture => {
write_handle.can_get_album_art = false;
write_handle.dirty_flag.store(true, Ordering::Relaxed);
- println!("Failed to get readpicture");
+ log(
+ "Failed to get readpicture",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
// Not setting error_text here since
// ReadPictureInDir is tried next
}
PollState::ReadPictureInDir => {
write_handle.can_get_album_art_in_dir = false;
write_handle.dirty_flag.store(true, Ordering::Relaxed);
- println!("Failed to get albumart");
+ log(
+ "Failed to get albumart",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
write_handle.error_text = "Failed to get album art from MPD".into();
}
_ => (),
write_handle.dirty_flag.store(true, Ordering::Relaxed);
write_handle.song_pos_get_time = Instant::now();
} else {
- println!("WARNING: Failed to parse current song position");
+ log(
+ "Failed to parse current song position",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
}
} else if line.starts_with("duration: ") {
let parse_pos_result = f64::from_str(&line.split_off(10));
write_handle.dirty_flag.store(true, Ordering::Relaxed);
write_handle.song_length_get_time = Instant::now();
} else {
- println!("WARNING: Failed to parse current song duration");
+ log(
+ "Failed to parse current song duration",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
}
} else if line.starts_with("size: ") {
let parse_artsize_result = usize::from_str(&line.split_off(6));
write_handle.art_data_size = value;
write_handle.dirty_flag.store(true, Ordering::Relaxed);
} else {
- println!("WARNING: Failed to parse album art byte size");
+ log(
+ "Failed to parse album art byte size",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
}
} else if line.starts_with("binary: ") {
let parse_artbinarysize_result = usize::from_str(&line.split_off(8));
if let Ok(value) = parse_artbinarysize_result {
write_handle.current_binary_size = value;
} else {
- println!("WARNING: Failed to parse album art chunk byte size");
+ log(
+ "Failed to parse album art chunk byte size",
+ LogState::WARNING,
+ write_handle.log_level,
+ );
}
} else if line.starts_with("Title: ") {
write_handle.current_song_title = line.split_off(7);
} else if line.starts_with("type: ") {
write_handle.art_data_type = line.split_off(6);
} else {
- log(format!("WARNING: Got unrecognized/ignored line: {}", line));
+ log(
+ format!("Got unrecognized/ignored line: {}", line),
+ LogState::WARNING,
+ write_handle.log_level,
+ );
}
} else if let Err((msg, read_line_in_progress)) = read_line_result {
- log(format!(
- "WARNING read_line: {}, saved size == {}, in_progress size == {}",
- msg,
- saved.len(),
- read_line_in_progress.len()
- ));
+ log(
+ format!(
+ "read_line: {}, saved size == {}, in_progress size == {}",
+ msg,
+ saved.len(),
+ read_line_in_progress.len()
+ ),
+ LogState::WARNING,
+ write_handle.log_level,
+ );
*saved_str = read_line_in_progress;
break 'handle_buf;
} else {
if write_result.is_ok() {
write_handle.poll_state = PollState::Password;
} else if let Err(e) = write_result {
- println!("ERROR: Failed to send password for authentication: {}", e);
+ log(
+ format!("Failed to send password for authentication: {}", e),
+ LogState::ERROR,
+ write_handle.log_level,
+ );
}
} else if write_handle.can_get_status
&& (write_handle.song_title_get_time.elapsed() > POLL_DURATION
if write_result.is_ok() {
write_handle.poll_state = PollState::CurrentSong;
} else if let Err(e) = write_result {
- println!("ERROR: Failed to request song info over stream: {}", e);
+ log(
+ format!("Failed to request song info over stream: {}", e),
+ LogState::ERROR,
+ write_handle.log_level,
+ );
}
} else if write_handle.can_get_status
&& (write_handle.song_length_get_time.elapsed() > POLL_DURATION
if write_result.is_ok() {
write_handle.poll_state = PollState::Status;
} else if let Err(e) = write_result {
- println!("ERROR: Failed to request status over stream: {}", e);
+ log(
+ format!("Failed to request status over stream: {}", e),
+ LogState::ERROR,
+ write_handle.log_level,
+ );
}
} else if (write_handle.art_data.is_empty()
|| write_handle.art_data.len() != write_handle.art_data_size)
if write_result.is_ok() {
write_handle.poll_state = PollState::ReadPicture;
} else if let Err(e) = write_result {
- println!("ERROR: Failed to request album art: {}", e);
+ log(
+ format!("Failed to request album art: {}", e),
+ LogState::ERROR,
+ write_handle.log_level,
+ );
}
} else if write_handle.can_get_album_art_in_dir {
let write_result = write_handle
if write_result.is_ok() {
write_handle.poll_state = PollState::ReadPictureInDir;
} else if let Err(e) = write_result {
- println!("ERROR: Failed to request album art in dir: {}", e);
+ log(
+ format!("Failed to request album art in dir: {}", e),
+ LogState::ERROR,
+ write_handle.log_level,
+ );
}
}
}
projects / mpd_info_screen / commitdiff
