From b6635a107dc6fd37694709b599192ca9a14680c6 Mon Sep 17 00:00:00 2001
From: Marek <gitlab@marha.de>
Date: Sun, 5 Apr 2026 23:26:55 +0200
Subject: [PATCH] update

---
 CLAUDE.md                                     |  35 ++++++----
 .../youtubeapp/data/LocalStorageService.kt    |   7 ++
 .../main/java/com/youtubeapp/data/VideoApi.kt |   7 +-
 .../com/youtubeapp/data/VideoRepository.kt    |  10 ++-
 .../youtubeapp/ui/screens/AllVideosScreen.kt  |   2 +-
 .../youtubeapp/ui/screens/DownloadedScreen.kt |   2 +-
 .../ui/screens/VideoDetailScreen.kt           |   2 +-
 .../youtubeapp/ui/viewmodel/VideoViewModel.kt |  48 ++++++++++++-
 architecture.md                               |   6 +-
 backend/main.py                               |  28 +++++++-
 backend/requirements.txt                      |   2 +-
 .../routes/__pycache__/videos.cpython-312.pyc | Bin 6546 -> 7998 bytes
 backend/routes/videos.py                      |  57 ++++++++++-----
 backend/schemas.py                            |   5 ++
 .../download_service.cpython-312.pyc          | Bin 977 -> 990 bytes
 .../__pycache__/video_service.cpython-312.pyc | Bin 4645 -> 5273 bytes
 backend/services/download_service.py          |   2 +-
 backend/services/stream_service.py            |  65 ++++++++++++------
 backend/services/video_service.py             |  20 +++---
 commication.md                                |   3 +-
 features.md                                   |   3 +-
 21 files changed, 229 insertions(+), 75 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index b721b5f..aa8e1be 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -31,41 +31,48 @@ Drei Komponenten:
 
 ### Server (`backend/`)
 - **Python, FastAPI, SQLAlchemy, SQLite** (`videos/youtubeapp.db`)
-- **yt-dlp + ffmpeg** fuer Video-Download und Live-Streaming
+- **yt-dlp + ffmpeg** fuer Video-Download und Streaming
+- **WebSocket** (`/ws`) — benachrichtigt verbundene Clients bei neuen Videos
 - Dockerisiert: `docker compose up --build -d` im `backend/` Verzeichnis
 - Laeuft auf `http://localhost:8000`
 - Download-Service speichert Videos unter `/videos/{id}.mp4`
-- Stream-Service: heruntergeladene Videos von Datei, sonst Live-Stream via yt-dlp + ffmpeg (fragmentiertes MP4)
+- Stream-Service: heruntergeladene Videos von Datei, sonst progressiver Download via yt-dlp mit gleichzeitigem Streaming
 - Dedup: beim Batch-Import wird bestehender Eintrag mit gleicher Video-ID geloescht und neu eingefuegt
 - Sortierung: nach ID absteigend (erstes Video im Batch bekommt hoechste ID)
 - Profile: fest in DB definiert, Videos ueber Many-to-Many zugeordnet
+- Nach lokalem Download wird die Server-Datei geloescht (file_path auf null)
 
 ### App (`app/`)
 - **Kotlin, Jetpack Compose**, Android/Android TV
 - Gradle-Projekt, Modul `frontend`
-- Screens: AllVideos (Grid), Downloaded, VideoDetail, VideoPlayer
+- Screens: AllVideos (Grid), Downloaded (lokal verfuegbare Videos), VideoDetail, VideoPlayer
 - Retrofit fuer API-Calls, Coil fuer Thumbnails, ExoPlayer fuer Streaming
-- Navigation mit TopBar (Profil-Auswahl) und Bottom Bar, Dark Theme
+- OkHttp WebSocket-Client — automatisches Neuladen bei neuen Videos
+- Navigation mit TopBar (Profil-Auswahl, Aufraeumen-Icon) und Bottom Bar, Dark Theme
 - Profil-Auswahl wird in SharedPreferences persistiert, filtert Videos nach Profil
 - Lokaler Download: Videos werden auf dem Geraet gespeichert, lokal bevorzugt abgespielt
+- Aufraeumen: loescht alle nicht lokal gespeicherten Videos des Profils (sendet lokale IDs als Ausnahme)
 - Server-IP konfigurierbar in `ApiClient.kt` (aktuell `192.168.178.92`)
 - Emulator: Android Studio → Device Manager → Pixel 6a, API 35
 
 ## API Endpoints
 
 - `GET /profiles` — alle Profile abrufen
-- `POST /videos` — Video-Batch von Extension empfangen (Dedup, Reverse-Insert, Profil-Zuordnung)
+- `POST /videos` — Video-Batch von Extension empfangen (Dedup, Reverse-Insert, Profil-Zuordnung, WebSocket-Benachrichtigung)
 - `GET /videos` — alle Videos abrufen (optional `?profile_id=X`, sortiert nach ID absteigend)
 - `GET /videos/downloaded` — heruntergeladene Videos abrufen (optional `?profile_id=X`)
+- `DELETE /videos?profile_id=X&exclude_ids=` — Videos des Profils loeschen (ausser lokal gespeicherte)
 - `POST /videos/{id}/download` — Download auf Server triggern
-- `GET /videos/{id}/stream` — Video streamen (von Datei oder Live via yt-dlp/ffmpeg)
+- `GET /videos/{id}/stream` — Video streamen (von Datei oder progressiver Download via yt-dlp)
 - `GET /videos/{id}/file` — Video-Datei zum Download auf Client ausliefern
+- `DELETE /videos/{id}/file` — Server-Datei loeschen (nach lokalem Download)
+- `WS /ws` — WebSocket, sendet Profile-IDs bei neuen Videos
 
 ## Projektstruktur
 
 ```
 backend/
-  main.py              — FastAPI App, CORS, Startup, Seed-Profile
+  main.py              — FastAPI App, CORS, Startup, Seed-Profile, WebSocket
   database.py          — SQLAlchemy Engine, Session, Base
   models.py            — Video, Profile, video_profiles (Many-to-Many)
   schemas.py           — Pydantic Schemas (VideoCreate, VideoResponse, ProfileResponse)
@@ -73,14 +80,14 @@ backend/
   services/
     video_service.py   — CRUD-Operationen, Dedup, Profil-Filter
     download_service.py — yt-dlp Download
-    stream_service.py  — Live-Streaming via yt-dlp + ffmpeg
+    stream_service.py  — Progressiver Download + Streaming via yt-dlp
   Dockerfile           — Python 3.12 + ffmpeg
   docker-compose.yml   — Service-Definition, Port 8000, Volume /videos
   .dockerignore        — videos/, __pycache__/
   .gitignore           — videos/, __pycache__/
 
 browser_extension/
-  manifest.json        — Manifest V2, Permissions, browser_action
+  manifest.json        — Manifest V2, Permissions, browser_action, storage
   content.js           — DOM-Extraktion + IntersectionObserver + Batch-Versand mit Profil
   background.js        — Batch-POST an Server
   popup.html           — Profil-Auswahl UI
@@ -93,9 +100,12 @@ app/
     data/              — Video, Profile, ApiClient, VideoApi, VideoRepository, LocalStorageService
     ui/screens/        — AllVideos, Downloaded, VideoDetail, VideoPlayer
     ui/components/     — VideoCard
-    ui/viewmodel/      — VideoViewModel
+    ui/viewmodel/      — VideoViewModel (inkl. WebSocket-Client)
     ui/navigation/     — AppNavigation, Routes
     ui/theme/          — Theme (Dark)
+  frontend/src/main/res/
+    layout/player_view.xml — PlayerView mit TextureView fuer TV-Kompatibilitaet
+    drawable/tv_banner.png — Android TV Launcher-Banner
 ```
 
 ## Entscheidungen
@@ -103,8 +113,9 @@ app/
 - Kein Jellyfin — erfuellt nicht die Anforderung, Videos vor dem Download aufzulisten
 - Kein PostgreSQL/MySQL — SQLite reicht fuer den Prototyp
 - Profile fest in DB — kein UI zum Erstellen/Loeschen, werden direkt in der Datenbank verwaltet
-- Videos werden auf dem Server gespeichert, Client speichert nur bei explizitem Download
+- Server-Datei wird nach lokalem Download geloescht — spart Speicherplatz auf dem Server
 - DOM-Extraktion statt ytInitialData-Parsing — funktioniert auch bei SPA-Navigation und Scrollen
 - IntersectionObserver statt blindem Scan — nur sichtbare Videos erfassen
-- Live-Streaming via yt-dlp/ffmpeg statt synchronem Download vor dem Streamen
+- Progressiver Download via yt-dlp mit gleichzeitigem Streaming statt komplettem Download vor dem Abspielen
+- WebSocket statt Polling — effiziente Echtzeit-Aktualisierung der Videoliste
 - Sprache der Dokumentation: Deutsch
diff --git a/app/frontend/src/main/java/com/youtubeapp/data/LocalStorageService.kt b/app/frontend/src/main/java/com/youtubeapp/data/LocalStorageService.kt
index 88c3d05..5be8431 100644
--- a/app/frontend/src/main/java/com/youtubeapp/data/LocalStorageService.kt
+++ b/app/frontend/src/main/java/com/youtubeapp/data/LocalStorageService.kt
@@ -24,6 +24,13 @@ class LocalStorageService(private val context: Context) {
 
     fun deleteLocalFile(videoId: Int): Boolean = videoFile(videoId).delete()
 
+    fun getLocalVideoIds(): List<Int> {
+        return videosDir().listFiles()
+            ?.filter { it.extension == "mp4" }
+            ?.mapNotNull { it.nameWithoutExtension.toIntOrNull() }
+            ?: emptyList()
+    }
+
     fun downloadAndSave(videoId: Int): File {
         val url = "${ApiClient.BASE_URL}videos/$videoId/file"
         val file = videoFile(videoId)
diff --git a/app/frontend/src/main/java/com/youtubeapp/data/VideoApi.kt b/app/frontend/src/main/java/com/youtubeapp/data/VideoApi.kt
index fa23baf..eda95c0 100644
--- a/app/frontend/src/main/java/com/youtubeapp/data/VideoApi.kt
+++ b/app/frontend/src/main/java/com/youtubeapp/data/VideoApi.kt
@@ -15,8 +15,11 @@ interface VideoApi {
     @POST("videos/{id}/download")
     suspend fun triggerDownload(@Path("id") id: Int): Map<String, String>
 
-    @retrofit2.http.DELETE("videos")
-    suspend fun deleteNotDownloaded(@Query("profile_id") profileId: Int): Map<String, Int>
+    @POST("videos/cleanup")
+    suspend fun cleanupVideos(@retrofit2.http.Body body: Map<String, @JvmSuppressWildcards Any>): Map<String, Int>
+
+    @retrofit2.http.DELETE("videos/{id}/file")
+    suspend fun deleteServerFile(@Path("id") id: Int): Map<String, String>
 
     @GET("profiles")
     suspend fun getProfiles(): List<Profile>
diff --git a/app/frontend/src/main/java/com/youtubeapp/data/VideoRepository.kt b/app/frontend/src/main/java/com/youtubeapp/data/VideoRepository.kt
index 82d8fd3..d84fdbc 100644
--- a/app/frontend/src/main/java/com/youtubeapp/data/VideoRepository.kt
+++ b/app/frontend/src/main/java/com/youtubeapp/data/VideoRepository.kt
@@ -13,8 +13,14 @@ class VideoRepository(private val api: VideoApi = ApiClient.api) {
         response["status"] ?: "unknown"
     }
 
-    suspend fun deleteNotDownloaded(profileId: Int): Result<Int> = runCatching {
-        val response = api.deleteNotDownloaded(profileId)
+    suspend fun deleteServerFile(videoId: Int): Result<String> = runCatching {
+        val response = api.deleteServerFile(videoId)
+        response["status"] ?: "unknown"
+    }
+
+    suspend fun cleanupVideos(profileId: Int, excludeIds: List<Int>): Result<Int> = runCatching {
+        val body = mapOf("profile_id" to profileId, "exclude_ids" to excludeIds)
+        val response = api.cleanupVideos(body)
         response["deleted"] ?: 0
     }
 
diff --git a/app/frontend/src/main/java/com/youtubeapp/ui/screens/AllVideosScreen.kt b/app/frontend/src/main/java/com/youtubeapp/ui/screens/AllVideosScreen.kt
index 95befbb..2119801 100644
--- a/app/frontend/src/main/java/com/youtubeapp/ui/screens/AllVideosScreen.kt
+++ b/app/frontend/src/main/java/com/youtubeapp/ui/screens/AllVideosScreen.kt
@@ -47,7 +47,7 @@ fun AllVideosScreen(viewModel: VideoViewModel, onVideoClick: (Int) -> Unit) {
         }
         else -> {
             LazyVerticalGrid(
-                columns = GridCells.Adaptive(minSize = 250.dp),
+                columns = GridCells.Adaptive(minSize = 160.dp),
                 contentPadding = PaddingValues(8.dp),
                 horizontalArrangement = Arrangement.spacedBy(8.dp),
                 verticalArrangement = Arrangement.spacedBy(8.dp),
diff --git a/app/frontend/src/main/java/com/youtubeapp/ui/screens/DownloadedScreen.kt b/app/frontend/src/main/java/com/youtubeapp/ui/screens/DownloadedScreen.kt
index 589c8a2..b7af243 100644
--- a/app/frontend/src/main/java/com/youtubeapp/ui/screens/DownloadedScreen.kt
+++ b/app/frontend/src/main/java/com/youtubeapp/ui/screens/DownloadedScreen.kt
@@ -52,7 +52,7 @@ fun DownloadedScreen(viewModel: VideoViewModel, onVideoClick: (Int) -> Unit) {
         }
         else -> {
             LazyVerticalGrid(
-                columns = GridCells.Adaptive(minSize = 250.dp),
+                columns = GridCells.Adaptive(minSize = 160.dp),
                 contentPadding = PaddingValues(8.dp),
                 horizontalArrangement = Arrangement.spacedBy(8.dp),
                 verticalArrangement = Arrangement.spacedBy(8.dp),
diff --git a/app/frontend/src/main/java/com/youtubeapp/ui/screens/VideoDetailScreen.kt b/app/frontend/src/main/java/com/youtubeapp/ui/screens/VideoDetailScreen.kt
index 05e73aa..5203a32 100644
--- a/app/frontend/src/main/java/com/youtubeapp/ui/screens/VideoDetailScreen.kt
+++ b/app/frontend/src/main/java/com/youtubeapp/ui/screens/VideoDetailScreen.kt
@@ -48,7 +48,7 @@ fun VideoDetailScreen(
 ) {
     val state by viewModel.state.collectAsState()
     val video = viewModel.getVideoById(videoId)
-    val isLocal = viewModel.isLocallyAvailable(videoId)
+    val isLocal = remember(state.downloadStatus) { viewModel.isLocallyAvailable(videoId) }
     val snackbarHostState = remember { SnackbarHostState() }
 
     LaunchedEffect(state.downloadStatus) {
diff --git a/app/frontend/src/main/java/com/youtubeapp/ui/viewmodel/VideoViewModel.kt b/app/frontend/src/main/java/com/youtubeapp/ui/viewmodel/VideoViewModel.kt
index 5d5b117..6e8bf32 100644
--- a/app/frontend/src/main/java/com/youtubeapp/ui/viewmodel/VideoViewModel.kt
+++ b/app/frontend/src/main/java/com/youtubeapp/ui/viewmodel/VideoViewModel.kt
@@ -1,8 +1,10 @@
 package com.youtubeapp.ui.viewmodel
 
 import android.content.Context
+import android.util.Log
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
+import com.youtubeapp.data.ApiClient
 import com.youtubeapp.data.LocalStorageService
 import com.youtubeapp.data.Profile
 import com.youtubeapp.data.Video
@@ -12,6 +14,11 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
+import okhttp3.OkHttpClient
+import okhttp3.Request
+import okhttp3.Response
+import okhttp3.WebSocket
+import okhttp3.WebSocketListener
 
 data class VideoUiState(
     val allVideos: List<Video> = emptyList(),
@@ -28,6 +35,7 @@ class VideoViewModel : ViewModel() {
     private val repository = VideoRepository()
     private var localStorage: LocalStorageService? = null
     private var prefs: android.content.SharedPreferences? = null
+    private var webSocket: WebSocket? = null
     private val _state = MutableStateFlow(VideoUiState())
     val state: StateFlow<VideoUiState> = _state
 
@@ -42,6 +50,37 @@ class VideoViewModel : ViewModel() {
                 _state.value = _state.value.copy(selectedProfileId = savedId)
             }
         }
+        if (webSocket == null) {
+            connectWebSocket()
+        }
+    }
+
+    private fun connectWebSocket() {
+        val wsUrl = ApiClient.BASE_URL.replace("http://", "ws://") + "ws"
+        val request = Request.Builder().url(wsUrl).build()
+        val client = OkHttpClient()
+        webSocket = client.newWebSocket(request, object : WebSocketListener() {
+            override fun onMessage(webSocket: WebSocket, text: String) {
+                val profileIds = text.split(",").mapNotNull { it.trim().toIntOrNull() }
+                val selected = _state.value.selectedProfileId
+                if (selected != null && selected in profileIds) {
+                    loadAllVideos()
+                }
+            }
+
+            override fun onFailure(webSocket: WebSocket, t: Throwable, response: Response?) {
+                Log.w("VideoViewModel", "WebSocket Fehler, reconnect in 5s", t)
+                viewModelScope.launch(Dispatchers.IO) {
+                    delay(5000)
+                    connectWebSocket()
+                }
+            }
+        })
+    }
+
+    override fun onCleared() {
+        webSocket?.close(1000, null)
+        super.onCleared()
     }
 
     fun loadProfiles() {
@@ -79,9 +118,10 @@ class VideoViewModel : ViewModel() {
     fun loadDownloadedVideos() {
         viewModelScope.launch {
             _state.value = _state.value.copy(isLoading = true, error = null)
-            repository.getDownloadedVideos(profileId = _state.value.selectedProfileId)
+            repository.getAllVideos(profileId = _state.value.selectedProfileId)
                 .onSuccess { videos ->
-                    _state.value = _state.value.copy(downloadedVideos = videos, isLoading = false)
+                    val local = videos.filter { localStorage?.isLocallyAvailable(it.id) == true }
+                    _state.value = _state.value.copy(downloadedVideos = local, isLoading = false)
                 }
                 .onFailure { e ->
                     _state.value = _state.value.copy(error = e.message, isLoading = false)
@@ -113,6 +153,7 @@ class VideoViewModel : ViewModel() {
                 }
 
                 localStorage?.downloadAndSave(videoId)
+                repository.deleteServerFile(videoId)
                 _state.value = _state.value.copy(
                     isDownloading = false,
                     downloadStatus = "Lokal gespeichert"
@@ -128,8 +169,9 @@ class VideoViewModel : ViewModel() {
 
     fun deleteNotDownloaded() {
         val profileId = _state.value.selectedProfileId ?: return
+        val localIds = localStorage?.getLocalVideoIds() ?: emptyList()
         viewModelScope.launch {
-            repository.deleteNotDownloaded(profileId)
+            repository.cleanupVideos(profileId, localIds)
             loadAllVideos()
         }
     }
diff --git a/architecture.md b/architecture.md
index ba38dc6..71df621 100644
--- a/architecture.md
+++ b/architecture.md
@@ -8,10 +8,12 @@
 - GET /videos — alle Videos abrufen (optional nach Profil filtern)
 - GET /profiles — alle Profile abrufen
 - GET /videos/downloaded — heruntergeladene Videos abrufen (optional nach Profil filtern)
-- DELETE /videos?profile_id=X — nicht heruntergeladene Videos des Profils loeschen
+- DELETE /videos?profile_id=X&exclude_ids= — Videos des Profils loeschen (ausser lokal gespeicherte)
 - POST /videos/{id}/download — Download triggern
 - GET /videos/{id}/stream — Video streamen
 - GET /videos/{id}/file — Video-Datei zum Download ausliefern
+- DELETE /videos/{id}/file — Server-Datei loeschen (nach lokalem Download)
+- WS /ws — WebSocket, benachrichtigt Clients bei neuen Videos
 ## Services
 - VideoService — Videos speichern, abrufen, Status verwalten
 - DownloadService — yt-dlp aufrufen, Video herunterladen
@@ -31,7 +33,7 @@
 ## Services
 - LocalStorageService — Videos lokal speichern, pruefen, loeschen
 ## API 
-- ServerApi — kommuniziert mit FastAPI (GET /profiles, GET /videos, POST /download, GET /stream, GET /videos/{id}/file)
+- ServerApi — kommuniziert mit FastAPI (GET /profiles, GET /videos, POST /download, GET /stream, GET /videos/{id}/file, DELETE /videos/{id}/file, DELETE /videos)
 ## Model 
 - Video — id, title, youtuber, thumbnailUrl, youtubeUrl, isDownloaded, localFilePath, profileIds
 - Profile — id, name
\ No newline at end of file
diff --git a/backend/main.py b/backend/main.py
index 97575ee..6d21d98 100644
--- a/backend/main.py
+++ b/backend/main.py
@@ -1,4 +1,4 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
 
 from database import SessionLocal, create_tables
@@ -17,6 +17,32 @@ app.add_middleware(
 app.include_router(videos_router)
 app.include_router(profiles_router)
 
+# --- WebSocket ---
+
+connected_clients: set[WebSocket] = set()
+
+
+@app.websocket("/ws")
+async def websocket_endpoint(websocket: WebSocket):
+    await websocket.accept()
+    connected_clients.add(websocket)
+    try:
+        while True:
+            await websocket.receive_text()
+    except WebSocketDisconnect:
+        connected_clients.discard(websocket)
+
+
+async def notify_clients(profile_ids: list[int]):
+    message = ",".join(str(pid) for pid in profile_ids)
+    for client in list(connected_clients):
+        try:
+            await client.send_text(message)
+        except Exception:
+            connected_clients.discard(client)
+
+
+# --- Startup ---
 
 @app.on_event("startup")
 def startup():
diff --git a/backend/requirements.txt b/backend/requirements.txt
index feec010..9ee0b70 100644
--- a/backend/requirements.txt
+++ b/backend/requirements.txt
@@ -1,5 +1,5 @@
 fastapi
-uvicorn
+uvicorn[standard]
 yt-dlp
 sqlalchemy
 aiosqlite
diff --git a/backend/routes/__pycache__/videos.cpython-312.pyc b/backend/routes/__pycache__/videos.cpython-312.pyc
index 532ec201b1fe913f0f35c83d79e20c0d7d36d6e0..7a7ca68c727c1855e5bff6659aa368b8995955b2 100644
GIT binary patch
literal 7998
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

literal 6546
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

diff --git a/backend/routes/videos.py b/backend/routes/videos.py
index 934d0d1..4a294ac 100644
--- a/backend/routes/videos.py
+++ b/backend/routes/videos.py
@@ -1,29 +1,39 @@
+import asyncio
 import threading
 from pathlib import Path
 from typing import Optional
 
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException, Query
 from fastapi.responses import FileResponse, StreamingResponse
 from sqlalchemy.orm import Session
 
 from database import get_db
-from schemas import ProfileResponse, VideoCreate, VideoResponse
+from schemas import CleanupRequest, ProfileResponse, VideoCreate, VideoResponse
 from services import video_service
 from services.download_service import download_video
 from services.stream_service import stream_video_live
+from services.video_service import update_file_path
 
 router = APIRouter(prefix="/videos", tags=["videos"])
 
 
 @router.post("", response_model=list[VideoResponse])
-def create_videos(videos_data: list[VideoCreate], db: Session = Depends(get_db)):
+async def create_videos(videos_data: list[VideoCreate], db: Session = Depends(get_db)):
     created_ids = []
+    profile_ids = set()
     for video_data in reversed(videos_data):
         video_id_match = video_data.youtube_url.split("v=")[-1].split("&")[0]
         video_service.delete_by_youtube_id(db, video_id_match)
         video = video_service.create_video(db, video_data)
         created_ids.append(video.id)
+        if video_data.profile_id:
+            profile_ids.add(video_data.profile_id)
     videos = [video_service.get_video(db, vid) for vid in created_ids]
+
+    if profile_ids:
+        from main import notify_clients
+        await notify_clients(list(profile_ids))
+
     return [VideoResponse.from_model(v) for v in videos if v]
 
 
@@ -39,9 +49,9 @@ def get_downloaded_videos(profile_id: Optional[int] = Query(None), db: Session =
     return [VideoResponse.from_model(v) for v in videos]
 
 
-@router.delete("")
-def delete_not_downloaded(profile_id: int = Query(...), db: Session = Depends(get_db)):
-    count = video_service.delete_not_downloaded(db, profile_id)
+@router.post("/cleanup")
+def cleanup_videos(request: CleanupRequest, db: Session = Depends(get_db)):
+    count = video_service.delete_not_downloaded(db, request.profile_id, request.exclude_ids or None)
     return {"deleted": count}
 
 
@@ -65,21 +75,23 @@ def stream_video(video_id: int, db: Session = Depends(get_db)):
         raise HTTPException(status_code=404, detail="Video nicht gefunden")
 
     if not video.file_path:
-        return StreamingResponse(
-            stream_video_live(video.youtube_url),
-            media_type="video/mp4",
-        )
+        def stream_and_save():
+            output_path = f"/videos/{video_id}.mp4"
+            yield from stream_video_live(video_id, video.youtube_url)
+            if Path(output_path).exists():
+                sdb = __import__("database").SessionLocal()
+                try:
+                    update_file_path(sdb, video_id, output_path)
+                finally:
+                    sdb.close()
+
+        return StreamingResponse(stream_and_save(), media_type="video/mp4")
 
     path = Path(video.file_path)
     if not path.exists():
         raise HTTPException(status_code=404, detail="Videodatei nicht gefunden")
 
-    def iter_file():
-        with open(path, "rb") as f:
-            while chunk := f.read(1024 * 1024):
-                yield chunk
-
-    return StreamingResponse(iter_file(), media_type="video/mp4")
+    return FileResponse(path, media_type="video/mp4")
 
 
 @router.get("/{video_id}/file")
@@ -97,6 +109,19 @@ def download_file(video_id: int, db: Session = Depends(get_db)):
     return FileResponse(path, media_type="video/mp4", filename=f"{video.title}.mp4")
 
 
+@router.delete("/{video_id}/file")
+def delete_server_file(video_id: int, db: Session = Depends(get_db)):
+    video = video_service.get_video(db, video_id)
+    if not video:
+        raise HTTPException(status_code=404, detail="Video nicht gefunden")
+    if video.file_path:
+        path = Path(video.file_path)
+        if path.exists():
+            path.unlink()
+        video_service.update_file_path(db, video_id, None)
+    return {"status": "deleted"}
+
+
 profiles_router = APIRouter(prefix="/profiles", tags=["profiles"])
 
 
diff --git a/backend/schemas.py b/backend/schemas.py
index 21c68b1..b92590d 100644
--- a/backend/schemas.py
+++ b/backend/schemas.py
@@ -34,6 +34,11 @@ class VideoResponse(BaseModel):
         )
 
 
+class CleanupRequest(BaseModel):
+    profile_id: int
+    exclude_ids: list[int] = []
+
+
 class ProfileResponse(BaseModel):
     id: int
     name: str
diff --git a/backend/services/__pycache__/download_service.cpython-312.pyc b/backend/services/__pycache__/download_service.cpython-312.pyc
index c73a32f3b84026786e2f6163acfbf0ebbdebf0c2..879edb7648491de9af24898af5cd6532068c6560 100644
GIT binary patch
delta 65
zcmcb}evh5^G%qg~0}#x<a4EBHBky)bd55Ib;*zq=l+^s_)QS?@+yax>=(6Pel+@%n
U+r+Zu&DR*&7#Tw*-(~s&0PW-#zW@LL

delta 52
zcmcb|evzH`G%qg~0}zNLUCJ!n$h)0U$T%srxTGvIB{e@fwW7o}x4>lcV@5VcM)%3D
Hn7#l2u96Y2

diff --git a/backend/services/__pycache__/video_service.cpython-312.pyc b/backend/services/__pycache__/video_service.cpython-312.pyc
index e53d09f33bb83f0c4eb11f2c7ec441326e0404cb..a8a520b40115e155820301851620d33ff31eaba7 100644
GIT binary patch
delta 1066
zcmZ8gUuY9a7@ygl-Rx$Q?B-9^Zk7JA)&?6-FYUDrwF<Vmw1<jlJgay?va8o16*g_P
zl3ZJ^aF+I{VFVkf<msTti3mOmJ)a6bn01AXp@<;&=7ZWNU&NX8R>gt&eZTMfe&5VD
zGrNDa7Q^jNyk0jTqwndn(MJLRuc_k<@qe<(z(V^VtSj7VaJlEWbCO1A>TsQgbf}5C
zs0DPlF4hyZCfsll<aP0qpaqH4U(@g;&(i!Qq=n|txxkbV-u7@O9B{+G@kQwd?7|z;
zfA9zV*b|05_>HG~PgT;dr>{(CdTLb5rdg*YV#x-8`kU_={7OE8@4MajrMn$>a9u7o
z#~Ax_EM9Xr;%+X8Pcoq$Ip!a@Rqoh4n`1M6Y>H}s9_7#gSmM&mWsqhr_yEXrIWFVb
zD)<@;%%Xxoo+o)e3#VWXWP-RL2BkVjmDxs@WHR+M91VRAs}B2OGdsU<hh-Y^K_;m3
zPM6<Wi2J<>dMaj1$r2@2g_eNE++!Uv1f;KK+Q&2m<GY=;bDvi|MUDx{%yZX37#%kl
zB8eLZ2!;cOLX5#t@Kc~iFq$bK3IPIDe(dV_=vc~VrH)I#uBRu)b%Uq*P8#B_{i+*!
z6{deQ_EDdu;_WqdMIQ^h4DyiygWj*vOMz}#<tIlq{c5%fC#zzO(nrtIhi+=Z0l8&*
zfY2zJ*^dNfK*i%*O3Wv2Cl^lGo)**7vLSeveDgkAP)$Ky=`O{Ju~pS<h+0DDCd+vF
znZb8F5P}t@?vAJ6SxJ`87SEPa#nkF~YgezO#BOpGZ(wO;eq`bNO#DUT9!qH}PA)g!
z^4|&J(DLN;%urcrdm)7?vQk0(AH%c5i@(`&t0}iya+@u8m~zLxU+l;sGjhm|#LY<D
zjtrZT;q_iClC<PA&(Y7cEHRr{O#XhtMyiR_m9A1xv8U8m>{}JBhVLyDwNcDOvGs{E
ziake3S}-&_H22en<lAv`YN5Z3>OZ{q0{`ADz3s=_gM*z2ugiD2IB}2SjPj?_MVQe;
zfnJyq$1eXa=@_B(2gpK*zw@u{f9LZ;b@}pJK+J<^&8(eX-~I1M`DD@@Ox6PBi`pj5
Kziq-&K>Y-h7yqyT

delta 576
zcmbQKxl~2tG%qg~0}zNDzLYtSoq^#ohyw#0P{!vE3==h68AT>ekY?v<VU6NW0W#xt
zSyCBOI8!-O*it#u*iwXASfT_|Kw@mET&c{GK)q=!DZ)Tep-K)-(am~{E?kV7lZ&~l
z7)>U><9^C$I{6BZCZqY}e>~>m$xJXifi%z=49r0MIb-row%W;6?D3pX=`7*N51FLY
zYMDwzVd`s`Rx?7_wahh4E)2243=Fj_H4ItelNp)iIC?}`7=Ro}pgvh;=3s^*1)yS0
z-XZ}YRm2J+1VMxbkhsO1SsXvPfkV_n1<cDy%_}knNs0prP1Yh%XcX~)q}a+bQ&RJb
zZ?Pulm*$leNdd)*L1s<<B%oAp3uJ(_6*mEi28J8F{QVJ~5mQpT<FE57U*uK3!@=9n
z-^qWSL;50z^bD8F9Eu<jzD~aD98woKq~@5<x0-3SLh7Ql@nsH^&#cURY~R@!*tr^$
zn^QlqGq7@h;b7nun84QU-Qap#P`rcn1_xI^XD8<b)vFv5AD9_Lg(M!Zu(f+OdbW7q
z;1+1`DUt)ZOiO4kt38lmKlzMMuYd`VRb&n#K&~yapPVTy%k2haf`YR6J;UUQ!UtqN
d@NqH<&Pe~j0Hih;gQ*?HpFzA25|isiqyUvWhI9Y`

diff --git a/backend/services/download_service.py b/backend/services/download_service.py
index 6f2debe..b0dfa15 100644
--- a/backend/services/download_service.py
+++ b/backend/services/download_service.py
@@ -12,7 +12,7 @@ def download_video(video_id: int, youtube_url: str):
     subprocess.run(
         [
             "yt-dlp",
-            "-f", "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]",
+            "-f", "bestvideo[ext=mp4][vcodec^=avc]+bestaudio[ext=m4a]/best[ext=mp4]",
             "-o", output_path,
             "--merge-output-format", "mp4",
             youtube_url,
diff --git a/backend/services/stream_service.py b/backend/services/stream_service.py
index 7cc47ec..f9577e7 100644
--- a/backend/services/stream_service.py
+++ b/backend/services/stream_service.py
@@ -1,32 +1,53 @@
 import subprocess
+import time
+from pathlib import Path
+
+VIDEOS_DIR = "/videos"
 
 
-def stream_video_live(youtube_url: str):
-    result = subprocess.run(
+def stream_video_live(video_id: int, youtube_url: str):
+    output_path = f"{VIDEOS_DIR}/{video_id}.mp4"
+    path = Path(output_path)
+
+    process = subprocess.Popen(
         [
             "yt-dlp",
-            "-f", "bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best",
-            "-g", youtube_url,
+            "-f", "best[ext=mp4][vcodec^=avc]/best[ext=mp4]",
+            "-o", output_path,
+            youtube_url,
         ],
-        capture_output=True, text=True, check=True,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
     )
-    urls = result.stdout.strip().split("\n")
 
-    cmd = ["ffmpeg"]
-    for url in urls:
-        cmd.extend(["-i", url])
-    cmd.extend(["-c", "copy", "-movflags", "frag_keyframe+empty_moov", "-f", "mp4", "pipe:1"])
+    # Warte bis Datei existiert und mindestens 1MB hat
+    while process.poll() is None:
+        if path.exists() and path.stat().st_size >= 1024 * 1024:
+            break
+        time.sleep(0.5)
 
-    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL)
-    try:
-        while True:
-            chunk = process.stdout.read(1024 * 1024)
-            if not chunk:
-                break
-            yield chunk
+    if not path.exists():
         process.wait()
-    except GeneratorExit:
-        process.kill()
-    finally:
-        if process.poll() is None:
-            process.kill()
+        return
+
+    # Streame aus der wachsenden Datei
+    pos = 0
+    stall_count = 0
+    with open(output_path, "rb") as f:
+        while True:
+            chunk = f.read(1024 * 1024)
+            if chunk:
+                pos += len(chunk)
+                stall_count = 0
+                yield chunk
+            else:
+                if process.poll() is not None:
+                    # Download fertig — restliche Bytes lesen
+                    remaining = f.read()
+                    if remaining:
+                        yield remaining
+                    break
+                stall_count += 1
+                if stall_count > 60:  # 30 Sekunden ohne neue Daten
+                    break
+                time.sleep(0.5)
diff --git a/backend/services/video_service.py b/backend/services/video_service.py
index e8164da..4a78077 100644
--- a/backend/services/video_service.py
+++ b/backend/services/video_service.py
@@ -48,16 +48,20 @@ def update_file_path(db: Session, video_id: int, path: str):
         db.commit()
 
 
-def delete_not_downloaded(db: Session, profile_id: int) -> int:
-    videos = db.query(Video).filter(
-        Video.file_path.is_(None),
+def delete_not_downloaded(db: Session, profile_id: int, exclude_ids: list[int] | None = None) -> int:
+    query = db.query(Video).filter(
         Video.profiles.any(Profile.id == profile_id),
-    ).all()
-    count = len(videos)
-    for video in videos:
-        db.delete(video)
+    )
+    if exclude_ids:
+        query = query.filter(Video.id.notin_(exclude_ids))
+    videos = query.all()
+    video_ids = [v.id for v in videos]
+    if not video_ids:
+        return 0
+    db.execute(video_profiles.delete().where(video_profiles.c.video_id.in_(video_ids)))
+    db.query(Video).filter(Video.id.in_(video_ids)).delete(synchronize_session=False)
     db.commit()
-    return count
+    return len(video_ids)
 
 
 def get_all_profiles(db: Session) -> list[Profile]:
diff --git a/commication.md b/commication.md
index aa73a2b..189d753 100644
--- a/commication.md
+++ b/commication.md
@@ -8,7 +8,8 @@
 - Video herunterladen 
 # Server -> App
 - Video streamen
-- Videodatei senden 
+- Videodatei senden
+- WebSocket: Benachrichtigung bei neuen Videos (Profile-IDs) 
 # App -> Server 
 - Profile abrufen
 - Videos nach Profil abrufen
diff --git a/features.md b/features.md
index 49a04e6..ea8286a 100644
--- a/features.md
+++ b/features.md
@@ -12,4 +12,5 @@
 - Klick auf Download lädt das Video herunter und wird lokal auf dem Client gespeichert
 - Klick auf Icon zeigt verfügbare Profile 
 - Das ausgewählte Profil wird persistiert und bestimmt welche Videos angezeigt werden 
-- Klick auf Icon löscht alle nicht heruntergeladenen Videos vom aktuellen Profil
\ No newline at end of file
+- Klick auf Icon löscht alle nicht heruntergeladenen Videos vom aktuellen Profil
+- Bei neuen Videoeinträgen in der DB werden die Videos für das zugehörige Profil in der App aktualisiert 
\ No newline at end of file