329 lines
15 KiB
Python
329 lines
15 KiB
Python
from kivy.config import Config
|
|
Config.set('kivy', 'video', 'ffpyplayer') # Set ffpyplayer as the video provider
|
|
|
|
from kivy.app import App
|
|
from kivy.uix.screenmanager import ScreenManager, Screen # Import ScreenManager and Screen for managing screens
|
|
from kivy.clock import Clock # Import Clock for scheduling tasks
|
|
from kivy.core.window import Window # Import Window for handling window events
|
|
from kivy.uix.video import Video # Import Video widget for video playback
|
|
from kivy.uix.image import Image # Import Image widget for displaying images
|
|
from kivy.logger import Logger # Import Logger for logging messages
|
|
from kivy.lang import Builder # Import Builder for loading KV files
|
|
from kivy.animation import Animation # Import Animation for fade effects
|
|
import os # Import os for file and directory operations
|
|
import json # Import json for handling JSON data
|
|
import datetime # Import datetime for timestamping logs
|
|
|
|
# Import functions from python_functions.py
|
|
from python_functions import load_playlist, download_media_files, clean_unused_files
|
|
|
|
# Load the KV file for UI layout
|
|
Builder.load_file('kv/media_player.kv')
|
|
|
|
# Path to the configuration file
|
|
CONFIG_FILE = './Resurse/app_config.txt'
|
|
|
|
class MediaPlayer(Screen):
|
|
"""Main screen for media playback."""
|
|
|
|
def __init__(self, **kwargs):
|
|
super(MediaPlayer, self).__init__(**kwargs)
|
|
self.playlist = [] # Initialize the playlist
|
|
self.current_index = 0 # Index of the currently playing media
|
|
self.video_player = self.ids.video_player # Reference to the Video widget
|
|
self.image_display = self.ids.image_display # Reference to the Image widget
|
|
self.log_file = os.path.join(os.path.dirname(__file__), 'Resurse', 'log.txt') # Path to the log file
|
|
self.is_paused = False # Track the state of the play/pause button
|
|
self.reset_timer = None # Timer to reset the button state after 3 minutes
|
|
self.image_timer = None # Timer for scheduling the next media for images
|
|
|
|
# Schedule periodic updates to check for playlist updates
|
|
Clock.schedule_interval(self.check_playlist_updates, 300) # Every 5 minutes
|
|
# Bind key events to handle fullscreen toggle
|
|
Window.bind(on_key_down=self.on_key_down)
|
|
|
|
# Start a timer to hide the buttons after 10 seconds
|
|
self.hide_button_timer = Clock.schedule_once(self.hide_buttons, 10)
|
|
|
|
def on_touch_down(self, touch):
|
|
"""Handle touch events to reset the button visibility."""
|
|
self.show_buttons() # Make all buttons visible
|
|
if hasattr(self, 'hide_button_timer'):
|
|
Clock.unschedule(self.hide_button_timer) # Cancel the existing hide timer
|
|
self.hide_button_timer = Clock.schedule_once(self.hide_buttons, 10) # Restart the hide timer
|
|
return super(MediaPlayer, self).on_touch_down(touch)
|
|
|
|
def hide_buttons(self, *args):
|
|
"""Hide all buttons after inactivity."""
|
|
self.ids.settings_button.opacity = 0 # Hide the Home button
|
|
self.ids.right_arrow_button.opacity = 0 # Hide the Right Arrow button
|
|
self.ids.play_pause_button.opacity = 0 # Hide the Play/Pause button
|
|
self.ids.left_arrow_button.opacity = 0 # Hide the Left Arrow button
|
|
|
|
def show_buttons(self):
|
|
"""Show all buttons."""
|
|
self.ids.settings_button.opacity = 1 # Show the Home button
|
|
self.ids.right_arrow_button.opacity = 1 # Show the Right Arrow button
|
|
self.ids.play_pause_button.opacity = 1 # Show the Play/Pause button
|
|
self.ids.left_arrow_button.opacity = 1 # Show the Left Arrow button
|
|
|
|
def on_key_down(self, window, key, *args):
|
|
"""Handle key events for toggling fullscreen mode."""
|
|
if key == 102: # 'f' key
|
|
Window.fullscreen = not Window.fullscreen
|
|
|
|
def on_enter(self):
|
|
"""Called when the screen is entered."""
|
|
self.playlist = load_playlist() # Load the playlist
|
|
download_media_files(self.playlist) # Download media files from the playlist
|
|
clean_unused_files(self.playlist) # Remove unused files from the resource folder
|
|
self.play_media() # Start playing media
|
|
self.show_buttons() # Ensure buttons are visible when the screen is entered
|
|
|
|
def log_event(self, file_name, event):
|
|
"""Log the start or stop event of a media file and clean up old logs."""
|
|
# Get the current timestamp
|
|
timestamp = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
|
|
log_message = f"{timestamp} - {event}: {file_name}\n" # Format the log message
|
|
|
|
# Write the log message to the log file
|
|
with open(self.log_file, 'a') as log:
|
|
log.write(log_message)
|
|
Logger.info(f"Logged event: {log_message.strip()}") # Log the event to the console
|
|
|
|
# Clean up logs older than 24 hours
|
|
self.cleanup_old_logs()
|
|
|
|
def cleanup_old_logs(self):
|
|
"""Delete log entries older than 24 hours."""
|
|
try:
|
|
# Read all log entries
|
|
if os.path.exists(self.log_file):
|
|
with open(self.log_file, 'r') as log:
|
|
lines = log.readlines()
|
|
|
|
# Get the current time
|
|
now = datetime.datetime.now()
|
|
|
|
# Filter out log entries older than 24 hours
|
|
filtered_lines = []
|
|
for line in lines:
|
|
try:
|
|
# Extract the timestamp from the log entry
|
|
timestamp_str = line.split(' - ')[0]
|
|
log_time = datetime.datetime.strptime(timestamp_str, '%Y-%m-%d %H:%M:%S')
|
|
|
|
# Keep the log entry if it's within the last 24 hours
|
|
if (now - log_time).total_seconds() <= 86400: # 24 hours in seconds
|
|
filtered_lines.append(line)
|
|
except (ValueError, IndexError):
|
|
# If the log entry is malformed, skip it
|
|
Logger.warning(f"Malformed log entry skipped: {line.strip()}")
|
|
|
|
# Write the filtered log entries back to the log file
|
|
with open(self.log_file, 'w') as log:
|
|
log.writelines(filtered_lines)
|
|
Logger.info("Old log entries cleaned up successfully.")
|
|
except Exception as e:
|
|
Logger.error(f"Failed to clean up old logs: {e}")
|
|
|
|
def play_media(self):
|
|
"""Play the current media in the playlist."""
|
|
if self.playlist:
|
|
media = self.playlist[self.current_index] # Get the current media
|
|
file_name = media.get('file_name', '') # Get the file name
|
|
file_extension = os.path.splitext(file_name)[1].lower() # Get the file extension
|
|
duration = media.get('duration', 10) # Get the duration (default: 10 seconds)
|
|
|
|
# Define the base directory for media files
|
|
base_dir = os.path.join(os.path.dirname(__file__), 'static', 'resurse')
|
|
file_path = os.path.join(base_dir, file_name) # Full path to the media file
|
|
|
|
Logger.info(f"Playing media: {file_path}")
|
|
|
|
# Log the start of the media
|
|
self.log_event(file_name, "STARTED")
|
|
|
|
# Determine the type of media and play it
|
|
if file_extension in ['.mp4', '.avi', '.mov']:
|
|
self.play_video(file_path) # Play video
|
|
elif file_extension in ['.jpg', '.jpeg', '.png', '.gif']:
|
|
self.show_image(file_path, duration) # Show image
|
|
else:
|
|
Logger.error(f"Unsupported media type for file: {file_name}")
|
|
|
|
def play_video(self, file_path):
|
|
"""Play a video file without a fade-in effect."""
|
|
Logger.info(f"Playing video: {file_path}")
|
|
if not os.path.exists(file_path):
|
|
Logger.error(f"Video file not found: {file_path}")
|
|
return
|
|
|
|
# Set the video source and start playback
|
|
self.video_player.source = file_path
|
|
self.video_player.state = 'play' # Start playing the video
|
|
self.video_player.opacity = 1 # Ensure the video is fully visible
|
|
self.image_display.opacity = 0 # Hide the image display
|
|
|
|
# Schedule the next media after the video's duration
|
|
Clock.schedule_once(self.next_media, self.video_player.duration)
|
|
|
|
def show_image(self, file_path, duration):
|
|
"""Display an image with a fade-in effect."""
|
|
Logger.info(f"Showing image: {file_path}")
|
|
if not os.path.exists(file_path):
|
|
Logger.error(f"Image file not found: {file_path}")
|
|
return
|
|
|
|
# Set the image source
|
|
self.image_display.source = file_path
|
|
self.image_display.opacity = 0 # Start with the image hidden
|
|
self.image_display.reload() # Reload the image to ensure it updates
|
|
self.video_player.opacity = 0 # Hide the video player
|
|
|
|
# Create a fade-in animation
|
|
fade_in = Animation(opacity=1, duration=1) # Fade in over 1 second
|
|
fade_in.start(self.image_display) # Start the fade-in animation
|
|
|
|
# Schedule the next media after the duration
|
|
self.image_timer = Clock.schedule_once(self.next_media, duration)
|
|
|
|
def next_media(self, dt=None):
|
|
"""Move to the next media in the playlist."""
|
|
Logger.info("Navigating to the next media.")
|
|
self.current_index = (self.current_index + 1) % len(self.playlist)
|
|
self.play_media()
|
|
|
|
def previous_media(self):
|
|
"""Go to the previous media in the playlist."""
|
|
Logger.info("Navigating to the previous media.")
|
|
self.current_index = (self.current_index - 1) % len(self.playlist)
|
|
self.play_media()
|
|
|
|
def toggle_play_pause(self):
|
|
"""Toggle the play/pause button state and update its appearance."""
|
|
self.manage_play_pause_state()
|
|
|
|
def manage_play_pause_state(self):
|
|
"""Manage the state of the play/pause button and media playback."""
|
|
if self.is_paused:
|
|
Logger.info("Resuming media playback.")
|
|
self.video_player.state = 'play'
|
|
|
|
# Resume the image timer if it exists
|
|
if self.image_timer:
|
|
Logger.info("Resuming image timer.")
|
|
self.image_timer()
|
|
|
|
# Update the button to indicate the playing state
|
|
self.ids.play_pause_button.background_down = './Resurse/play.png'
|
|
self.ids.play_pause_button.background_normal = './Resurse/play.png'
|
|
|
|
# Cancel the reset timer if it exists
|
|
if self.reset_timer:
|
|
Clock.unschedule(self.reset_timer)
|
|
else:
|
|
Logger.info("Pausing media playback.")
|
|
self.video_player.state = 'pause'
|
|
|
|
# Pause the image timer if it exists
|
|
if self.image_timer:
|
|
Logger.info("Pausing image timer.")
|
|
Clock.unschedule(self.image_timer)
|
|
|
|
# Update the button to indicate the paused state
|
|
self.ids.play_pause_button.background_down = './Resurse/pause.png'
|
|
self.ids.play_pause_button.background_normal = './Resurse/pause.png'
|
|
|
|
# Start a timer to reset the button state after 3 minutes
|
|
self.reset_timer = Clock.schedule_once(self.reset_play_pause_state, 180)
|
|
|
|
# Toggle the state
|
|
self.is_paused = not self.is_paused
|
|
|
|
def reset_play_pause_state(self, dt):
|
|
"""Reset the play/pause button state to 'play' after 3 minutes."""
|
|
Logger.info("Resetting play/pause button state to 'play' after timeout.")
|
|
self.is_paused = False
|
|
self.video_player.state = 'play'
|
|
|
|
# Resume the image timer if it exists
|
|
if self.image_timer:
|
|
Logger.info("Resuming image timer.")
|
|
self.image_timer()
|
|
|
|
self.ids.play_pause_button.background_down = './Resurse/play.png'
|
|
self.ids.play_pause_button.background_normal = './Resurse/play.png'
|
|
|
|
def check_playlist_updates(self, dt):
|
|
"""Check for updates to the playlist."""
|
|
new_playlist = load_playlist() # Load the new playlist
|
|
if new_playlist != self.playlist: # Compare the new playlist with the current one
|
|
Logger.info("Playlist updated. Changes detected.")
|
|
self.playlist = new_playlist # Update the playlist
|
|
download_media_files(self.playlist) # Download new media files
|
|
clean_unused_files(self.playlist) # Remove unused files
|
|
self.play_media() # Restart media playback
|
|
else:
|
|
Logger.info("Playlist update skipped. No changes detected.")
|
|
|
|
class SettingsScreen(Screen):
|
|
"""Settings screen for configuring the app."""
|
|
|
|
def __init__(self, **kwargs):
|
|
super(SettingsScreen, self).__init__(**kwargs)
|
|
self.config_data = self.load_config() # Load the configuration data
|
|
|
|
def load_config(self):
|
|
"""Load the configuration from the config file."""
|
|
if os.path.exists(CONFIG_FILE):
|
|
with open(CONFIG_FILE, 'r') as file:
|
|
return json.load(file)
|
|
return {
|
|
"screen_orientation": "",
|
|
"screen_name": "",
|
|
"quickconnect_key": "",
|
|
"server_ip": "",
|
|
"port": "" # Default port
|
|
}
|
|
|
|
def save_config(self):
|
|
"""Save the configuration to the config file."""
|
|
self.config_data["screen_orientation"] = self.ids.orientation_input.text
|
|
self.config_data["screen_name"] = self.ids.screen_name_input.text
|
|
self.config_data["quickconnect_key"] = self.ids.quickconnect_key_input.text
|
|
self.config_data["server_ip"] = self.ids.server_ip_input.text
|
|
self.config_data["port"] = self.ids.port_input.text
|
|
|
|
with open(CONFIG_FILE, 'w') as file:
|
|
json.dump(self.config_data, file)
|
|
Logger.info("SettingsScreen: Configuration saved.")
|
|
|
|
# Return to the MediaPlayer screen after saving
|
|
self.manager.current = 'media_player'
|
|
|
|
def on_pre_enter(self):
|
|
"""Populate input fields with current config data."""
|
|
self.ids.orientation_input.text = self.config_data.get("screen_orientation", "landscape")
|
|
self.ids.screen_name_input.text = self.config_data.get("screen_name", "")
|
|
self.ids.quickconnect_key_input.text = self.config_data.get("quickconnect_key", "")
|
|
self.ids.server_ip_input.text = self.config_data.get("server_ip", "")
|
|
self.ids.port_input.text = self.config_data.get("port", "8080")
|
|
|
|
class MediaPlayerApp(App):
|
|
"""Main application class."""
|
|
|
|
def build(self):
|
|
"""Build the app and initialize screens."""
|
|
Window.fullscreen = True # Start the app in fullscreen mode
|
|
sm = ScreenManager() # Create a screen manager
|
|
sm.add_widget(MediaPlayer(name='media_player')) # Add the MediaPlayer screen
|
|
sm.add_widget(SettingsScreen(name='settings')) # Add the SettingsScreen
|
|
return sm
|
|
|
|
def open_settings(self):
|
|
"""Switch to the SettingsScreen."""
|
|
self.root.current = 'settings'
|
|
|
|
if __name__ == '__main__':
|
|
MediaPlayerApp().run() # Run the app |