release: bump version to 0.0.8.8

OnePlus A12 stallte bei kurzem Text mit pos=0/34112: 336KB Buffer fuer
3.5s Preroll, aber nur 68KB Daten drin → AudioTrack faehrt nicht an.

Fix: Buffer fest auf ~2s, plus play()-Retry bei pos=0 nach 500ms.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

README.md

@@ -384,7 +384,7 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 - **VAD (Voice Activity Detection)**: Adaptive Schwelle (Baseline aus ersten 500ms Mic-Pegel + 6dB Offset). Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme einstellbar (1–30 min, Default 5 min)
 - **Barge-In**: Wenn du waehrend ARIAs Antwort eine neue Sprach-/Text-Nachricht reinschickst, wird sie unterbrochen + bekommt den Hint "das ist eine Korrektur"
 - **Wake-Word waehrend TTS**: Du kannst "Computer" sagen waehrend ARIA noch redet — AcousticEchoCanceler verhindert dass ARIAs eigene Stimme das Wake-Word triggert
-- **Anruf-Pause**: TTS verstummt automatisch wenn das Telefon klingelt (READ_PHONE_STATE Permission)
+- **Anruf-Pause + Auto-Resume**: TTS verstummt bei klassischem Anruf oder VoIP-Call (WhatsApp/Signal/Discord). Nach dem Auflegen geht ARIA von der **genauen Stelle** weiter wo sie unterbrochen wurde — die App misst die Position vom Wiedergabe-Anfang und nutzt den WAV-Cache der Antwort
 - **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
 - **STT (Speech-to-Text)**: 16kHz mono → Bridge → Gamebox-Whisper (CUDA) → Text im Chat. Fast in Echtzeit.
 - **"ARIA denkt..." Indicator**: Zeigt live den Status vom Core (Denken, Tool, Schreiben) + Abbrechen-Button
@@ -510,10 +510,36 @@ Der Update-Flow:
 App (Mikrofon) → AAC/MP4 Aufnahme → Base64 → RVS → Bridge
 Bridge: FFmpeg (16kHz PCM) → Whisper STT → Text → aria-core
 Bridge: STT-Ergebnis → RVS → App (Placeholder wird durch transkribierten Text ersetzt)
-aria-core → Antwort → Bridge → XTTS (Gaming-PC) → PCM-Stream → RVS → App
+aria-core → Antwort → Bridge → F5-TTS (Gaming-PC) → PCM-Stream → RVS → App
 App: AudioTrack MODE_STREAM (nahtlos), Cache als WAV pro Message
 ```
 
+### Audio-Verhalten in der App
+
+| Phase                        | Andere App (Spotify) | ARIA-Mikro              |
+|------------------------------|----------------------|-------------------------|
+| Idle / Ohr aus               | spielt frei          | aus                     |
+| Wake-Word lauscht (armed)    | spielt frei          | passiv (openWakeWord)   |
+| User-Aufnahme laeuft         | pausiert (EXCLUSIVE) | Recording               |
+| Aufnahme zu Ende             | resumed              | aus                     |
+| ARIA denkt/schreibt (~20s)   | spielt frei          | aus                     |
+| TTS startet                  | pausiert (DUCK)      | aus (oder barge)        |
+| TTS spielt (auch GPU-Pausen) | bleibt pausiert      | barge wenn Wake-Word    |
+| TTS zu Ende                  | nach 800ms resumed   | (Conversation-Window)   |
+| Eingehender Anruf (auch VoIP)| —                    | Mikro pausiert          |
+| Anruf vorbei (Auto-Resume)   | pausiert wieder       | aus                     |
+| Neue Frage waehrend Anruf    | —                    | (Resume verworfen)      |
+
+Mechanismen: Underrun-Schutz im PcmStreamPlayer (Stille-Fill in Render-
+Pausen), Conversation-Focus bei Wake-Word, Foreground-Service mit
+mediaPlayback|microphone, Anruf-Erkennung ueber TelephonyManager +
+AudioFocus-Loss-Listener mit Polling-Fallback (VoIP). Bei Anruf wird
+die Wiedergabe-Position gemerkt — nach dem Auflegen spielt ARIA ab
+der genauen Stelle weiter (oder verwirft das wenn der User waehrend
+des Telefonats per Text eine neue Frage gestellt hat). PcmPlayback-
+Finished-Event vom Native sorgt dafuer dass Spotify erst pausiert
+bleibt bis ARIA wirklich verstummt ist.
+
 ### Datei-Pipeline (Bilder & Anhaenge)
 
 ```
@@ -568,8 +594,7 @@ aria-data/
 │   └── diag-state/                 ← Diagnostic persistenter State
 │
 │   (im Shared Volume /shared/config/):
-│   ├── voice_config.json           ← TTS-Einstellungen (Stimme, Speed, Engine)
+│   ├── voice_config.json           ← TTS-Einstellungen (Stimme, Speed, F5-TTS-Tuning)
-│   ├── highlight_triggers.json     ← Highlight-Trigger Woerter
 │   └── chat_backup.jsonl           ← Nachrichten-Backup (on-the-fly)
 │
 └── ssh/                            ← SSH Keys fuer VM-Zugriff
@@ -816,7 +841,7 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] SSH-Zugriff auf VM (aria-wohnung)
 - [x] Diagnostic Web-UI + Einstellungen
 - [x] Session-Verwaltung + Chat-History
-- [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed, Highlight-Trigger) — durch XTTS v2 Voice Cloning ersetzt
+- [x] Stimmen-Einstellungen (frueher Piper Ramona/Thorsten, Highlight-Trigger) — durch XTTS, dann F5-TTS Voice Cloning ersetzt
 - [x] Piper komplett entfernt — nur noch XTTS v2 als TTS (Gaming-PC)
 - [x] Streaming TTS: PCM-Chunks direkt in AudioTrack, nahtlose Wiedergabe
 - [x] TTS satzweise fuer lange Texte
@@ -845,12 +870,17 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] Audio-Pause statt Ducking (TRANSIENT statt MAY_DUCK) + release-Timing fix
 - [x] VAD-Stille-Toleranz einstellbar (1-8s) + adaptive Mikro-Baseline + Max-Aufnahme einstellbar (1-30 min)
 - [x] Barge-In: User kann ARIA waehrend Antwort unterbrechen, aria-core bekommt Kontext-Hint
-- [x] Anruf-Pause: TTS verstummt bei eingehendem Anruf (PhoneStateListener)
+- [x] Anruf-Pause + Auto-Resume: TTS verstummt bei Anruf, faehrt nach Auflegen ab der gemerkten Position fort (Date.now()-Tracking + WAV-Cache der Antwort)
+- [x] PcmPlaybackFinished-Event: AudioFocus wird erst released wenn AudioTrack wirklich durch ist — kein Spotify-mid-TTS mehr
+- [x] Edge-Case: neue Frage waehrend Telefonat verwirft pending Auto-Resume, neueste Antwort gewinnt
 - [x] Settings-Sub-Screens: 8 Kategorien statt langer Liste
 - [x] APK ABI-Split arm64-v8a: 35 MB statt 136 MB
 - [x] Sprachnachrichten-Bubble: audioRequestId statt Substring-Match — keine vertauschten Bubbles mehr bei parallelen Aufnahmen
 - [x] Bereit-Sound (Airplane Ding-Dong) wenn Mikro nach Wake-Word offen ist — akustische Bestaetigung, in Settings abschaltbar
 - [x] Wake-Word parallel zu TTS mit AcousticEchoCanceler — "Computer" sagen waehrend ARIA spricht stoppt sie und oeffnet Mikro
+- [x] GPS-Position mit Nachrichten mitsenden (Toggle in Settings) — ARIA nutzt sie nur bei standortbezogenen Fragen, im Chat sichtbar nur in ihrer Antwort
+- [x] Sprachnachrichten ohne STT-Result werden nach Timeout automatisch entfernt (skaliert mit Aufnahmedauer)
+- [x] Background Audio Service: TTS, Wake-Word-Lauschen + Aufnahme laufen auch bei minimierter App weiter (Foreground-Service mit mediaPlayback|microphone, dynamische Notification)
 - [x] Disk-Voll Banner in Diagnostic mit copy-baren Cleanup-Befehlen
 - [x] Wake-Word on-device via openWakeWord (ONNX Runtime, kein API-Key) + State-Icon
 

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 708
+        versionCode 808
-        versionName "0.0.7.8"
+        versionName "0.0.8.8"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }

android/android/app/src/main/AndroidManifest.xml

@@ -6,6 +6,14 @@
     <uses-permission android:name="android.permission.REQUEST_INSTALL_PACKAGES" />
     <!-- Anruf-State lesen damit TTS bei klingelndem Telefon pausiert -->
     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <!-- Foreground-Service damit TTS auch bei minimierter App weiterlaeuft.
+         FOREGROUND_SERVICE_MICROPHONE ist Pflicht ab Android 14 wenn der
+         Service waehrend des Backgrounds aufs Mikro zugreift (Wake-Word,
+         Aufnahme im Gespraechsmodus). -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
 
     <application
       android:name=".MainApplication"
@@ -37,5 +45,10 @@
           android:name="android.support.FILE_PROVIDER_PATHS"
           android:resource="@xml/file_paths" />
       </provider>
+
+      <service
+        android:name=".AriaPlaybackService"
+        android:exported="false"
+        android:foregroundServiceType="mediaPlayback|microphone" />
     </application>
 </manifest>

android/android/app/src/main/java/com/ariacockpit/AriaPlaybackService.kt

@@ -0,0 +1,108 @@
+package com.ariacockpit
+
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Intent
+import android.os.Build
+import android.os.IBinder
+import android.util.Log
+import androidx.core.app.NotificationCompat
+
+/**
+ * Foreground-Service der den App-Prozess waehrend TTS-Wiedergabe am Leben
+ * haelt — Android killt sonst den Prozess sobald die App im Hintergrund ist
+ * und ARIA verstummt mitten im Satz.
+ *
+ * Notification ist persistent (ongoing) waehrend der Service laeuft.
+ * Tap auf die Notification bringt MainActivity zurueck nach vorne.
+ *
+ * foregroundServiceType="mediaPlayback" ist Pflicht ab Android 14, sonst
+ * wirft startForeground() eine SecurityException.
+ */
+class AriaPlaybackService : Service() {
+    companion object {
+        private const val TAG = "AriaPlaybackService"
+        private const val CHANNEL_ID = "aria_playback"
+        private const val NOTIFICATION_ID = 1042
+        const val EXTRA_REASON = "reason"  // "tts" | "wake" | "rec" | ""
+    }
+
+    private var currentReason: String = ""
+
+    override fun onCreate() {
+        super.onCreate()
+        ensureNotificationChannel()
+    }
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        val reason = intent?.getStringExtra(EXTRA_REASON) ?: ""
+        currentReason = reason
+        Log.i(TAG, "Foreground-Service start/update (reason=$reason)")
+        try {
+            startForeground(NOTIFICATION_ID, buildNotification(reason))
+        } catch (e: Exception) {
+            Log.e(TAG, "startForeground fehlgeschlagen", e)
+            stopSelf()
+        }
+        // START_NOT_STICKY: wenn Android den Service killt, NICHT automatisch
+        // wieder starten — die App entscheidet wann der Service noetig ist.
+        return START_NOT_STICKY
+    }
+
+    override fun onDestroy() {
+        Log.i(TAG, "Foreground-Service gestoppt")
+        super.onDestroy()
+    }
+
+    override fun onBind(intent: Intent?): IBinder? = null
+
+    private fun ensureNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            val nm = getSystemService(NotificationManager::class.java) ?: return
+            if (nm.getNotificationChannel(CHANNEL_ID) == null) {
+                val channel = NotificationChannel(
+                    CHANNEL_ID,
+                    "ARIA Audio-Wiedergabe",
+                    NotificationManager.IMPORTANCE_LOW,
+                ).apply {
+                    description = "Notification waehrend ARIA spricht (haelt die App im Hintergrund am Leben)"
+                    setShowBadge(false)
+                }
+                nm.createNotificationChannel(channel)
+            }
+        }
+    }
+
+    private fun buildNotification(reason: String): Notification {
+        val launchIntent = Intent(this, MainActivity::class.java).apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP
+        }
+        val pendingFlags = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+            PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+        else
+            PendingIntent.FLAG_UPDATE_CURRENT
+        val pendingIntent = PendingIntent.getActivity(this, 0, launchIntent, pendingFlags)
+
+        val (title, body) = when (reason) {
+            "tts"  -> "ARIA spricht" to "Antwort wird abgespielt — antippen oeffnet die App"
+            "rec"  -> "ARIA hoert zu" to "Sprachaufnahme laeuft — antippen oeffnet die App"
+            "wake" -> "ARIA bereit"   to "Wake-Word lauscht passiv — antippen oeffnet die App"
+            else   -> "ARIA aktiv"    to "Hintergrund-Modus — antippen oeffnet die App"
+        }
+
+        return NotificationCompat.Builder(this, CHANNEL_ID)
+            .setContentTitle(title)
+            .setContentText(body)
+            .setSmallIcon(R.mipmap.ic_launcher)
+            .setContentIntent(pendingIntent)
+            .setOngoing(true)
+            .setShowWhen(false)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .setCategory(NotificationCompat.CATEGORY_SERVICE)
+            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+            .build()
+    }
+}

android/android/app/src/main/java/com/ariacockpit/AudioFocusModule.kt

@@ -5,26 +5,71 @@ import android.media.AudioAttributes
 import android.media.AudioFocusRequest
 import android.media.AudioManager
 import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.modules.core.DeviceEventManagerModule
 
 /**
- * Steuert Audio-Focus fuer Ducking/Muten anderer Apps.
+ * Steuert Audio-Focus fuer Ducking/Muten anderer Apps + emittiert Loss-Events
+ * an JS damit ARIA bei VoIP-Anrufen (WhatsApp/Signal/Discord/...) aufhoert
+ * zu sprechen — diese Anrufe gehen nicht ueber TelephonyManager, sondern
+ * requestn AudioFocus_GAIN_TRANSIENT_EXCLUSIVE was wir hier mitbekommen.
  *
  * - requestDuck()      → andere Apps werden leiser (ARIA spricht TTS)
  * - requestExclusive() → andere Apps werden pausiert (Mikrofon-Aufnahme)
  * - release()          → Focus abgeben, andere Apps duerfen wieder
+ *
+ * Events:
+ * - "AudioFocusChanged" mit type:
+ *     "loss"           — endgueltiger Verlust (Anruf, andere App permanent)
+ *     "loss_transient" — vorruebergehender Verlust (kurze Unterbrechung)
+ *     "gain"           — Fokus zurueck
  */
 class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
     override fun getName() = "AudioFocus"
 
+    companion object { private const val TAG = "AudioFocus" }
+
     private var currentRequest: AudioFocusRequest? = null
 
     private fun audioManager(): AudioManager? =
         reactApplicationContext.getSystemService(Context.AUDIO_SERVICE) as? AudioManager
 
+    private fun emitFocusChange(type: String) {
+        try {
+            val params = Arguments.createMap().apply { putString("type", type) }
+            reactApplicationContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("AudioFocusChanged", params)
+        } catch (e: Exception) {
+            Log.w(TAG, "emit failed: ${e.message}")
+        }
+    }
+
+    private val focusListener = AudioManager.OnAudioFocusChangeListener { focusChange ->
+        when (focusChange) {
+            AudioManager.AUDIOFOCUS_LOSS -> {
+                Log.i(TAG, "AUDIOFOCUS_LOSS (z.B. Anruf, anderer Player permanent)")
+                emitFocusChange("loss")
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT -> {
+                Log.i(TAG, "AUDIOFOCUS_LOSS_TRANSIENT (kurze Unterbrechung)")
+                emitFocusChange("loss_transient")
+            }
+            AudioManager.AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK -> {
+                // Notification-Sound o.ae. — wir ignorieren das, ARIA macht weiter
+                Log.d(TAG, "AUDIOFOCUS_LOSS_CAN_DUCK ignoriert")
+            }
+            AudioManager.AUDIOFOCUS_GAIN -> {
+                Log.i(TAG, "AUDIOFOCUS_GAIN")
+                emitFocusChange("gain")
+            }
+        }
+    }
+
     private fun requestFocus(durationHint: Int, usage: Int, promise: Promise) {
         val am = audioManager()
         if (am == null) {
@@ -41,13 +86,13 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
                 .build()
             val req = AudioFocusRequest.Builder(durationHint)
                 .setAudioAttributes(attrs)
-                .setOnAudioFocusChangeListener { /* kein Callback noetig */ }
+                .setOnAudioFocusChangeListener(focusListener)
                 .build()
             currentRequest = req
             am.requestAudioFocus(req)
         } else {
             @Suppress("DEPRECATION")
-            am.requestAudioFocus(null, AudioManager.STREAM_MUSIC, durationHint)
+            am.requestAudioFocus(focusListener, AudioManager.STREAM_MUSIC, durationHint)
         }
 
         promise.resolve(result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED)
@@ -92,8 +137,24 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
             currentRequest?.let { am.abandonAudioFocusRequest(it) }
         } else {
             @Suppress("DEPRECATION")
-            am.abandonAudioFocus(null)
+            am.abandonAudioFocus(focusListener)
         }
         currentRequest = null
     }
+
+    /** Aktueller Audio-Mode: NORMAL=0, IN_CALL=2, IN_COMMUNICATION=3, CALL_SCREENING=4.
+     *  IN_COMMUNICATION ist der typische VoIP-Anruf-Mode (WhatsApp, Signal, etc.) —
+     *  kann gepollt werden um zu erkennen wann der Anruf vorbei ist (zurueck NORMAL). */
+    @ReactMethod
+    fun getMode(promise: Promise) {
+        val am = audioManager()
+        if (am == null) {
+            promise.resolve(0)
+            return
+        }
+        promise.resolve(am.mode)
+    }
+
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
 }

android/android/app/src/main/java/com/ariacockpit/BackgroundAudioModule.kt

@@ -0,0 +1,59 @@
+package com.ariacockpit
+
+import android.content.Intent
+import android.os.Build
+import android.util.Log
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReactContextBaseJavaModule
+import com.facebook.react.bridge.ReactMethod
+
+/**
+ * RN-Bridge fuer den AriaPlaybackService.
+ *
+ * Wird vom JS waehrend einer TTS-Wiedergabe gestartet damit Android den
+ * App-Prozess nicht killt wenn die App im Hintergrund ist (= ARIA spricht
+ * weiter, auch wenn Stefan die App minimiert hat).
+ *
+ * Service stoppt entweder explizit per stop() oder wird von Android
+ * mitgekillt wenn der Prozess weg ist (was bei Foreground-Service nur
+ * passiert wenn der User die App force-stopped).
+ */
+class BackgroundAudioModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
+    override fun getName() = "BackgroundAudio"
+
+    companion object { private const val TAG = "BackgroundAudio" }
+
+    @ReactMethod
+    fun start(reason: String, promise: Promise) {
+        try {
+            val ctx = reactApplicationContext
+            val intent = Intent(ctx, AriaPlaybackService::class.java)
+            intent.putExtra(AriaPlaybackService.EXTRA_REASON, reason ?: "")
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                ctx.startForegroundService(intent)
+            } else {
+                ctx.startService(intent)
+            }
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "start fehlgeschlagen: ${e.message}")
+            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
+        }
+    }
+
+    @ReactMethod
+    fun stop(promise: Promise) {
+        try {
+            val ctx = reactApplicationContext
+            ctx.stopService(Intent(ctx, AriaPlaybackService::class.java))
+            promise.resolve(true)
+        } catch (e: Exception) {
+            Log.w(TAG, "stop fehlgeschlagen: ${e.message}")
+            promise.reject("STOP_FAILED", e.message ?: "Unbekannter Fehler", e)
+        }
+    }
+
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+}

android/android/app/src/main/java/com/ariacockpit/BackgroundAudioPackage.kt

@@ -0,0 +1,16 @@
+package com.ariacockpit
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class BackgroundAudioPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
+        return listOf(BackgroundAudioModule(reactContext))
+    }
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
+        return emptyList()
+    }
+}

android/android/app/src/main/java/com/ariacockpit/MainApplication.kt

@@ -23,6 +23,7 @@ class MainApplication : Application(), ReactApplication {
               add(PcmStreamPlayerPackage())
               add(OpenWakeWordPackage())
               add(PhoneCallPackage())
+              add(BackgroundAudioPackage())
             }
 
         override fun getJSMainModuleName(): String = "index"

android/android/app/src/main/java/com/ariacockpit/PcmStreamPlayerModule.kt

@@ -6,10 +6,12 @@ import android.media.AudioManager
 import android.media.AudioTrack
 import android.util.Base64
 import android.util.Log
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContextBaseJavaModule
 import com.facebook.react.bridge.ReactMethod
+import com.facebook.react.modules.core.DeviceEventManagerModule
 import java.util.concurrent.LinkedBlockingQueue
 
 /**
@@ -76,9 +78,12 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
             val encoding = AudioFormat.ENCODING_PCM_16BIT
             val minBuf = AudioTrack.getMinBufferSize(sampleRate, channelConfig, encoding)
             val bytesPerSecond = sampleRate * channels * 2 // 16-bit = 2 bytes
-            // Buffer muss mindestens PREROLL + etwas Spielraum fassen.
             val prerollTarget = (bytesPerSecond * prerollSec).toInt()
-            val bufferSize = (minBuf * 32).coerceAtLeast(prerollTarget * 2)
+            // Buffer entkoppelt von Preroll — fester ~2s-Buffer reicht. Wenn er
+            // an Preroll gekoppelt ist (z.B. 7s bei preroll=3.5s) und nur kurz
+            // gefuettert wird, stallt AudioTrack auf manchen Geraeten (OnePlus
+            // Android 12: pos bleibt 0 obwohl play() lief).
+            val bufferSize = (bytesPerSecond * 2).coerceAtLeast(minBuf * 8)
             prerollBytes = prerollTarget
             bytesBuffered = 0
             playbackStarted = false
@@ -137,10 +142,12 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                             Log.w(TAG, "play() sofort failed: ${e.message}")
                         }
                     }
-                    // Idle-Cutoff: wenn endRequested NICHT kam aber 30s nichts mehr
+                    // Idle-Cutoff: wenn endRequested NICHT kam aber lange nichts mehr
                     // reinkommt, brechen wir ab (Bridge-Crash, verlorener final).
+                    // 120s damit lange F5-TTS-Render-Pausen zwischen Saetzen (z.B. bei
+                    // Modell-Wechsel oder kalter GPU) nicht den Stream abreissen.
                     var idleMs = 0L
-                    val maxIdleMs = 30_000L
+                    val maxIdleMs = 120_000L
                     // Zielpufferfuellung — unter diesem Wasserstand fuettern wir
                     // Stille rein damit AudioTrack nicht underrunt waehrend die
                     // Bridge den naechsten Satz rendert. Spotify/YouTube reagieren
@@ -233,12 +240,21 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         val totalFrames = (bytesBuffered / streamBytesPerFrame).toInt()
                         var lastPos = -1
                         var stalledCount = 0
+                        var retried = false
                         while (!writerShouldStop) {
                             val pos = t.playbackHeadPosition
                             if (pos >= totalFrames) break
-                            // Safety: wenn Position 2s nicht mehr vorwaerts → AudioTrack hing
                             if (pos == lastPos) {
                                 stalledCount++
+                                // Nach 500ms Stillstand: AudioTrack-Quirk auf manchen
+                                // Geraeten (OnePlus A12) — play() nochmal anstossen.
+                                if (stalledCount == 10 && pos == 0 && !retried) {
+                                    retried = true
+                                    Log.w(TAG, "playback nicht angefahren — retry play()")
+                                    try { t.play() } catch (e: Exception) {
+                                        Log.w(TAG, "retry play() failed: ${e.message}")
+                                    }
+                                }
                                 if (stalledCount > 40) {
                                     Log.w(TAG, "playback stalled at $pos/$totalFrames — give up")
                                     break
@@ -253,6 +269,17 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                     } catch (_: Exception) {}
                     try { t.stop() } catch (_: Exception) {}
                     try { t.release() } catch (_: Exception) {}
+                    // RN-Event: AudioTrack ist wirklich durch (alle Samples gespielt).
+                    // JS released erst JETZT den AudioFocus — sonst spielt Spotify
+                    // beim end()-Cap waehrend ARIA noch redet (15s+ je nach Buffer).
+                    try {
+                        val params = Arguments.createMap()
+                        reactApplicationContext
+                            .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                            .emit("PcmPlaybackFinished", params)
+                    } catch (e: Exception) {
+                        Log.w(TAG, "PlaybackFinished emit failed: ${e.message}")
+                    }
                 }
             }, "PcmStreamWriter").apply { start() }
 
@@ -309,6 +336,9 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
         promise.resolve(true)
     }
 
+    @ReactMethod fun addListener(eventName: String) {}
+    @ReactMethod fun removeListeners(count: Int) {}
+
     private fun stopInternal() {
         writerShouldStop = true
         endRequested = true

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.0.7.8",
+  "version": "0.0.8.8",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/screens/ChatScreen.tsx

@@ -19,6 +19,7 @@ import {
   ScrollView,
   Modal,
   ToastAndroid,
+  AppState,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
@@ -27,6 +28,10 @@ import audioService from '../services/audio';
 import wakeWordService from '../services/wakeword';
 import phoneCallService from '../services/phoneCall';
 import { playWakeReadySound } from '../services/wakeReadySound';
+import {
+  acquireBackgroundAudio,
+  releaseBackgroundAudio,
+} from '../services/backgroundAudio';
 import updateService from '../services/updater';
 import VoiceButton from '../components/VoiceButton';
 import FileUpload, { FileData } from '../components/FileUpload';
@@ -75,6 +80,45 @@ const capMessages = (msgs: ChatMessage[]): ChatMessage[] =>
 const DEFAULT_ATTACHMENT_DIR = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
 const STORAGE_PATH_KEY = 'aria_attachment_storage_path';
 
+/** Image-Vorschau in der Chat-Bubble. Misst die echte Bild-Dimension via
+ *  Image.getSize + setzt aspectRatio dynamisch — dadurch passt sich die
+ *  Bubble ans Bild an (kein "Strich" mehr bei breiten oder hohen Bildern). */
+const CHAT_IMAGE_STYLE = {
+  width: 260,
+  borderRadius: 8,
+  marginBottom: 6,
+  backgroundColor: '#0D0D1A',
+} as const;
+const ChatImage: React.FC<{
+  uri: string;
+  onPress: () => void;
+  onError: () => void;
+}> = ({ uri, onPress, onError }) => {
+  const [aspectRatio, setAspectRatio] = useState<number>(4 / 3);
+  useEffect(() => {
+    let cancelled = false;
+    Image.getSize(uri, (w, h) => {
+      if (!cancelled && w > 0 && h > 0) {
+        // Aspect-Ratio capen damit sehr lange Panorama-Bilder oder hohe
+        // Screenshot-Streifen die Bubble nicht sprengen
+        const r = Math.max(0.5, Math.min(2.5, w / h));
+        setAspectRatio(r);
+      }
+    }, () => {});
+    return () => { cancelled = true; };
+  }, [uri]);
+  return (
+    <TouchableOpacity onPress={onPress} activeOpacity={0.8}>
+      <Image
+        source={{ uri }}
+        style={[CHAT_IMAGE_STYLE, { aspectRatio }]}
+        resizeMode="cover"
+        onError={onError}
+      />
+    </TouchableOpacity>
+  );
+};
+
 async function getAttachmentDir(): Promise<string> {
   try {
     const saved = await AsyncStorage.getItem(STORAGE_PATH_KEY);
@@ -142,20 +186,24 @@ const ChatScreen: React.FC = () => {
     return `msg_${Date.now()}_${messageIdCounter.current}`;
   };
 
-  // TTS-Settings beim Mount + bei Screen-Fokus neu laden (damit Settings-Toggle sofort greift)
+  // TTS- + GPS-Settings beim Mount + alle 2s neu laden (damit Settings-Toggle
+  // sofort greift, ohne Context- oder Event-System)
   useEffect(() => {
-    const loadTtsSettings = async () => {
+    const loadSettings = async () => {
       const enabled = await AsyncStorage.getItem('aria_tts_enabled');
       setTtsDeviceEnabled(enabled !== 'false'); // default true
       const muted = await AsyncStorage.getItem('aria_tts_muted');
-      setTtsMuted(muted === 'true'); // default false
+      const isMuted = muted === 'true';
+      setTtsMuted(isMuted); // default false
+      audioService.setMuted(isMuted);  // service-internen Flag synchronisieren
       const voice = await AsyncStorage.getItem('aria_xtts_voice');
       localXttsVoiceRef.current = voice || '';
       ttsSpeedRef.current = await loadTtsSpeed();
+      const gps = await AsyncStorage.getItem('aria_gps_enabled');
+      setGpsEnabled(gps === 'true');
     };
-    loadTtsSettings();
+    loadSettings();
-    // Poll alle 2s um Settings-Aenderung mitzubekommen (einfache Loesung ohne Context)
+    const interval = setInterval(loadSettings, 2000);
-    const interval = setInterval(loadTtsSettings, 2000);
     return () => clearInterval(interval);
   }, []);
 
@@ -171,6 +219,11 @@ const ChatScreen: React.FC = () => {
       // 'armed' oder 'off' fallen, darf Spotify wieder.
       if (s === 'conversing') audioService.acquireConversationFocus();
       else audioService.releaseConversationFocus();
+      // Foreground-Service-Slot 'wake' — solange das Ohr ueberhaupt aktiv ist
+      // (armed oder conversing), soll der App-Prozess im Hintergrund am Leben
+      // bleiben damit Mikro-Lauschen + Aufnahme weiterlaufen.
+      if (s !== 'off') acquireBackgroundAudio('wake').catch(() => {});
+      else releaseBackgroundAudio('wake').catch(() => {});
     });
     return () => unsub();
   }, []);
@@ -182,6 +235,31 @@ const ChatScreen: React.FC = () => {
     return () => { phoneCallService.stop().catch(() => {}); };
   }, []);
 
+  // App-Resume: kurzer Wake-Word-Cooldown — beim Wechsel Background→Foreground
+  // gibt's haeufig Audio-Pegel-Spikes (AudioFocus-Switch, AudioTrack re-route)
+  // die openWakeWord sonst faelschlich als Wake-Word interpretiert.
+  useEffect(() => {
+    let lastState: string = AppState.currentState;
+    const sub = AppState.addEventListener('change', (next) => {
+      if (lastState !== 'active' && next === 'active') {
+        wakeWordService.setResumeCooldown(1500);
+      }
+      lastState = next;
+    });
+    return () => sub.remove();
+  }, []);
+
+  // Recording-State an Background-Service-Slot 'rec' koppeln — damit das Mikro
+  // auch im Hintergrund weiter aufnehmen darf (Android killt den App-Prozess
+  // sonst und die Aufnahme bricht ab).
+  useEffect(() => {
+    const unsub = audioService.onStateChange((s) => {
+      if (s === 'recording') acquireBackgroundAudio('rec').catch(() => {});
+      else releaseBackgroundAudio('rec').catch(() => {});
+    });
+    return () => unsub();
+  }, []);
+
   // ttsCanPlayRef live aktuell halten — Closure in onMessage unten liest
   // darueber statt direkt ttsDeviceEnabled/ttsMuted (sonst stale).
   useEffect(() => {
@@ -192,11 +270,15 @@ const ChatScreen: React.FC = () => {
     setTtsMuted(prev => {
       const next = !prev;
       AsyncStorage.setItem('aria_tts_muted', String(next));
-      // Bei Muten sofort laufende Wiedergabe stoppen
+      // Ref synchron updaten — sonst kommen noch Chunks im selben Tick
-      if (next) audioService.stopPlayback();
+      // mit canPlay=true durch (Race vor dem useEffect-Update).
+      ttsCanPlayRef.current = ttsDeviceEnabled && !next;
+      // Globalen Mute-Flag im audioService setzen — uebersteuert auch
+      // payload.silent in handlePcmChunk und stoppt laufende Wiedergabe.
+      audioService.setMuted(next);
       return next;
     });
-  }, []);
+  }, [ttsDeviceEnabled]);
 
   // Chat-Verlauf aus AsyncStorage laden
   const isInitialLoad = useRef(true);
@@ -413,6 +495,8 @@ const ChatScreen: React.FC = () => {
         const activity = (message.payload.activity as string) || 'idle';
         const tool = (message.payload.tool as string) || '';
         setAgentActivity({ activity, tool });
+        // Spotify darf waehrend "ARIA denkt/schreibt" weiterspielen — pausiert
+        // nur wenn TTS startet (dann acquired _firePlaybackStarted den Focus).
       }
 
       // Voice-Config aus Diagnostic — setzt die lokale App-Stimme auf den
@@ -535,7 +619,7 @@ const ChatScreen: React.FC = () => {
           audioRequestId,
           ...(location && { location }),
         });
-        scheduleStaleAudioCleanup(audioRequestId);
+        scheduleStaleAudioCleanup(audioRequestId, result.durationMs);
         // resume() wird durch onPlaybackFinished nach ARIAs Antwort getriggert.
       } else {
         // Kein Speech im Window → Konversation beenden (Ohr geht aus oder
@@ -566,12 +650,16 @@ const ChatScreen: React.FC = () => {
 
     // TTS-Lifecycle: solange ARIA spricht und Wake-Word verfuegbar ist,
     // parallel mitlauschen — User kann "Computer" sagen statt manuell tappen.
+    // PLUS: Foreground-Service-Slot 'tts' belegen damit Android den App-
+    // Prozess nicht killt wenn die App im Hintergrund ist.
     const unsubTtsStart = audioService.onPlaybackStarted(() => {
+      acquireBackgroundAudio('tts').catch(() => {});
       if (wakeWordService.isConversing() && wakeWordService.hasWakeWord()) {
         wakeWordService.startBargeListening().catch(() => {});
       }
     });
     const unsubTtsEnd = audioService.onPlaybackFinished(() => {
+      releaseBackgroundAudio('tts').catch(() => {});
       // Vor naechster Aufnahme: barge-listening aus damit der AudioRecorder
       // das Mikro greifen kann.
       wakeWordService.stopBargeListening().catch(() => {});
@@ -658,10 +746,13 @@ const ChatScreen: React.FC = () => {
   // --- Nachricht senden ---
 
   // Aufraeumen von "verarbeitet"-Placeholder die nie ein STT-Result bekommen
-  // haben (leere Aufnahme, Wake-Word-Echo, STT-Fehler etc). Nach 30s werden
+  // haben (leere Aufnahme, Wake-Word-Echo, STT-Fehler etc). Timeout skaliert
-  // sie automatisch entfernt damit nicht-erkannte Aufnahmen nicht den State
+  // mit der Aufnahmedauer — Whisper braucht auf der Gamebox grob real-time/5,
-  // verstopfen + naechste echte Aufnahmen die richtige Bubble ersetzen koennen.
+  // plus Bridge-Roundtrip + Network. Formel: 60s Buffer + 1x Aufnahmedauer.
-  const scheduleStaleAudioCleanup = useCallback((audioRequestId: string) => {
+  // Bei 5min Aufnahme = 6 min Wait, bei 5s Aufnahme = 65s. Sicher genug damit
+  // langsame STTs nicht versehentlich aufgeraeumt werden.
+  const scheduleStaleAudioCleanup = useCallback((audioRequestId: string, recordingMs: number) => {
+    const timeoutMs = 60000 + recordingMs;
     setTimeout(() => {
       setMessages(prev => {
         const idx = prev.findIndex(m =>
@@ -669,11 +760,12 @@ const ChatScreen: React.FC = () => {
           m.text.includes('Spracheingabe wird verarbeitet')
         );
         if (idx < 0) return prev;
-        console.log('[Chat] Sprachnachricht ohne STT-Result entfernt: %s', audioRequestId);
+        console.log('[Chat] Sprachnachricht ohne STT-Result nach %dms entfernt: %s',
+                    timeoutMs, audioRequestId);
         ToastAndroid.show('Sprachnachricht nicht erkannt — entfernt', ToastAndroid.SHORT);
         return prev.filter((_, i) => i !== idx);
       });
-    }, 30000);
+    }, timeoutMs);
   }, []);
 
   const sendTextMessage = useCallback(async () => {
@@ -763,7 +855,18 @@ const ChatScreen: React.FC = () => {
       audioRequestId,
       ...(location && { location }),
     });
-    scheduleStaleAudioCleanup(audioRequestId);
+    scheduleStaleAudioCleanup(audioRequestId, result.durationMs);
+
+    // Manueller Mikro-Stop waehrend Wake-Word-Konversation: User hat explizit
+    // den Knopf gedrueckt → er moechte nicht in den automatischen Multi-Turn-
+    // Modus, sondern nach ARIAs Antwort zurueck zu passivem Wake-Word-Lauschen.
+    // Bei VAD-Auto-Stop (Wake-Word-Pfad) laeuft das ueber den silence-callback
+    // und endet mit resume() — der manuelle Stop hier ist der "ich bin fertig"-
+    // Knopf.
+    if (wakeWordService.isConversing()) {
+      console.log('[Chat] Manueller Stop in Konversation → endConversation, zurueck zu armed');
+      await wakeWordService.endConversation();
+    }
   }, [getCurrentLocation, interruptAriaIfBusy, scheduleStaleAudioCleanup]);
 
   // Datei auswaehlen → zur Pending-Liste hinzufuegen
@@ -869,11 +972,9 @@ const ChatScreen: React.FC = () => {
         {item.attachments?.map((att, idx) => (
           <View key={idx}>
             {att.type === 'image' && att.uri ? (
-              <TouchableOpacity onPress={() => setFullscreenImage(att.uri || null)} activeOpacity={0.8}>
+              <ChatImage
-              <Image
+                uri={att.uri}
-                source={{ uri: att.uri }}
+                onPress={() => setFullscreenImage(att.uri || null)}
-                style={styles.attachmentImage}
-                resizeMode="cover"
                 onError={() => {
                   setMessages(prev => prev.map(m =>
                     m.id === item.id ? { ...m, attachments: m.attachments?.map((a, i) =>
@@ -882,7 +983,6 @@ const ChatScreen: React.FC = () => {
                   ));
                 }}
               />
-              </TouchableOpacity>
             ) : att.type === 'image' && !att.uri ? (
               <TouchableOpacity
                 style={styles.attachmentFile}
@@ -1285,9 +1385,11 @@ const styles = StyleSheet.create({
     color: '#E0E0F0',
   },
   attachmentImage: {
-    width: '100%',
+    // Feste Breite + dynamische aspectRatio (in ChatImage gesetzt) damit die
-    minHeight: 200,
+    // Bubble sich ans Bild anpasst. Mit width: '100%' ohne explizite Parent-
-    maxHeight: 400,
+    // Breite wuerde RN das Bild auf 0px schrumpfen → "Strich".
+    width: 260,
+    aspectRatio: 4 / 3,
     borderRadius: 8,
     marginBottom: 6,
     backgroundColor: '#0D0D1A',

android/src/screens/SettingsScreen.tsx

@@ -17,6 +17,7 @@ import {
   Platform,
   ToastAndroid,
   ActivityIndicator,
+  Modal,
 } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import RNFS from 'react-native-fs';
@@ -39,6 +40,10 @@ import {
   MAX_RECORDING_MIN_SEC,
   MAX_RECORDING_MAX_SEC,
   MAX_RECORDING_STORAGE_KEY,
+  VAD_SILENCE_DB_DEFAULT,
+  VAD_SILENCE_DB_MIN,
+  VAD_SILENCE_DB_MAX,
+  VAD_SILENCE_DB_OVERRIDE_KEY,
   TTS_SPEED_DEFAULT,
   TTS_SPEED_MIN,
   TTS_SPEED_MAX,
@@ -58,6 +63,7 @@ import wakeWordService, {
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
 import VoiceCloneModal from '../components/VoiceCloneModal';
+import updateService from '../services/updater';
 
 const STORAGE_PATH_KEY = 'aria_attachment_storage_path';
 const DEFAULT_STORAGE_PATH = `${RNFS.DocumentDirectoryPath}/chat_attachments`;
@@ -124,6 +130,10 @@ const SettingsScreen: React.FC = () => {
   const [vadSilenceSec, setVadSilenceSec] = useState<number>(VAD_SILENCE_DEFAULT_SEC);
   const [convWindowSec, setConvWindowSec] = useState<number>(CONV_WINDOW_DEFAULT_SEC);
   const [maxRecordingSec, setMaxRecordingSec] = useState<number>(MAX_RECORDING_DEFAULT_SEC);
+  // null = automatisch (adaptive Baseline), sonst manueller dB-Override
+  const [vadSilenceDb, setVadSilenceDb] = useState<number | null>(null);
+  const [showVadInfo, setShowVadInfo] = useState(false);
+  const [apkCacheInfo, setApkCacheInfo] = useState<{count: number, totalMB: number} | null>(null);
   const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
   const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
   const [wakeStatus, setWakeStatus] = useState<string>('');
@@ -159,6 +169,9 @@ const SettingsScreen: React.FC = () => {
     AsyncStorage.getItem('aria_tts_enabled').then(saved => {
       if (saved !== null) setTtsEnabled(saved === 'true');
     });
+    AsyncStorage.getItem('aria_gps_enabled').then(saved => {
+      if (saved !== null) setGpsEnabled(saved === 'true');
+    });
     AsyncStorage.getItem(TTS_PREROLL_STORAGE_KEY).then(saved => {
       if (saved != null) {
         const n = parseFloat(saved);
@@ -191,6 +204,14 @@ const SettingsScreen: React.FC = () => {
         }
       }
     });
+    AsyncStorage.getItem(VAD_SILENCE_DB_OVERRIDE_KEY).then(saved => {
+      if (saved != null && saved !== '') {
+        const n = parseFloat(saved);
+        if (isFinite(n) && n >= VAD_SILENCE_DB_MIN && n <= VAD_SILENCE_DB_MAX) {
+          setVadSilenceDb(n);
+        }
+      }
+    });
     AsyncStorage.getItem(TTS_SPEED_STORAGE_KEY).then(saved => {
       if (saved != null) {
         const n = parseFloat(saved);
@@ -201,6 +222,7 @@ const SettingsScreen: React.FC = () => {
       if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
     });
     isWakeReadySoundEnabled().then(setWakeReadySound);
+    updateService.getApkCacheSize().then(setApkCacheInfo).catch(() => {});
     AsyncStorage.getItem('aria_xtts_voice').then(saved => {
       if (saved) setXttsVoice(saved);
     });
@@ -437,7 +459,7 @@ const SettingsScreen: React.FC = () => {
 
   const handleGPSToggle = useCallback((value: boolean) => {
     setGpsEnabled(value);
-    // In Produktion: Wert in AsyncStorage persistieren
+    AsyncStorage.setItem('aria_gps_enabled', String(value)).catch(() => {});
   }, []);
 
   // --- XTTS Voice ---
@@ -661,7 +683,11 @@ const SettingsScreen: React.FC = () => {
           <View style={styles.toggleInfo}>
             <Text style={styles.toggleLabel}>GPS-Position mitsenden</Text>
             <Text style={styles.toggleHint}>
-              Standort wird automatisch an Nachrichten angehaengt
+              Position (lat/lon) wird mit jeder Nachricht an ARIA mitgeschickt.
+              Sie sieht's nur intern und nutzt es bei standortbezogenen Fragen
+              ("wo bin ich?", "Wetter hier?"), erwaehnt es sonst nicht.
+              Im Chat-Verlauf bleibt die Bubble unveraendert — nur ARIAs
+              Antwort kann darauf eingehen.
             </Text>
           </View>
           <Switch
@@ -775,8 +801,94 @@ const SettingsScreen: React.FC = () => {
             <Text style={styles.prerollButtonText}>+1m</Text>
           </TouchableOpacity>
         </View>
+
+        <View style={{flexDirection: 'row', alignItems: 'center', marginTop: 24, gap: 8}}>
+          <Text style={styles.toggleLabel}>Stille-Pegel (dB)</Text>
+          <TouchableOpacity onPress={() => setShowVadInfo(true)} style={styles.infoBtn}>
+            <Text style={styles.infoBtnText}>i</Text>
+          </TouchableOpacity>
+        </View>
+        <Text style={styles.toggleHint}>
+          Welcher Mikro-Pegel als "Stille" gilt. Standard: automatisch (Baseline aus
+          den ersten 500ms). Manuell setzen wenn Auto nicht zuverlaessig greift.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = vadSilenceDb == null
+                ? VAD_SILENCE_DB_DEFAULT - 1
+                : Math.max(VAD_SILENCE_DB_MIN, vadSilenceDb - 1);
+              setVadSilenceDb(next);
+              AsyncStorage.setItem(VAD_SILENCE_DB_OVERRIDE_KEY, String(next));
+            }}
+          >
+            <Text style={styles.prerollButtonText}>−1</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>
+            {vadSilenceDb == null ? 'auto' : `${vadSilenceDb} dB`}
+          </Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = vadSilenceDb == null
+                ? VAD_SILENCE_DB_DEFAULT + 1
+                : Math.min(VAD_SILENCE_DB_MAX, vadSilenceDb + 1);
+              setVadSilenceDb(next);
+              AsyncStorage.setItem(VAD_SILENCE_DB_OVERRIDE_KEY, String(next));
+            }}
+          >
+            <Text style={styles.prerollButtonText}>+1</Text>
+          </TouchableOpacity>
+        </View>
+        {vadSilenceDb != null && (
+          <TouchableOpacity
+            onPress={() => {
+              setVadSilenceDb(null);
+              AsyncStorage.removeItem(VAD_SILENCE_DB_OVERRIDE_KEY);
+            }}
+            style={{alignSelf: 'center', marginTop: 8, paddingVertical: 6, paddingHorizontal: 12}}
+          >
+            <Text style={{color: '#0096FF', fontSize: 13}}>↻ Auf automatisch zuruecksetzen</Text>
+          </TouchableOpacity>
+        )}
       </View>
 
+      <Modal
+        visible={showVadInfo}
+        transparent
+        animationType="fade"
+        onRequestClose={() => setShowVadInfo(false)}
+      >
+        <View style={styles.modalOverlay}>
+          <View style={styles.modalCard}>
+            <Text style={styles.modalTitle}>Stille-Pegel (dB)</Text>
+            <Text style={styles.modalText}>
+              Lautstaerken werden in Dezibel (dB) gemessen — negative Werte, je
+              hoeher (naeher an 0), desto lauter.{'\n\n'}
+              <Text style={{fontWeight: '700'}}>Standard:</Text> automatisch.
+              Die App misst die ersten 500ms Hintergrundpegel und setzt die
+              Stille-Schwelle auf Baseline + 6 dB. Funktioniert in den meisten
+              Umgebungen.{'\n\n'}
+              <Text style={{fontWeight: '700'}}>Manuell:</Text> Pegel unter dem
+              eingestellten Wert gilt als "Stille" → Aufnahme stoppt.{'\n\n'}
+              <Text style={{fontWeight: '700'}}>Faustregel:</Text>{'\n'}
+              • <Text style={{color: '#FFD60A'}}>−45 dB</Text> sehr empfindlich (stoppt schnell, auch bei Atmen){'\n'}
+              • <Text style={{color: '#34C759'}}>−38 dB</Text> ausgewogen (typische Bueroumgebung){'\n'}
+              • <Text style={{color: '#FF6B6B'}}>−25 dB</Text> unempfindlich (laute Umgebung, nur klare Sprache zaehlt){'\n\n'}
+              <Text style={{color: '#8888AA'}}>Niedrigere Zahl (z.B. −50) = sensibler.{'\n'}
+              Hoehere Zahl (z.B. −20) = robuster gegen Hintergrundlaerm,
+              braucht aber lautere Sprache.</Text>
+            </Text>
+            <TouchableOpacity
+              style={[styles.connectButton, {marginTop: 16, alignSelf: 'stretch'}]}
+              onPress={() => setShowVadInfo(false)}
+            >
+              <Text style={styles.connectButtonText}>OK</Text>
+            </TouchableOpacity>
+          </View>
+        </View>
+      </Modal>
       </>)}
 
       {/* === Wake-Word (komplett on-device, openWakeWord) === */}
@@ -1085,6 +1197,37 @@ const SettingsScreen: React.FC = () => {
         )}
       </View>
 
+      {/* === Update-Cache === */}
+      <Text style={[styles.sectionTitle, {marginTop: 16}]}>Update-Cache</Text>
+      <View style={styles.card}>
+        <Text style={styles.toggleHint}>
+          Heruntergeladene APK-Dateien fuer App-Updates. Werden automatisch
+          beim App-Start und vor jedem neuen Download geloescht — der Button
+          ist fuer den Notfall (z.B. wenn ein Download haengen geblieben ist).
+        </Text>
+        <Text style={[styles.storageSizeText, {marginTop: 8}]}>
+          {apkCacheInfo === null ? '...' :
+           apkCacheInfo.count === 0 ? 'leer' :
+           `${apkCacheInfo.count} APK${apkCacheInfo.count === 1 ? '' : 's'} · ${apkCacheInfo.totalMB.toFixed(1)}MB`}
+        </Text>
+        <TouchableOpacity
+          style={[styles.clearButton, {marginTop: 8, backgroundColor: 'rgba(255,59,48,0.15)'}]}
+          onPress={async () => {
+            const res = await updateService.cleanupOldApks();
+            ToastAndroid.show(
+              res.removed === 0
+                ? 'Update-Cache war schon leer'
+                : `${res.removed} APK${res.removed === 1 ? '' : 's'} geloescht (${res.freedMB.toFixed(1)}MB frei)`,
+              ToastAndroid.SHORT,
+            );
+            const info = await updateService.getApkCacheSize();
+            setApkCacheInfo(info);
+          }}
+        >
+          <Text style={[styles.clearButtonText, {color: '#FF3B30'}]}>Update-Cache leeren</Text>
+        </TouchableOpacity>
+      </View>
+
       </>)}
 
       {/* === Logs === */}
@@ -1628,6 +1771,48 @@ const styles = StyleSheet.create({
     textAlign: 'center',
   },
 
+  infoBtn: {
+    width: 22,
+    height: 22,
+    borderRadius: 11,
+    borderWidth: 1.5,
+    borderColor: '#0096FF',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  infoBtnText: {
+    color: '#0096FF',
+    fontSize: 13,
+    fontWeight: '700',
+    fontStyle: 'italic',
+    lineHeight: 16,
+  },
+  modalOverlay: {
+    flex: 1,
+    backgroundColor: 'rgba(0,0,0,0.7)',
+    justifyContent: 'center',
+    alignItems: 'center',
+    padding: 20,
+  },
+  modalCard: {
+    backgroundColor: '#1E1E2E',
+    borderRadius: 14,
+    padding: 20,
+    maxWidth: 460,
+    width: '100%',
+  },
+  modalTitle: {
+    color: '#FFFFFF',
+    fontSize: 18,
+    fontWeight: '700',
+    marginBottom: 12,
+  },
+  modalText: {
+    color: '#E0E0F0',
+    fontSize: 14,
+    lineHeight: 20,
+  },
+
   keywordChip: {
     backgroundColor: '#1E1E2E',
     borderWidth: 1,

android/src/services/audio.ts

@@ -6,10 +6,11 @@
  * Nutzt react-native-audio-recorder-player fuer Aufnahme.
  */
 
-import { Platform, PermissionsAndroid, NativeModules, ToastAndroid } from 'react-native';
+import { Platform, PermissionsAndroid, NativeModules, ToastAndroid, NativeEventEmitter } from 'react-native';
 import Sound from 'react-native-sound';
 import RNFS from 'react-native-fs';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { acquireBackgroundAudio, releaseBackgroundAudio, stopBackgroundAudio } from './backgroundAudio';
 import AudioRecorderPlayer, {
   AudioEncoderAndroidType,
   AudioSourceAndroidType,
@@ -84,6 +85,29 @@ const VAD_SPEECH_OFFSET_DB = 12;       // sicheres Speech = Baseline + 12dB
 const VAD_BASELINE_SAMPLES = 5;        // 5 × 100ms = 500ms Baseline
 const VAD_SPEECH_MIN_MS = 500;         // ms Sprache bevor Aufnahme zaehlt — laenger = keine Huestler/Klopfer mehr
 
+// Override fuer die Stille-Schwelle — wenn gesetzt, wird die adaptive Baseline
+// ignoriert. Nuetzlich wenn die adaptive Logik in spezifischen Umgebungen
+// nicht zuverlaessig greift. Range -55..-15 dB. Speech-Schwelle wird auf
+// override+10 dB gesetzt (Speech muss klar lauter als Stille sein).
+export const VAD_SILENCE_DB_DEFAULT = -38;  // wenn User Manuell-Modus waehlt
+export const VAD_SILENCE_DB_MIN = -85;      // extrem empfindlich, praktisch alles gilt als Sprache
+export const VAD_SILENCE_DB_MAX = -15;      // sehr unempfindlich, nur lautes Reden gilt
+export const VAD_SILENCE_DB_OVERRIDE_KEY = 'aria_vad_silence_db_override';
+
+/** Liefert den manuellen Override-Wert oder null wenn "automatisch". */
+export async function loadVadSilenceDbOverride(): Promise<number | null> {
+  try {
+    const raw = await AsyncStorage.getItem(VAD_SILENCE_DB_OVERRIDE_KEY);
+    if (raw == null || raw === '') return null;
+    const n = parseFloat(raw);
+    if (!isFinite(n)) return null;
+    if (n < VAD_SILENCE_DB_MIN || n > VAD_SILENCE_DB_MAX) return null;
+    return n;
+  } catch {
+    return null;
+  }
+}
+
 // VAD-Stille (in Sekunden) — wie lange Sprechpause toleriert wird, bevor
 // die Aufnahme automatisch beendet wird. Einstellbar in den App-Settings.
 export const VAD_SILENCE_DEFAULT_SEC = 2.8;
@@ -245,9 +269,38 @@ class AudioService {
   private vadAdaptiveSilenceDb: number = VAD_SILENCE_FALLBACK_DB;
   private vadAdaptiveSpeechDb: number = VAD_SPEECH_FALLBACK_DB;
 
+  // Interruption-Tracking fuer Auto-Resume nach Anruf:
+  // - playbackStartTime: ms-Timestamp wenn AudioTrack tatsaechlich anfing
+  //   abzuspielen (= _firePlaybackStarted)
+  // - currentPlaybackMsgId: welche Antwort lief gerade
+  // - pausedPosition / pausedMessageId: bei captureInterruption gemerkt
+  private playbackStartTime: number = 0;
+  private currentPlaybackMsgId: string = '';
+  private pausedPosition: number = 0;       // Sekunden in der Audio-Datei
+  private pausedMessageId: string = '';
+  private resumeSound: Sound | null = null;  // halten damit GC nicht zuschlaegt
+  // Leading-Silence wird im Native vor den Chunks geschrieben — beim
+  // Position-Berechnen vom playbackStarted abziehen
+  private readonly LEADING_SILENCE_SEC = 0.3;
+
   constructor() {
     this.recorder = new AudioRecorderPlayer();
     this.recorder.setSubscriptionDuration(0.1); // 100ms Metering-Updates
+    // Native Event: AudioTrack hat alle Samples wirklich durchgespielt (nach
+    // dem finally{}-Block im Writer-Thread). ERST jetzt darf AudioFocus
+    // freigegeben werden — sonst spielt Spotify schon waehrend ARIA noch
+    // redet (PcmStreamPlayer.end() returnt mit 15s-Cap viel zu frueh).
+    if (PcmStreamPlayer) {
+      try {
+        const emitter = new NativeEventEmitter(NativeModules.PcmStreamPlayer as any);
+        emitter.addListener('PcmPlaybackFinished', () => {
+          console.log('[Audio] PcmPlaybackFinished — Focus jetzt freigeben');
+          this._releaseFocusDeferred();
+        });
+      } catch (err) {
+        console.warn('[Audio] PcmPlaybackFinished-Subscription fehlgeschlagen:', err);
+      }
+    }
   }
 
   /** AudioFocus mit kleiner Verzoegerung freigeben — Spotify/YouTube
@@ -302,6 +355,84 @@ class AudioService {
     this.stopPlayback();
   }
 
+  /** Bei Anruf: aktuelle Wiedergabe-Position merken damit wir nach dem
+   *  Auflegen von dort weitermachen koennen. Returnt Position in Sekunden
+   *  oder 0 wenn nichts spielte. */
+  captureInterruption(): number {
+    if (!this.playbackStartTime || !this.currentPlaybackMsgId) {
+      this.pausedPosition = 0;
+      this.pausedMessageId = '';
+      return 0;
+    }
+    const elapsedMs = Date.now() - this.playbackStartTime;
+    const positionSec = Math.max(0, elapsedMs / 1000 - this.LEADING_SILENCE_SEC);
+    this.pausedPosition = positionSec;
+    this.pausedMessageId = this.currentPlaybackMsgId;
+    console.log('[Audio] captureInterruption: msgId=%s pos=%ss',
+                this.pausedMessageId, positionSec.toFixed(2));
+    return positionSec;
+  }
+
+  /** Nach Anruf-Ende: ab gemerkter Position weiterspielen. Wenn Cache noch
+   *  nicht geschrieben (final kam waehrend Anruf vielleicht doch nicht),
+   *  warten bis maxWaitMs und dann probieren. Returnt true wenn gestartet. */
+  async resumeFromInterruption(maxWaitMs: number = 30000): Promise<boolean> {
+    const msgId = this.pausedMessageId;
+    const position = this.pausedPosition;
+    if (!msgId) return false;
+    this.pausedMessageId = '';  // konsumieren
+    const cachePath = `${RNFS.DocumentDirectoryPath}/tts_cache/${msgId}.wav`;
+    const startTime = Date.now();
+    while (Date.now() - startTime < maxWaitMs) {
+      try {
+        if (await RNFS.exists(cachePath)) {
+          return await this._playFromPathAtPosition(cachePath, position);
+        }
+      } catch {}
+      await new Promise(r => setTimeout(r, 500));
+    }
+    console.warn('[Audio] resumeFromInterruption: WAV %s nicht binnen %dms verfuegbar',
+                  msgId, maxWaitMs);
+    return false;
+  }
+
+  private async _playFromPathAtPosition(path: string, positionSec: number): Promise<boolean> {
+    try {
+      // Bestehende laufende Wiedergabe abbrechen damit wir sauber starten
+      if (this.resumeSound) {
+        try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
+        this.resumeSound = null;
+      }
+      const sound = await new Promise<Sound>((resolve, reject) => {
+        const s = new Sound(path.replace(/^file:\/\//, ''), '', (err) =>
+          err ? reject(err) : resolve(s));
+      });
+      // Audio-Focus anfordern damit Spotify pausiert
+      this._cancelDeferredFocusRelease();
+      AudioFocus?.requestDuck().catch(() => {});
+      this._firePlaybackStarted();
+      this.isPlaying = true;
+      this.resumeSound = sound;
+      console.log('[Audio] Resume von Position %ss aus %s',
+                  positionSec.toFixed(2), path);
+      sound.setCurrentTime(Math.max(0, positionSec));
+      sound.play((success) => {
+        if (!success) console.warn('[Audio] Resume-Wiedergabe fehlgeschlagen');
+        try { sound.release(); } catch {}
+        if (this.resumeSound === sound) this.resumeSound = null;
+        this.isPlaying = false;
+        this.playbackFinishedListeners.forEach(cb => {
+          try { cb(); } catch (e) { console.warn('[Audio] cb err:', e); }
+        });
+        this._releaseFocusDeferred();
+      });
+      return true;
+    } catch (err: any) {
+      console.warn('[Audio] _playFromPathAtPosition fehlgeschlagen:', err?.message || err);
+      return false;
+    }
+  }
+
   /** True wenn ARIA gerade was abspielt — egal ob WAV-Queue oder PCM-Stream.
    *  Nuetzlich fuer "Barge-In": wenn der User spricht waehrend ARIA spricht,
    *  soll die ARIA-Wiedergabe abgebrochen + die neue User-Message verarbeitet
@@ -367,6 +498,12 @@ class AudioService {
 
       this.recordingPath = `${RNFS.CachesDirectoryPath}/aria_recording_${Date.now()}.mp4`;
 
+      // Foreground-Service VOR dem AudioRecord starten — sonst blockt Android
+      // den Background-Mic-Zugriff (foregroundServiceType=microphone muss zum
+      // Zeitpunkt des startRecorder() schon aktiv sein, sonst greifen die
+      // Background-Mic-Restrictions ab Android 11+).
+      await acquireBackgroundAudio('rec');
+
       // Aufnahme mit Metering starten
       await this.recorder.startRecorder(this.recordingPath, {
         AudioEncoderAndroid: AudioEncoderAndroidType.AAC,
@@ -388,11 +525,22 @@ class AudioService {
           if (db > -100) {
             this.vadBaselineSamples.push(db);
             if (this.vadBaselineSamples.length === VAD_BASELINE_SAMPLES) {
-              const avg = this.vadBaselineSamples.reduce((a, b) => a + b, 0) / VAD_BASELINE_SAMPLES;
+              // Minimum statt Mittelwert: robust gegen Spike-Samples (z.B. wenn
-              this.vadAdaptiveSilenceDb = avg + VAD_SILENCE_OFFSET_DB;
+              // der User direkt nach Wake-Word sofort spricht oder das Wake-Word-
-              this.vadAdaptiveSpeechDb = avg + VAD_SPEECH_OFFSET_DB;
+              // Echo noch im Mikro ist). Min ist der ruhigste Moment.
-              const msg = `VAD: ambient=${avg.toFixed(0)}dB stille>${this.vadAdaptiveSilenceDb.toFixed(0)}dB`;
+              const lowest = Math.min(...this.vadBaselineSamples);
-              console.log('[Audio] %s speech>%s', msg, this.vadAdaptiveSpeechDb.toFixed(1));
+              const rawSilence = lowest + VAD_SILENCE_OFFSET_DB;
+              const rawSpeech = lowest + VAD_SPEECH_OFFSET_DB;
+              // Cap auf einen vernuenftigen Bereich:
+              // - Silence-Schwelle nicht ueber -28dB (sonst zaehlt Hintergrund-
+              //   geraeusch dauerhaft als "Sprache" → VAD feuert nie)
+              // - Silence-Schwelle nicht unter -50dB (sonst zu strikt)
+              this.vadAdaptiveSilenceDb = Math.max(-50, Math.min(rawSilence, -28));
+              this.vadAdaptiveSpeechDb = Math.max(-40, Math.min(rawSpeech, -18));
+              const msg = `VAD: ambient=${lowest.toFixed(0)}dB stille>${this.vadAdaptiveSilenceDb.toFixed(0)}dB`;
+              console.log('[Audio] %s speech>%s (raw silence=%s speech=%s)',
+                          msg, this.vadAdaptiveSpeechDb.toFixed(1),
+                          rawSilence.toFixed(1), rawSpeech.toFixed(1));
               try { ToastAndroid.show(msg, ToastAndroid.SHORT); } catch {}
             }
           }
@@ -425,11 +573,22 @@ class AudioService {
       this.speechDetected = false;
       this.speechStartTime = 0;
       // VAD-Adaptive zurueckgesetzt: Baseline wird in den ersten 500ms neu
-      // gemessen. Bis dahin gelten die Fallback-Schwellen — die sind etwas
+      // gemessen. Bis dahin gelten die Fallback-Schwellen.
-      // empfindlicher als die alten Werte (-38 statt -45 fuer Stille).
       this.vadBaselineSamples = [];
       this.vadAdaptiveSilenceDb = VAD_SILENCE_FALLBACK_DB;
       this.vadAdaptiveSpeechDb = VAD_SPEECH_FALLBACK_DB;
+
+      // Manueller Override aus Settings — wenn gesetzt, wird die adaptive
+      // Baseline-Messung uebersteuert. User-Wahl gewinnt vor Auto-Magic.
+      const dbOverride = await loadVadSilenceDbOverride();
+      if (dbOverride != null) {
+        this.vadAdaptiveSilenceDb = dbOverride;
+        this.vadAdaptiveSpeechDb = dbOverride + 10;  // Speech klar ueber Stille
+        this.vadBaselineSamples = new Array(VAD_BASELINE_SAMPLES).fill(0);  // Baseline-Sammeln deaktivieren
+        const msg = `VAD: manuell stille>${dbOverride}dB`;
+        console.log('[Audio] %s', msg);
+        try { ToastAndroid.show(msg, ToastAndroid.SHORT); } catch {}
+      }
       this.setState('recording');
 
       // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
@@ -558,7 +717,9 @@ class AudioService {
   /** Base64-kodiertes Audio in die Queue stellen und abspielen */
   async playAudio(base64Data: string): Promise<void> {
     if (!base64Data) return;
-
+    // Mute-Flag respektieren — robust gegen Race-Conditions zwischen User-
+    // Klick auf Mute und einem TTS-Chunk der im selben Tick eintrifft.
+    if (this._muted) return;
     this.audioQueue.push(base64Data);
     if (!this.isPlaying) {
       this._playNext();
@@ -625,7 +786,9 @@ class AudioService {
     final?: boolean;
     silent?: boolean;
   }): Promise<string> {
-    const silent = !!payload.silent;
+    // Globaler Mute-Flag uebersteuert das per-Call silent — verhindert
+    // Race-Conditions wenn der User zwischen Chunks den Mute-Knopf drueckt.
+    const silent = !!payload.silent || this._muted;
     if (!silent && !PcmStreamPlayer) {
       console.warn('[Audio] PcmStreamPlayer Native Module nicht verfuegbar');
       return '';
@@ -651,6 +814,21 @@ class AudioService {
         this.pcmBuffer = [];
         this.pcmBytesCollected = 0;
       }
+      // Resume-Sound stoppen falls noch aktiv (User hat nach Anruf eine
+      // neue Frage gestellt — die alte interruptierte Antwort ist obsolet).
+      if (this.resumeSound) {
+        try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
+        this.resumeSound = null;
+      }
+      // Pending Auto-Resume verwerfen wenn die neue Antwort eine andere
+      // messageId hat. Sonst spielt nach 30s-Wartezeit der Resume die
+      // ueberholte Antwort ab.
+      if (this.pausedMessageId && this.pausedMessageId !== messageId) {
+        console.log('[Audio] Neue TTS-Antwort (msgId=%s) — Auto-Resume fuer %s verworfen',
+                    messageId, this.pausedMessageId);
+        this.pausedMessageId = '';
+        this.pausedPosition = 0;
+      }
       this.pcmStreamActive = true;
       this.pcmMessageId = messageId;
       this.pcmSampleRate = sampleRate;
@@ -685,13 +863,16 @@ class AudioService {
 
     if (isFinal) {
       if (!silent) {
-        // end() resolved jetzt erst wenn der native Writer-Thread fertig
+        // end() signalisiert dem Writer "keine weiteren Chunks". Aber WIR
-        // ist (alle Samples ausgespielt) — danach AudioFocus verzoegert
+        // releasen den AudioFocus NICHT hier — der writer braucht u.U. noch
-        // freigeben, damit Spotify/YouTube nicht im Mikro-Gap zwischen zwei
+        // 30+ Sekunden bis der Buffer wirklich abgespielt ist. Den release
-        // ARIA-Antworten wieder hochdrehen. Wenn ein neuer Stream innerhalb
+        // triggert das native Event "PcmPlaybackFinished" wenn AudioTrack
-        // FOCUS_RELEASE_DELAY_MS startet, wird das Release abgebrochen.
+        // wirklich am Ende ist (siehe ensurePlaybackFinishedListener).
         try { await PcmStreamPlayer!.end(); } catch {}
-        this._releaseFocusDeferred();
+        // playbackFinished-Listener informieren (UI-Logik)
+        this.playbackFinishedListeners.forEach(cb => {
+          try { cb(); } catch (e) { console.warn('[Audio] playbackFinished cb err:', e); }
+        });
       }
       this.pcmStreamActive = false;
 
@@ -802,6 +983,9 @@ class AudioService {
   }
 
   private _firePlaybackStarted(): void {
+    // Tracking fuer Auto-Resume nach Anruf-Pause
+    this.playbackStartTime = Date.now();
+    this.currentPlaybackMsgId = this.pcmMessageId || '';
     this.playbackStartedListeners.forEach(cb => {
       try { cb(); } catch (e) { console.warn('[Audio] playbackStarted listener err:', e); }
     });
@@ -885,8 +1069,22 @@ class AudioService {
     }
   }
 
+  /** Mute: alle eingehenden TTS-Chunks/WAVs werden ignoriert bis wieder
+   *  unmuted. Robuster als ein React-Ref weil hier kein Re-Render-Race ist
+   *  — die Bridge kann einen Chunk im selben JS-Tick liefern in dem der
+   *  User Mute geklickt hat. */
+  private _muted: boolean = false;
+  setMuted(muted: boolean): void {
+    this._muted = muted;
+    if (muted) this.stopPlayback();
+  }
+  isMuted(): boolean { return this._muted; }
+
   /** Laufende Wiedergabe stoppen + Queue leeren */
   stopPlayback(): void {
+    // Foreground-Service auch stoppen — sonst bleibt die Notification haengen
+    // wenn Wiedergabe abgebrochen wird (Anruf, Cancel, Barge-In).
+    stopBackgroundAudio().catch(() => {});
     this.audioQueue = [];
     this.isPlaying = false;
     if (this.currentSound) {

android/src/services/backgroundAudio.ts

@@ -0,0 +1,76 @@
+/**
+ * Background-Audio: ARIAs TTS, Mic-Aufnahme und Wake-Word-Lauschen sollen
+ * auch bei minimierter App weiterlaufen. Wir starten dafuer einen Foreground-
+ * Service mit foregroundServiceType=mediaPlayback|microphone, der eine
+ * persistente Notification zeigt waehrend irgendein Audio-Slot aktiv ist.
+ *
+ * Mehrere Komponenten koennen den Service unabhaengig "halten":
+ *   - 'tts'  : ARIA spricht
+ *   - 'rec'  : Aufnahme laeuft
+ *   - 'wake' : Wake-Word lauscht passiv (Ohr aktiv)
+ *
+ * Solange mindestens ein Slot aktiv ist, laeuft der Service. Wenn alle
+ * Slots leer sind, wird er gestoppt. Der Notification-Text passt sich an
+ * den hoechstprioren Slot an (tts > rec > wake).
+ */
+
+import { NativeModules } from 'react-native';
+
+interface BackgroundAudioNative {
+  start(reason: string): Promise<boolean>;
+  stop(): Promise<boolean>;
+}
+
+const { BackgroundAudio } = NativeModules as { BackgroundAudio?: BackgroundAudioNative };
+
+type Slot = 'tts' | 'rec' | 'wake';
+
+const slots = new Set<Slot>();
+
+// Prioritaet fuer den Notification-Text — hoechste zuerst.
+const PRIORITY: Slot[] = ['tts', 'rec', 'wake'];
+
+function topReason(): string {
+  for (const s of PRIORITY) {
+    if (slots.has(s)) return s;
+  }
+  return '';
+}
+
+async function applyState(): Promise<void> {
+  if (!BackgroundAudio) return;
+  if (slots.size === 0) {
+    try { await BackgroundAudio.stop(); } catch {}
+    console.log('[BackgroundAudio] Service gestoppt (keine Slots)');
+    return;
+  }
+  const reason = topReason();
+  try {
+    await BackgroundAudio.start(reason);
+    console.log('[BackgroundAudio] Service aktiv (slot=%s, slots=%s)',
+                reason, [...slots].join('+'));
+  } catch (err: any) {
+    console.warn('[BackgroundAudio] start fehlgeschlagen:', err?.message || err);
+  }
+}
+
+export async function acquireBackgroundAudio(slot: Slot): Promise<void> {
+  if (slots.has(slot)) return;
+  slots.add(slot);
+  await applyState();
+}
+
+export async function releaseBackgroundAudio(slot: Slot): Promise<void> {
+  if (!slots.has(slot)) return;
+  slots.delete(slot);
+  await applyState();
+}
+
+export function backgroundAudioActive(): boolean {
+  return slots.size > 0;
+}
+
+// --- Legacy API (nur tts-Slot) — fuer Aufruf-Sites die noch nichts vom Slot-
+// system wissen. Mappt auf den 'tts'-Slot. ---
+export const startBackgroundAudio = () => acquireBackgroundAudio('tts');
+export const stopBackgroundAudio = () => releaseBackgroundAudio('tts');

android/src/services/phoneCall.ts

@@ -1,14 +1,19 @@
 /**
- * PhoneCall-Service — pausiert die TTS-Wiedergabe wenn das Telefon klingelt
+ * PhoneCall-Service — pausiert ARIA bei Telefonaten:
- * oder ein Anruf laeuft. Native-Bindung an PhoneCallModule.kt.
  *
- * Bei "ringing" oder "offhook" wird audioService.haltAllPlayback() gerufen —
+ * 1. Klassischer Mobilfunk-Anruf via TelephonyManager (PhoneCallModule.kt)
- * ARIA verstummt sofort. Nach dem Auflegen passiert nichts automatisch
+ *    Status: idle / ringing / offhook
- * (Audio kommt nicht zurueck), der User muesste die Antwort manuell
- * nochmal anfordern (Play-Button auf der Nachricht).
  *
- * Permission READ_PHONE_STATE muss vom Nutzer einmalig erteilt werden —
+ * 2. VoIP-Anrufe (WhatsApp, Signal, Discord, Telegram, Teams, ...) via
- * wenn nicht, failed start() leise und der Rest funktioniert wie bisher.
+ *    AudioFocus-Loss-Event (AudioFocusModule.kt). Diese Apps requestn
+ *    AUDIOFOCUS_GAIN_TRANSIENT_EXCLUSIVE wenn ein Anruf reinkommt — wir
+ *    bekommen ein "loss" Event und reagieren genauso wie auf RINGING.
+ *
+ * In beiden Faellen wird audioService.haltAllPlayback() + wakeWordService.
+ * pauseForCall() gerufen. Bei call-end (idle / focus-gain) → resumeFromCall.
+ *
+ * Permission READ_PHONE_STATE ist nur fuer Pfad 1 noetig — Pfad 2 braucht
+ * keine extra Berechtigung weil unser eigener AudioFocus-Listener feuert.
  */
 
 import {
@@ -19,6 +24,7 @@ import {
   ToastAndroid,
 } from 'react-native';
 import audioService from './audio';
+import wakeWordService from './wakeword';
 
 interface PhoneCallNative {
   start(): Promise<boolean>;
@@ -32,75 +38,173 @@ type PhoneState = 'idle' | 'ringing' | 'offhook';
 class PhoneCallService {
   private started: boolean = false;
   private subscription: { remove: () => void } | null = null;
+  private focusSubscription: { remove: () => void } | null = null;
   private lastState: PhoneState = 'idle';
+  /** Damit Resume nach VoIP-Loss nicht doppelt feuert wenn auch
+   *  TelephonyManager-IDLE-Event kommt. */
+  private interruptedByFocus: boolean = false;
 
   async start(): Promise<boolean> {
-    if (this.started || !PhoneCall) return false;
+    if (this.started || Platform.OS !== 'android') return false;
-    if (Platform.OS !== 'android') return false;
 
-    // Runtime-Permission holen (nur einmal noetig)
+    // 1. AudioFocus-Listener IMMER registrieren — fangs VoIP-Calls (WhatsApp,
+    //    Signal, Discord etc.) abdecken, brauchen keine Permission.
     try {
-      const granted = await PermissionsAndroid.request(
+      const focusEmitter = new NativeEventEmitter(NativeModules.AudioFocus as any);
-        PermissionsAndroid.PERMISSIONS.READ_PHONE_STATE,
+      this.focusSubscription = focusEmitter.addListener(
-        {
+        'AudioFocusChanged',
-          title: 'ARIA Cockpit — Anruf-Erkennung',
+        (e: { type: 'loss' | 'loss_transient' | 'gain' }) => this._onFocusChanged(e.type),
-          message: 'Damit ARIA bei einem eingehenden Anruf nicht weiterredet, '
-            + 'darf die App den Anruf-Status sehen (Klingeln/Aktiv/Aufgelegt). '
-            + 'Es werden keine Anrufdaten gelesen oder gespeichert.',
-          buttonPositive: 'Erlauben',
-          buttonNegative: 'Spaeter',
-        },
       );
-      if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
+      console.log('[PhoneCall] AudioFocus-Listener aktiv (fuer VoIP-Calls)');
-        console.warn('[PhoneCall] READ_PHONE_STATE Permission abgelehnt');
+    } catch (err: any) {
-        return false;
+      console.warn('[PhoneCall] AudioFocus-Subscription gescheitert', err?.message || err);
-      }
-    } catch (err) {
-      console.warn('[PhoneCall] Permission-Anfrage gescheitert', err);
     }
 
-    try {
+    // 2. TelephonyManager-Listener — fuer klassische Mobilfunk-Anrufe
-      const ok = await PhoneCall.start();
+    if (PhoneCall) {
-      if (!ok) {
+      try {
-        console.warn('[PhoneCall] Native start() lieferte false (Permission?)');
+        const granted = await PermissionsAndroid.request(
-        return false;
+          PermissionsAndroid.PERMISSIONS.READ_PHONE_STATE,
+          {
+            title: 'ARIA Cockpit — Anruf-Erkennung',
+            message: 'Damit ARIA bei einem eingehenden Anruf nicht weiterredet, '
+              + 'darf die App den Anruf-Status sehen (Klingeln/Aktiv/Aufgelegt). '
+              + 'Es werden keine Anrufdaten gelesen oder gespeichert.',
+            buttonPositive: 'Erlauben',
+            buttonNegative: 'Spaeter',
+          },
+        );
+        if (granted === PermissionsAndroid.RESULTS.GRANTED) {
+          const ok = await PhoneCall.start();
+          if (ok) {
+            const emitter = new NativeEventEmitter(NativeModules.PhoneCall as any);
+            this.subscription = emitter.addListener(
+              'PhoneCallStateChanged',
+              (e: { state: PhoneState }) => this._onStateChanged(e.state),
+            );
+            console.log('[PhoneCall] TelephonyManager-Listener aktiv');
+          }
+        } else {
+          console.warn('[PhoneCall] READ_PHONE_STATE abgelehnt — VoIP-Calls werden trotzdem ueber AudioFocus erkannt');
+        }
+      } catch (err: any) {
+        console.warn('[PhoneCall] TelephonyManager-Setup gescheitert:', err?.message || err);
       }
-      const emitter = new NativeEventEmitter(NativeModules.PhoneCall as any);
-      this.subscription = emitter.addListener('PhoneCallStateChanged', (e: { state: PhoneState }) => {
-        this._onStateChanged(e.state);
-      });
-      this.started = true;
-      console.log('[PhoneCall] Listener aktiv');
-      return true;
-    } catch (err: any) {
-      console.warn('[PhoneCall] start gescheitert:', err?.message || err);
-      return false;
     }
+
+    this.started = true;
+    return true;
   }
 
   async stop(): Promise<void> {
-    if (!this.started || !PhoneCall) return;
+    if (!this.started) return;
-    try {
+    try { this.subscription?.remove(); } catch {}
-      this.subscription?.remove();
+    try { this.focusSubscription?.remove(); } catch {}
-      this.subscription = null;
+    this.subscription = null;
-      await PhoneCall.stop();
+    this.focusSubscription = null;
-    } catch {}
+    if (PhoneCall) {
+      try { await PhoneCall.stop(); } catch {}
+    }
     this.started = false;
     this.lastState = 'idle';
+    this.interruptedByFocus = false;
   }
 
   private _onStateChanged(state: PhoneState): void {
     if (state === this.lastState) return;
-    console.log('[PhoneCall] State: %s → %s', this.lastState, state);
+    const prev = this.lastState;
+    console.log('[PhoneCall] State: %s → %s', prev, state);
     this.lastState = state;
     if (state === 'ringing' || state === 'offhook') {
-      audioService.haltAllPlayback(`Telefon-State: ${state}`);
+      this._haltForCall(state === 'ringing' ? 'Anruf — ARIA pausiert' : 'Im Gespraech — ARIA pausiert');
-      ToastAndroid.show(
+    } else if (state === 'idle' && prev !== 'idle') {
-        state === 'ringing' ? 'Anruf — ARIA pausiert' : 'Im Gespraech — ARIA pausiert',
+      // Wenn schon durch AudioFocus-Loss pausiert wurde, NICHT doppelt resumen.
-        ToastAndroid.SHORT,
+      // Der Focus-Gain-Event triggert das Resume.
-      );
+      if (!this.interruptedByFocus) {
+        this._resumeAfterCall('Anruf beendet — ARIA wieder aktiv');
+      }
     }
-    // idle: nichts automatisch — User soll nichts unbeabsichtigt re-triggern
+  }
+
+  /** AudioFocus-Loss = irgendeine andere App hat den Focus uebernommen.
+   *  Das passiert bei VoIP-Anrufen (was wir wollen) ABER auch bei normalen
+   *  Audio-Playern (anderer Player startet, Notification-Sound, sogar
+   *  unsere eigenen Sound-Calls beim Play-Button). Daher checken wir den
+   *  AudioMode — nur IN_CALL (2) oder IN_COMMUNICATION (3) zaehlt als Anruf. */
+  private async _onFocusChanged(type: 'loss' | 'loss_transient' | 'gain'): Promise<void> {
+    if (type === 'loss' || type === 'loss_transient') {
+      // Schon durch klassischen TelephonyManager pausiert? Dann nichts doppeln.
+      if (this.lastState === 'ringing' || this.lastState === 'offhook') return;
+      // Mode pruefen — nur echte Anrufe behandeln.
+      let mode = -1;
+      try { mode = await (NativeModules.AudioFocus as any)?.getMode?.(); } catch {}
+      if (mode !== 2 && mode !== 3) {
+        // NORMAL-Mode → kein Anruf (Stefan hat z.B. Play-Button gedrueckt
+        // oder Spotify hat sich neu reingedraengelt). Keine Toasts.
+        console.log('[PhoneCall] FOCUS_LOSS ignoriert (AudioMode=%d, kein Call)', mode);
+        return;
+      }
+      this.interruptedByFocus = true;
+      this._haltForCall('Anruf erkannt (VoIP) — ARIA pausiert');
+      // Pollen, weil GAIN nicht zuverlaessig kommt (wir releasen den Focus
+      // selbst beim halt → kein automatischer GAIN). AudioMode != IN_COMMUNICATION
+      // = Call vorbei.
+      this._startVoipResumePoll();
+    } else if (type === 'gain') {
+      if (this.interruptedByFocus) {
+        this.interruptedByFocus = false;
+        this._stopVoipResumePoll();
+        this._resumeAfterCall('Audio frei — ARIA wieder aktiv');
+      }
+    }
+  }
+
+  /** Polling-Fallback: alle 3s checken ob AudioMode wieder NORMAL ist. */
+  private voipPollTimer: ReturnType<typeof setInterval> | null = null;
+  private _startVoipResumePoll(): void {
+    if (this.voipPollTimer) return;
+    this.voipPollTimer = setInterval(async () => {
+      if (!this.interruptedByFocus) {
+        this._stopVoipResumePoll();
+        return;
+      }
+      try {
+        const mode = await (NativeModules.AudioFocus as any)?.getMode?.();
+        // 0 = MODE_NORMAL — Call ist vorbei
+        if (typeof mode === 'number' && mode === 0) {
+          this.interruptedByFocus = false;
+          this._stopVoipResumePoll();
+          this._resumeAfterCall('Anruf beendet — ARIA wieder aktiv');
+        }
+      } catch {}
+    }, 3000);
+  }
+  private _stopVoipResumePoll(): void {
+    if (this.voipPollTimer) {
+      clearInterval(this.voipPollTimer);
+      this.voipPollTimer = null;
+    }
+  }
+
+  private _haltForCall(toast: string): void {
+    // Position merken bevor wir den Stream killen — fuer Auto-Resume.
+    audioService.captureInterruption();
+    audioService.haltAllPlayback(toast);
+    wakeWordService.pauseForCall().catch(() => {});
+    ToastAndroid.show(toast, ToastAndroid.SHORT);
+  }
+
+  private _resumeAfterCall(toast: string): void {
+    wakeWordService.resumeFromCall().catch(() => {});
+    ToastAndroid.show(toast, ToastAndroid.SHORT);
+    // Auto-Resume: ab gemerkter Position weiterspielen wenn ARIA vor dem
+    // Anruf gerade redete. Wartet bis zu 30s auf den WAV-Cache (falls
+    // final-Marker erst nach dem Anruf-Ende kam).
+    audioService.resumeFromInterruption(30000).then(ok => {
+      if (ok) {
+        console.log('[PhoneCall] Auto-Resume von gemerkter Position gestartet');
+      }
+    }).catch(() => {});
   }
 }
 

android/src/services/updater.ts

@@ -50,28 +50,69 @@ class UpdateService {
     });
   }
 
-  /** Raeumt alte heruntergeladene APK-Dateien aus dem Cache auf. */
+  /** Sucht ueberall wo .apk-Dateien herumliegen koennten. */
-  private async cleanupOldApks(): Promise<void> {
+  private async _apkSearchDirs(): Promise<string[]> {
-    try {
+    const dirs = [RNFS.CachesDirectoryPath, RNFS.DocumentDirectoryPath];
-      const files = await RNFS.readDir(RNFS.CachesDirectoryPath);
+    if ((RNFS as any).ExternalCachesDirectoryPath) {
-      const apks = files.filter(f => /\.apk$/i.test(f.name));
+      dirs.push((RNFS as any).ExternalCachesDirectoryPath);
-      let freed = 0;
-      for (const f of apks) {
-        try {
-          const size = parseInt(f.size as any, 10) || 0;
-          await RNFS.unlink(f.path);
-          freed += size;
-          console.log(`[Update] Alte APK geloescht: ${f.name} (${(size / 1024 / 1024).toFixed(1)}MB)`);
-        } catch (err: any) {
-          console.warn(`[Update] APK-Loeschen fehlgeschlagen: ${f.name} (${err?.message || err})`);
-        }
-      }
-      if (apks.length > 0) {
-        console.log(`[Update] Cleanup fertig: ${apks.length} APKs entfernt, ${(freed / 1024 / 1024).toFixed(1)}MB freigegeben`);
-      }
-    } catch (err: any) {
-      console.warn(`[Update] Cleanup-Fehler: ${err?.message || err}`);
     }
+    if (RNFS.ExternalDirectoryPath) {
+      dirs.push(RNFS.ExternalDirectoryPath);
+    }
+    return dirs;
+  }
+
+  /** Raeumt alte heruntergeladene APK-Dateien aus den App-Verzeichnissen auf.
+   *  Public damit Settings den Button "Update-Cache leeren" benutzen kann. */
+  async cleanupOldApks(keepCurrentName?: string): Promise<{ removed: number; freedMB: number }> {
+    const dirs = await this._apkSearchDirs();
+    let removed = 0;
+    let freed = 0;
+    for (const dir of dirs) {
+      try {
+        if (!(await RNFS.exists(dir))) continue;
+        const files = await RNFS.readDir(dir);
+        const apks = files.filter(f => /\.apk$/i.test(f.name));
+        for (const f of apks) {
+          if (keepCurrentName && f.name === keepCurrentName) continue;
+          try {
+            const size = parseInt(f.size as any, 10) || 0;
+            await RNFS.unlink(f.path);
+            removed += 1;
+            freed += size;
+            console.log(`[Update] APK geloescht: ${f.path} (${(size / 1024 / 1024).toFixed(1)}MB)`);
+          } catch (err: any) {
+            console.warn(`[Update] APK-Loeschen fehlgeschlagen: ${f.path} (${err?.message || err})`);
+          }
+        }
+      } catch (err: any) {
+        console.warn(`[Update] Cleanup-Fehler in ${dir}: ${err?.message || err}`);
+      }
+    }
+    const freedMB = freed / 1024 / 1024;
+    if (removed > 0) {
+      console.log(`[Update] Cleanup fertig: ${removed} APK${removed === 1 ? '' : 's'} entfernt, ${freedMB.toFixed(1)}MB freigegeben`);
+    }
+    return { removed, freedMB };
+  }
+
+  /** Aktuelle Groesse aller APK-Dateien in den App-Verzeichnissen (in MB). */
+  async getApkCacheSize(): Promise<{ count: number; totalMB: number }> {
+    const dirs = await this._apkSearchDirs();
+    let count = 0;
+    let total = 0;
+    for (const dir of dirs) {
+      try {
+        if (!(await RNFS.exists(dir))) continue;
+        const files = await RNFS.readDir(dir);
+        for (const f of files) {
+          if (!f.isFile() || !/\.apk$/i.test(f.name)) continue;
+          count += 1;
+          total += parseInt(f.size as any, 10) || 0;
+        }
+      } catch {}
+    }
+    return { count, totalMB: total / 1024 / 1024 };
   }
 
   /** Bei App-Start Update pruefen */

android/src/services/wakeword.ts

@@ -22,6 +22,7 @@
 
 import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { acquireBackgroundAudio } from './backgroundAudio';
 
 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;
@@ -77,6 +78,14 @@ class WakeWordService {
   private bargeCallbacks: WakeWordCallback[] = [];
   /** True solange Wake-Word parallel zu TTS aktiv ist. */
   private bargeListening: boolean = false;
+  /** Anruf-Pause: state wird gemerkt damit nach Auflegen wiederhergestellt wird. */
+  private callPaused: boolean = false;
+  private preCallState: WakeWordState = 'off';
+  /** Cooldown nach App-Resume: kurze Phase in der Wake-Word-Detections
+   *  ignoriert werden. Beim Wechsel von Background nach Vordergrund gibt's
+   *  oft einen Audio-Pegel-Spike (AudioFocus-Switch, AudioTrack re-route),
+   *  der openWakeWord faelschlich triggern kann. */
+  private cooldownUntilMs: number = 0;
 
   private keyword: WakeKeyword = DEFAULT_KEYWORD;
   private nativeReady: boolean = false;
@@ -157,6 +166,10 @@ class WakeWordService {
   /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
   async start(): Promise<boolean> {
     if (this.state !== 'off') return true;
+    // Foreground-Service VOR dem Mic-Zugriff hochziehen damit Background-
+    // Lauschen funktioniert (Android braucht foregroundServiceType=microphone
+    // aktiv zum Zeitpunkt des AudioRecord.startRecording).
+    await acquireBackgroundAudio('wake');
     if (this.nativeReady && OpenWakeWord) {
       try {
         await OpenWakeWord.start();
@@ -200,8 +213,22 @@ class WakeWordService {
     this.setState('off');
   }
 
+  /** Cooldown setzen — alle Wake-Word-Detections in den naechsten ms ignorieren.
+   *  Wird beim App-Resume gerufen weil AppState-Wechsel Audio-Spikes erzeugen
+   *  die openWakeWord faelschlich als Trigger interpretiert. */
+  setResumeCooldown(ms: number = 1500): void {
+    this.cooldownUntilMs = Date.now() + ms;
+    console.log('[WakeWord] Cooldown aktiv fuer %dms', ms);
+  }
+
   /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
   private async onWakeDetected(): Promise<void> {
+    const now = Date.now();
+    if (now < this.cooldownUntilMs) {
+      const left = this.cooldownUntilMs - now;
+      console.log('[WakeWord] Trigger ignoriert (Cooldown noch %dms aktiv — wahrscheinlich App-Resume-Spike)', left);
+      return;
+    }
     console.log('[WakeWord] Wake-Word "%s" erkannt! (state=%s, barge=%s)',
                 this.keyword, this.state, this.bargeListening);
     if (this.nativeReady && OpenWakeWord) {
@@ -255,6 +282,43 @@ class WakeWordService {
     console.log('[WakeWord] Barge-Listening aus');
   }
 
+  /** Bei eingehendem Anruf: Wake-Word + Aufnahme stoppen, Pre-Call-State
+   *  merken. Telefonie-App belegt das Mikro waehrend des Anrufs, plus ARIA
+   *  soll nicht in laufende Telefonate reinhoeren. */
+  async pauseForCall(): Promise<void> {
+    if (this.callPaused) return;
+    this.preCallState = this.state;
+    if (this.state === 'off') {
+      this.callPaused = true;  // merken dass wir pausiert wurden
+      return;
+    }
+    this.callPaused = true;
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.stop(); } catch {}
+    }
+    this.bargeListening = false;
+    console.log('[WakeWord] Anruf — Wake-Word pausiert (war: %s)', this.preCallState);
+  }
+
+  /** Nach Auflegen: Pre-Call-State wiederherstellen. Aktive Konversation
+   *  geht zu armed zurueck (User soll nicht in einen halben Dialog springen). */
+  async resumeFromCall(): Promise<void> {
+    if (!this.callPaused) return;
+    const restoreTo = this.preCallState;
+    this.callPaused = false;
+    this.preCallState = 'off';
+    console.log('[WakeWord] Anruf zu Ende — restore state=%s', restoreTo);
+    if (restoreTo === 'off') return;
+    // Aktive Konversation war wahrscheinlich durch haltAllPlayback eh abgebrochen,
+    // sicher zu armed degraden.
+    if (restoreTo === 'conversing') this.setState('armed');
+    if (this.nativeReady && OpenWakeWord) {
+      try { await OpenWakeWord.start(); } catch (err) {
+        console.warn('[WakeWord] Restore-Start fehlgeschlagen:', err);
+      }
+    }
+  }
+
   /** Konversation beenden — User hat im Window nichts gesagt.
    *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
    *  Ohne: zurueck zu 'off'.

aria-data/config/AGENT.md

@@ -54,13 +54,6 @@ Fuer Web-Anfragen: **WebFetch** oder **Bash mit curl**. Niemals sagen "ich habe
 
 ## Stimme
 
-| Stimme | Modell | Wann |
+TTS laeuft ueber F5-TTS (Voice Cloning, Gaming-PC). Stefan kann eigene
-|--------|--------|------|
+Stimmen aus Audio-Samples klonen (Diagnostic → Stimmen → Stimme klonen)
-| **Ramona** (weiblich) | `de_DE-ramona-low` | Alltag, Antworten, Gespraeche (Standard) |
+und in App + Diagnostic auswaehlen.
-| **Thorsten** (maennlich, tief) | `de_DE-thorsten-high` | Epische Momente, Alarme, besondere Ereignisse |
-
-**Thorsten spricht bei:**
-- Build erfolgreich deployed
-- Ticket geloest / Aufgabe abgeschlossen
-- Kritischer Alarm (Server down, Sicherheitswarnung)
-- Wenn Stefan sagt "So soll es sein"

aria-data/config/BOOTSTRAP.md

@@ -80,10 +80,8 @@ Wenn ein Tool nicht klappt, probiere die Alternative. Niemals sagen "ich habe ke
 
 ## Stimme
 
-| Stimme | Modell | Wann |
+TTS laeuft ueber F5-TTS auf der Gamebox (Voice Cloning). Stefan kann
-|--------|--------|------|
+eigene Stimmen aus Audio-Samples klonen und in App/Diagnostic auswaehlen.
-| **Ramona** (weiblich) | `de_DE-ramona-low` | Alltag, Antworten, Gespraeche (Standard) |
-| **Thorsten** (maennlich, tief) | `de_DE-thorsten-high` | Epische Momente, Alarme, besondere Ereignisse |
 
 ## Gedaechtnis (Memory)
 
@@ -147,4 +145,4 @@ Danach den Eintrag in `memory/MEMORY.md` (Index) verlinken.
 ### Netzwerk
 - **aria-net:** Internes Docker-Netz (proxy, aria-core)
 - **RVS:** Rendezvous-Server im Rechenzentrum — Relay fuer die Android-App
-- **Bridge:** Voice Bridge (Whisper STT + Piper TTS) — teilt Netzwerk mit aria-core
+- **Bridge:** Voice Bridge (orchestriert STT/TTS via Gamebox-Bridges) — teilt Netzwerk mit aria-core

bridge/aria_bridge.py

@@ -1,17 +1,13 @@
 """
 ARIA Voice Bridge — Hauptmodul.
 
-Verbindet die Android App (via RVS) mit ARIA-Core und bietet
+Verbindet die Android App (via RVS) mit ARIA-Core. Spracheingabe laeuft
-lokale Spracheingabe (Wake-Word + Whisper STT) und Sprachausgabe (Piper TTS).
+ueber die whisper-bridge (Gamebox, faster-whisper auf CUDA), Sprachausgabe
+ueber die f5tts-bridge (Voice Cloning, satzweises PCM-Streaming).
 
 Nachrichtenfluss:
   App  → RVS → Bridge → aria-core
-  aria-core → Bridge → RVS → App
+  aria-core → Bridge → f5tts-bridge → PCM → RVS → App
-                     → Lautsprecher (TTS)
-
-Stimmen:
-  - Ramona (de_DE-ramona-low)  — Alltag, Gespraeche
-  - Thorsten (de_DE-thorsten-high) — epische Momente, Alarme
 """
 
 from __future__ import annotations
@@ -493,7 +489,7 @@ class ARIABridge:
         self.current_mode = self._load_persisted_mode()
         self.running = False
 
-        # Komponenten (TTS: immer XTTS remote, Piper wurde entfernt)
+        # Komponenten (TTS: F5-TTS remote auf der Gamebox, lokales TTS wurde entfernt)
         self.tts_enabled = True
         self.xtts_voice = ""
         self._f5tts_config: dict = {}
@@ -1028,6 +1024,31 @@ class ARIABridge:
         except Exception as e:
             logger.debug("[session] Diagnostic nicht erreichbar (%s) — nutze '%s'", e, self._session_key)
 
+    def _build_core_text(self, text: str, interrupted: bool = False,
+                          location: Optional[dict] = None) -> str:
+        """Baut den Text fuer aria-core mit allen relevanten Hints (Barge-In,
+        GPS-Position). Hints sind in eckigen Klammern, der eigentliche User-
+        Text folgt unverandert."""
+        parts: list[str] = []
+        if interrupted:
+            parts.append(
+                "[Hinweis: Stefan hat dich gerade unterbrochen waehrend du noch "
+                "gesprochen oder gearbeitet hast. Folgendes ist eine Korrektur, "
+                "Ergaenzung oder ein Themenwechsel zu deiner letzten Antwort.]"
+            )
+        if location and isinstance(location, dict):
+            lat = location.get("lat")
+            lon = location.get("lon") or location.get("lng")
+            if lat is not None and lon is not None:
+                parts.append(
+                    f"[Stefans aktuelle GPS-Position: {float(lat):.6f}, {float(lon):.6f}. "
+                    f"Nutze die nur wenn die Frage sich auf seinen Standort bezieht. "
+                    f"Erwaehne sie nicht von dir aus, ausser er fragt explizit danach.]"
+                )
+        if parts:
+            return " ".join(parts) + " " + text
+        return text
+
     def _build_pending_files_message(self, user_text: str) -> str:
         """Baut eine Anweisung an aria-core aus den gepufferten Files + optionalem
         User-Text. user_text leer → 'warte auf Anweisung'-Variante."""
@@ -1236,6 +1257,7 @@ class ARIABridge:
                     self._next_speed_override = None
             if text:
                 interrupted = bool(payload.get("interrupted", False))
+                location = payload.get("location") or None
                 # Wenn Files gerade gepuffert sind (Bild + Text gleichzeitig
                 # gesendet), mergen wir sie zu einer einzigen Anfrage statt
                 # zwei separater send_to_core-Calls.
@@ -1243,15 +1265,11 @@ class ARIABridge:
                 if merged:
                     logger.info("[rvs] App-Chat (mit Anhaengen): '%s'", text[:80])
                 else:
-                    core_text = (
+                    core_text = self._build_core_text(text, interrupted, location)
-                        f"[Hinweis: Stefan hat dich gerade unterbrochen waehrend du noch "
+                    logger.info("[rvs] App-Chat%s%s: '%s'",
-                        f"gesprochen oder gearbeitet hast. Folgendes ist eine Korrektur, "
+                                " [BARGE-IN]" if interrupted else "",
-                        f"Ergaenzung oder ein Themenwechsel zu deiner letzten Antwort.] "
+                                " [GPS]" if location else "",
-                        f"{text}"
+                                text[:80])
-                        if interrupted else text
-                    )
-                    logger.info("[rvs] App-Chat%s: '%s'",
-                                " [BARGE-IN]" if interrupted else "", text[:80])
                     await self.send_to_core(core_text, source="app" + (" [barge-in]" if interrupted else ""))
             return
 
@@ -1511,11 +1529,14 @@ class ARIABridge:
                     self._next_speed_override = None
             interrupted = bool(payload.get("interrupted", False))
             audio_request_id = payload.get("audioRequestId", "") or ""
-            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB%s%s",
+            location = payload.get("location") or None
+            logger.info("[rvs] Audio empfangen: %s, %dms, %dKB%s%s%s",
                         mime_type, duration_ms, len(audio_b64) // 1365,
                         " [BARGE-IN]" if interrupted else "",
+                        " [GPS]" if location else "",
                         f" reqId={audio_request_id[:16]}" if audio_request_id else "")
-            asyncio.create_task(self._process_app_audio(audio_b64, mime_type, interrupted, audio_request_id))
+            asyncio.create_task(self._process_app_audio(
+                audio_b64, mime_type, interrupted, audio_request_id, location))
 
         elif msg_type == "stt_response":
             # Antwort der whisper-bridge auf unseren stt_request
@@ -1573,7 +1594,8 @@ class ARIABridge:
 
     async def _process_app_audio(self, audio_b64: str, mime_type: str,
                                   interrupted: bool = False,
-                                  audio_request_id: str = "") -> None:
+                                  audio_request_id: str = "",
+                                  location: Optional[dict] = None) -> None:
         """App-Audio → STT → aria-core. Primaer via whisper-bridge (RVS), Fallback lokal.
 
         interrupted=True wenn der User waehrend ARIA noch sprach/dachte aufgenommen hat
@@ -1583,7 +1605,10 @@ class ARIABridge:
 
         audio_request_id: Korrelations-ID die die App im audio-Event mitschickt — wird
         unveraendert ans STT-Result zurueckgegeben damit die App die EXAKT richtige
-        'wird verarbeitet'-Bubble ersetzen kann (auch bei mehreren parallelen Aufnahmen)."""
+        'wird verarbeitet'-Bubble ersetzen kann (auch bei mehreren parallelen Aufnahmen).
+
+        location: Optional GPS-Position {lat, lon} — wird als Hinweis-Praefix mitgegeben
+        damit ARIA bei standortbezogenen Fragen sie nutzen kann."""
         # Erst Remote versuchen
         text = await self._stt_remote(audio_b64, mime_type)
         if text is None:
@@ -1595,15 +1620,9 @@ class ARIABridge:
 
         if text.strip():
             logger.info("[rvs] STT Ergebnis: '%s'", text[:80])
-            # Barge-In-Hinweis: gibt ARIA den Kontext dass sie unterbrochen wurde
+            # Hints (Barge-In, GPS) als Praefix vorschalten — gemeinsamer Helper
-            # und dies eine Korrektur/Aenderung der vorherigen Anweisung sein kann.
+            # mit dem chat-Pfad damit das Verhalten konsistent ist.
-            core_text = (
+            core_text = self._build_core_text(text, interrupted, location)
-                f"[Hinweis: Stefan hat dich gerade unterbrochen waehrend du noch "
-                f"gesprochen oder gearbeitet hast. Folgendes ist eine Korrektur, "
-                f"Ergaenzung oder ein Themenwechsel zu deiner letzten Antwort.] "
-                f"{text}"
-                if interrupted else text
-            )
             # ERST an aria-core senden (wichtigster Schritt)
             await self.send_to_core(core_text, source="app-voice" + (" [barge-in]" if interrupted else ""))
             # STT-Text an RVS senden (fuer Anzeige in App + Diagnostic)

diagnostic/index.html

@@ -278,6 +278,10 @@
             <input type="checkbox" id="tts-debug-toggle" onchange="toggleTtsDebug()" style="margin-right:4px;vertical-align:middle;">
             TTS-Text einblenden
           </label>
+          <label style="color:#8888AA;font-size:11px;cursor:pointer;">
+            <input type="checkbox" id="gps-debug-toggle" onchange="toggleGpsDebug()" style="margin-right:4px;vertical-align:middle;">
+            GPS-Position einblenden
+          </label>
           <button class="btn secondary" onclick="toggleChatFullscreen()" id="btn-chat-fs" style="padding:4px 10px;font-size:11px;">Vollbild</button>
         </div>
       </div>
@@ -665,24 +669,6 @@
       </div>
     </div>
 
-    <!-- Highlight-Trigger -->
-    <div class="settings-section">
-      <h2>Highlight-Trigger</h2>
-      <div style="font-size:11px;color:#8888AA;margin-bottom:8px;">
-        Woerter die automatisch die Highlight-Stimme (Thorsten) ausloesen.
-        Eines pro Zeile. Aenderungen werden in der Bridge gespeichert.
-      </div>
-      <div class="card" style="max-width:500px;">
-        <textarea id="highlight-triggers" rows="8" style="width:100%;box-sizing:border-box;background:#1E1E2E;border:1px solid #2A2A3E;border-radius:6px;padding:8px;color:#fff;font-size:13px;font-family:monospace;resize:vertical;"
-          placeholder="Lade..."></textarea>
-        <div style="display:flex;gap:8px;margin-top:8px;">
-          <button class="btn" onclick="saveHighlightTriggers()" style="flex:1;">Speichern</button>
-          <button class="btn secondary" onclick="loadHighlightTriggers()" style="flex:1;">Neu laden</button>
-        </div>
-        <div id="trigger-status" style="font-size:11px;color:#555570;margin-top:6px;"></div>
-      </div>
-    </div>
-
     <!-- Tool-Berechtigungen -->
     <div class="settings-section">
       <h2>Tool-Berechtigungen</h2>
@@ -956,14 +942,6 @@
           return;
         }
 
-        if (msg.type === 'trigger_list') {
-          const textarea = document.getElementById('highlight-triggers');
-          textarea.value = (msg.triggers || []).join('\n');
-          document.getElementById('trigger-status').textContent = msg.triggers.length + ' Trigger geladen';
-          document.getElementById('trigger-status').style.color = '#8888AA';
-          return;
-        }
-
         if (msg.type === 'service_status') {
           updateServiceStatus(msg.payload || {});
           return;
@@ -1030,7 +1008,7 @@
           if (sender === 'aria') return;
           const chatType = 'sent';
           const label = sender === 'stt' ? '\uD83C\uDFA4 Spracheingabe' : `via RVS (${sender})`;
-          addChat(chatType, p.text || '?', label);
+          addChat(chatType, p.text || '?', label, { location: p.location });
           return;
         }
         if (msg.type === 'proxy_result') {
@@ -1421,6 +1399,16 @@
       if (el) el.checked = showTtsDebug;
     }
 
+    // Debug-Toggle: GPS-Position unter User-Nachrichten einblenden (nur Diagnostic).
+    // App zeigt's bewusst nicht — die Position geht nur an aria-core.
+    let showGpsDebug = localStorage.getItem('aria-show-gps-debug') === '1';
+    function toggleGpsDebug() {
+      showGpsDebug = !showGpsDebug;
+      localStorage.setItem('aria-show-gps-debug', showGpsDebug ? '1' : '0');
+      const el = document.getElementById('gps-debug-toggle');
+      if (el) el.checked = showGpsDebug;
+    }
+
     // Minimal-JS-Port von clean_text_for_tts() (Bridge) — reine Anzeige
     function previewTtsText(text) {
       if (!text) return '';
@@ -1460,7 +1448,18 @@
           ttsBlock = `<div style="margin-top:6px;padding:4px 8px;background:rgba(0,150,255,0.08);border-left:2px solid #0096FF;font-size:11px;color:#88AACC;"><span style="color:#0096FF;font-weight:bold;">TTS:</span> ${escapeHtml(ttsText)}</div>`;
         }
       }
-      const html = `${linked}${ttsBlock}<div class="meta">${escapeHtml(meta)} — ${new Date().toLocaleTimeString('de-DE')}</div>`;
+      // Optional: GPS-Position als Block unter User-Nachrichten (nur Diagnostic)
+      let gpsBlock = '';
+      if (showGpsDebug && options && options.location) {
+        const loc = options.location;
+        const lat = typeof loc.lat === 'number' ? loc.lat.toFixed(6) : '?';
+        const lon = typeof loc.lon === 'number' ? loc.lon.toFixed(6) : (typeof loc.lng === 'number' ? loc.lng.toFixed(6) : '?');
+        if (lat !== '?' && lon !== '?') {
+          const mapLink = `https://www.openstreetmap.org/?mlat=${lat}&mlon=${lon}#map=16/${lat}/${lon}`;
+          gpsBlock = `<div style="margin-top:6px;padding:4px 8px;background:rgba(52,199,89,0.08);border-left:2px solid #34C759;font-size:11px;color:#88BB99;"><span style="color:#34C759;font-weight:bold;">📍 GPS:</span> <a href="${mapLink}" target="_blank" rel="noopener" style="color:#88BB99;text-decoration:underline;">${lat}, ${lon}</a></div>`;
+        }
+      }
+      const html = `${linked}${ttsBlock}${gpsBlock}<div class="meta">${escapeHtml(meta)} — ${new Date().toLocaleTimeString('de-DE')}</div>`;
 
       // Thinking-Indikator ausblenden bei neuer Nachricht
       updateThinkingIndicator({ activity: 'idle' });
@@ -1958,20 +1957,6 @@
       }
     }
 
-    // ── Highlight-Trigger ────────────────────────
-    function loadHighlightTriggers() {
-      send({ action: 'get_triggers' });
-    }
-    function saveHighlightTriggers() {
-      const text = document.getElementById('highlight-triggers').value;
-      const triggers = text.split('\n').map(t => t.trim()).filter(t => t.length > 0);
-      send({ action: 'save_triggers', triggers });
-      document.getElementById('trigger-status').textContent = 'Gespeichert (' + triggers.length + ' Trigger)';
-      document.getElementById('trigger-status').style.color = '#34C759';
-    }
-    // Beim Tab-Wechsel zu Einstellungen: Trigger laden
-    const origSwitchMainTab = typeof switchMainTab === 'function' ? switchMainTab : null;
-
     // ── Modus-Wechsel ────────────────────────────
     // Kanonische IDs (matchen bridge/modes.py canonical_id + android ModeSelector)
     const MODE_LABELS = { normal: 'Normal', nicht_stoeren: 'Nicht stoeren', fluester: 'Fluestern', hangar: 'Hangar', gaming: 'Gaming' };
@@ -2456,9 +2441,8 @@
       document.querySelectorAll('.main-nav-btn').forEach(b => {
         if (b.textContent.trim().toLowerCase().includes(tab === 'main' ? 'main' : 'einstellung')) b.classList.add('active');
       });
-      // Einstellungen: Config + Trigger + QR laden
+      // Einstellungen: Config + QR laden
       if (tab === 'settings') {
-        loadHighlightTriggers();
         send({ action: 'get_voice_config' });
         loadRuntimeConfig();
         loadOnboardingQR();
@@ -2492,6 +2476,8 @@
     // Toggle-Checkbox initial korrekt setzen
     const ttsToggleEl = document.getElementById('tts-debug-toggle');
     if (ttsToggleEl) ttsToggleEl.checked = showTtsDebug;
+    const gpsToggleEl = document.getElementById('gps-debug-toggle');
+    if (gpsToggleEl) gpsToggleEl.checked = showGpsDebug;
 
     // Disk-Space Banner aktualisieren (wird vom Server via disk_status gepusht)
     function updateDiskBanner(status) {

diagnostic/server.js

@@ -1475,10 +1475,6 @@ wss.on("connection", (ws) => {
         } catch {}
         sendToRVS_raw({ type: "config", payload: voiceConfig, timestamp: Date.now() });
         log("info", "server", `Voice-Config gespeichert: xttsVoice=${voiceConfig.xttsVoice || "default"}, whisper=${voiceConfig.whisperModel || "-"}`);
-      } else if (msg.action === "get_triggers") {
-        handleGetTriggers(ws);
-      } else if (msg.action === "save_triggers") {
-        handleSaveTriggers(ws, msg.triggers || []);
       } else if (msg.action === "test_tts") {
         handleTestTTS(ws, msg.text || "Test");
       } else if (msg.action === "preview_voice") {
@@ -1629,31 +1625,6 @@ function handleGetVoiceConfig(clientWs) {
   }
 }
 
-// ── Highlight-Trigger (legacy UI — wird nicht mehr ausgewertet seit Piper raus) ─
-const TRIGGERS_FILE = "/shared/config/highlight_triggers.json";
-
-async function handleGetTriggers(clientWs) {
-  try {
-    const triggers = fs.existsSync(TRIGGERS_FILE)
-      ? JSON.parse(fs.readFileSync(TRIGGERS_FILE, "utf-8"))
-      : [];
-    clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
-  } catch (err) {
-    clientWs.send(JSON.stringify({ type: "trigger_list", triggers: [], error: err.message }));
-  }
-}
-
-async function handleSaveTriggers(clientWs, triggers) {
-  try {
-    fs.mkdirSync("/shared/config", { recursive: true });
-    fs.writeFileSync(TRIGGERS_FILE, JSON.stringify(triggers, null, 2));
-    log("info", "server", `${triggers.length} Highlight-Trigger gespeichert`);
-    clientWs.send(JSON.stringify({ type: "trigger_list", triggers }));
-  } catch (err) {
-    log("error", "server", `Trigger speichern fehlgeschlagen: ${err.message}`);
-  }
-}
-
 // ── TTS Diagnose (XTTS) ───────────────────────────────
 // ── Voice Preview ────────────────────────────────────────
 // Sammelt audio_pcm Chunks einer Preview-Anfrage, baut am Ende eine WAV

issue.md

@@ -1,7 +1,93 @@
 # ARIA Issues & Features
 
+## Audio-Verhalten in der App
+
+So sollte die App in den verschiedenen Phasen mit fremden Audio-Apps
+(Spotify, YouTube, Podcasts etc.) und dem eigenen Mikro umgehen.
+Wenn was anders ist, ist's ein Bug.
+
+| Phase                        | Andere App (Spotify) | ARIA-Mikro          | Hintergrund-Service |
+|------------------------------|----------------------|---------------------|---------------------|
+| Idle / Ohr aus               | spielt frei          | aus                 | aus                 |
+| Wake-Word lauscht (armed)    | spielt frei          | passiv (openWakeWord) | aktiv ('wake')    |
+| User-Aufnahme laeuft         | pausiert (EXCLUSIVE) | Recording           | aktiv ('rec')       |
+| Aufnahme zu Ende             | resumed              | aus                 | (rec released)      |
+| ARIA denkt/schreibt (~20s)   | spielt frei          | aus                 | (kein Slot)         |
+| TTS startet                  | pausiert (DUCK)      | aus (oder barge)    | aktiv ('tts')       |
+| TTS spielt (auch GPU-Pausen) | bleibt pausiert      | barge wenn Wake-Word| aktiv               |
+| TTS zu Ende                  | nach 800ms resumed   | (Conversation-Window)| (tts released)     |
+| Eingehender Anruf (auch VoIP)| —                    | Mikro pausiert      | aus                 |
+| Anruf vorbei                 | —                    | Mikro wieder armed  | aktiv ('wake')      |
+| Anruf vorbei (Auto-Resume)   | pausiert wieder       | aus                 | aktiv ('tts')       |
+| Neue Frage waehrend Anruf    | —                    | Mikro pausiert      | (rec waehrend Anruf nicht) |
+| Anruf vorbei nach neuer Frage | (siehe TTS-Phasen)   | (siehe TTS-Phasen)  | (tts gewinnt, alter Resume verworfen) |
+
+Wichtige Mechanismen:
+- **Underrun-Schutz** im PcmStreamPlayer fuettert Stille rein wenn die
+  Bridge in Render-Pausen liefert — Spotify bleibt durchgehend pausiert,
+  auch zwischen den Saetzen einer langen Antwort.
+- **Conversation-Focus** (nur bei Wake-Word 'conversing') haelt den
+  AudioFocus dauerhaft. Bei reinem Tap-to-Talk oder Text-Chat greift's
+  nicht — Spotify darf in der Denk-Phase ruhig weiterspielen.
+- **Foreground-Service** (mediaPlayback|microphone) haelt App-Prozess
+  am Leben damit TTS/Mikro/Wake-Word auch bei minimierter App weiter-
+  laufen. Notification zeigt aktuellen Status ("ARIA spricht/hoert
+  zu/bereit").
+- **Anruf-Erkennung** ueber TelephonyManager (klassisch) + AudioFocus-
+  Loss-Listener mit Polling-Fallback (VoIP wie WhatsApp/Signal/Discord).
+- **Auto-Resume nach Anruf**: beim Halt wird die Wiedergabe-Position
+  gemerkt (Date.now() - playbackStart - leadingSilence). Nach Auflegen
+  wartet die App bis zu 30s auf den WAV-Cache und spielt dann ab der
+  gemerkten Position weiter. Wenn das Telefonat länger als die Antwort
+  dauerte, ist der Cache schon fertig — instant Resume.
+- **Neue Frage waehrend Anruf** (Text-Chat geht trotz Telefonat): die
+  neue Antwort ueberschreibt den pending Resume. _handlePcmChunkImpl
+  stoppt einen ggf. laufenden resumeSound und setzt pausedMessageId
+  zurueck wenn die neue Stream-messageId abweicht. Die letzte Antwort
+  gewinnt immer.
+- **Audio-Ausgabe trotz aktivem Telefonat**: ARIA antwortet auch waehrend
+  eines Telefonats per Lautsprecher (Telefon-Audio geht ueber separaten
+  Stream zur Gegenseite). haltAllPlayback wird nur beim STATE-WECHSEL
+  ringing/offhook gerufen — wenn der Anruf schon laeuft (offhook→offhook),
+  triggert eine neue Frage keinen Halt mehr.
+
 ## Erledigt
 
+### Bugs / Fixes
+
+- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen
+- [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
+- [x] Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
+- [x] Voice-Auswahl funktioniert wieder: speaker_wav als Basename statt Pfad fuer daswer123 local-Mode
+- [x] Diagnostic-Voice-Wechsel resettet alle App-lokalen Voice-Overrides via type "config"
+- [x] Streaming TTS Stop-Race: Writer wartet auf playbackHeadPosition vor stop()/release() — keine abgeschnittenen Saetze mehr
+- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
+- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
+- [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
+- [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
+- [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
+- [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
+- [x] Wake-Word Embedding rank-4 Fix (Pipeline-Bug der das Triggern verhinderte) + Frame-Count aus Modell-Metadaten lesen
+- [x] PCM-Underrun-Schutz: Stille-Fill in Render-Pausen verhindert Spotify-Auto-Resume nach 10s Stillstand
+- [x] Conversation-Focus-Lifecycle: AudioFocus haengt am Wake-Word-State 'conversing' statt an einzelnen Streams — Spotify bleibt durchgehend gepaust, auch zwischen mehreren Antworten
+- [x] Voice-Override behaelt Stimme ueber alle TTS-Calls einer Antwort (vorher: nach erstem TTS-Call zurueck auf Default)
+- [x] Sprachnachricht-Bubble defensiv: STT-Result fuegt neue Bubble hinzu wenn Placeholder fehlt (Race-Schutz)
+- [x] Bild + Text als EINE Anfrage: Bridge buffert files 800ms, merged mit folgendem chat-Text zu einem send_to_core (statt zwei getrennten ARIA-Antworten)
+- [x] Diagnostic→App: persistente RVS-Connection statt frische pro Send (Race-Probleme mit Zombie-WS geloest)
+- [x] Textauswahl in Bubbles wieder funktional (nested Text+onPress raus, dataDetectorType="all" macht Links automatisch klickbar)
+- [x] **Placeholder-Race bei parallelen Sprachnachrichten geloest**: jede Aufnahme bekommt eine eindeutige audioRequestId, Bridge gibt sie ans STT-Result zurueck — App matcht jetzt punktgenau die richtige Bubble statt per Substring
+- [x] Mikro-Offen-Toast "🎤 sprich jetzt" erscheint erst wenn audioService.startRecording wirklich erfolgreich war (statt ~400ms vorher beim Wake-Word-Detect)
+- [x] Sprachnachrichten ohne STT-Result werden nach 60s+Aufnahmedauer automatisch entfernt (sicher genug fuer 5-30min-Aufnahmen, schnell genug fuer leere Wake-Word-Echos)
+- [x] VAD adaptive Baseline robuster: minimum statt avg + Cap auf -50dB bis -28dB (Stille) / -40dB bis -18dB (Speech) — keine "tote" VAD-Konfiguration mehr bei lauter Umgebung oder Wake-Word-Echo
+- [x] Push-to-Talk raus, nur noch Tap-to-Talk (verhinderte Touch-Race-Probleme)
+- [x] Manueller Mikro-Stop beendet Wake-Word-Konversation: Tap auf Mikro-Knopf waehrend conversing → audio raus + zurueck zu armed (= Wake-Word lauscht wieder, kein Auto-Mikro nach ARIAs Antwort). VAD-Auto-Stop bleibt bei Multi-Turn
+- [x] **Wake-Word pausiert bei Anruf**: phoneCall ruft pauseForCall (openWakeWord.stop) bei RINGING/OFFHOOK, resumeFromCall bei IDLE. Pre-Call-State wird gemerkt — armed bleibt armed, conversing degraded zu armed (User soll nicht in halbem Dialog landen)
+- [x] **App-Resume-Cooldown**: Wechsel von Background → Foreground triggert keinen falschen Wake-Word-Trigger mehr. AppState-Listener setzt 1.5s Cooldown in dem onWakeDetected-Events ignoriert werden (Audio-Pegel-Spike beim AudioFocus-Switch sonst als Wake-Word interpretiert)
+- [x] Background-Mikro robust: acquireBackgroundAudio('rec'/'wake') wird jetzt VOR AudioRecord.startRecording gerufen — Foreground-Service mit foregroundServiceType=microphone muss aktiv sein bevor das Mikro greift, sonst blockiert Android ab 11+ den Background-Zugriff
+- [x] **Stille-Pegel manuell setzbar** (Settings → Spracheingabe): Override-Wert in dB von -55 bis -15, default "automatisch". Info-Button mit Modal erklaert die Skala (niedriger = sensibler, hoeher = robuster gegen Hintergrundlaerm). Bei manuell gesetztem Wert wird die adaptive Baseline ignoriert
+
+### App Features
+
 - [x] Bildupload funktioniert (Shared Volume /shared/uploads/)
 - [x] Sprachnachrichten werden als Text angezeigt (STT → Chat-Bubble)
 - [x] Cache leeren + Auto-Download von Anhaengen
@@ -11,13 +97,9 @@
 - [x] Ohr-Button → Gespraechsmodus (Auto-Aufnahme nach ARIA-Antwort)
 - [x] Play-Button in ARIA-Nachrichten fuer Sprachwiedergabe
 - [x] Chat-Suche in der App (Lupe in Statusleiste)
-- [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
 - [x] Abbrechen-Button im Diagnostic Chat
-- [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
-- [x] Grosse Nachrichten satzweise aufteilen fuer TTS
-- [x] RVS Nachrichten vom Smartphone gehen durch
 - [x] Stimmen-Einstellungen (Ramona/Thorsten, Speed pro Stimme — durch XTTS/F5-TTS ersetzt)
-- [x] Highlight-Trigger konfigurierbar in Diagnostic
+- [x] Highlight-Trigger konfigurierbar in Diagnostic (spaeter komplett entfernt — war Piper-Relikt)
 - [x] XTTS v2 Integration (Gaming-PC, GPU, Voice Cloning) — durch F5-TTS ersetzt
 - [x] XTTS Voice Cloning (Audio-Samples hochladen, eigene Stimme)
 - [x] TTS Engine waehlbar (Piper/XTTS) — Piper raus, XTTS raus, jetzt nur F5-TTS
@@ -25,16 +107,12 @@
 - [x] Auto-Update: APK-Installation via FileProvider
 - [x] Auto-Update: "Auf Updates pruefen" Button in App-Einstellungen
 - [x] Audio-Queue (sequentielle Wiedergabe, kein Ueberlappen)
-- [x] Textnachrichten werden von ARIA beantwortet (Bridge chat handler fix)
 - [x] Mehrere Anhaenge + Text vor dem Senden (Pending-Vorschau)
 - [x] Paste-Support fuer Bilder in Diagnostic Chat
 - [x] Markdown-Bereinigung fuer TTS (fett, kursiv, code, links, etc.)
-- [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
 - [x] Diagnostic: Sessions als Markdown exportieren (Download-Button)
 - [x] Speech Gate: Aufnahme wird verworfen wenn keine Sprache erkannt
 - [x] Session-Persistenz: Gewaehlte Session bleibt ueber Container-Restarts erhalten
-- [x] Diagnostic: "ARIA denkt..." bleibt nicht mehr stehen
-- [x] App: "ARIA denkt..." Indicator + Abbrechen-Button (Bridge spiegelt agent_activity via RVS)
 - [x] Whisper STT: Model-Auswahl in Diagnostic (tiny/base/small/medium/large-v3), Hot-Reload
 - [x] App: Audio-Aufnahme explizit 16kHz mono (spart Resample, optimal fuer Whisper)
 - [x] Streaming TTS: PCM-Stream → AudioTrack MODE_STREAM, keine WAV-Gaps
@@ -51,14 +129,11 @@
 - [x] Disk-Voll Banner in Diagnostic: rotes Overlay + copy-baren Cleanup-Befehlen (safe + aggressiv)
 - [x] cleanup.sh: kombinierter Docker-Aufraeum-Befehl (safe / --full)
 - [x] Streaming TTS Pre-Roll: AudioTrack play() startet erst wenn 2.5s gepuffert sind
-- [x] Streaming TTS Stop-Race: Writer wartet auf playbackHeadPosition vor stop()/release() — keine abgeschnittenen Saetze mehr
 - [x] Leading-Silence (200ms) am Stream-Anfang — AudioTrack faehrt sauber an
 - [x] Pre-Roll-Buffer einstellbar in App-Settings (1.0-6.0s, Default 3.5s)
 - [x] Fade-In auf erstem PCM-Chunk (120ms) — versteckt XTTS/F5-TTS Warmup-Glitches
 - [x] Decimal-zu-Worte fuer TTS (0.1 → null komma eins, mit IP-Schutz-Lookahead)
 - [x] Generic Acronym-Buchstabieren (XTTS → X T T S, USB → U S B, ueber expliziter Liste)
-- [x] Voice-Auswahl funktioniert wieder: speaker_wav als Basename statt Pfad fuer daswer123 local-Mode
-- [x] Diagnostic-Voice-Wechsel resettet alle App-lokalen Voice-Overrides via type "config"
 - [x] voice_preload/voice_ready: Stille Mini-Render bei Voice-Wechsel + Toast/Status "bereit"
 - [x] Whisper STT auf die Gamebox ausgelagert (faster-whisper CUDA, float16) — neuer aria-whisper-bridge Container
 - [x] aria-bridge: STT primaer remote (Gamebox), Fallback lokal nach 45s Timeout
@@ -66,48 +141,46 @@
 - [x] **F5-TTS ersetzt XTTS komplett** — neuer aria-f5tts-bridge Container, Voice Cloning, satzweises Streaming
 - [x] Voice-Upload mit Whisper-Auto-Transkription — User muss keinen Referenz-Text eintippen
 - [x] Audio-Pause statt Ducking: Spotify/YouTube pausieren komplett waehrend TTS (TRANSIENT statt MAY_DUCK)
-- [x] AudioFocus.release wartet auf echten Playback-Ende — kein Volume-Hochfahren mehr mid-Antwort
 - [x] VAD-Stille einstellbar in App-Settings (1.0-8.0s, Default 2.8s)
 - [x] MAX_RECORDING auf 120s — laengere Erklaerungen moeglich
-- [x] App: Audioausgabe hoert nicht mehr mitten im Satz auf (playbackHeadPosition wait + Stop-Race fix)
 - [x] F5-TTS: Referenz-WAV-Preprocessing — Loudness-Normalisierung -16 LUFS + Silence-Trim + 10s Clip fuer konsistente Cloning-Quali
 - [x] F5-TTS: deutsches Fine-Tune (aihpi/F5-TTS-German, Vocos-Variante) via hf:// Pfad in Diagnostic konfigurierbar
-- [x] Whisper transkribiert Voice-Uploads nicht mehr mit hardcoded "small" — aktuelles Modell wird behalten, kein unnoetiger Modell-Swap
-- [x] RVS/WebSocket maxPayload 50MB: voice_upload mit WAV als base64 sprengt kein Frame-Limit mehr
 - [x] Dynamischer STT-Timeout in aria-bridge: 300s waehrend whisper-bridge 'loading', 45s wenn 'ready'
 - [x] service_status Broadcasts: f5tts/whisper melden Lade-Status, Banner in Diagnostic (unten rechts) + App (oben)
 - [x] config_request Pattern: Bridges fragen beim Connect die aktuelle Voice-Config an, aria-bridge antwortet
 - [x] F5-TTS Tuning via Diagnostic (Modell-ID, Checkpoint, cfg_strength, nfe_step) statt ENV-Vars — Hot-Reload bei Modell-Wechsel
 - [x] Conversation-Window: Gespraechsmodus endet nach X Sekunden Stille (1.0-20.0s, Default 8s, einstellbar in Settings)
-- [x] Porcupine Wake-Word-Integration in der App (Built-In Keywords + Custom spaeter, per Geraet einstellbar)
+- [x] Porcupine Wake-Word-Integration in der App (durch openWakeWord ersetzt)
 - [x] HF-Cache als Bind-Mount statt Docker Volume — kein .vhdx-Bloat auf Docker Desktop / Windows
 - [x] cleanup-windows.ps1 / .bat: VHDX-Cleanup via diskpart (ohne Hyper-V) mit Self-Elevation
-- [x] App Mute-/Auto-Playback-Bug: Closure-Bug geloest (ttsCanPlayRef live-gespiegelt, nicht mehr stale)
-- [x] App Zombie-Recording: Ohr-aus kill laufende Aufnahme damit der Aufnahme-Button weiter funktioniert
 - [x] App Text-Rendering: Nachrichten selektierbar + Autolink fuer URLs/E-Mails/Telefonnummern (Browser/Mail/Dialer)
 - [x] TTS-Wiedergabegeschwindigkeit pro Geraet einstellbar (Settings → 0.5-2.0x in 0.1-Schritten, Default 1.0)
 - [x] Diagnostic: Voice-Preview-Modal (Play-Icon vor Delete-X, Textfeld mit Default, WAV im Browser abspielen)
 - [x] **Wake-Word komplett on-device via openWakeWord (ONNX Runtime)** — Porcupine raus, kein API-Key/keine Lizenzgebuehren mehr. Mitgelieferte Keywords: hey_jarvis, computer, alexa, hey_mycroft, hey_rhasspy
-- [x] Wake-Word Embedding rank-4 Fix (Pipeline-Bug der das Triggern verhinderte) + Frame-Count aus Modell-Metadaten lesen
 - [x] APK ABI-Split auf arm64-v8a — von ~136 MB auf ~35 MB, Auto-Update-Downloads aufs Phone deutlich kleiner
-- [x] PCM-Underrun-Schutz: Stille-Fill in Render-Pausen verhindert Spotify-Auto-Resume nach 10s Stillstand
-- [x] Conversation-Focus-Lifecycle: AudioFocus haengt am Wake-Word-State 'conversing' statt an einzelnen Streams — Spotify bleibt durchgehend gepaust, auch zwischen mehreren Antworten
 - [x] PhoneStateListener: TTS pausiert bei eingehendem Anruf (READ_PHONE_STATE Permission)
-- [x] Voice-Override behaelt Stimme ueber alle TTS-Calls einer Antwort (vorher: nach erstem TTS-Call zurueck auf Default)
+- [x] **VoIP-Anrufe** (WhatsApp/Signal/Discord/Teams) erkannt via AudioFocus-Loss-Listener + getMode-Polling-Fallback (alle 3s)
-- [x] Sprachnachricht-Bubble defensiv: STT-Result fuegt neue Bubble hinzu wenn Placeholder fehlt (Race-Schutz)
+- [x] **Auto-Resume nach Anruf**: ARIAs unterbrochene Antwort spielt nach dem Auflegen ab der gemerkten Position weiter (Date.now()-Tracking + WAV-Cache, 30s-Wartezeit auf final-Marker bei kurzem Telefonat)
-- [x] Bild + Text als EINE Anfrage: Bridge buffert files 800ms, merged mit folgendem chat-Text zu einem send_to_core (statt zwei getrennten ARIA-Antworten)
+- [x] **Neue Frage waehrend Telefonat** ueberschreibt pending Auto-Resume — letzte Antwort gewinnt, alter resumeSound wird gestoppt
+- [x] **Audio-Ausgabe waehrend aktivem Telefonat** funktioniert (haltAllPlayback nur bei state-Wechsel idle→ringing/offhook, nicht bei offhook→offhook)
+- [x] **PcmPlaybackFinished-Event** im Native: AudioFocus wird erst released wenn AudioTrack wirklich durch ist (vorher: end()-Cap nach 0.5s → Spotify spielte 32s parallel zu ARIA)
+- [x] **APK-Cache-Cleanup robuster**: durchsucht jetzt CachesDirectoryPath + DocumentDirectoryPath + ExternalCachesDirectoryPath + ExternalDirectoryPath statt nur Caches. Plus manueller Button "Update-Cache leeren" in Settings → Speicher mit Live-Anzeige der aktuellen Groesse
 - [x] Diagnostic-Chat: bubblige Formatierung, mehrzeiliges Eingabefeld (textarea, Enter sendet, Shift+Enter neue Zeile)
-- [x] Diagnostic→App: persistente RVS-Connection statt frische pro Send (Race-Probleme mit Zombie-WS geloest)
+- [x] Adaptive VAD-Schwelle: Baseline aus den ersten 500ms Mic-Pegel, Stille = baseline+6dB / Sprache = baseline+12dB
-- [x] Adaptive VAD-Schwelle: Baseline aus den ersten 500ms Mic-Pegel, Stille = baseline+6dB / Sprache = baseline+12dB. Funktioniert in lauten wie leisen Umgebungen
 - [x] Max-Aufnahmedauer konfigurierbar in Settings (1-30 min, Default 5 min) — laengere Diktate moeglich
 - [x] Barge-In: User kann ARIA waehrend Antwort/Tool-Use unterbrechen, alte Aktivitaet wird abgebrochen, Bridge gibt aria-core einen Kontext-Hint dass es eine Korrektur ist
-- [x] Push-to-Talk raus, nur noch Tap-to-Talk (verhinderte Touch-Race-Probleme)
 - [x] Settings-Sub-Screens: 8 Kategorien (Verbindung, Allgemein, Spracheingabe, Wake-Word, Sprachausgabe, Speicher, Protokoll, Ueber) statt langer Liste
-- [x] Textauswahl in Bubbles wieder funktional (nested Text+onPress raus, dataDetectorType="all" macht Links automatisch klickbar)
-- [x] **Placeholder-Race bei parallelen Sprachnachrichten geloest**: jede Aufnahme bekommt eine eindeutige audioRequestId, Bridge gibt sie ans STT-Result zurueck — App matcht jetzt punktgenau die richtige Bubble statt per Substring "Spracheingabe wird verarbeitet"
-- [x] Mikro-Offen-Toast "🎤 sprich jetzt" erscheint erst wenn audioService.startRecording wirklich erfolgreich war (statt ~400ms vorher beim Wake-Word-Detect)
 - [x] **Bereit-Sound (Airplane Ding-Dong) wenn Mikro nach Wake-Word offen** — akustische Bestaetigung statt nur Toast. Toggle in Settings → Wake-Word, default aktiv
-- [x] **Wake-Word parallel zu TTS** mit AcousticEchoCanceler: User sagt "Computer" waehrend ARIA spricht → TTS verstummt sofort, neue Aufnahme startet. Native AEC verhindert dass ARIAs eigene Stimme das Wake-Word triggert. Audio-Source ist VOICE_COMMUNICATION + zusaetzlich AEC/NS/AGC-Effekte aktiviert
+- [x] **Wake-Word parallel zu TTS** mit AcousticEchoCanceler: User sagt "Computer" waehrend ARIA spricht → TTS verstummt sofort, neue Aufnahme startet
+- [x] **GPS-Position mitsenden**: Toggle in Settings → Allgemein → Standort, persistiert in AsyncStorage. Wenn aktiv wird lat/lon mit jeder chat/audio-Message mitgegeben. Bridge prefixed den Text fuer aria-core mit GPS-Hint (mit Anweisung dass die Position nur bei Bedarf erwaehnt wird)
+- [x] **Background Audio Service**: TTS, Wake-Word-Lauschen UND Aufnahme laufen auch bei minimierter App weiter. Foreground-Service mit foregroundServiceType=mediaPlayback|microphone, persistente Notification mit dynamischem Text ("ARIA spricht" / "ARIA hoert zu" / "ARIA bereit")
+
+### Infrastruktur
+
+- [x] Watchdog mit Container-Restart (2min Warnung → 5min doctor --fix → 8min Restart)
+- [x] Nachrichten Backup on-the-fly (/shared/config/chat_backup.jsonl)
+- [x] RVS Nachrichten vom Smartphone gehen durch
+- [x] SSH Volume read-write fuer Proxy (kein -F Workaround mehr)
 
 ## Offen
 
@@ -115,9 +188,7 @@
 
 ### App Features
 - [ ] Chat-History zuverlaessiger laden (AsyncStorage Race Condition)
-- [ ] Background Audio Service (TTS auch bei minimierter App)
 - [ ] Custom-Wake-Word-Upload via Diagnostic (eigene .onnx-Files ohne App-Rebuild)
-- [ ] Pause+Resume bei Anruf: aktuell wird der TTS-Stream bei Klingeln hart gestoppt, schoener waere Pause + Resume nach Auflegen
 
 ### Architektur
 - [ ] Bilder: Claude Vision direkt nutzen (aktuell nur Dateipfad an ARIA)