release: bump version to 0.1.0.9

Logs zeigen jetzt KEINEN haengenden RNSound-Focus mehr (Library-Version
oder Sound-Lifecycle hat sich geaendert). Der Kick mit AUDIOFOCUS_GAIN
(permanent) sagte Spotify "user hat manuell etwas anderes gestartet" →
Spotify resumed nicht automatisch.

Ohne Kick: unser Focus war AUDIOFOCUS_GAIN_TRANSIENT (USAGE_ASSISTANT) —
beim release bekommt Spotify einen sauberen GAIN nach TRANSIENT-Loss
und resumed automatisch.

Native kickReleaseMedia bleibt fuer den Fall dass es nochmal gebraucht
wird, wird aber nicht mehr gerufen.

Co-Authored-By: Claude Opus 4.7 (1M context) <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 10004
-        versionName "0.1.0.4"
+        versionCode 10009
+        versionName "0.1.0.9"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }

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

@@ -148,33 +148,39 @@ class AudioFocusModule(reactContext: ReactApplicationContext) : ReactContextBase
             promise.resolve(false)
             return
         }
-        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)
-                am.abandonAudioFocusRequest(kickReq)
-            } else {
-                @Suppress("DEPRECATION")
-                val kickListener = AudioManager.OnAudioFocusChangeListener { /* ignorieren */ }
-                @Suppress("DEPRECATION")
-                am.requestAudioFocus(kickListener, AudioManager.STREAM_MUSIC, AudioManager.AUDIOFOCUS_GAIN)
-                @Suppress("DEPRECATION")
-                am.abandonAudioFocus(kickListener)
+        // 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}")
             }
-            Log.i(TAG, "kickReleaseMedia: USAGE_MEDIA-Stack aufgemischt")
-            promise.resolve(true)
-        } catch (e: Exception) {
-            Log.w(TAG, "kickReleaseMedia failed: ${e.message}")
-            promise.resolve(false)
-        }
+        }.start()
+        promise.resolve(true)
     }
 
     private fun release() {

android/package.json

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

android/src/services/audio.ts

@@ -868,11 +868,16 @@ class AudioService {
     final?: boolean;
     silent?: boolean;
   }): Promise<string> {
+    // _stoppedMessageId: User hat diese Antwort mid-Wiedergabe gestoppt
+    // (Mute geklickt). Auch wenn Mute jetzt wieder aus ist, soll diese
+    // Antwort nicht weiterspielen. Erst eine neue messageId resetted das.
+    const incomingMsgId = payload.messageId || '';
+    const stoppedByUser = !!this._stoppedMessageId && incomingMsgId === this._stoppedMessageId;
     // Globaler Mute-Flag uebersteuert das per-Call silent — verhindert
     // Race-Conditions wenn der User zwischen Chunks den Mute-Knopf drueckt.
     // _pausedForCall: AudioTrack ist gestoppt waehrend Anruf — Chunks weiter
     // sammeln (fuer WAV-Cache), aber NICHT in den Player schicken.
-    const silent = !!payload.silent || this._muted || this._pausedForCall;
+    const silent = !!payload.silent || this._muted || this._pausedForCall || stoppedByUser;
     if (!silent && !PcmStreamPlayer) {
       console.warn('[Audio] PcmStreamPlayer Native Module nicht verfuegbar');
       return '';
@@ -913,6 +918,13 @@ class AudioService {
         this.pausedMessageId = '';
         this.pausedPosition = 0;
       }
+      // Stop-Marker zuruecksetzen wenn neue messageId — neue Antwort darf
+      // wieder normal abspielen, egal ob Mute zwischendurch aktiv war.
+      if (this._stoppedMessageId && this._stoppedMessageId !== messageId) {
+        console.log('[Audio] Neue Antwort (msgId=%s) — Stop-Marker fuer %s zurueckgesetzt',
+                    messageId, this._stoppedMessageId);
+        this._stoppedMessageId = '';
+      }
       this.pcmStreamActive = true;
       this.pcmMessageId = messageId;
       this.pcmSampleRate = sampleRate;
@@ -1181,16 +1193,37 @@ class AudioService {
    *  abgespielt. Wird in pauseForCall gesetzt, in endCallPause/resumeFrom-
    *  Interruption zurueckgenommen. */
   private _pausedForCall: boolean = false;
+  /** Wenn der User mid-Wiedergabe Mute drueckt: messageId der ABGEBROCHENEN
+   *  Antwort merken. Folge-Chunks dieser msgId werden silent ignoriert, auch
+   *  wenn der User Mute wieder ausschaltet — kein "Resume mid-Antwort". Eine
+   *  NEUE messageId resetted das, dann spielt's wieder normal. */
+  private _stoppedMessageId: string = '';
   setMuted(muted: boolean): void {
     console.log('[Audio] setMuted: %s (currentSound=%s pcmStreamActive=%s)',
                 muted, this.currentSound ? 'aktiv' : 'null', this.pcmStreamActive);
     this._muted = muted;
-    if (muted) this.stopPlayback();
+    if (muted) {
+      // Aktuell laufende Antwort als "verworfen" markieren — nachfolgende
+      // chunks dieser msgId werden silent gehalten auch wenn der User Mute
+      // gleich wieder ausschaltet. Erst eine NEUE Antwort darf wieder reden.
+      const activeMsgId = this.pcmMessageId || this.currentPlaybackMsgId;
+      if (activeMsgId) {
+        this._stoppedMessageId = activeMsgId;
+        console.log('[Audio] Antwort %s als gestoppt markiert', activeMsgId);
+      }
+      this.stopPlayback();
+    }
   }
   isMuted(): boolean { return this._muted; }
 
   /** 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
@@ -1198,10 +1231,6 @@ class AudioService {
     stopBackgroundAudio().catch(() => {});
     this.audioQueue = [];
     this.isPlaying = false;
-    // Merken: war ein react-native-sound-Sound aktiv? Dann muessen wir nach
-    // release() den Focus-Stack aufmischen (RNSound-Bug: stop+release laesst
-    // den AudioFocusRequest haengen, Spotify resumed sonst nicht).
-    const hadRnSound = !!(this.currentSound || this.resumeSound || this.preloadedSound);
     if (this.currentSound) {
       this.currentSound.stop();
       this.currentSound.release();
@@ -1227,14 +1256,13 @@ class AudioService {
     this.pcmBuffer = [];
     this.pcmBytesCollected = 0;
     this.pcmMessageId = '';
-    // Audio-Focus sofort freigeben — User hat explizit abgebrochen
+    // Audio-Focus sofort freigeben — User hat explizit abgebrochen.
+    // Unser Focus war TRANSIENT, Spotify resumed darum automatisch beim
+    // Abandon. Den frueheren kickReleaseMedia haben wir entfernt: er
+    // requestete USAGE_MEDIA mit GAIN (permanent), was Spotify als
+    // "user-action stopp" interpretierte und Auto-Resume verhinderte.
     this._cancelDeferredFocusRelease();
     AudioFocus?.release().catch(() => {});
-    if (hadRnSound) {
-      // RNSound's haengender USAGE_MEDIA-Focus aufloesen — sonst bleibt
-      // Spotify pausiert obwohl unser Focus released ist.
-      AudioFocus?.kickReleaseMedia?.().catch(() => {});
-    }
   }
 
   // --- Status & Callbacks ---