Onglet Radio sur le serveur, bouton de synchronisation sur le mobile (2.5.0)

Le serveur gagne un onglet Radio : les stations de l'annuaire, écoutables en
direct dans le navigateur ou enregistrables — jusqu'à l'arrêt ou pour une durée
choisie —, puis réécoutables depuis l'interface. Quatre enregistrements en
parallèle au plus ; si le flux tombe, il est rouvert et le fichier continue.
Les enregistrements rejoignent la bibliothèque : le mobile les reçoit.

Un redémarrage du service clôt proprement les captures en cours, et celles
restées « en cours » après un plantage sont récupérées au démarrage suivant.
La copie de flux sans blocs ICY, propre au guet, est extraite pour être
partagée.

Côté mobile, la synchronisation manuelle n'était qu'un petit lien dans l'onglet
Connexion : elle a maintenant un vrai bouton dans l'onglet Synchronisation.
Deux passages ne se chevauchent plus, et une erreur inattendue s'affiche au lieu
de fermer l'application.

Le code Kotlin n'a pas été compilé sur cette machine (pas de JDK) : il a été
relu, mais reste à construire.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01N6pmSE168yjyf8vgV8mZx6

server/noxely_server/workers.py

@@ -195,44 +195,21 @@ class Watcher:
                 async with client.stream("GET", station["url"]) as response:
                     response.raise_for_status()
                     interval = int(response.headers.get("icy-metaint") or 0)
+                    # Fin du morceau : la station en annonce un autre. Les gardes-fous bornent
+                    # le fichier quand aucune annonce ne vient (40 Mo sans ICY, 60 Mo avec).
+                    limit = 40_000_000 if interval <= 0 else 60_000_000
+
+                    def keep_going(total: int, announced: str | None) -> bool:
+                        return not (announced and announced != title) and total <= limit
+
                     with target.open("wb") as handle:
-                        written = await self._copy(response, handle, interval, title)
+                        written = await radio.copy_stream(response, handle, interval, keep_going)
             self.storage.update_media(media_id, state="ready", size=written)
         except Exception as error:
             self.storage.update_media(media_id, state="failed", error=str(error)[:200])
         finally:
             self.recording = None
 
-    async def _copy(self, response, handle, interval: int, wanted: str) -> int:
-        """Retire les blocs ICY du flux : laissés dedans, ils rendraient le fichier illisible."""
-        if interval <= 0:
-            total = 0
-            async for chunk in response.aiter_bytes(32768):
-                handle.write(chunk)
-                total += len(chunk)
-                if total > 40_000_000:  # garde-fou : 40 Mo sans annonce de fin
-                    break
-            return total
-
-        buffer = bytearray()
-        total = 0
-        async for chunk in response.aiter_bytes(32768):
-            buffer.extend(chunk)
-            while len(buffer) >= interval + 1:
-                length = buffer[interval] * 16
-                if len(buffer) < interval + 1 + length:
-                    break
-                handle.write(bytes(buffer[:interval]))
-                total += interval
-                meta = bytes(buffer[interval + 1:interval + 1 + length]).decode("utf-8", "replace")
-                del buffer[:interval + 1 + length]
-                announced = radio.STREAM_TITLE.search(meta)
-                if announced and announced.group(1).strip() and announced.group(1).strip() != wanted:
-                    return total  # le morceau est terminé
-            if total > 60_000_000:
-                return total
-        return total
-
 
 def _now() -> int:
     return int(time.time() * 1000)