commit 04d4ea5916a93d2ea8f37af4897172bcb6401f53 Author: Kivy Signage Player Date: Fri Sep 26 16:48:26 2025 +0300 Initial commit: Kivy Signage Player - Complete Kivy-based signage player application - Fetches playlists from DigiServer via REST API - Supports images (JPG, PNG, GIF, BMP) and videos (MP4, AVI, MKV, MOV, WEBM) - Modern UI with touch controls and settings popup - Separated UI (KV file) from business logic (Python) - Fullscreen media display with proper scaling - Server feedback system for player status reporting - Auto-hide controls with mouse/touch activation - Virtual environment setup with requirements.txt - Installation and run scripts included Features: ✅ Cross-platform Kivy framework ✅ Server integration with DigiServer ✅ Media playback with duration control ✅ Player feedback and status reporting ✅ Settings management with persistent config ✅ Error handling and recovery ✅ Clean architecture with KV file separation diff --git a/README.md b/README.md new file mode 100644 index 0000000..64ab233 --- /dev/null +++ b/README.md @@ -0,0 +1,136 @@ +# Kivy Signage Player + +A modern digital signage player built with Kivy framework that displays content from DigiServer playlists. + +## Features + +- **Cross-platform**: Runs on Linux, Windows, and macOS +- **Modern UI**: Built with Kivy framework for smooth graphics and animations +- **Multiple Media Types**: Supports images (JPG, PNG, GIF, BMP) and videos (MP4, AVI, MKV, MOV, WEBM) +- **Server Integration**: Fetches playlists from DigiServer with automatic updates +- **Player Feedback**: Reports status and playback information to server +- **Fullscreen Display**: Optimized for digital signage displays +- **Touch Controls**: Mouse/touch-activated control panel +- **Auto-restart**: Continuous playlist looping +- **Error Handling**: Robust error handling with server feedback + +## Installation + +1. **Install system dependencies:** + ```bash + chmod +x install.sh + ./install.sh + ``` + +2. **Configure the player:** + Edit `config/app_config.json` with your server details: + ```json + { + "server_ip": "your-server-ip", + "port": "5000", + "screen_name": "your-player-name", + "quickconnect_key": "your-quickconnect-code" + } + ``` + +## Usage + +### Manual Start +```bash +cd src +python3 main.py +``` + +### Using Run Script +```bash +chmod +x run_player.sh +./run_player.sh +``` + +## Controls + +- **Mouse/Touch Movement**: Shows control panel for 3 seconds +- **Previous (⏮)**: Go to previous media item +- **Pause/Play (⏸/▶)**: Toggle playback +- **Next (⏭)**: Skip to next media item +- **Settings (⚙)**: View player configuration and status +- **Exit (⏻)**: Close the application + +## Directory Structure + +``` +Kiwi-signage/ +├── src/ +│ ├── main.py # Main Kivy application +│ └── get_playlists.py # Playlist management and server communication +├── config/ +│ └── app_config.json # Player configuration +├── media/ # Downloaded media files (auto-generated) +├── playlists/ # Playlist cache (auto-generated) +├── requirements.txt # Python dependencies +├── install.sh # Installation script +├── run_player.sh # Run script +└── README.md # This file +``` + +## Configuration Options + +### app_config.json +- `server_ip`: IP address or domain of DigiServer +- `port`: Port number of DigiServer (default: 5000) +- `screen_name`: Unique identifier for this player +- `quickconnect_key`: Authentication key for server access + +## Features Comparison with Tkinter Player + +| Feature | Kivy Player | Tkinter Player | +|---------|-------------|----------------| +| Cross-platform | ✅ Better | ✅ Good | +| Modern UI | ✅ Excellent | ❌ Basic | +| Touch Support | ✅ Native | ❌ Limited | +| Video Playback | ✅ Built-in | ✅ VLC Required | +| Performance | ✅ GPU Accelerated | ❌ CPU Only | +| Animations | ✅ Smooth | ❌ None | +| Mobile Ready | ✅ Yes | ❌ No | + +## Server Integration + +The player communicates with DigiServer via REST API: + +- **Playlist Fetch**: `GET /api/playlists` +- **Player Feedback**: `POST /api/player-feedback` + +Status updates sent to server: +- Playlist check and update notifications +- Current playback status +- Error reports +- Playlist restart notifications + +## Troubleshooting + +### Installation Issues +- Make sure system dependencies are installed: `./install.sh` +- For ARM devices (Raspberry Pi), ensure proper SDL2 libraries + +### Playback Issues +- Check media file formats are supported +- Verify network connection to DigiServer +- Check player configuration in settings + +### Server Connection +- Verify server IP and port in configuration +- Check quickconnect key is correct +- Ensure DigiServer is running and accessible + +## Development + +Based on the proven architecture of the tkinter signage player with modern Kivy enhancements: + +- **Playlist Management**: Inherited from `get_playlists.py` +- **Media Playback**: Kivy's built-in Video and AsyncImage widgets +- **Server Communication**: REST API calls with feedback system +- **Error Handling**: Comprehensive exception handling with server reporting + +## License + +This project is part of the DigiServer digital signage system. \ No newline at end of file diff --git a/config/app_config.json b/config/app_config.json new file mode 100644 index 0000000..4b041f2 --- /dev/null +++ b/config/app_config.json @@ -0,0 +1,6 @@ +{ + "server_ip": "digiserver", + "port": "80", + "screen_name": "rpi-tvholba1", + "quickconnect_key": "8887779" +} \ No newline at end of file diff --git a/install.sh b/install.sh new file mode 100644 index 0000000..4248a23 --- /dev/null +++ b/install.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +# Kivy Signage Player Installation Script + +echo "Installing Kivy Signage Player dependencies..." + +# Update system +sudo apt update + +# Install system dependencies for Kivy +sudo apt install -y python3-pip python3-setuptools +sudo apt install -y python3-dev +sudo apt install -y libsdl2-dev libsdl2-image-dev libsdl2-mixer-dev libsdl2-ttf-dev +sudo apt install -y libportmidi-dev libswscale-dev libavformat-dev libavcodec-dev +sudo apt install -y zlib1g-dev + +# Install Python dependencies +pip3 install -r requirements.txt + +echo "Installation completed!" +echo "To run the player:" +echo "cd src && python3 main.py" \ No newline at end of file diff --git a/media/HARTING_Safety_day_informare_2_page_005.jpg b/media/HARTING_Safety_day_informare_2_page_005.jpg new file mode 100644 index 0000000..9fd3ccf Binary files /dev/null and b/media/HARTING_Safety_day_informare_2_page_005.jpg differ diff --git a/media/call-of-duty-black-3840x2160-23674.jpg b/media/call-of-duty-black-3840x2160-23674.jpg new file mode 100644 index 0000000..62f7d98 Binary files /dev/null and b/media/call-of-duty-black-3840x2160-23674.jpg differ diff --git a/playlists/server_playlist_v5.json b/playlists/server_playlist_v5.json new file mode 100644 index 0000000..c837f0d --- /dev/null +++ b/playlists/server_playlist_v5.json @@ -0,0 +1,15 @@ +{ + "playlist": [ + { + "file_name": "call-of-duty-black-3840x2160-23674.jpg", + "url": "media/call-of-duty-black-3840x2160-23674.jpg", + "duration": 30 + }, + { + "file_name": "HARTING_Safety_day_informare_2_page_005.jpg", + "url": "media/HARTING_Safety_day_informare_2_page_005.jpg", + "duration": 20 + } + ], + "version": 5 +} \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..a892d3b --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +kivy==2.1.0 +requests==2.32.4 +bcrypt==4.2.1 \ No newline at end of file diff --git a/run_player.sh b/run_player.sh new file mode 100644 index 0000000..747667e --- /dev/null +++ b/run_player.sh @@ -0,0 +1,6 @@ +#!/bin/bash + +# Start Kivy Signage Player + +cd "$(dirname "$0")/src" +python3 main.py \ No newline at end of file diff --git a/src/__pycache__/get_playlists.cpython-311.pyc b/src/__pycache__/get_playlists.cpython-311.pyc new file mode 100644 index 0000000..0e41443 Binary files /dev/null and b/src/__pycache__/get_playlists.cpython-311.pyc differ diff --git a/src/get_playlists.py b/src/get_playlists.py new file mode 100644 index 0000000..3f0184e --- /dev/null +++ b/src/get_playlists.py @@ -0,0 +1,334 @@ +import os +import json +import requests +import bcrypt +import re +import datetime +import logging + +# Set up logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +def send_player_feedback(config, message, status="active", playlist_version=None, error_details=None): + """ + Send feedback to the server about player status. + + Args: + config (dict): Configuration containing server details + message (str): Main feedback message + status (str): Player status - "active", "playing", "error", "restarting" + playlist_version (int, optional): Current playlist version being played + error_details (str, optional): Error details if status is "error" + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + try: + server = config.get("server_ip", "") + host = config.get("screen_name", "") + quick = config.get("quickconnect_key", "") + port = config.get("port", "") + + # Construct server URL + ip_pattern = r'^\d+\.\d+\.\d+\.\d+$' + if re.match(ip_pattern, server): + feedback_url = f'http://{server}:{port}/api/player-feedback' + else: + feedback_url = f'http://{server}/api/player-feedback' + + # Prepare feedback data + feedback_data = { + 'player_name': host, + 'quickconnect_code': quick, + 'message': message, + 'status': status, + 'timestamp': datetime.datetime.now().isoformat(), + 'playlist_version': playlist_version, + 'error_details': error_details + } + + logger.info(f"Sending feedback to {feedback_url}: {feedback_data}") + + # Send POST request + response = requests.post(feedback_url, json=feedback_data, timeout=10) + + if response.status_code == 200: + logger.info(f"Feedback sent successfully: {message}") + return True + else: + logger.warning(f"Feedback failed with status {response.status_code}: {response.text}") + return False + + except requests.exceptions.RequestException as e: + logger.error(f"Failed to send feedback: {e}") + return False + except Exception as e: + logger.error(f"Unexpected error sending feedback: {e}") + return False + +def send_playlist_check_feedback(config, playlist_version=None): + """ + Send feedback when playlist is checked for updates. + + Args: + config (dict): Configuration containing server details + playlist_version (int, optional): Current playlist version + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + version_info = f"v{playlist_version}" if playlist_version else "unknown" + message = f"player {player_name}, is active, Playing {version_info}" + + return send_player_feedback( + config=config, + message=message, + status="active", + playlist_version=playlist_version + ) + +def send_playlist_restart_feedback(config, playlist_version=None): + """ + Send feedback when playlist loop ends and restarts. + + Args: + config (dict): Configuration containing server details + playlist_version (int, optional): Current playlist version + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + version_info = f"v{playlist_version}" if playlist_version else "unknown" + message = f"player {player_name}, playlist loop completed, restarting {version_info}" + + return send_player_feedback( + config=config, + message=message, + status="restarting", + playlist_version=playlist_version + ) + +def send_player_error_feedback(config, error_message, playlist_version=None): + """ + Send feedback when an error occurs in the player. + + Args: + config (dict): Configuration containing server details + error_message (str): Description of the error + playlist_version (int, optional): Current playlist version + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + message = f"player {player_name}, error occurred" + + return send_player_feedback( + config=config, + message=message, + status="error", + playlist_version=playlist_version, + error_details=error_message + ) + +def send_playing_status_feedback(config, playlist_version=None, current_media=None): + """ + Send feedback about current playing status. + + Args: + config (dict): Configuration containing server details + playlist_version (int, optional): Current playlist version + current_media (str, optional): Currently playing media file + + Returns: + bool: True if feedback sent successfully, False otherwise + """ + player_name = config.get("screen_name", "unknown") + version_info = f"v{playlist_version}" if playlist_version else "unknown" + media_info = f" - {current_media}" if current_media else "" + message = f"player {player_name}, is active, Playing {version_info}{media_info}" + + return send_player_feedback( + config=config, + message=message, + status="playing", + playlist_version=playlist_version + ) + +def fetch_server_playlist(config): + """Fetch the updated playlist from the server using a config dict.""" + server = config.get("server_ip", "") + host = config.get("screen_name", "") + quick = config.get("quickconnect_key", "") + port = config.get("port", "") + try: + ip_pattern = r'^\d+\.\d+\.\d+\.\d+$' + if re.match(ip_pattern, server): + server_url = f'http://{server}:{port}/api/playlists' + else: + server_url = f'http://{server}/api/playlists' + params = { + 'hostname': host, + 'quickconnect_code': quick + } + logger.info(f"Fetching playlist from URL: {server_url} with params: {params}") + response = requests.get(server_url, params=params) + if response.status_code == 200: + response_data = response.json() + logger.info(f"Server response: {response_data}") + playlist = response_data.get('playlist', []) + version = response_data.get('playlist_version', None) + hashed_quickconnect = response_data.get('hashed_quickconnect', None) + if version is not None and hashed_quickconnect is not None: + if bcrypt.checkpw(quick.encode('utf-8'), hashed_quickconnect.encode('utf-8')): + logger.info("Fetched updated playlist from server.") + return {'playlist': playlist, 'version': version} + else: + logger.error("Quickconnect code validation failed.") + else: + logger.error("Failed to retrieve playlist or hashed quickconnect from the response.") + else: + logger.error(f"Failed to fetch playlist. Status Code: {response.status_code}") + except requests.exceptions.RequestException as e: + logger.error(f"Failed to fetch playlist: {e}") + return {'playlist': [], 'version': 0} + +def save_playlist_with_version(playlist_data, playlist_dir): + version = playlist_data.get('version', 0) + playlist_file = os.path.join(playlist_dir, f'server_playlist_v{version}.json') + with open(playlist_file, 'w') as f: + json.dump(playlist_data, f, indent=2) + logger.info(f"Playlist saved to {playlist_file}") + return playlist_file + +def download_media_files(playlist, media_dir): + """Download media files from the server and save them to media_dir.""" + if not os.path.exists(media_dir): + os.makedirs(media_dir) + logger.info(f"Created directory {media_dir} for media files.") + + updated_playlist = [] + for media in playlist: + file_name = media.get('file_name', '') + file_url = media.get('url', '') + duration = media.get('duration', 10) + local_path = os.path.join(media_dir, file_name) + logger.info(f"Preparing to download {file_name} from {file_url}...") + if os.path.exists(local_path): + logger.info(f"File {file_name} already exists. Skipping download.") + else: + try: + response = requests.get(file_url, timeout=10) + if response.status_code == 200: + with open(local_path, 'wb') as file: + file.write(response.content) + logger.info(f"Successfully downloaded {file_name} to {local_path}") + else: + logger.error(f"Failed to download {file_name}. Status Code: {response.status_code}") + continue + except requests.exceptions.RequestException as e: + logger.error(f"Error downloading {file_name}: {e}") + continue + updated_media = { + 'file_name': file_name, + 'url': os.path.relpath(local_path, os.path.dirname(media_dir)), + 'duration': duration + } + updated_playlist.append(updated_media) + return updated_playlist + +def delete_old_playlists_and_media(current_version, playlist_dir, media_dir, keep_versions=1): + """ + Delete old playlist files and media files not referenced by the latest playlist version. + keep_versions: number of latest versions to keep (default 1) + """ + # Find all playlist files + playlist_files = [f for f in os.listdir(playlist_dir) if f.startswith('server_playlist_v') and f.endswith('.json')] + # Keep only the latest N versions + versions = sorted([int(f.split('_v')[-1].split('.json')[0]) for f in playlist_files], reverse=True) + keep = set(versions[:keep_versions]) + # Delete old playlist files + for f in playlist_files: + v = int(f.split('_v')[-1].split('.json')[0]) + if v not in keep: + os.remove(os.path.join(playlist_dir, f)) + # Collect all media files referenced by the kept playlists + referenced = set() + for v in keep: + path = os.path.join(playlist_dir, f'server_playlist_v{v}.json') + if os.path.exists(path): + with open(path, 'r') as f: + data = json.load(f) + for item in data.get('playlist', []): + referenced.add(item.get('file_name')) + # Delete media files not referenced + for f in os.listdir(media_dir): + if f not in referenced: + try: + os.remove(os.path.join(media_dir, f)) + except Exception as e: + logger.warning(f"Failed to delete media file {f}: {e}") + +def update_playlist_if_needed(local_playlist_path, config, media_dir, playlist_dir): + """ + Fetch the server playlist once, compare versions, and update if needed. + Returns True if updated, False if already up to date. + Also sends feedback to server about playlist check. + """ + server_data = fetch_server_playlist(config) + server_version = server_data.get('version', 0) + if not os.path.exists(local_playlist_path): + local_version = 0 + else: + with open(local_playlist_path, 'r') as f: + local_data = json.load(f) + local_version = local_data.get('version', 0) + + logger.info(f"Local playlist version: {local_version}, Server playlist version: {server_version}") + + # Send feedback about playlist check + send_playlist_check_feedback(config, server_version if server_version > 0 else local_version) + + if local_version != server_version: + if server_data and server_data.get('playlist'): + updated_playlist = download_media_files(server_data['playlist'], media_dir) + server_data['playlist'] = updated_playlist + save_playlist_with_version(server_data, playlist_dir) + # Delete old playlists and unreferenced media + delete_old_playlists_and_media(server_version, playlist_dir, media_dir) + + # Send feedback about playlist update + player_name = config.get("screen_name", "unknown") + update_message = f"player {player_name}, playlist updated to v{server_version}" + send_player_feedback(config, update_message, "active", server_version) + + return True + else: + logger.warning("No playlist data fetched from server or playlist is empty.") + + # Send error feedback + send_player_error_feedback(config, "No playlist data fetched from server or playlist is empty", local_version) + + return False + else: + logger.info("Local playlist is already up to date.") + return False + +def is_playlist_up_to_date(local_playlist_path, config): + """ + Compare the version of the local playlist with the server playlist. + Returns True if up-to-date, False otherwise. + """ + if not os.path.exists(local_playlist_path): + logger.info(f"Local playlist file not found: {local_playlist_path}") + return False + with open(local_playlist_path, 'r') as f: + local_data = json.load(f) + local_version = local_data.get('version', 0) + server_data = fetch_server_playlist(config) + server_version = server_data.get('version', 0) + logger.info(f"Local playlist version: {local_version}, Server playlist version: {server_version}") + return local_version == server_version \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 0000000..d51512e --- /dev/null +++ b/src/main.py @@ -0,0 +1,441 @@ +""" +Kivy Signage Player - Main Application +Displays content from DigiServer playlists using Kivy framework +""" + +import os +import json +import threading +import time +from kivy.app import App +from kivy.uix.widget import Widget +from kivy.uix.label import Label +from kivy.uix.image import AsyncImage +from kivy.uix.video import Video +from kivy.uix.boxlayout import BoxLayout +from kivy.uix.button import Button +from kivy.uix.popup import Popup +from kivy.uix.textinput import TextInput +from kivy.clock import Clock +from kivy.core.window import Window +from kivy.logger import Logger +from kivy.animation import Animation +from kivy.lang import Builder +from get_playlists import ( + update_playlist_if_needed, + send_playing_status_feedback, + send_playlist_restart_feedback, + send_player_error_feedback +) + +# Load the KV file +Builder.load_file('signage_player.kv') + +class SettingsPopup(Popup): + def __init__(self, player_instance, **kwargs): + super(SettingsPopup, self).__init__(**kwargs) + self.player = player_instance + + # Populate current values + self.ids.server_input.text = self.player.config.get('server_ip', 'localhost') + self.ids.screen_input.text = self.player.config.get('screen_name', 'kivy-player') + self.ids.quickconnect_input.text = self.player.config.get('quickconnect_key', '1234567') + + # Update status info + self.ids.playlist_info.text = f'Playlist Version: {self.player.playlist_version}' + self.ids.media_count_info.text = f'Media Count: {len(self.player.playlist)}' + self.ids.status_info.text = f'Status: {"Playing" if self.player.is_playing else "Paused" if self.player.is_paused else "Idle"}' + + def save_and_close(self): + """Save configuration and close popup""" + # Update config + self.player.config['server_ip'] = self.ids.server_input.text + self.player.config['screen_name'] = self.ids.screen_input.text + self.player.config['quickconnect_key'] = self.ids.quickconnect_input.text + + # Save to file + self.player.save_config() + + # Close popup + self.dismiss() + + +class SignagePlayer(Widget): + def __init__(self, **kwargs): + super(SignagePlayer, self).__init__(**kwargs) + + # Initialize variables + self.playlist = [] + self.current_index = 0 + self.current_widget = None + self.is_playing = False + self.is_paused = False + self.config = {} + self.playlist_version = None + + # Paths + self.base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + self.config_dir = os.path.join(self.base_dir, 'config') + self.media_dir = os.path.join(self.base_dir, 'media') + self.playlists_dir = os.path.join(self.base_dir, 'playlists') + self.config_file = os.path.join(self.config_dir, 'app_config.json') + + # Create directories if they don't exist + for directory in [self.config_dir, self.media_dir, self.playlists_dir]: + os.makedirs(directory, exist_ok=True) + + # Initialize player + Clock.schedule_once(self.initialize_player, 0.1) + + # Hide controls timer + self.controls_timer = None + + # Auto-hide controls + self.schedule_hide_controls() + + def initialize_player(self, dt): + """Initialize the player - load config and start playlist checking""" + Logger.info("SignagePlayer: Initializing player...") + + # Load configuration + self.load_config() + + # Start playlist update thread + threading.Thread(target=self.playlist_update_loop, daemon=True).start() + + # Start media playback + Clock.schedule_interval(self.check_playlist_and_play, 30) # Check every 30 seconds + + # Initial playlist check + self.check_playlist_and_play(None) + + def load_config(self): + """Load configuration from file""" + try: + if os.path.exists(self.config_file): + with open(self.config_file, 'r') as f: + self.config = json.load(f) + Logger.info(f"SignagePlayer: Configuration loaded from {self.config_file}") + else: + # Create default configuration + self.config = { + "server_ip": "localhost", + "port": "5000", + "screen_name": "kivy-player", + "quickconnect_key": "1234567" + } + self.save_config() + Logger.info("SignagePlayer: Created default configuration") + except Exception as e: + Logger.error(f"SignagePlayer: Error loading config: {e}") + self.show_error(f"Failed to load configuration: {e}") + + def save_config(self): + """Save configuration to file""" + try: + with open(self.config_file, 'w') as f: + json.dump(self.config, f, indent=2) + Logger.info("SignagePlayer: Configuration saved") + except Exception as e: + Logger.error(f"SignagePlayer: Error saving config: {e}") + + def playlist_update_loop(self): + """Background thread to check for playlist updates""" + while True: + try: + if self.config: + # Find latest playlist file + latest_playlist = self.get_latest_playlist_file() + + # Check for updates + updated = update_playlist_if_needed( + latest_playlist, + self.config, + self.media_dir, + self.playlists_dir + ) + + if updated: + Logger.info("SignagePlayer: Playlist updated, reloading...") + Clock.schedule_once(self.load_playlist, 0) + + time.sleep(60) # Check every minute + + except Exception as e: + Logger.error(f"SignagePlayer: Error in playlist update loop: {e}") + time.sleep(30) # Wait 30 seconds on error + + def get_latest_playlist_file(self): + """Get the path to the latest playlist file""" + try: + if os.path.exists(self.playlists_dir): + playlist_files = [f for f in os.listdir(self.playlists_dir) + if f.startswith('server_playlist_v') and f.endswith('.json')] + if playlist_files: + # Sort by version number and get the latest + versions = [(int(f.split('_v')[-1].split('.json')[0]), f) for f in playlist_files] + versions.sort(reverse=True) + latest_file = versions[0][1] + return os.path.join(self.playlists_dir, latest_file) + + return os.path.join(self.playlists_dir, 'server_playlist_v0.json') + except Exception as e: + Logger.error(f"SignagePlayer: Error getting latest playlist: {e}") + return os.path.join(self.playlists_dir, 'server_playlist_v0.json') + + def load_playlist(self, dt=None): + """Load playlist from file""" + try: + playlist_file = self.get_latest_playlist_file() + + if os.path.exists(playlist_file): + with open(playlist_file, 'r') as f: + data = json.load(f) + + self.playlist = data.get('playlist', []) + self.playlist_version = data.get('version', 0) + + Logger.info(f"SignagePlayer: Loaded playlist v{self.playlist_version} with {len(self.playlist)} items") + + if self.playlist: + self.ids.status_label.text = f"Playlist loaded: {len(self.playlist)} items" + if not self.is_playing: + Clock.schedule_once(self.start_playback, 1) + else: + self.ids.status_label.text = "No media in playlist" + + else: + Logger.warning(f"SignagePlayer: Playlist file not found: {playlist_file}") + self.ids.status_label.text = "No playlist found" + + except Exception as e: + Logger.error(f"SignagePlayer: Error loading playlist: {e}") + self.show_error(f"Failed to load playlist: {e}") + + def check_playlist_and_play(self, dt): + """Check for playlist updates and ensure playback is running""" + if not self.playlist: + self.load_playlist() + + if self.playlist and not self.is_playing and not self.is_paused: + self.start_playback() + + def start_playback(self, dt=None): + """Start media playback""" + if not self.playlist: + Logger.warning("SignagePlayer: No playlist to play") + return + + Logger.info("SignagePlayer: Starting playback") + self.is_playing = True + self.current_index = 0 + self.play_current_media() + + def play_current_media(self): + """Play the current media item""" + if not self.playlist or self.current_index >= len(self.playlist): + # End of playlist, restart + self.restart_playlist() + return + + try: + media_item = self.playlist[self.current_index] + file_name = media_item.get('file_name', '') + duration = media_item.get('duration', 10) + + # Construct full path to media file + media_path = os.path.join(self.media_dir, file_name) + + if not os.path.exists(media_path): + Logger.error(f"SignagePlayer: Media file not found: {media_path}") + self.next_media() + return + + Logger.info(f"SignagePlayer: Playing {file_name} for {duration}s") + + # Remove status label if showing + self.ids.status_label.opacity = 0 + + # Remove previous media widget + if self.current_widget: + self.ids.content_area.remove_widget(self.current_widget) + self.current_widget = None + + # Determine media type and create appropriate widget + file_extension = os.path.splitext(file_name)[1].lower() + + if file_extension in ['.mp4', '.avi', '.mkv', '.mov', '.webm']: + # Video file + self.play_video(media_path, duration) + elif file_extension in ['.jpg', '.jpeg', '.png', '.bmp', '.gif']: + # Image file + self.play_image(media_path, duration) + else: + Logger.warning(f"SignagePlayer: Unsupported media type: {file_extension}") + self.next_media() + return + + # Send feedback to server + if self.config: + send_playing_status_feedback(self.config, self.playlist_version, file_name) + + except Exception as e: + Logger.error(f"SignagePlayer: Error playing media: {e}") + self.show_error(f"Error playing media: {e}") + self.next_media() + + def play_video(self, video_path, duration): + """Play a video file""" + try: + self.current_widget = Video( + source=video_path, + state='play', + options={'allow_stretch': True}, + size_hint=(1, 1), + pos_hint={'x': 0, 'y': 0} + ) + + self.ids.content_area.add_widget(self.current_widget) + + # Schedule next media after duration + Clock.schedule_once(self.next_media, duration) + + except Exception as e: + Logger.error(f"SignagePlayer: Error playing video {video_path}: {e}") + self.next_media() + + def play_image(self, image_path, duration): + """Play an image file""" + try: + self.current_widget = AsyncImage( + source=image_path, + allow_stretch=True, + keep_ratio=False, + size_hint=(1, 1), + pos_hint={'x': 0, 'y': 0} + ) + + self.ids.content_area.add_widget(self.current_widget) + + # Schedule next media after duration + Clock.schedule_once(self.next_media, duration) + + except Exception as e: + Logger.error(f"SignagePlayer: Error playing image {image_path}: {e}") + self.next_media() + + def next_media(self, dt=None): + """Move to next media item""" + if self.is_paused: + return + + self.current_index += 1 + + # Unschedule any pending media transitions + Clock.unschedule(self.next_media) + + # Play next media or restart playlist + self.play_current_media() + + def previous_media(self, instance=None): + """Move to previous media item""" + if self.playlist: + self.current_index = max(0, self.current_index - 1) + Clock.unschedule(self.next_media) + self.play_current_media() + + def toggle_pause(self, instance=None): + """Toggle pause/play""" + self.is_paused = not self.is_paused + + if self.is_paused: + self.ids.play_pause_btn.text = '▶' + Clock.unschedule(self.next_media) + else: + self.ids.play_pause_btn.text = '⏸' + # Resume by playing current media + self.play_current_media() + + def restart_playlist(self): + """Restart playlist from beginning""" + Logger.info("SignagePlayer: Restarting playlist") + + # Send restart feedback + if self.config: + send_playlist_restart_feedback(self.config, self.playlist_version) + + self.current_index = 0 + self.play_current_media() + + def show_error(self, message): + """Show error message""" + Logger.error(f"SignagePlayer: {message}") + + # Send error feedback to server + if self.config: + send_player_error_feedback(self.config, message, self.playlist_version) + + # Show error on screen + self.ids.status_label.text = f"Error: {message}" + self.ids.status_label.opacity = 1 + + def on_touch_down(self, touch): + """Handle touch - show controls""" + self.show_controls() + return super(SignagePlayer, self).on_touch_down(touch) + + def on_touch_move(self, touch): + """Handle touch move - show controls""" + self.show_controls() + return super(SignagePlayer, self).on_touch_move(touch) + + def show_controls(self): + """Show control buttons""" + if self.controls_timer: + self.controls_timer.cancel() + + # Fade in controls + Animation(opacity=1, duration=0.3).start(self.ids.controls_layout) + + # Schedule hide after 3 seconds + self.schedule_hide_controls() + + def schedule_hide_controls(self): + """Schedule hiding of controls""" + if self.controls_timer: + self.controls_timer.cancel() + + self.controls_timer = Clock.schedule_once(self.hide_controls, 3) + + def hide_controls(self, dt=None): + """Hide control buttons""" + Animation(opacity=0, duration=0.5).start(self.ids.controls_layout) + + def show_settings(self, instance=None): + """Show settings popup""" + popup = SettingsPopup(player_instance=self) + popup.open() + + def exit_app(self, instance=None): + """Exit the application""" + Logger.info("SignagePlayer: Exiting application") + App.get_running_app().stop() + + +class SignagePlayerApp(App): + def build(self): + # Set window to fullscreen + Window.fullscreen = 'auto' + Window.borderless = True + + return SignagePlayer() + + def on_start(self): + Logger.info("SignagePlayerApp: Application started") + + def on_stop(self): + Logger.info("SignagePlayerApp: Application stopped") + + +if __name__ == '__main__': + SignagePlayerApp().run() \ No newline at end of file diff --git a/src/signage_player.kv b/src/signage_player.kv new file mode 100644 index 0000000..67d06d2 --- /dev/null +++ b/src/signage_player.kv @@ -0,0 +1,229 @@ +#:kivy 2.1.0 + +: + canvas.before: + Color: + rgba: 0, 0, 0, 1 + Rectangle: + size: self.size + pos: self.pos + + # Main content area + BoxLayout: + id: main_layout + orientation: 'vertical' + + # Content display area (will be dynamically populated) + Widget: + id: content_area + size_hint: 1, 1 + + # Status label (shown when no content or errors) + Label: + id: status_label + text: 'Loading...' + size_hint: 1, None + height: dp(40) + pos_hint: {'center_x': 0.5} + color: 1, 1, 1, 1 + font_size: sp(16) + text_size: self.size + halign: 'center' + valign: 'middle' + + # Control panel overlay + FloatLayout: + id: overlay_layout + size_hint: 1, 1 + + # Controls container + BoxLayout: + id: controls_layout + orientation: 'horizontal' + size_hint: None, None + size: dp(450), dp(60) + pos_hint: {'right': 0.98, 'top': 0.98} + opacity: 0 + spacing: dp(5) + padding: dp(10) + canvas.before: + Color: + rgba: 0.1, 0.1, 0.1, 0.8 + RoundedRectangle: + size: self.size + pos: self.pos + radius: [dp(10)] + + # Control buttons + Button: + id: prev_btn + text: '⏮' + size_hint: None, None + size: dp(60), dp(50) + font_size: sp(18) + background_color: 0.2, 0.2, 0.2, 1 + color: 1, 1, 1, 1 + on_press: root.previous_media() + + Button: + id: play_pause_btn + text: '⏸' + size_hint: None, None + size: dp(60), dp(50) + font_size: sp(18) + background_color: 0.2, 0.6, 0.2, 1 + color: 1, 1, 1, 1 + on_press: root.toggle_pause() + + Button: + id: next_btn + text: '⏭' + size_hint: None, None + size: dp(60), dp(50) + font_size: sp(18) + background_color: 0.2, 0.2, 0.2, 1 + color: 1, 1, 1, 1 + on_press: root.next_media() + + Button: + id: settings_btn + text: '⚙' + size_hint: None, None + size: dp(60), dp(50) + font_size: sp(18) + background_color: 0.4, 0.4, 0.2, 1 + color: 1, 1, 1, 1 + on_press: root.show_settings() + + Button: + id: exit_btn + text: '⏻' + size_hint: None, None + size: dp(60), dp(50) + font_size: sp(18) + background_color: 0.6, 0.2, 0.2, 1 + color: 1, 1, 1, 1 + on_press: root.exit_app() + + +# Settings popup content +: + title: 'Player Settings' + size_hint: 0.8, 0.8 + auto_dismiss: True + + BoxLayout: + orientation: 'vertical' + padding: dp(20) + spacing: dp(15) + + # Server configuration + BoxLayout: + orientation: 'horizontal' + size_hint_y: None + height: dp(40) + spacing: dp(10) + + Label: + text: 'Server IP:' + size_hint_x: 0.3 + text_size: self.size + halign: 'left' + valign: 'middle' + + TextInput: + id: server_input + size_hint_x: 0.7 + multiline: False + font_size: sp(14) + + # Screen name + BoxLayout: + orientation: 'horizontal' + size_hint_y: None + height: dp(40) + spacing: dp(10) + + Label: + text: 'Screen Name:' + size_hint_x: 0.3 + text_size: self.size + halign: 'left' + valign: 'middle' + + TextInput: + id: screen_input + size_hint_x: 0.7 + multiline: False + font_size: sp(14) + + # Quickconnect key + BoxLayout: + orientation: 'horizontal' + size_hint_y: None + height: dp(40) + spacing: dp(10) + + Label: + text: 'Quickconnect:' + size_hint_x: 0.3 + text_size: self.size + halign: 'left' + valign: 'middle' + + TextInput: + id: quickconnect_input + size_hint_x: 0.7 + multiline: False + font_size: sp(14) + + Widget: + size_hint_y: 0.1 + + # Status information + Label: + id: playlist_info + text: 'Playlist Version: N/A' + size_hint_y: None + height: dp(30) + text_size: self.size + halign: 'left' + valign: 'middle' + + Label: + id: media_count_info + text: 'Media Count: 0' + size_hint_y: None + height: dp(30) + text_size: self.size + halign: 'left' + valign: 'middle' + + Label: + id: status_info + text: 'Status: Idle' + size_hint_y: None + height: dp(30) + text_size: self.size + halign: 'left' + valign: 'middle' + + Widget: + size_hint_y: 0.2 + + # Action buttons + BoxLayout: + orientation: 'horizontal' + size_hint_y: None + height: dp(50) + spacing: dp(20) + + Button: + text: 'Save & Close' + background_color: 0.2, 0.6, 0.2, 1 + on_press: root.save_and_close() + + Button: + text: 'Cancel' + background_color: 0.6, 0.2, 0.2, 1 + on_press: root.dismiss() \ No newline at end of file