Add autostart functionality and power management for Raspberry Pi

- Enhanced install.sh with comprehensive autostart workflow: * XDG autostart entry (desktop environment) * systemd user service (most reliable) * LXDE autostart support (Raspberry Pi OS) * Cron fallback (@reboot) * Terminal mode enabled for debugging - Added Raspberry Pi power management features: * Disable HDMI screen blanking * Prevent CPU power saving (performance mode) * Disable system sleep/suspend * X11 screensaver disabled * Display power management (DPMS) disabled - Fixed sudo compatibility: * Properly detects actual user when run with sudo * Correct file ownership for user configs * systemctl --user works correctly - Player launches in terminal for error visibility - Autostart configured to use start.sh (watchdog with auto-restart)
2026-01-17 18:50:47 +02:00
parent c5bf6c1eaf
commit 81432ac832
14 changed files with 1948 additions and 41 deletions
@@ -1,12 +1,14 @@
 """
 Updated get_playlists.py for Kiwy-Signage with DigiServer v2 authentication
 Uses secure auth flow: hostname → password/quickconnect → auth_code → API calls
+Now with HTTPS support and SSL certificate management
 """
 import os
 import json
 import requests
 import logging
 from player_auth import PlayerAuth
+from ssl_utils import SSLManager

 # Set up logging
 logging.basicConfig(level=logging.INFO)
@@ -16,11 +18,17 @@ logger = logging.getLogger(__name__)
 _auth_instance = None


-def get_auth_instance(config_file='player_auth.json'):
-    """Get or create global auth instance."""
+def get_auth_instance(config_file='player_auth.json', use_https=True, verify_ssl=True):
+    """Get or create global auth instance.
+    
+    Args:
+        config_file: Authentication config file path
+        use_https: Whether to use HTTPS
+        verify_ssl: Whether to verify SSL certificates
+    """
    global _auth_instance
    if _auth_instance is None:
-        _auth_instance = PlayerAuth(config_file)
+        _auth_instance = PlayerAuth(config_file, use_https=use_https, verify_ssl=verify_ssl)
    return _auth_instance


@@ -33,7 +41,10 @@ def ensure_authenticated(config):
    Returns:
        PlayerAuth instance if authenticated, None otherwise
    """
-    auth = get_auth_instance()
+    auth = get_auth_instance(
+        use_https=config.get('use_https', True),
+        verify_ssl=config.get('verify_ssl', True)
+    )
    
    # If already authenticated and valid, return auth instance
    if auth.is_authenticated():
@@ -49,6 +60,7 @@ def ensure_authenticated(config):
    hostname = config.get("screen_name", "")
    quickconnect_key = config.get("quickconnect_key", "")
    port = config.get("port", "")
+    use_https = config.get("use_https", True)
    
    if not all([server_ip, hostname, quickconnect_key]):
        logger.error("❌ Missing configuration: server_ip, screen_name, or quickconnect_key")
@@ -58,12 +70,20 @@ def ensure_authenticated(config):
    import re
    ip_pattern = r'^\d+\.\d+\.\d+\.\d+$'
    if re.match(ip_pattern, server_ip):
-        server_url = f'http://{server_ip}:{port}'
+        if use_https:
+            # Use HTTPS for IP addresses
+            server_url = f'https://{server_ip}:{port}' if port else f'https://{server_ip}'
+        else:
+            server_url = f'http://{server_ip}:{port}'
    else:
-        server_url = f'http://{server_ip}'
+        # For domain names, use HTTPS by default
+        if use_https:
+            server_url = f'https://{server_ip}'
+        else:
+            server_url = f'http://{server_ip}'
    
    # Authenticate using quickconnect code
-    logger.info(f"🔐 Authenticating player: {hostname}")
+    logger.info(f"🔐 Authenticating player: {hostname} at {server_url}")
    success, error = auth.authenticate(
        server_url=server_url,
        hostname=hostname,
@@ -202,12 +222,22 @@ def save_playlist(playlist_data, playlist_dir):
    return playlist_file


-def download_media_files(playlist, media_dir):
-    """Download media files from the server and save them to media_dir."""
+def download_media_files(playlist, media_dir, ssl_manager=None, server_url=None):
+    """Download media files from the server and save them to media_dir.
+    
+    Args:
+        playlist: List of media items
+        media_dir: Directory to save media files
+        ssl_manager: Optional SSLManager for HTTPS downloads
+        server_url: Server base URL for constructing full file URLs
+    """
    if not os.path.exists(media_dir):
        os.makedirs(media_dir)
        logger.info(f"📁 Created directory {media_dir} for media files")

+    # Use SSL manager if provided, otherwise use requests directly
+    session = ssl_manager.get_session() if ssl_manager else requests.Session()
+    
    updated_playlist = []
    for media in playlist:
        file_name = media.get('file_name', '')
@@ -224,18 +254,57 @@ def download_media_files(playlist, media_dir):
                # Create parent directories if they don't exist (for nested paths like edited_media/5/)
                os.makedirs(os.path.dirname(local_path), exist_ok=True)
                
-                response = requests.get(file_url, timeout=30)
+                # Construct full URL
+                download_url = file_url
+                
+                # Handle localhost URLs - replace with actual server IP
+                if 'localhost' in file_url or 'localhost' in (server_url or ''):
+                    if server_url:
+                        # Extract the path from localhost URL
+                        if 'localhost' in file_url:
+                            # URL like: https://localhost/static/uploads/file.jpg
+                            # Extract path: /static/uploads/file.jpg
+                            parts = file_url.split('localhost')
+                            if len(parts) > 1:
+                                path = parts[1]
+                                download_url = f"{server_url}{path}"
+                                logger.info(f"🔄 Replacing localhost with {server_url}")
+                            else:
+                                download_url = file_url
+                        else:
+                            download_url = file_url
+                    else:
+                        logger.warning(f"⚠️ localhost URL provided but no server_url available: {file_url}")
+                        download_url = file_url
+                
+                # Construct full URL if relative path is provided
+                elif not file_url.startswith('http'):
+                    if server_url:
+                        download_url = f"{server_url}/{file_url}".replace('//', '/')
+                        # Fix the protocol part that might have been double-slashed
+                        download_url = download_url.replace('https:/', 'https://').replace('http:/', 'http://')
+                    else:
+                        logger.warning(f"⚠️ Relative URL provided but no server_url available: {file_url}")
+                        download_url = file_url
+                
+                logger.info(f"📥 Downloading from: {download_url}")
+                response = session.get(download_url, timeout=30, verify=False)
                if response.status_code == 200:
                    with open(local_path, 'wb') as file:
                        file.write(response.content)
-                    logger.info(f"✅ Successfully downloaded {file_name}")
+                    logger.info(f"✅ Successfully downloaded {file_name} ({len(response.content)} bytes)")
                else:
                    logger.error(f"❌ Failed to download {file_name}. Status: {response.status_code}")
-                    continue
+                    # Still add to playlist even if download failed - might be cached or available later
+            except requests.exceptions.SSLError as e:
+                logger.error(f"❌ SSL Error downloading {file_name}: {e}")
+                # Don't skip - may still add to playlist
            except requests.exceptions.RequestException as e:
                logger.error(f"❌ Error downloading {file_name}: {e}")
-                continue
+                # Don't skip - may still add to playlist
        
+        # Always add the media item to the playlist, even if download failed
+        # (it might already exist or be available later)
        updated_media = {
            'file_name': file_name,
            'url': os.path.relpath(local_path, os.path.dirname(media_dir)),
@@ -247,6 +316,7 @@ def download_media_files(playlist, media_dir):
    return updated_playlist


+
 def delete_unused_media(playlist_data, media_dir):
    """Delete media files not referenced in the current playlist."""
    try:
@@ -303,14 +373,31 @@ def delete_unused_media(playlist_data, media_dir):


 def update_playlist_if_needed(config, playlist_dir, media_dir):
-    """Check for and download updated playlist if available."""
+    """Check for and download updated playlist if available.
+    
+    Args:
+        config: Configuration dict with server settings
+        playlist_dir: Directory to save playlist
+        media_dir: Directory to save media files
+    """
    try:
+        # Initialize auth with SSL settings from config
+        auth = ensure_authenticated(config)
+        if not auth:
+            logger.error("❌ Cannot update playlist - authentication failed")
+            return None
+        
        # Fetch latest playlist from server
-        server_data = fetch_server_playlist(config)
-        server_version = server_data.get('version', 0)
+        server_data = auth.get_playlist()
+        
+        if not server_data:
+            logger.warning("⚠️ No valid playlist received from server")
+            return None
+        
+        server_version = server_data.get('playlist_version', 0)
        
        if server_version == 0:
-            logger.warning("⚠️ No valid playlist received from server")
+            logger.warning("⚠️ No valid playlist version received from server")
            return None
        
        # Check local version from single playlist file
@@ -321,7 +408,8 @@ def update_playlist_if_needed(config, playlist_dir, media_dir):
            try:
                with open(playlist_file, 'r') as f:
                    local_data = json.load(f)
-                    local_version = local_data.get('version', 0)
+                    # Check for both 'version' and 'playlist_version' keys (for backward compatibility)
+                    local_version = local_data.get('version', local_data.get('playlist_version', 0))
            except Exception as e:
                logger.warning(f"⚠️ Could not read local playlist: {e}")
        
@@ -331,8 +419,14 @@ def update_playlist_if_needed(config, playlist_dir, media_dir):
        if server_version > local_version:
            logger.info(f"🔄 Updating playlist from v{local_version} to v{server_version}")
            
+            # Get SSL manager for downloads if using HTTPS
+            ssl_manager = auth.ssl_manager if config.get('use_https', True) else None
+            
+            # Get server URL from auth
+            server_url = auth.auth_data.get('server_url', '')
+            
            # Download media files
-            updated_playlist = download_media_files(server_data['playlist'], media_dir)
+            updated_playlist = download_media_files(server_data.get('playlist', []), media_dir, ssl_manager, server_url)
            server_data['playlist'] = updated_playlist
            
            # Save new playlist (single file, no versioning)