diff --git a/radioPlayer.py b/radioPlayer.py index 8037f6c..d5eb4cd 100644 --- a/radioPlayer.py +++ b/radioPlayer.py @@ -31,15 +31,6 @@ udp_host = ("127.0.0.1", 5000) logger = log95.log95("radioPlayer") # Global variables for state tracking -current_state = { - "current_file": None, - "start_time": None, - "duration": None, - "playlist_path": None, - "playlist_position": 0 -} -state_thread = None -state_lock = threading.Lock() # Crossfade management cross_for_cross_time = 0 @@ -47,11 +38,70 @@ current_process = None next_process = None process_lock = threading.Lock() -def get_current_hour(): - return datetime.now().hour +class Time: + @staticmethod + def get_day_hour(): + return datetime.now().strftime('%A').lower(), datetime.now().hour + @staticmethod + def get_playlist_modification_time(playlist_path): + try: + return os.path.getmtime(playlist_path) + except OSError: + return 0 -def get_current_day(): - return datetime.now().strftime('%A').lower() +class StateManager: + def __init__(self) -> None: + self._reset() + self._state_lock = threading.Lock() + def _reset(self): + self._current_state = { + "current_file": None, + "start_time": None, + "duration": None, + "playlist_path": None, + "playlist_position": 0 + } + def save_state(self): + try: + with self._state_lock: + with open(state_file_path, 'w') as f: + json.dump(self._current_state, f) + except Exception as e: + logger.error(f"Error saving state: {e}") + def load_state(self): + try: + if os.path.exists(state_file_path): + with open(state_file_path, 'r') as f: + loaded_state = json.load(f) + with self._state_lock: + self._current_state.update(loaded_state) + logger.info(f"Loaded state: {self._current_state}") + return True + except Exception as e: + logger.error(f"Error loading state: {e}") + return False + def clear_state(self): + with self._state_lock: + self._reset() + try: + if os.path.exists(state_file_path): + os.remove(state_file_path) + except Exception as e: + logger.error(f"Error clearing state: {e}") + def update_current_state(self, file_path, playlist_path=None, playlist_position=0): + with self._state_lock: + self._current_state["current_file"] = file_path + self._current_state["start_time"] = time.time() + self._current_state["duration"] = get_audio_duration(file_path) + self._current_state["playlist_path"] = playlist_path + self._current_state["playlist_position"] = playlist_position + self.save_state() + def get_state(self): + with self._state_lock: + return self._current_state.copy() + + +stateman = StateManager() def load_dict_from_custom_format(file_path: str) -> dict: try: @@ -67,90 +117,29 @@ def load_dict_from_custom_format(file_path: str) -> dict: logger.error(f"{name_table_path} does not exist, or could not be accesed") return {} -def save_state(): - """Save current state to file""" - try: - with state_lock: - with open(state_file_path, 'w') as f: - json.dump(current_state, f) - except Exception as e: - logger.error(f"Error saving state: {e}") - -def load_state(): - """Load state from file""" - global current_state - try: - if os.path.exists(state_file_path): - with open(state_file_path, 'r') as f: - loaded_state = json.load(f) - with state_lock: - current_state.update(loaded_state) - logger.info(f"Loaded state: {current_state}") - return True - except Exception as e: - logger.error(f"Error loading state: {e}") - return False - -def clear_state(): - """Clear state file""" - try: - if os.path.exists(state_file_path): - os.remove(state_file_path) - except Exception as e: - logger.error(f"Error clearing state: {e}") - def get_audio_duration(file_path): - """Get duration of audio file using ffprobe""" try: result = subprocess.run([ 'ffprobe', '-v', 'quiet', '-show_entries', 'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1', file_path ], capture_output=True, text=True) - if result.returncode == 0: - duration = float(result.stdout.strip()) - return duration - except Exception as e: - logger.error(f"Error getting duration for {file_path}: {e}") + if result.returncode == 0: return float(result.stdout.strip()) + except Exception as e: logger.warning(f"Exception while reading audio duration: {e}") return None -def update_current_state(file_path, playlist_path=None, playlist_position=0): - """Update current state with new file""" - with state_lock: - current_state["current_file"] = file_path - current_state["start_time"] = time.time() - current_state["duration"] = get_audio_duration(file_path) - current_state["playlist_path"] = playlist_path - current_state["playlist_position"] = playlist_position - save_state() - -def clear_current_state(): - """Clear current playing state""" - with state_lock: - current_state["current_file"] = None - current_state["start_time"] = None - current_state["duration"] = None - save_state() - def should_resume_from_state(tracks, playlist_path): - """Check if we should resume from saved state""" - if not current_state["current_file"] or not current_state["start_time"]: - return False, tracks, 0 + if not stateman.get_state()["current_file"] or not stateman.get_state()["start_time"]: return False, tracks, 0 # Check if the saved file is still in the current playlist - if current_state["current_file"] in tracks and current_state["playlist_path"] == playlist_path: - elapsed = time.time() - current_state["start_time"] - - # Only resume if less than the track duration and less than 10 minutes have passed - if (current_state["duration"] and elapsed < current_state["duration"] and elapsed < 600): + if stateman.get_state()["current_file"] in tracks and stateman.get_state()["playlist_path"] == playlist_path: + elapsed = time.time() - stateman.get_state()["start_time"] + if (stateman.get_state()["duration"] and elapsed < stateman.get_state()["duration"] and elapsed < 600): # Find position of the current file try: - resume_index = tracks.index(current_state["current_file"]) - logger.info(f"Resuming from {os.path.basename(current_state['current_file'])} at {elapsed:.0f}s") - return True, tracks, resume_index - except ValueError: - pass - + logger.info(f"Resuming from {os.path.basename(stateman.get_state()['current_file'])} at {elapsed:.0f}s") + return True, tracks, tracks.index(stateman.get_state()["current_file"]) + except ValueError: pass return False, tracks, 0 def update_rds(track_name: str): @@ -184,11 +173,7 @@ def update_rds(track_name: str): f = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) f.settimeout(1.0) - try: - f.sendto(f"TEXT={prt}\r\n".encode(), udp_host) - except socket.timeout: - logger.error("Could not send TEXT to RDS, timeout.") - return + f.sendto(f"TEXT={prt}\r\n".encode(), udp_host) logger.info("RT set to", prt) rtp = [4] # type 1 @@ -199,33 +184,19 @@ def update_rds(track_name: str): rtp.append(len(title)) # len 2 rtp = list(map(str, rtp)) - try: - f.sendto(f"RTP={','.join(rtp)}\r\n".encode(), udp_host) - except socket.timeout: - logger.error("Could not send TEXT to RDS, timeout.") - return + f.sendto(f"RTP={','.join(rtp)}\r\n".encode(), udp_host) f.close() - except Exception as e: - logger.error(f"Error updating RDS: {e}") - -def get_playlist_modification_time(playlist_path): - try: - return os.path.getmtime(playlist_path) - except OSError: - return 0 + except Exception as e: logger.error(f"Error updating RDS: {e}") def load_playlist(playlist_path): try: - with open(playlist_path, 'r') as f: - tracks = [line.strip() for line in f.readlines() if line.strip()] - return tracks + with open(playlist_path, 'r') as f: return [line.strip() for line in f.readlines() if line.strip()] except FileNotFoundError: logger.error(f"Playlist not found: {playlist_path}") return [] def get_newest_track(tracks): - if not tracks: - return None + if not tracks: return None newest_track = None newest_time = 0 @@ -237,8 +208,7 @@ def get_newest_track(tracks): if mod_time > newest_time: newest_time = mod_time newest_track = track - except OSError: - continue + except OSError: continue return newest_track @@ -266,8 +236,7 @@ def stop_all_processes(): try: current_process.kill() current_process.wait(timeout=2) - except (subprocess.TimeoutExpired, ProcessLookupError): - pass + except (subprocess.TimeoutExpired, ProcessLookupError): pass current_process = None if next_process and next_process.poll() is None: @@ -334,7 +303,7 @@ def play_audio_with_crossfade(current_track_path, next_track_path=None, resume_s def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first=False, do_shuffle=True): global current_process, next_process, cross_for_cross_time - last_modified_time = get_playlist_modification_time(playlist_path) + last_modified_time = Time.get_playlist_modification_time(playlist_path) tracks = load_playlist(playlist_path) if not tracks: logger.info(f"No tracks found in {playlist_path}, checking again in 15 seconds...") @@ -350,8 +319,7 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= if should_resume: start_index = resume_index - with state_lock: - resume_seconds = time.time() - current_state["start_time"] + resume_seconds = time.time() - stateman.get_state()["start_time"] else: # Normal playlist preparation if play_newest_first: @@ -370,19 +338,18 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= for i, track in enumerate(tracks[start_index:], start_index): if return_pending: stop_all_processes() - clear_current_state() + stateman.clear_state() return track_path = os.path.abspath(os.path.expanduser(track)) track_name = os.path.basename(track_path) - current_modified_time = get_playlist_modification_time(playlist_path) + current_modified_time = Time.get_playlist_modification_time(playlist_path) if current_modified_time > last_modified_time: logger.info(f"Playlist {playlist_path} has been modified, reloading...") return_pending = True continue - current_hour = get_current_hour() - current_day = get_current_day() + current_day, current_hour = Time.get_day_hour() morning_playlist_path = os.path.join(playlist_dir, current_day, 'morning') day_playlist_path = os.path.join(playlist_dir, current_day, 'day') night_playlist_path = os.path.join(playlist_dir, current_day, 'night') @@ -414,7 +381,7 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= action = check_control_files() if action == "quit": stop_all_processes() - clear_state() + stateman.clear_state() exit() elif action == "reload": logger.info("Reload requested during playback...") @@ -425,7 +392,7 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= with process_lock: next_process = create_audio_process(track_path, fade_in=True, fade_out=True) update_rds(track_name) - update_current_state(track_path, playlist_path, i) + stateman.update_current_state(track_path, playlist_path, i) # Wait for crossfade to complete time.sleep(CROSSFADE_DURATION * 1.5) @@ -446,7 +413,7 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= current_process = None # Update state before playing - update_current_state(track_path, playlist_path, i) + stateman.update_current_state(track_path, playlist_path, i) if i == start_index and resume_seconds > 0: logger.info(f"Resuming: {track_name} at {resume_seconds:.0f}s") @@ -491,7 +458,7 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= action = check_control_files() if action == "quit": stop_all_processes() - clear_state() + stateman.clear_state() exit() elif action == "reload": logger.info("Reload requested during playback...") @@ -501,7 +468,7 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= logger.info(f"Starting crossfade to: {os.path.basename(next_track_path)}") with process_lock: next_process = create_audio_process(next_track_path, fade_in=True, fade_out=True) - update_rds(next_track_path) + update_rds(os.path.basename(next_track_path)) # Wait for crossfade to complete time.sleep(CROSSFADE_DURATION * 1.5) @@ -522,20 +489,20 @@ def play_playlist(playlist_path, custom_playlist: bool=False, play_newest_first= current_process = None - update_current_state(next_track_path, playlist_path, i+1) + stateman.update_current_state(next_track_path, playlist_path, i+1) # Check control files after each song action = check_control_files() if can_delete_file("/tmp/radioPlayer_onplaylist"): action = None if action == "quit": stop_all_processes() - clear_state() + stateman.clear_state() exit() elif action == "reload": logger.info("Reload requested, restarting with new arguments...") stop_all_processes() return "reload" - clear_state() + stateman.clear_state() def can_delete_file(filepath): if not os.path.isfile(filepath): @@ -596,7 +563,7 @@ def parse_arguments(): def main(): # Load state at startup - state_loaded = load_state() + state_loaded = stateman.load_state() try: while True: # Main reload loop @@ -605,40 +572,40 @@ def main(): if pre_track_path: track_name = os.path.basename(pre_track_path) logger.info(f"Now playing: {track_name}") - update_current_state(pre_track_path) + stateman.update_current_state(pre_track_path) update_rds(track_name) play_single_track(pre_track_path) - clear_current_state() + stateman.clear_state() action = check_control_files() if can_delete_file("/tmp/radioPlayer_onplaylist"): action = None if action == "quit": - clear_state() + stateman.clear_state() exit() elif action == "reload": logger.info("Reload requested, restarting with new arguments...") continue # Restart the main loop # Check if we should resume from loaded state first - if state_loaded and current_state.get("current_file") and current_state.get("playlist_path"): + if state_loaded and stateman.get_state().get("current_file") and stateman.get_state().get("playlist_path"): # Try to resume from the loaded state - if os.path.exists(current_state["playlist_path"]): - logger.info(f"Attempting to resume from saved state: {current_state['playlist_path']}") + if os.path.exists(stateman.get_state()["playlist_path"]): + logger.info(f"Attempting to resume from saved state: {stateman.get_state()['playlist_path']}") # Check if the saved playlist is a time-based playlist (not custom) # A time-based playlist ends with 'morning', 'day', 'night', or 'late_night' - saved_playlist_name = os.path.basename(current_state["playlist_path"]) + saved_playlist_name = os.path.basename(stateman.get_state()["playlist_path"]) is_time_based_playlist = saved_playlist_name in ['morning', 'day', 'night', 'late_night'] - result = play_playlist(current_state["playlist_path"], + result = play_playlist(stateman.get_state()["playlist_path"], not is_time_based_playlist, # custom_playlist = NOT time-based play_newest_first, do_shuffle) state_loaded = False # Don't try to resume again if result == "reload": continue else: - logger.warning(f"Saved playlist path no longer exists: {current_state['playlist_path']}") - clear_current_state() + logger.warning(f"Saved playlist path no longer exists: {stateman.get_state()['playlist_path']}") + stateman.clear_state() state_loaded = False playlist_loop_active = True @@ -650,8 +617,7 @@ def main(): playlist_loop_active = False # Break out to reload continue - current_hour = get_current_hour() - current_day = get_current_day() + current_day, current_hour = Time.get_day_hour() morning_playlist = os.path.join(playlist_dir, current_day, 'morning') day_playlist = os.path.join(playlist_dir, current_day, 'day') @@ -692,7 +658,7 @@ def main(): if action == "quit": if os.path.exists("/tmp/radioPlayer_onplaylist"): os.remove("/tmp/radioPlayer_onplaylist") - clear_state() + stateman.clear_state() exit() elif action == "reload": if os.path.exists("/tmp/radioPlayer_onplaylist"): diff --git a/radioPlaylist.py b/radioPlaylist.py index 68d3bed..9234a27 100644 --- a/radioPlaylist.py +++ b/radioPlaylist.py @@ -184,7 +184,7 @@ class PlaylistManager: def load_playlists(self, days: List[str]) -> Dict[str, Dict[str, Set[str]]]: """Load all playlists from disk.""" - if self.config.is_custom_mode: + if self.config.is_custom_mode and self.config.custom_playlist_file: # In custom mode, we only need one "day" entry playlists = {"custom": {period: set() for period in self.periods}} # Load existing custom playlist if it exists @@ -228,6 +228,7 @@ class PlaylistManager: def _update_custom_playlist(self, file_item: FileItem, add: bool): """Update the custom playlist file.""" + if not self.config.custom_playlist_file: raise Exception # Ensure the directory exists os.makedirs(os.path.dirname(self.config.custom_playlist_file), exist_ok=True) @@ -472,8 +473,9 @@ class DisplayManager: def draw_header(self, playlists: Dict, current_day: str, current_day_idx: int, days: List[str], term_width: int, all_file_items: List[FileItem], - force_redraw: bool = False, state: InterfaceState = None): + force_redraw: bool = False, state: InterfaceState | None = None): """Draw the header, only if content has changed.""" + if not state: raise Exception result = self.stats.calculate_category_percentages(playlists, current_day, self.config, all_file_items) percentages, polskie_percentages, total_pl = result or ({}, {}, 0) @@ -514,8 +516,9 @@ class DisplayManager: return 2 if self.config.is_custom_mode else 3 def draw_search_bar(self, search_term: str, term_width: int, force_redraw: bool = False, - state: InterfaceState = None): + state: InterfaceState | None = None): """Draw the search bar, only if the search term has changed.""" + if not state: raise Exception # Optimization: Only redraw if search term changes if force_redraw or state.last_search != search_term: search_row = self.get_header_height() + 3 @@ -527,8 +530,9 @@ class DisplayManager: def draw_files_section(self, file_items: List[FileItem], playlists: Dict, selected_idx: int, current_day: str, scroll_offset: int, term_width: int, term_height: int, - force_redraw: bool = False, state: InterfaceState = None): + force_redraw: bool = False, state: InterfaceState | None = None): """Draw the files list, optimized to only redraw when necessary.""" + if not state: raise Exception header_height = self.get_header_height() content_start_row = header_height + 5 available_lines = term_height - content_start_row