release: bump version to 0.2.1.0

Zwei Fehler: (1) War der PCM-Stream schon komplett empfangen (isFinal durch),
sind pcmStreamActive+isPlaying false — der AudioTrack spielt aber seinen
Buffer noch sekundenlang aus. stopPlayback() returnte dann früh ("nichts
aktiv") und rief PcmStreamPlayer.stop() NIE → Mund-Button wirkungslos.
(2) stopPlayback() wirft pcmBuffer weg → die Cache-WAV waere unvollstaendig,
Nachhoeren via Lautsprecher-Symbol kaputt.

Neue _silenceAudibleOutput(): stoppt den AudioTrack IMMER (auch im Drain-Fall),
laesst aber pcmBuffer/pcmMessageId/pcmStreamActive stehen — restliche Chunks
cachen stumm weiter, isFinal schreibt die vollstaendige WAV. setMuted(true)
nutzt das statt stopPlayback(). stopPlayback bleibt fuer Barge-In/Cancel.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

android/android/app/build.gradle

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

android/package.json

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

android/src/screens/ChatScreen.tsx

@@ -1212,11 +1212,10 @@ const ChatScreen: React.FC = () => {
         const _isSilent = (message.payload as any).speak === false
           || ((message.payload as any).answeredBy === 'fast-path');
         if (_isSilent && wakeWordService.isConversing()) {
-          if (AppState.currentState === 'active') {
-            wakeWordService.resume();
-          } else {
-            wakeWordService.endConversation().catch(() => {});
-          }
+          // Klarer Steuerbefehl (Liedersteuerung etc.) = KEINE Konversation →
+          // STOP: direkt zurueck aufs Wake-Word. Kein Gong, keine Aufnahme,
+          // kein 30s-Fenster (skipPassive=true).
+          wakeWordService.endConversation(true).catch(() => {});
         }
       }
 
@@ -1446,12 +1445,11 @@ const ChatScreen: React.FC = () => {
   useEffect(() => {
     const unsubPlayback = audioService.onPlaybackFinished(() => {
       if (!wakeWordService.isActive()) return;
-      if (AppState.currentState === 'active') {
-        wakeWordService.resume();
-      } else {
-        console.log('[Chat] TTS fertig im Background → endConversation (kein Multi-Turn)');
-        wakeWordService.endConversation().catch(() => {});
-      }
+      // Gespraech (gesprochene Antwort): KEIN neuer Gong / kein Aufnahme-Fenster,
+      // sondern direkt passives Lauschen (30s weiterreden wie mit einem Menschen).
+      // Im Hintergrund gibt's kein Multi-Turn → direkt re-armen (skipPassive).
+      const bg = AppState.currentState !== 'active';
+      wakeWordService.endConversation(bg).catch(() => {});
     });
     return () => unsubPlayback();
   }, []);
@@ -2072,7 +2070,7 @@ const ChatScreen: React.FC = () => {
     await audioService.stopStreamingRecording('user');
     if (wakeWordService.isConversing()) {
       console.log('[Chat] Manueller Stop in Konversation → endConversation, zurueck zu armed');
-      await wakeWordService.endConversation();
+      await wakeWordService.endConversation(true);  // explizit gestoppt → STOP (kein 30s-Passiv)
     }
   }, []);
 

android/src/screens/SettingsScreen.tsx

@@ -105,6 +105,14 @@ import wakeWordService, {
   KEYWORD_LABELS,
   DEFAULT_KEYWORD,
   WAKE_KEYWORD_STORAGE,
+  WAKE_THRESHOLD_DEFAULT,
+  WAKE_THRESHOLD_MIN,
+  WAKE_THRESHOLD_MAX,
+  loadWakeThreshold,
+  saveWakeThreshold,
+  PASSIVE_LISTEN_DEFAULT_MS,
+  loadPassiveListenMs,
+  savePassiveListenMs,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
 import QRScanner from '../components/QRScanner';
@@ -200,6 +208,8 @@ const SettingsScreen: React.FC = () => {
   const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
   const [wakeStatus, setWakeStatus] = useState<string>('');
   const [wakeReadySound, setWakeReadySound] = useState<boolean>(true);
+  const [wakeThreshold, setWakeThreshold] = useState<number>(WAKE_THRESHOLD_DEFAULT);
+  const [passiveSec, setPassiveSec] = useState<number>(Math.round(PASSIVE_LISTEN_DEFAULT_MS / 1000));
   const [editingPath, setEditingPath] = useState(false);
   const [xttsVoice, setXttsVoice] = useState('');
   const [loadingVoice, setLoadingVoice] = useState<string | null>(null);
@@ -322,6 +332,8 @@ const SettingsScreen: React.FC = () => {
       if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
     });
     isWakeReadySoundEnabled().then(setWakeReadySound);
+    loadWakeThreshold().then(setWakeThreshold).catch(() => {});
+    loadPassiveListenMs().then(ms => setPassiveSec(Math.round(ms / 1000))).catch(() => {});
     updateService.getApkCacheSize().then(setApkCacheInfo).catch(() => {});
     audioService.getTtsCacheSize().then(setTtsCacheInfo).catch(() => {});
     AsyncStorage.getItem('aria_xtts_voice').then(saved => {
@@ -1862,6 +1874,40 @@ const SettingsScreen: React.FC = () => {
           ))}
         </View>
 
+        <Text style={[styles.toggleLabel, {marginTop: 20}]}>Empfindlichkeit</Text>
+        <Text style={styles.toggleHint}>
+          Wie leicht das Wake-Word anspringt. Hoeher = strenger = weniger
+          Fehlauslösung (z.B. durch Musik/Radio, die das Mikro mithoert — der
+          Echo-Canceler kann nur ARIAs eigene Stimme rausrechnen, nicht Spotify),
+          aber du musst evtl. deutlicher sprechen. Default: {WAKE_THRESHOLD_DEFAULT.toFixed(2)}.
+          Wird beim „Speichern + Aktivieren" uebernommen.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.max(WAKE_THRESHOLD_MIN, Math.round((wakeThreshold - 0.05) * 100) / 100);
+              setWakeThreshold(next);
+              saveWakeThreshold(next);
+            }}
+            disabled={wakeThreshold <= WAKE_THRESHOLD_MIN}
+          >
+            <Text style={styles.prerollButtonText}>−0.05</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>{wakeThreshold.toFixed(2)}</Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.min(WAKE_THRESHOLD_MAX, Math.round((wakeThreshold + 0.05) * 100) / 100);
+              setWakeThreshold(next);
+              saveWakeThreshold(next);
+            }}
+            disabled={wakeThreshold >= WAKE_THRESHOLD_MAX}
+          >
+            <Text style={styles.prerollButtonText}>+0.05</Text>
+          </TouchableOpacity>
+        </View>
+
         <View style={{flexDirection: 'row', gap: 8, marginTop: 16, alignItems: 'center'}}>
           <TouchableOpacity
             style={[styles.connectButton, {flex: 1}]}
@@ -1907,6 +1953,39 @@ const SettingsScreen: React.FC = () => {
             thumbColor={wakeReadySound ? '#FFFFFF' : '#666680'}
           />
         </View>
+
+        <Text style={[styles.toggleLabel, {marginTop: 20}]}>Weiterreden-Fenster (Gespraech)</Text>
+        <Text style={styles.toggleHint}>
+          Nach einer gesprochenen ARIA-Antwort kannst du so lange einfach
+          weiterreden — ohne Wake-Word — bevor zurueck aufs Wake-Word geschaltet
+          wird. Reine Steuerbefehle (z.B. „nächster Titel") beenden sofort.
+          Default: {Math.round(PASSIVE_LISTEN_DEFAULT_MS / 1000)}s.
+        </Text>
+        <View style={styles.prerollRow}>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.max(10, passiveSec - 5);
+              setPassiveSec(next);
+              savePassiveListenMs(next * 1000);
+            }}
+            disabled={passiveSec <= 10}
+          >
+            <Text style={styles.prerollButtonText}>−5</Text>
+          </TouchableOpacity>
+          <Text style={styles.prerollValue}>{passiveSec} s</Text>
+          <TouchableOpacity
+            style={styles.prerollButton}
+            onPress={() => {
+              const next = Math.min(60, passiveSec + 5);
+              setPassiveSec(next);
+              savePassiveListenMs(next * 1000);
+            }}
+            disabled={passiveSec >= 60}
+          >
+            <Text style={styles.prerollButtonText}>+5</Text>
+          </TouchableOpacity>
+        </View>
       </View>
       </>)}
 

android/src/services/audio.ts

@@ -1731,11 +1731,39 @@ class AudioService {
         this._stoppedMessageId = activeMsgId;
         console.log('[Audio] Antwort %s als gestoppt markiert', activeMsgId);
       }
-      this.stopPlayback();
+      // NUR die hoerbare Wiedergabe stoppen — Cache-Buffer behalten, damit die
+      // Nachricht spaeter ueber das Lautsprecher-Symbol nachgehoert werden kann.
+      this._silenceAudibleOutput();
     }
   }
   isMuted(): boolean { return this._muted; }
 
+  /** Mund-Button: laufendes Vorlesen SOFORT verstummen lassen, aber den
+   *  PCM-Cache NICHT verwerfen (der Stream cached zu Ende → Nachhoeren via
+   *  Lautsprecher-Symbol bleibt moeglich). Unterschied zu stopPlayback():
+   *  - stopt den AudioTrack IMMER (auch wenn pcmStreamActive schon false ist,
+   *    weil der Stream fertig empfangen wurde aber der AudioTrack seinen Buffer
+   *    noch sekundenlang ausspielt — genau da war der Mund-Button wirkungslos),
+   *  - laesst pcmBuffer/pcmMessageId/pcmStreamActive stehen (Cache laeuft weiter). */
+  private _silenceAudibleOutput(): void {
+    console.log('[Audio] _silenceAudibleOutput: AudioTrack+WAV stoppen, Cache behalten');
+    this.audioQueue = [];
+    this.isPlaying = false;
+    if (this.currentSound) {
+      try { this.currentSound.stop(); this.currentSound.release(); } catch {}
+      this.currentSound = null;
+    }
+    if (this.resumeSound) {
+      try { this.resumeSound.stop(); this.resumeSound.release(); } catch {}
+      this.resumeSound = null;
+    }
+    // AudioTrack IMMER hart stoppen (idempotent) — auch im Drain-Fall.
+    PcmStreamPlayer?.stop().catch(() => {});
+    stopBackgroundAudio().catch(() => {});
+    this._cancelDeferredFocusRelease();
+    AudioFocus?.release().catch(() => {});
+  }
+
   /** Laufende Wiedergabe stoppen + Queue leeren */
   stopPlayback(): void {
     // Idempotent: wenn nichts mehr aktiv ist, NICHT noch einen Focus-Release/

android/src/services/wakeword.ts

@@ -53,6 +53,30 @@ export async function savePassiveListenMs(ms: number): Promise<void> {
 
 export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';
 
+// Wake-Word-Empfindlichkeit (openWakeWord-Threshold). Hoeher = strenger =
+// weniger Fehlauslösung (z.B. durch Musik/Radio ueber die Auto-Lautsprecher,
+// die das Mikro mithoert — der App-Echo-Canceler kann nur ARIAs eigenes TTS
+// rausrechnen, NICHT Spotify). Default 0.6 (war 0.5). 0..1.
+export const WAKE_THRESHOLD_DEFAULT = 0.6;
+export const WAKE_THRESHOLD_MIN = 0.3;
+export const WAKE_THRESHOLD_MAX = 0.9;
+export const WAKE_THRESHOLD_STORAGE_KEY = 'aria_wake_threshold';
+
+export async function loadWakeThreshold(): Promise<number> {
+  try {
+    const raw = await AsyncStorage.getItem(WAKE_THRESHOLD_STORAGE_KEY);
+    if (raw != null) {
+      const n = parseFloat(raw);
+      if (isFinite(n) && n >= WAKE_THRESHOLD_MIN && n <= WAKE_THRESHOLD_MAX) return n;
+    }
+  } catch {}
+  return WAKE_THRESHOLD_DEFAULT;
+}
+
+export async function saveWakeThreshold(v: number): Promise<void> {
+  await AsyncStorage.setItem(WAKE_THRESHOLD_STORAGE_KEY, String(v));
+}
+
 /** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
  *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
  *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
@@ -76,8 +100,9 @@ export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
   hey_rhasspy: 'Hey Rhasspy',
 };
 
-// Detection-Tuning — kann in Settings spaeter konfigurierbar werden.
-const DEFAULT_THRESHOLD = 0.5;
+// Detection-Tuning. Threshold ist ueber die Settings konfigurierbar
+// (loadWakeThreshold) — der Wert hier ist nur der Fallback.
+const DEFAULT_THRESHOLD = WAKE_THRESHOLD_DEFAULT;
 const DEFAULT_PATIENCE = 2;
 const DEFAULT_DEBOUNCE_MS = 1500;
 
@@ -197,7 +222,9 @@ class WakeWordService {
     if (this.initInProgress) return this.initInProgress;
     this.initInProgress = (async () => {
       try {
-        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
+        const threshold = await loadWakeThreshold();
+        console.log('[WakeWord] init mit threshold=%s', threshold);
+        await OpenWakeWord.init(this.keyword, threshold, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
         // Subscribe nur einmal
         if (!this.eventSub) {
           const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
@@ -441,7 +468,10 @@ class WakeWordService {
    *  wuerde sonst OpenWakeWord.stop() rufen weil bargeListening noch true
    *  ist, und unseren frisch re-armierten Listener killen.
    */
-  async endConversation(): Promise<void> {
+  /** @param skipPassive true = KEIN passives Lauschen, direkt zurueck aufs
+   *  Wake-Word (armed). Fuer klare Steuerbefehle (Fast-Path) — nach
+   *  "nächster Titel" will Stefan kein 30s-Fenster, sondern Stop. */
+  async endConversation(skipPassive: boolean = false): Promise<void> {
     if (this.state !== 'conversing') {
       import('./logger').then(m => m.reportAppDebug('wake.end',
         `endConversation called but state=${this.state} → noop`)).catch(()=>{});
@@ -461,7 +491,7 @@ class WakeWordService {
     // (Phase 3) filtert fremde Stimmen weg, der User kann ohne erneute
     // Anrede weitersprechen.
     const passiveMs = await loadPassiveListenMs();
-    if (passiveMs > 0 && this.nativeReady) {
+    if (!skipPassive && passiveMs > 0 && this.nativeReady) {
       this.enterPassiveListening(passiveMs);
       return;
     }