Commit vers. 2.1.0

config/ajaxModule.inc.php

@@ -1,5 +1,7 @@
 <?php
 
+header('Content-Type: text/html; charset=UTF-8');
+
 // Verifica se è una richiesta AJAX
 $is_ajax = !empty($_SERVER['HTTP_X_REQUESTED_WITH']) && strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest';
 

config/config.php

@@ -1,5 +1,8 @@
 <?php
 
+header('Content-Type: text/html; charset=UTF-8');
+
+
 // Information App
 $title_site = "RPIGroup Play";
 $description_site = "Ascolta le radio del gruppo RPIGroup";

config/getBasePath.inc.php

@@ -1,5 +1,7 @@
 <?php
 
+header('Content-Type: text/html; charset=UTF-8');
+
 // Determina il percorso base dell'applicazione
 $script_name = $_SERVER['SCRIPT_NAME'];
 $script_path = dirname($script_name);

config/getPage.inc.php

@@ -1,10 +1,27 @@
 <?php
 
+header('Content-Type: text/html; charset=UTF-8');
+
+// File: config/getPage.inc.php
+
+// Whitelist delle pagine valide
+$validPages = ['home', 'radio', 'tv', 'play', 'playtv', 'page'];
+$validSubPages = ['about', 'contact', 'copyright', 'addradio', 'termini-condizioni', 'policy-privacy', 'changelog'];
+
 // Rileva se l'utente sta usando un dispositivo mobile
 function isMobile() {
     return preg_match("/(android|avantgo|blackberry|bolt|boost|cricket|docomo|fone|hiptop|mini|mobi|palm|phone|pie|tablet|up\.browser|up\.link|webos|wos)/i", $_SERVER["HTTP_USER_AGENT"]);
 }
 
+// Funzione per sanitizzare l'input
+function sanitizePageInput($input) {
+    // Rimuovi caratteri pericolosi
+    $input = preg_replace('/[^a-zA-Z0-9\-_]/', '', $input);
+    // Previeni path traversal
+    $input = str_replace(['..', '/', '\\'], '', $input);
+    return $input;
+}
+
 // Recupera l'URL richiesto
 $request_uri = $_SERVER['REQUEST_URI'];
 $path = substr(urldecode($request_uri), strlen($base_path));
@@ -23,9 +40,45 @@ if (isset($path_parts[0]) && $path_parts[0] == 'index.php') {
     array_shift($path_parts);
 }
 
-// Determina la pagina da mostrare in base all'URL
+// Determina la pagina da mostrare in base all'URL con validazione
-$page = isset($path_parts[0]) && !empty($path_parts[0]) ? $path_parts[0] : 'home';
+$page = 'home'; // Default sicuro
-$param = isset($path_parts[1]) && !empty($path_parts[1]) ? $path_parts[1] : '';
+$param = '';
+
+if (isset($path_parts[0]) && !empty($path_parts[0])) {
+    $requestedPage = sanitizePageInput($path_parts[0]);
+    
+    // Verifica se la pagina è nella whitelist
+    if (in_array($requestedPage, $validPages)) {
+        $page = $requestedPage;
+    } else {
+        // Pagina non valida, redirect a 404
+        $page = 'home';
+        error_log("Tentativo di accesso a pagina non valida: " . $path_parts[0]);
+    }
+}
+
+if (isset($path_parts[1]) && !empty($path_parts[1])) {
+    $requestedParam = sanitizePageInput($path_parts[1]);
+    
+    // Validazione specifica per tipo di pagina
+    if ($page === 'play' || $page === 'playtv') {
+        // Per play/playtv, il parametro deve essere un numero
+        if (ctype_digit($requestedParam)) {
+            $param = $requestedParam;
+        } else {
+            error_log("ID stazione non valido: " . $path_parts[1]);
+            $page = 'home';
+        }
+    } elseif ($page === 'page') {
+        // Per page, il parametro deve essere nella whitelist
+        if (in_array($requestedParam, $validSubPages)) {
+            $param = $requestedParam;
+        } else {
+            error_log("Sottopagina non valida: " . $path_parts[1]);
+            $page = 'home';
+        }
+    }
+}
 
 // Debug (rimuovi in produzione)
- error_log("Page: $page, Param: $param, Path: $path");
+error_log("Page: $page, Param: $param, Path: $path");

config/getStation.inc.php

@@ -1,54 +1,202 @@
 <?php
 
-// Funzione per caricare il file XML delle radio
+/**
+ * Cache XML in memoria per la durata della richiesta
+ * Previene caricamenti multipli dello stesso file
+ */
+class StationCache {
+    private static $radioXML = null;
+    private static $tvXML = null;
+    private static $changelogXML = null;
+    
+    /**
+     * Carica e cachea il file XML delle radio
+     */
+    public static function getRadioXML() {
+        if (self::$radioXML === null) {
+            $xmlPath = './data/radio.xml';
+            
+            if (!file_exists($xmlPath)) {
+                error_log("File XML non trovato: $xmlPath");
+                return false;
+            }
+            
+            if (!is_readable($xmlPath)) {
+                error_log("File XML non leggibile: $xmlPath");
+                return false;
+            }
+            
+            libxml_use_internal_errors(true);
+            self::$radioXML = simplexml_load_file($xmlPath);
+            
+            if (self::$radioXML === false) {
+                $errors = libxml_get_errors();
+                foreach ($errors as $error) {
+                    error_log("Errore XML radio.xml: " . trim($error->message) . " (Linea: " . $error->line . ")");
+                }
+                libxml_clear_errors();
+                return false;
+            }
+        }
+        
+        return self::$radioXML;
+    }
+    
+    /**
+     * Carica e cachea il file XML delle TV
+     */
+    public static function getTVXML() {
+        if (self::$tvXML === null) {
+            $xmlPath = './data/tv.xml';
+            
+            if (!file_exists($xmlPath)) {
+                error_log("File XML non trovato: $xmlPath");
+                return false;
+            }
+            
+            if (!is_readable($xmlPath)) {
+                error_log("File XML non leggibile: $xmlPath");
+                return false;
+            }
+            
+            libxml_use_internal_errors(true);
+            self::$tvXML = simplexml_load_file($xmlPath);
+            
+            if (self::$tvXML === false) {
+                $errors = libxml_get_errors();
+                foreach ($errors as $error) {
+                    error_log("Errore XML tv.xml: " . trim($error->message) . " (Linea: " . $error->line . ")");
+                }
+                libxml_clear_errors();
+                return false;
+            }
+        }
+        
+        return self::$tvXML;
+    }
+    
+    /**
+     * Carica e cachea il file XML del changelog
+     */
+    public static function getChangelogXML() {
+        if (self::$changelogXML === null) {
+            $xmlPath = './data/changelog.xml';
+            
+            if (!file_exists($xmlPath)) {
+                error_log("File XML non trovato: $xmlPath");
+                return false;
+            }
+            
+            if (!is_readable($xmlPath)) {
+                error_log("File XML non leggibile: $xmlPath");
+                return false;
+            }
+            
+            libxml_use_internal_errors(true);
+            self::$changelogXML = simplexml_load_file($xmlPath);
+            
+            if (self::$changelogXML === false) {
+                $errors = libxml_get_errors();
+                foreach ($errors as $error) {
+                    error_log("Errore XML changelog.xml: " . trim($error->message) . " (Linea: " . $error->line . ")");
+                }
+                libxml_clear_errors();
+                return false;
+            }
+        }
+        
+        return self::$changelogXML;
+    }
+}
+
+/**
+ * Funzione per caricare tutte le stazioni radio
+ * @return array|SimpleXMLElement Array di stazioni o array vuoto in caso di errore
+ */
 function loadRadioStations() {
-    $xml = simplexml_load_file('./data/radio.xml');
+    $xml = StationCache::getRadioXML();
-    if ($xml === false) {
+    if ($xml === false || !isset($xml->station)) {
-        error_log("Errore nel caricamento del file XML: data/radio.xml");
+        error_log("Impossibile caricare le stazioni radio");
         return [];
     }
     return $xml->station;
 }
 
-// Funzione per ottenere una singola stazione radio
+/**
+ * Funzione per ottenere una singola stazione radio
+ * @param int $id ID della stazione
+ * @return SimpleXMLElement|null Stazione o null se non trovata
+ */
 function getRadioStation($id) {
-    $xml = simplexml_load_file('./data/radio.xml');
+    $xml = StationCache::getRadioXML();
     if ($xml === false) {
-        error_log("Errore nel caricamento del file XML: data/radio.xml");
+        error_log("Impossibile caricare XML radio per ID: $id");
         return null;
     }
+    
+    if (!isset($xml->station)) {
+        error_log("Nessuna stazione trovata nel file XML");
+        return null;
+    }
+    
     foreach ($xml->station as $station) {
-        if ((int)$station->id === $id) {
+        if ((int)$station->id === (int)$id) {
             return $station;
         }
     }
+    
+    error_log("Stazione radio non trovata con ID: $id");
     return null;
 }
 
-// Funzione per caricare il file XML delle TV
+/**
+ * Funzione per caricare tutte le stazioni TV
+ * @return array|SimpleXMLElement Array di stazioni o array vuoto in caso di errore
+ */
 function loadTVStations() {
-    $xml = simplexml_load_file('./data/tv.xml');
+    $xml = StationCache::getTVXML();
-    if ($xml === false) {
+    if ($xml === false || !isset($xml->station)) {
-        error_log("Errore nel caricamento del file XML: data/tv.xml");
+        error_log("Impossibile caricare le stazioni TV");
         return [];
     }
     return $xml->station;
 }
 
-// Funzione per ottenere una singola stazione TV
+/**
+ * Funzione per ottenere una singola stazione TV
+ * @param int $id ID della stazione
+ * @return SimpleXMLElement|null Stazione o null se non trovata
+ */
 function getTVStation($id) {
-    $xml = simplexml_load_file('./data/tv.xml');
+    $xml = StationCache::getTVXML();
     if ($xml === false) {
-        error_log("Errore nel caricamento del file XML: data/tv.xml");
+        error_log("Impossibile caricare XML TV per ID: $id");
         return null;
     }
+    
+    if (!isset($xml->station)) {
+        error_log("Nessuna stazione TV trovata nel file XML");
+        return null;
+    }
+    
     foreach ($xml->station as $station) {
-        if ((int)$station->id === $id) {
+        if ((int)$station->id === (int)$id) {
             return $station;
         }
     }
+    
+    error_log("Stazione TV non trovata con ID: $id");
     return null;
 }
 
-$changelog = simplexml_load_file("./data/changelog.xml") or die("Errore: Impossibile accedere al file CHANGELOG");
+/**
-$version_app = $changelog->version->number[0];
+ * Carica il changelog e la versione dell'app
+ */
+$changelog = StationCache::getChangelogXML();
+$version_app = "1.0.0"; // Versione di default
+
+if ($changelog !== false && isset($changelog->version) && isset($changelog->version[0]->number)) {
+    $version_app = (string)$changelog->version[0]->number;
+} else {
+    error_log("Impossibile leggere la versione dal changelog.xml, uso versione di default: $version_app");
+}

data/changelog.xml

@@ -2,6 +2,15 @@
 
 <changelog>
 
+    <version>
+        <number>2.1.0</number>
+        <logs>
+            <log>Risoluzione dei problemi minori presenti nel codice, che causava problemi nella navigazione in app</log>
+            <log>Risoluzione dei problemi minori presenti nel codice, che causava problemi di riproduzione audio al player</log>
+            <log>Correzione e bugfix di problematiche varie.</log>
+        </logs>
+    </version>
+
     <version>
         <number>2.0.4</number>
         <logs>

index.php

@@ -11,6 +11,8 @@
 #   Version app: VEDERE IN CHANGELOG.XML
 */
 
+header('Content-Type: text/html; charset=UTF-8');
+
 
 #   Import config file
 include_once './config/config.php';

js/app.js

@@ -4,6 +4,11 @@ document.addEventListener('DOMContentLoaded', function() {
     let currentPage = getCurrentPageFromPath();
     let audioPlayer = null;
     let hlsInstance = null;
+    let currentXHR = null;
+    let isLoading = false;
+    
+    // WeakMap per tracciare i listener degli elementi
+    const linkListeners = new WeakMap();
     
     loadHlsLibrary();
     
@@ -12,8 +17,8 @@ document.addEventListener('DOMContentLoaded', function() {
         
         const script = document.createElement('script');
         script.src = 'https://cdn.jsdelivr.net/npm/hls.js@latest';
-        script.onload = () => console.log('HLS.js caricato');
+        script.onload = () => console.log('HLS.js caricato con successo');
-        script.onerror = () => console.error('Errore caricamento HLS.js');
+        script.onerror = () => console.error('Errore nel caricamento di HLS.js');
         document.head.appendChild(script);
     }
     
@@ -29,68 +34,162 @@ document.addEventListener('DOMContentLoaded', function() {
         return path || 'home';
     }
     
-    function loadPage(page) {
+    /**
-        const contentContainer = document.getElementById('content');
+     * Pulizia completa del player audio
-        if (!contentContainer) return;
+     * Previene memory leak rimuovendo istanze HLS e player audio
+     */
+    function cleanupPlayer() {
+        console.log('Pulizia player audio...');
         
+        // Distruggi istanza HLS
+        if (hlsInstance) {
+            try {
+                hlsInstance.destroy();
+                console.log('HLS instance distrutta');
+            } catch (e) {
+                console.error('Errore nella distruzione di HLS:', e);
+            }
+            hlsInstance = null;
+        }
+        
+        // Pulisci audio player
+        if (audioPlayer) {
+            try {
+                audioPlayer.pause();
+                audioPlayer.src = '';
+                audioPlayer.load(); // Libera risorse
+                
+                // Rimuovi tutti gli event listeners clonando il nodo
+                const parent = audioPlayer.parentNode;
+                if (parent) {
+                    const newPlayer = audioPlayer.cloneNode(true);
+                    parent.replaceChild(newPlayer, audioPlayer);
+                }
+                
+                console.log('Audio player pulito');
+            } catch (e) {
+                console.error('Errore nella pulizia del player audio:', e);
+            }
+            audioPlayer = null;
+        }
+        
+        // Reset Media Session
+        if ('mediaSession' in navigator) {
+            navigator.mediaSession.metadata = null;
+            navigator.mediaSession.playbackState = 'none';
+        }
+    }
+    
+    /**
+     * Caricamento pagina con protezione da race condition
+     */
+    function loadPage(page) {
+        // Previeni richieste multiple simultanee
+        if (isLoading) {
+            console.log('Caricamento già in corso, richiesta ignorata');
+            return;
+        }
+        
+        // Annulla richiesta XHR precedente se presente
+        if (currentXHR) {
+            console.log('Annullamento richiesta precedente');
+            currentXHR.abort();
+            currentXHR = null;
+        }
+        
+        isLoading = true;
+        const contentContainer = document.getElementById('content');
+        
+        if (!contentContainer) {
+            console.error('Container contenuto non trovato');
+            isLoading = false;
+            return;
+        }
+        
+        // Animazione fade out
         contentContainer.classList.remove('fade-in');
         contentContainer.classList.add('fade-out');
         
         setTimeout(() => {
             const url = BASE_PATH + '/index.php/' + page;
             
-            const xhr = new XMLHttpRequest();
+            currentXHR = new XMLHttpRequest();
-            xhr.open('GET', url, true);
+            currentXHR.open('GET', url, true);
-            xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
+            currentXHR.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
             
-            xhr.onload = function() {
+            currentXHR.onload = function() {
-                if (xhr.status === 200) {
+                isLoading = false;
-                    contentContainer.innerHTML = xhr.responseText;
+                currentXHR = null;
                 
+                if (this.status === 200) {
+                    contentContainer.innerHTML = this.responseText;
+                    
+                    // Animazione fade in
                     contentContainer.classList.remove('fade-out');
                     contentContainer.classList.add('fade-in');
                     
+                    // Aggiorna URL nella history
                     const historyUrl = page === 'home' ? BASE_PATH + '/' : BASE_PATH + '/' + page;
                     history.pushState({page: page}, null, historyUrl);
                     currentPage = page;
                     
+                    // Aggiorna navigazione attiva
                     updateActiveNavigation(page);
                     
+                    // Inizializza componenti specifici della pagina
                     if (page.startsWith('play/')) {
-                        initializePlayer();
+                        setTimeout(() => initializePlayer(), 100);
                     }
                     
                     if (page.startsWith('playtv/')) {
-                        initializeTVPlayer();
+                        setTimeout(() => initializeTVPlayer(), 100);
                     }
                     
+                    // Riattacca i listener ai link
                     attachLinkListeners();
                     
+                    // Inizializza form contatti se presente
                     if (page === 'page/contact') {
-                        initializeContactForm();
+                        setTimeout(() => initializeContactForm(), 100);
                     }
                     
+                    // Scroll to top
                     window.scrollTo({
                         top: 0,
                         behavior: 'smooth'
                     });
+                    
+                    console.log('Pagina caricata:', page);
                 } else {
-                    contentContainer.innerHTML = '<div class="content-page"><h2>Errore</h2><p>Impossibile caricare la pagina. Codice errore: ' + xhr.status + '</p></div>';
+                    contentContainer.innerHTML = '<div class="content-page"><h2>Errore</h2><p>Impossibile caricare la pagina. Codice errore: ' + this.status + '</p></div>';
                     contentContainer.classList.remove('fade-out');
                     contentContainer.classList.add('fade-in');
+                    console.error('Errore caricamento pagina:', this.status);
                 }
             };
             
-            xhr.onerror = function() {
+            currentXHR.onerror = function() {
-                contentContainer.innerHTML = '<div class="content-page"><h2>Errore di connessione</h2><p>Controlla la tua connessione internet.</p></div>';
+                isLoading = false;
+                currentXHR = null;
+                contentContainer.innerHTML = '<div class="content-page"><h2>Errore di connessione</h2><p>Controlla la tua connessione internet e riprova.</p></div>';
                 contentContainer.classList.remove('fade-out');
                 contentContainer.classList.add('fade-in');
+                console.error('Errore di rete durante il caricamento della pagina');
             };
             
-            xhr.send();
+            currentXHR.onabort = function() {
+                isLoading = false;
+                currentXHR = null;
+                console.log('Richiesta XHR annullata');
+            };
+            
+            currentXHR.send();
         }, 200);
     }
     
+    /**
+     * Aggiorna la navigazione attiva
+     */
     function updateActiveNavigation(page) {
         const navLinks = document.querySelectorAll('.navLink');
         navLinks.forEach(link => {
@@ -104,24 +203,24 @@ document.addEventListener('DOMContentLoaded', function() {
                 link.classList.add('active');
             } else if (page.startsWith('playtv/') && linkPage === 'tv') {
                 link.classList.add('active');
-            } else if (page.startsWith('page/')) {
+            } else if (page.startsWith('page/') && linkPage === page) {
-                if (linkPage === page) {
+                link.classList.add('active');
-                    link.classList.add('active');
-                }
             }
         });
     }
 
-    // NUOVA FUNZIONE: Setup Media Session API
+    /**
+     * Setup Media Session API per controlli sistema
+     */
     function setupMediaSession(stationName, stationSlogan, stationLogo, playIcon, pauseIcon) {
         if (!('mediaSession' in navigator)) {
-            console.log('Media Session API non supportata');
+            console.log('Media Session API non supportata su questo browser');
             return;
         }
 
-        console.log('Setup Media Session:', stationName, stationSlogan);
+        console.log('Configurazione Media Session:', stationName);
 
-        // Imposta i metadati
+        // Imposta i metadati della riproduzione
         navigator.mediaSession.metadata = new MediaMetadata({
             title: stationName,
             artist: stationSlogan,
@@ -136,25 +235,26 @@ document.addEventListener('DOMContentLoaded', function() {
             ]
         });
 
-        // Gestisci i controlli del centro notifiche
+        // Handler per il comando Play dal sistema
         navigator.mediaSession.setActionHandler('play', () => {
-            console.log('Media Session: Play richiesto dal centro notifiche');
+            console.log('Media Session: Play richiesto');
             if (audioPlayer) {
                 audioPlayer.play().then(() => {
-                    // Aggiorna UI
                     if (playIcon && pauseIcon) {
                         playIcon.style.display = 'none';
                         pauseIcon.style.display = 'block';
                     }
+                }).catch(err => {
+                    console.error('Errore play da Media Session:', err);
                 });
             }
         });
 
+        // Handler per il comando Pause dal sistema
         navigator.mediaSession.setActionHandler('pause', () => {
-            console.log('Media Session: Pause richiesto dal centro notifiche');
+            console.log('Media Session: Pause richiesto');
             if (audioPlayer) {
                 audioPlayer.pause();
-                // Aggiorna UI
                 if (playIcon && pauseIcon) {
                     playIcon.style.display = 'block';
                     pauseIcon.style.display = 'none';
@@ -162,14 +262,18 @@ document.addEventListener('DOMContentLoaded', function() {
             }
         });
 
-        // Opzionale: gestisci skip (per radio potrebbe non servire)
+        // Disabilita i controlli non utilizzati per radio streaming
         navigator.mediaSession.setActionHandler('seekbackward', null);
         navigator.mediaSession.setActionHandler('seekforward', null);
         navigator.mediaSession.setActionHandler('previoustrack', null);
         navigator.mediaSession.setActionHandler('nexttrack', null);
+        
+        console.log('Media Session configurata correttamente');
     }
 
-    // NUOVA FUNZIONE: Aggiorna playback state
+    /**
+     * Aggiorna lo stato di riproduzione nella Media Session
+     */
     function updateMediaSessionPlaybackState(state) {
         if ('mediaSession' in navigator) {
             navigator.mediaSession.playbackState = state;
@@ -177,11 +281,20 @@ document.addEventListener('DOMContentLoaded', function() {
         }
     }
 
+    /**
+     * Inizializza il player audio con gestione HLS migliorata
+     */
     function initializePlayer() {
-        console.log('Inizializzazione player...');
+        console.log('Inizializzazione player audio...');
+        
+        // Pulisci eventuali istanze precedenti
+        cleanupPlayer();
         
         const playPauseBtn = document.getElementById('playPauseBtn');
-        if (!playPauseBtn) return;
+        if (!playPauseBtn) {
+            console.error('Pulsante play/pause non trovato');
+            return;
+        }
 
         const playIcon = document.querySelector('.play-icon');
         const pauseIcon = document.querySelector('.pause-icon');
@@ -192,29 +305,24 @@ document.addEventListener('DOMContentLoaded', function() {
         const stationLogo = playPauseBtn.getAttribute('data-station-logo');
         const statusElement = document.getElementById('playerStatus');
 
-        console.log('Station:', stationName);
+        console.log('Stazione:', stationName);
-        console.log('HLS URL:', hlsUrl);
+        console.log('URL HLS:', hlsUrl);
-        console.log('Fallback URL:', fallbackUrl);
+        console.log('URL Fallback:', fallbackUrl);
 
-        // Setup Media Session all'inizio passando anche le icone
+        // Setup Media Session
         setupMediaSession(stationName, stationSlogan, stationLogo, playIcon, pauseIcon);
 
-        if (hlsInstance) {
+        // Ottieni riferimento al player audio
-            hlsInstance.destroy();
-            hlsInstance = null;
-        }
-
-        if (audioPlayer) {
-            audioPlayer.pause();
-            audioPlayer = null;
-        }
-
         audioPlayer = document.getElementById('hlsAudioPlayer');
         if (!audioPlayer) {
-            audioPlayer = new Audio();
+            console.error('Elemento audio player non trovato nel DOM');
+            return;
         }
         audioPlayer.preload = 'none';
 
+        /**
+         * Aggiorna lo stato visualizzato
+         */
         function updateStatus(msg, isError = false) {
             console.log('Status:', msg);
             if (statusElement) {
@@ -223,31 +331,56 @@ document.addEventListener('DOMContentLoaded', function() {
             }
         }
 
+        /**
+         * Verifica supporto HLS nativo (Safari)
+         */
         function canPlayHLS() {
             const video = document.createElement('video');
             return video.canPlayType('application/vnd.apple.mpegurl') !== '';
         }
 
+        /**
+         * Setup HLS.js con gestione errori robusta
+         */
         function setupHLS() {
             if (!window.Hls || !Hls.isSupported()) {
-                console.log('HLS.js non disponibile');
+                console.log('HLS.js non disponibile o non supportato');
                 return false;
             }
 
-            console.log('Uso HLS.js');
+            console.log('Utilizzo HLS.js per lo streaming');
-            updateStatus('Caricamento...');
+            updateStatus('Caricamento stream...');
 
-            hlsInstance = new Hls({
+            const hlsConfig = {
                 enableWorker: true,
-                lowLatencyMode: true
+                lowLatencyMode: true,
-            });
+                maxBufferLength: 30,
+                maxMaxBufferLength: 60,
+                maxBufferSize: 60 * 1000 * 1000,
+                manifestLoadingTimeOut: 10000,
+                manifestLoadingMaxRetry: 3,
+                manifestLoadingRetryDelay: 500,
+                levelLoadingTimeOut: 10000,
+                levelLoadingMaxRetry: 4,
+                fragLoadingTimeOut: 20000,
+                fragLoadingMaxRetry: 6
+            };
+
+            hlsInstance = new Hls(hlsConfig);
+
+            let networkErrorCount = 0;
+            let mediaErrorCount = 0;
+            const MAX_NETWORK_ERRORS = 3;
+            const MAX_MEDIA_ERRORS = 2;
 
             hlsInstance.loadSource(hlsUrl);
             hlsInstance.attachMedia(audioPlayer);
 
             hlsInstance.on(Hls.Events.MANIFEST_PARSED, function() {
-                console.log('HLS manifest caricato');
+                console.log('Manifest HLS caricato con successo');
-                updateStatus('Pronto');
+                updateStatus('Pronto per la riproduzione');
+                networkErrorCount = 0;
+                mediaErrorCount = 0;
             });
 
             hlsInstance.on(Hls.Events.ERROR, function(event, data) {
@@ -256,40 +389,82 @@ document.addEventListener('DOMContentLoaded', function() {
                 if (data.fatal) {
                     switch(data.type) {
                         case Hls.ErrorTypes.NETWORK_ERROR:
-                            console.log('Errore rete, riprovo...');
+                            networkErrorCount++;
-                            hlsInstance.startLoad();
+                            console.log(`Errore di rete ${networkErrorCount}/${MAX_NETWORK_ERRORS}`);
+                            
+                            if (networkErrorCount < MAX_NETWORK_ERRORS) {
+                                updateStatus('Riconnessione in corso...');
+                                // Backoff esponenziale
+                                setTimeout(() => {
+                                    console.log('Tentativo di riconnessione...');
+                                    hlsInstance.startLoad();
+                                }, 1000 * networkErrorCount);
+                            } else {
+                                console.error('Troppi errori di rete, utilizzo stream fallback');
+                                updateStatus('Utilizzo stream alternativo...', true);
+                                hlsInstance.destroy();
+                                hlsInstance = null;
+                                useFallback();
+                            }
                             break;
+                            
                         case Hls.ErrorTypes.MEDIA_ERROR:
-                            console.log('Errore media, riprovo...');
+                            mediaErrorCount++;
-                            hlsInstance.recoverMediaError();
+                            console.log(`Errore media ${mediaErrorCount}/${MAX_MEDIA_ERRORS}`);
+                            
+                            if (mediaErrorCount < MAX_MEDIA_ERRORS) {
+                                updateStatus('Recupero errore media...');
+                                hlsInstance.recoverMediaError();
+                            } else {
+                                console.error('Troppi errori media, utilizzo stream fallback');
+                                updateStatus('Utilizzo stream alternativo...', true);
+                                hlsInstance.destroy();
+                                hlsInstance = null;
+                                useFallback();
+                            }
                             break;
+                            
                         default:
-                            console.error('Errore fatale, uso fallback');
+                            console.error('Errore fatale non recuperabile:', data.details);
+                            updateStatus('Stream non disponibile', true);
                             hlsInstance.destroy();
                             hlsInstance = null;
                             useFallback();
                             break;
                     }
+                } else {
+                    // Errori non fatali
+                    console.warn('Errore HLS non fatale:', data.details);
                 }
             });
 
             return true;
         }
 
+        /**
+         * Utilizza stream fallback MP3
+         */
         function useFallback() {
-            console.log('Uso fallback:', fallbackUrl);
+            console.log('Utilizzo stream fallback MP3:', fallbackUrl);
             if (fallbackUrl) {
-                audioPlayer.src = fallbackUrl;
+                try {
-                audioPlayer.load();
+                    audioPlayer.src = fallbackUrl;
-                updateStatus('Pronto (MP3)');
+                    audioPlayer.load();
+                    updateStatus('Pronto (MP3)');
+                } catch (e) {
+                    console.error('Errore nel caricamento del fallback:', e);
+                    updateStatus('Stream non disponibile', true);
+                }
             } else {
+                console.error('Nessuno stream fallback disponibile');
                 updateStatus('Stream non disponibile', true);
             }
         }
 
+        // Inizializza lo streaming
         if (hlsUrl) {
             if (canPlayHLS()) {
-                console.log('Uso HLS nativo (Safari)');
+                console.log('Utilizzo supporto HLS nativo (Safari)');
                 audioPlayer.src = hlsUrl;
                 updateStatus('Pronto');
             } else if (!setupHLS()) {
@@ -299,10 +474,10 @@ document.addEventListener('DOMContentLoaded', function() {
             useFallback();
         }
 
-        // Gestore pulsante play/pause
+        // Event handler per il pulsante play/pause
         playPauseBtn.addEventListener('click', function() {
             if (audioPlayer.paused) {
-                updateStatus('Connessione...');
+                updateStatus('Connessione allo stream...');
                 
                 audioPlayer.play()
                     .then(() => {
@@ -310,25 +485,28 @@ document.addEventListener('DOMContentLoaded', function() {
                         pauseIcon.style.display = 'block';
                         updateStatus('In riproduzione');
                         updateMediaSessionPlaybackState('playing');
+                        console.log('Riproduzione avviata');
                     })
                     .catch(error => {
                         console.error('Errore nella riproduzione:', error);
                         updateStatus('Errore riproduzione', true);
                         updateMediaSessionPlaybackState('paused');
                         
+                        // Tentativo con fallback se HLS fallisce
                         if (hlsInstance && fallbackUrl) {
-                            console.log('Tentativo con fallback...');
+                            console.log('Tentativo con stream fallback...');
                             hlsInstance.destroy();
                             hlsInstance = null;
                             useFallback();
+                            
                             setTimeout(() => {
                                 audioPlayer.play().catch(e => {
-                                    console.error('Fallback fallito:', e);
+                                    console.error('Anche il fallback è fallito:', e);
-                                    alert('Impossibile riprodurre lo stream audio. Riprova più tardi.');
+                                    alert('Impossibile riprodurre lo stream audio. Verifica la tua connessione e riprova.');
                                 });
                             }, 500);
                         } else {
-                            alert('Impossibile riprodurre lo stream audio. Riprova più tardi.');
+                            alert('Impossibile riprodurre lo stream audio. Verifica la tua connessione e riprova.');
                         }
                     });
             } else {
@@ -337,14 +515,14 @@ document.addEventListener('DOMContentLoaded', function() {
                 pauseIcon.style.display = 'none';
                 updateStatus('In pausa');
                 updateMediaSessionPlaybackState('paused');
+                console.log('Riproduzione in pausa');
             }
         });
 
-        // Event listeners con Media Session updates e sincronizzazione UI
+        // Event listeners per sincronizzazione UI e Media Session
         audioPlayer.addEventListener('play', function() {
             updateMediaSessionPlaybackState('playing');
             updateStatus('In riproduzione');
-            // Sincronizza UI quando l'audio parte (da qualsiasi fonte)
             playIcon.style.display = 'none';
             pauseIcon.style.display = 'block';
         });
@@ -352,7 +530,6 @@ document.addEventListener('DOMContentLoaded', function() {
         audioPlayer.addEventListener('pause', function() {
             updateMediaSessionPlaybackState('paused');
             updateStatus('In pausa');
-            // Sincronizza UI quando l'audio va in pausa (da qualsiasi fonte)
             playIcon.style.display = 'block';
             pauseIcon.style.display = 'none';
         });
@@ -364,27 +541,48 @@ document.addEventListener('DOMContentLoaded', function() {
             updateMediaSessionPlaybackState('paused');
         });
 
-        audioPlayer.addEventListener('error', function() {
+        audioPlayer.addEventListener('error', function(e) {
             playIcon.style.display = 'block';
             pauseIcon.style.display = 'none';
             updateStatus('Errore stream', true);
             updateMediaSessionPlaybackState('paused');
+            console.error('Errore audio player:', e);
             alert('Si è verificato un errore durante la riproduzione. Riprova più tardi.');
         });
 
-        audioPlayer.addEventListener('waiting', () => updateStatus('Buffering...'));
+        audioPlayer.addEventListener('waiting', () => {
-        audioPlayer.addEventListener('playing', () => updateStatus('In riproduzione'));
+            updateStatus('Buffering...');
+        });
         
-        console.log('Player inizializzato con Media Session');
+        audioPlayer.addEventListener('playing', () => {
+            updateStatus('In riproduzione');
+        });
+
+        audioPlayer.addEventListener('stalled', () => {
+            console.warn('Stream stalled');
+            updateStatus('Connessione lenta...');
+        });
+        
+        console.log('Player audio inizializzato correttamente');
     }
 
+    /**
+     * Inizializza player TV
+     */
     function initializeTVPlayer() {
         console.log('TV Player inizializzato');
+        // Implementare logica specifica per TV se necessario
     }
 
+    /**
+     * Inizializza form contatti
+     */
     function initializeContactForm() {
         const contactForm = document.getElementById('contactForm');
-        if (!contactForm) return;
+        if (!contactForm) {
+            console.log('Form contatti non trovato');
+            return;
+        }
 
         contactForm.addEventListener('submit', function(e) {
             e.preventDefault();
@@ -392,53 +590,78 @@ document.addEventListener('DOMContentLoaded', function() {
             const formData = new FormData(contactForm);
             const formResponse = document.getElementById('formResponse');
 
-            formResponse.innerHTML = 'Invio in corso...';
+            if (formResponse) {
-            formResponse.className = 'form-response';
+                formResponse.innerHTML = 'Invio in corso...';
-            formResponse.style.display = 'block';
+                formResponse.className = 'form-response';
+                formResponse.style.display = 'block';
+            }
 
             const xhr = new XMLHttpRequest();
             xhr.open('POST', BASE_PATH + '/process_contact.php', true);
+            
             xhr.onload = function() {
                 if (xhr.status === 200) {
                     try {
                         const response = JSON.parse(xhr.responseText);
                         if (response.success) {
-                            formResponse.innerHTML = 'Messaggio inviato con successo! Ti risponderemo presto.';
+                            if (formResponse) {
-                            formResponse.className = 'form-response success';
+                                formResponse.innerHTML = 'Messaggio inviato con successo! Ti risponderemo presto.';
+                                formResponse.className = 'form-response success';
+                            }
                             contactForm.reset();
                         } else {
-                            formResponse.innerHTML = 'Errore: ' + (response.message || 'Si è verificato un errore durante l\'invio del messaggio.');
+                            if (formResponse) {
-                            formResponse.className = 'form-response error';
+                                formResponse.innerHTML = 'Errore: ' + (response.message || 'Si è verificato un errore durante l\'invio del messaggio.');
+                                formResponse.className = 'form-response error';
+                            }
                         }
                     } catch (e) {
-                        formResponse.innerHTML = 'Si è verificato un errore durante l\'elaborazione della risposta.';
+                        console.error('Errore parsing risposta:', e);
-                        formResponse.className = 'form-response error';
+                        if (formResponse) {
+                            formResponse.innerHTML = 'Si è verificato un errore durante l\'elaborazione della risposta.';
+                            formResponse.className = 'form-response error';
+                        }
                     }
                 } else {
-                    formResponse.innerHTML = 'Si è verificato un errore durante l\'invio del messaggio.';
+                    if (formResponse) {
+                        formResponse.innerHTML = 'Si è verificato un errore durante l\'invio del messaggio.';
+                        formResponse.className = 'form-response error';
+                    }
+                }
+            };
+            
+            xhr.onerror = function() {
+                if (formResponse) {
+                    formResponse.innerHTML = 'Errore di connessione. Controlla la tua connessione internet.';
                     formResponse.className = 'form-response error';
                 }
             };
-            xhr.onerror = function() {
+            
-                formResponse.innerHTML = 'Errore di connessione. Controlla la tua connessione internet.';
-                formResponse.className = 'form-response error';
-            };
             xhr.send(formData);
         });
+        
+        console.log('Form contatti inizializzato');
     }
 
+    /**
+     * Attacca event listener ai link con gestione migliorata
+     */
     function attachLinkListeners() {
         const navLinks = document.querySelectorAll('.navLink, .nav-link, .station-link, .linkBox');
         
         navLinks.forEach(link => {
-            const newLink = link.cloneNode(true);
+            // Rimuovi listener precedente se esiste
-            link.parentNode.replaceChild(newLink, link);
+            const oldListener = linkListeners.get(link);
+            if (oldListener) {
+                link.removeEventListener('click', oldListener);
+            }
             
-            newLink.addEventListener('click', function(e) {
+            const clickHandler = function(e) {
                 const href = this.getAttribute('href');
                 const target = this.getAttribute('target');
                 const page = this.getAttribute('data-page');
                 
+                // Verifica se è un link esterno
                 const isExternal = href && (
                     href.startsWith('http://') || 
                     href.startsWith('https://') || 
@@ -447,27 +670,35 @@ document.addEventListener('DOMContentLoaded', function() {
                 );
                 
                 if (isExternal) {
-                    console.log('Link esterno rilevato:', href);
+                    console.log('Link esterno:', href);
-                    e.preventDefault();
+                    return; // Lascia che il browser gestisca normalmente
-                    window.location.href = href;
-                    return;
                 }
                 
                 e.preventDefault();
                 e.stopPropagation();
                 
-                console.log('Link cliccato, pagina:', page, 'currentPage:', currentPage);
+                console.log('Navigazione a:', page);
                 
-                if (page && page !== currentPage) {
+                // Naviga solo se la pagina è diversa e non stiamo già caricando
+                if (page && page !== currentPage && !isLoading) {
+                    // Metti in pausa l'audio se in riproduzione
                     if (audioPlayer && !audioPlayer.paused) {
                         audioPlayer.pause();
                     }
                     loadPage(page);
                 }
-            });
+            };
+            
+            link.addEventListener('click', clickHandler);
+            linkListeners.set(link, clickHandler);
         });
+        
+        console.log('Event listener attaccati a', navLinks.length, 'link');
     }
 
+    /**
+     * Setup pulsante apertura app (desktop)
+     */
     function setupOpenAppButton() {
         const openAppBtn = document.getElementById('openAppBtn');
         if (openAppBtn) {
@@ -486,9 +717,14 @@ document.addEventListener('DOMContentLoaded', function() {
                 const windowFeatures = 'width=' + width + ',height=' + height + ',left=' + left + ',top=' + top + ',resizable=yes,scrollbars=yes,status=yes';
                 window.open(BASE_PATH + '/?app=true' + redirectParam, 'RadioApp', windowFeatures);
             });
+            
+            console.log('Pulsante apertura app configurato');
         }
     }
 
+    /**
+     * Setup navigazione con history API
+     */
     function setupHistoryNavigation() {
         window.addEventListener('popstate', function(e) {
             if (e.state && e.state.page) {
@@ -503,76 +739,89 @@ document.addEventListener('DOMContentLoaded', function() {
         });
 
         history.replaceState({page: currentPage}, null, window.location.pathname);
+        console.log('Navigazione history configurata');
     }
 
+    /**
+     * Setup modalità standalone (PWA)
+     */
     function setupStandaloneMode() {
         const appContainer = document.querySelector('.container');
         if (!appContainer) return;
         
         if (window.opener && !window.opener.closed) {
             appContainer.classList.add('standalone-app');
+            console.log('App in modalità finestra popup');
         }
 
         if (window.navigator.standalone || window.matchMedia('(display-mode: standalone)').matches) {
             appContainer.classList.add('standalone-app');
+            console.log('App in modalità standalone (PWA)');
         }
     }
 
-    function init() {
+    /**
-        setupOpenAppButton();
+     * Inizializza la pagina corrente
-
+     */
-        if (document.querySelector('.container')) {
-            setupStandaloneMode();
-
-            attachLinkListeners();
-
-            setupHistoryNavigation();
-
-            initializeCurrentPage();
-        }
-    }
-
     function initializeCurrentPage() {
         console.log('Inizializzazione pagina corrente:', currentPage);
         
         updateActiveNavigation(currentPage);
         
         if (currentPage.startsWith('play/')) {
-            setTimeout(function() {
+            setTimeout(() => initializePlayer(), 100);
-                initializePlayer();
-            }, 100);
         }
 
         if (currentPage.startsWith('playtv/')) {
-            setTimeout(function() {
+            setTimeout(() => initializeTVPlayer(), 100);
-                initializeTVPlayer();
-            }, 100);
         }
 
         if (currentPage === 'page/contact') {
-            setTimeout(function() {
+            setTimeout(() => initializeContactForm(), 100);
-                initializeContactForm();
-            }, 100);
         }
     }
 
+    /**
+     * Inizializzazione principale
+     */
+    function init() {
+        console.log('Inizializzazione app...');
+        
+        setupOpenAppButton();
+
+        if (document.querySelector('.container')) {
+            setupStandaloneMode();
+            attachLinkListeners();
+            setupHistoryNavigation();
+            initializeCurrentPage();
+        }
+        
+        console.log('App inizializzata correttamente');
+    }
+
+    // Avvia l'inizializzazione
     init();
 });
 
 
-// Funzione per bloccare l'orientamento (funziona solo in PWA/fullscreen)
+/**
+ * GESTIONE ORIENTAMENTO SCHERMO
+ */
+
+/**
+ * Blocca l'orientamento in portrait (funziona solo in PWA/fullscreen)
+ */
 function lockScreenOrientation() {
-    // Prova a bloccare l'orientamento con Screen Orientation API
+    // Screen Orientation API
     if (screen.orientation && screen.orientation.lock) {
         screen.orientation.lock('portrait').then(() => {
             console.log('Orientamento bloccato in portrait');
         }).catch((err) => {
             console.log('Impossibile bloccare orientamento:', err.message);
-            // Non è un errore grave, il CSS gestirà la situazione
         });
     }
     
-    // Alternativa per browser più vecchi
+    // Fallback per browser più vecchi
     if (screen.lockOrientation) {
         screen.lockOrientation('portrait');
     } else if (screen.mozLockOrientation) {
@@ -582,9 +831,20 @@ function lockScreenOrientation() {
     }
 }
 
-// Prova a bloccare quando l'app è in fullscreen/standalone
+/**
+ * Gestisce il cambio di orientamento
+ */
+function handleOrientationChange() {
+    const orientation = window.orientation || (screen.orientation && screen.orientation.angle) || 0;
+    console.log('Orientamento schermo:', orientation);
+    
+    // Puoi aggiungere logica specifica qui se necessario
+}
+
+/**
+ * Tenta di bloccare l'orientamento quando appropriato
+ */
 function tryLockOrientation() {
-    // Controlla se siamo in modalità standalone (PWA)
     const isStandalone = window.navigator.standalone || 
                          window.matchMedia('(display-mode: standalone)').matches;
     
@@ -592,7 +852,6 @@ function tryLockOrientation() {
         lockScreenOrientation();
     }
     
-    // Prova anche quando entriamo in fullscreen
     document.addEventListener('fullscreenchange', () => {
         if (document.fullscreenElement) {
             lockScreenOrientation();

pages/desktop.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <div id="proradio-secondary-header" class="proradio-secondaryhead proradio-primary" style="border-bottom: solid 3px #3849a8;">
 
     <style>

pages/page/404.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Pagina non trovata</h1>
 
 <p class="text-center">La pagina che hai provato a cercare non esiste o non è disponibile.</p>

pages/page/about.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Come funziona RPIGroup Play?</h1>
 
 <hr>

pages/page/addradio.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Aggiungi la tua radio</h1>
 
 <hr>

pages/page/changelog.php

@@ -1,13 +1,31 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Changelog</h1>
-<p class="subtitlePage">Visualizza tutti gli ricevuti</p>
+<p class="subtitlePage">Visualizza tutti gli aggiornamenti ricevuti</p>
 
 <?php
-foreach($changelog->version as $version){
+// Verifica che $changelog sia stato caricato correttamente in getStation.inc.php
-    echo "<hr>";
+if (isset($changelog) && $changelog !== false && isset($changelog->version)) {
-    echo "<p class=\"changelogTitle\">Versione ".$version->number."</p>";
+    // Itera attraverso le versioni
-    foreach($version->logs->log as $log_print){
+    foreach($changelog->version as $version) {
-        echo "<p class=\"changelogList\">• ".$log_print."</p>";
+        echo "<hr>";
+        echo "<p class=\"changelogTitle\">Versione " . htmlspecialchars((string)$version->number) . "</p>";
+        
+        // Verifica che esistano i log prima di iterare
+        if (isset($version->logs) && isset($version->logs->log)) {
+            foreach($version->logs->log as $log_print) {
+                echo "<p class=\"changelogList\">• " . htmlspecialchars((string)$log_print) . "</p>";
+            }
+        } else {
+            echo "<p class=\"changelogList\" style=\"font-style: italic; color: #999;\">Nessun dettaglio disponibile per questa versione.</p>";
+        }
     }
+} else {
+    // Messaggio di errore se il changelog non è disponibile
+    echo "<hr>";
+    echo "<div style=\"padding: 20px; background: #fff3cd; border: 1px solid #ffc107; border-radius: 5px; margin: 20px 0;\">";
+    echo "<p style=\"margin: 0; color: #856404;\"><strong>Attenzione:</strong> Impossibile caricare il changelog. Il file potrebbe essere mancante o corrotto.</p>";
+    echo "</div>";
 }
 ?>
 

pages/page/contact.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <!-- <div class="content-page">
     <h2>Contatti</h2>
     <div class="content-box">

pages/page/copyright.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Diritti d'Autore</h1>
 <p class="subtitlePage">Come funziona e chi lo gestisce</p>
 

pages/page/home.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Benvenuto</h1>
 <p class="subtitlePage">nella nuova RPIGroup Play</p>
 

pages/page/policyprivacy.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Policy Privacy</h1>
 <p class="subtitlePage">Ultimo aggiornamento: 17/11/2025</p>
 

pages/page/radio.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <?php
 // views/home.php - Vista della pagina principale
 $stations = loadRadioStations();

pages/page/terminicondizioni.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">Termini & Condizioni</h1>
 <p class="subtitlePage">Ultimo aggiornamento: 17/11/2025</p>
 

pages/page/tv.php

@@ -1,3 +1,5 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
 <h1 class="titlePage">TV</h1>
 <p class="subtitlePage">Guarda in streaming <b>RC105 TV</b></p>
 

static/footer.php

@@ -1,7 +1,4 @@
 
-<div style="display:none">
-<p><a href="https://www.jennymcnieceflowers.com/">777slot</a></p>
-</div>
     <script src="<?php echo $base_path; ?>/js/app.js?v=<?=time()?>"></script>
 </body>
 </html>

static/head.php

@@ -1,3 +1,14 @@
+<?php header('Content-Type: text/html; charset=UTF-8'); ?>
+
+<?php
+
+header('X-Content-Type-Options: nosniff');
+header('X-Frame-Options: SAMEORIGIN');
+header('X-XSS-Protection: 1; mode=block');
+header('Referrer-Policy: strict-origin-when-cross-origin');
+
+?>
+
 <!DOCTYPE html>
 <html lang="it">
 <head>