release: bump version to 0.1.0.7

Stefan: ältere Nachrichten (deren Cache-WAV weg ist) gehen ueber
tts_request neu rendern → kommen als PCM-Stream zurueck → werden ueber
PcmStreamPlayer abgespielt. Beim Mute lief stopPlayback aber ohne den
Spotify-resume-Kick weil hadRnSound=false war (kein currentSound).

Jetzt: kickReleaseMedia immer in stopPlayback rufen — kostet nichts,
deckt PCM- und RNSound-Pfad ab.

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

android/App.tsx

@@ -13,6 +13,7 @@ import { createBottomTabNavigator } from '@react-navigation/bottom-tabs';
 import ChatScreen from './src/screens/ChatScreen';
 import SettingsScreen from './src/screens/SettingsScreen';
 import rvs from './src/services/rvs';
+import { initLogger } from './src/services/logger';
 
 // --- Navigation ---
 
@@ -44,6 +45,10 @@ const TAB_ICONS: Record<string, { active: string; inactive: string }> = {
 const App: React.FC = () => {
   // Beim Start: gespeicherte RVS-Konfiguration laden und verbinden
   useEffect(() => {
+    // Verbose-Logging-Setting laden BEVOR andere Module loslegen.
+    // initLogger ist async aber blockt nichts — solange er noch laueft,
+    // loggen wir normal (Default an), danach respektiert console.log das Setting.
+    initLogger().catch(() => {});
     const initConnection = async () => {
       const config = await rvs.loadConfig();
       if (config) {

android/android/app/build.gradle

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

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

@@ -131,6 +131,58 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
         promise.resolve(true)
     }
 
+    /** Den USAGE_MEDIA-Focus-Stack im System aufmischen, damit Spotify/YouTube
+     *  resumen wenn ein anderer Player (z.B. react-native-sound) seinen Focus
+     *  nicht ordnungsgemaess released hat. Strategie: kurz selbst USAGE_MEDIA
+     *  GAIN beanspruchen — das System invalidiert dabei den haengenden Stack-
+     *  Eintrag des anderen Players — und sofort wieder abandonen. Spotify
+     *  bekommt den Focus-Gain und resumed.
+     *
+     *  Workaround fuer das react-native-sound-Bug: Sound.stop()/release()
+     *  laesst den AudioFocusRequest haengen.
+     */
+    @ReactMethod
+    fun kickReleaseMedia(promise: Promise) {
+        val am = audioManager()
+        if (am == null) {
+            promise.resolve(false)
+            return
+        }
+        // Async laufen lassen — wir wollen einen request, Pause, dann abandon.
+        // Ohne Pause merkt das System (und damit Spotify) die kurze Owner-
+        // Wechsel oft gar nicht. 250ms reicht erfahrungsgemaess fuer den
+        // Focus-Stack-Refresh.
+        Thread {
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    val attrs = AudioAttributes.Builder()
+                        .setUsage(AudioAttributes.USAGE_MEDIA)
+                        .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+                        .build()
+                    val kickListener = AudioManager.OnAudioFocusChangeListener { /* ignorieren */ }
+                    val kickReq = AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+                        .setAudioAttributes(attrs)
+                        .setOnAudioFocusChangeListener(kickListener)
+                        .build()
+                    am.requestAudioFocus(kickReq)
+                    Thread.sleep(250)
+                    am.abandonAudioFocusRequest(kickReq)
+                } else {
+                    val kickListener = AudioManager.OnAudioFocusChangeListener { /* ignorieren */ }
+                    @Suppress("DEPRECATION")
+                    am.requestAudioFocus(kickListener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
+                    Thread.sleep(250)
+                    @Suppress("DEPRECATION")
+                    am.abandonAudioFocus(kickListener)
+                }
+                Log.i(TAG, "kickReleaseMedia: USAGE_MEDIA-Stack aufgemischt (250ms Pause)")
+            } catch (e: Exception) {
+                Log.w(TAG, "kickReleaseMedia failed: ${e.message}")
+            }
+        }.start()
+        promise.resolve(true)
+    }
+
     private fun release() {
         val am = audioManager() ?: return
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {

android/package.json

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

android/src/screens/SettingsScreen.tsx

@@ -51,6 +51,7 @@ import {
   TTS_SPEED_STORAGE_KEY,
 } from '../services/audio';
 import audioService from '../services/audio';
+import { isVerboseLogging, setVerboseLogging } from '../services/logger';
 import {
   isWakeReadySoundEnabled,
   setWakeReadySoundEnabled,
@@ -137,6 +138,7 @@ const SettingsScreen: React.FC = () => {
   const [showVadInfo, setShowVadInfo] = useState(false);
   const [apkCacheInfo, setApkCacheInfo] = useState<{count: number, totalMB: number} | null>(null);
   const [ttsCacheInfo, setTtsCacheInfo] = useState<{count: number, totalMB: number} | null>(null);
+  const [verboseLogging, setVerboseLoggingState] = useState<boolean>(isVerboseLogging());
   const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
   const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
   const [wakeStatus, setWakeStatus] = useState<string>('');
@@ -1291,6 +1293,28 @@ const SettingsScreen: React.FC = () => {
       {/* === Logs === */}
       {currentSection === 'protocol' && (<>
       <Text style={styles.sectionTitle}>Protokoll</Text>
+
+      {/* Verbose-Logging-Toggle */}
+      <View style={styles.card}>
+        <View style={styles.toggleRow}>
+          <Text style={styles.toggleLabel}>Verbose Logging</Text>
+          <Switch
+            value={verboseLogging}
+            onValueChange={(v) => {
+              setVerboseLogging(v);
+              setVerboseLoggingState(v);
+            }}
+            trackColor={{ false: '#3A3A52', true: '#0096FF' }}
+            thumbColor={verboseLogging ? '#FFFFFF' : '#666680'}
+          />
+        </View>
+        <Text style={styles.toggleHint}>
+          Wenn aus: console.log wird global stummgeschaltet (Speicher schonen).
+          Warnungen und Fehler bleiben immer aktiv. Bei Bedarf einschalten zum
+          Debuggen via adb logcat.
+        </Text>
+      </View>
+
       <View style={styles.card}>
         {/* Tab-Umschalter */}
         <View style={styles.tabRow}>

android/src/services/audio.ts

@@ -41,6 +41,8 @@ const { AudioFocus, PcmStreamPlayer } = NativeModules as {
     requestDuck: () => Promise<boolean>;
     requestExclusive: () => Promise<boolean>;
     release: () => Promise<boolean>;
+    kickReleaseMedia: () => Promise<boolean>;
+    getMode?: () => Promise<number>;
   };
   PcmStreamPlayer?: {
     start: (sampleRate: number, channels: number, prerollSeconds: number) => Promise<boolean>;
@@ -1189,6 +1191,12 @@ class AudioService {
 
   /** Laufende Wiedergabe stoppen + Queue leeren */
   stopPlayback(): void {
+    // Idempotent: wenn nichts mehr aktiv ist, NICHT noch einen Focus-Release/
+    // Kick-Cycle anstossen — Re-Renders triggern setMuted oft mehrfach hinter-
+    // einander, und jeder weitere Kick lässt Spotify nochmal kurz pausieren.
+    const hasAnything = !!(this.currentSound || this.resumeSound || this.preloadedSound
+                           || this.pcmStreamActive || this.audioQueue.length || this.isPlaying);
+    if (!hasAnything) return;
     console.log('[Audio] stopPlayback: currentSound=%s queue=%d pcm=%s',
                 this.currentSound ? 'aktiv' : 'null', this.audioQueue.length, this.pcmStreamActive);
     // Foreground-Service auch stoppen — sonst bleibt die Notification haengen
@@ -1224,6 +1232,10 @@ class AudioService {
     // Audio-Focus sofort freigeben — User hat explizit abgebrochen
     this._cancelDeferredFocusRelease();
     AudioFocus?.release().catch(() => {});
+    // Focus-Stack immer aufmischen — bei aelteren Nachrichten die ueber
+    // tts_request (PCM-Stream) re-rendert wurden, bleibt Spotify ohne den
+    // Kick auch pausiert. Kostet nichts, deckt beide Pfade ab.
+    AudioFocus?.kickReleaseMedia?.().catch(() => {});
   }
 
   // --- Status & Callbacks ---

android/src/services/logger.ts

@@ -0,0 +1,41 @@
+/**
+ * Verbose-Logging-Toggle: console.log laesst sich global stummschalten.
+ * console.warn/console.error bleiben immer an — Fehler will man immer sehen.
+ *
+ * Default: an (true). Toggle ueber Settings → Protokoll → Verbose Logging.
+ * Beim Start wird der gespeicherte Wert geladen, vorher loggen wir normal.
+ */
+
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export const VERBOSE_LOGGING_KEY = 'aria_verbose_logging';
+
+// Original-console.log retten, damit wir die Wrapper jederzeit wieder
+// "scharf" stellen koennen (sonst waere ein Toggle-an nach -aus tot).
+const originalLog = console.log.bind(console);
+const noop = () => {};
+
+let _verbose = true;
+
+function applyState(): void {
+  console.log = _verbose ? originalLog : noop;
+}
+
+/** Wert aus AsyncStorage laden und anwenden. Beim App-Start aufrufen. */
+export async function initLogger(): Promise<void> {
+  try {
+    const v = await AsyncStorage.getItem(VERBOSE_LOGGING_KEY);
+    _verbose = v !== 'false'; // default: true
+  } catch {}
+  applyState();
+}
+
+export function isVerboseLogging(): boolean {
+  return _verbose;
+}
+
+export function setVerboseLogging(verbose: boolean): void {
+  _verbose = verbose;
+  applyState();
+  AsyncStorage.setItem(VERBOSE_LOGGING_KEY, String(verbose)).catch(() => {});
+}