release: bump version to 0.0.9.2

pcmStreamActive wurde beim isFinal-Chunk schon auf false gesetzt, der
AudioTrack spielte aber noch aus seinem Buffer (kann sekundenlang sein).
stopPlayback() uebersprang darum PcmStreamPlayer.stop() — ARIA redete
weiter obwohl Spotify schon resumed war.

Fix: stop() immer rufen, der Flag-Check faellt weg (ist eh idempotent).

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 807
+        versionCode 902
-        versionName "0.0.8.7"
+        versionName "0.0.9.2"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }

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

@@ -78,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 ~4s-Buffer. OnePlus A12
+            // mit USAGE_ASSISTANT laeuft AudioTrack erst ab ~3s gepufferter
+            // Daten an. Wir padden Kurztexte vor play() auf 3s (siehe Block
+            // nach mainLoop), Buffer braucht ~1s Headroom weil write() blockt.
+            val bufferSize = (bytesPerSecond * 4).coerceAtLeast(minBuf * 8)
             prerollBytes = prerollTarget
             bytesBuffered = 0
             playbackStarted = false
@@ -156,15 +159,11 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS)
                         if (data == null) {
                             if (endRequested) {
-                                // Falls wir vor Pre-Roll enden (kurzer Text): trotzdem abspielen
+                                // Falls play() noch gar nicht lief (Stream ohne data
+                                // ueberhaupt — sehr seltene Edge-Case): jetzt anstossen
+                                // damit das finally{}-Wait nicht endlos blockt.
                                 if (!playbackStarted) {
-                                    try {
+                                    try { t.play(); playbackStarted = true } catch (_: Exception) {}
-                                        t.play()
-                                        playbackStarted = true
-                                        Log.i(TAG, "Playback gestartet VOR Pre-Roll (kurzer Text, ${bytesBuffered}B gepuffert)")
-                                    } catch (e: Exception) {
-                                        Log.w(TAG, "play() fallback failed: ${e.message}")
-                                    }
                                 }
                                 break@mainLoop
                             }
@@ -196,12 +195,16 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         }
                         idleMs = 0L
 
-                        // Pre-Roll Check: play() erst wenn genug gepuffert
+                        // play() beim ALLERERSTEN data-chunk aufrufen — egal wie wenig
-                        if (!playbackStarted && bytesBuffered + data.size >= prerollBytes) {
+                        // Daten da sind. Sonst stallt AudioTrack auf OnePlus A12 wenn
+                        // play() erst gerufen wird nachdem der Buffer komplett gefuellt
+                        // ist. Pre-Roll als "Vorrat aufbauen" passiert dann waehrend
+                        // der Track schon spielt — Underrun-Schutz fuettert ggf. Stille.
+                        if (!playbackStarted) {
                             try {
                                 t.play()
                                 playbackStarted = true
-                                Log.i(TAG, "Playback gestartet nach Pre-Roll ${bytesBuffered + data.size} Bytes")
+                                Log.i(TAG, "Playback gestartet beim 1. Chunk (${bytesBuffered}B leading + ${data.size}B data)")
                             } catch (e: Exception) {
                                 Log.w(TAG, "play() failed: ${e.message}")
                             }
@@ -237,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

android/package.json

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

android/src/services/audio.ts

@@ -1098,14 +1098,15 @@ class AudioService {
       if (this.preloadedPath) RNFS.unlink(this.preloadedPath).catch(() => {});
       this.preloadedPath = '';
     }
-    // PCM-Stream ebenfalls hart stoppen (Cancel/Abbruch)
+    // PCM-Stream ebenfalls hart stoppen (Cancel/Abbruch).
-    if (this.pcmStreamActive) {
+    // pcmStreamActive wird beim isFinal-Chunk schon false gesetzt — der
-      PcmStreamPlayer?.stop().catch(() => {});
+    // AudioTrack spielt aber noch sekundenlang aus seinem Buffer ab. Daher
-      this.pcmStreamActive = false;
+    // IMMER stop() aufrufen, ohne den Flag zu pruefen (ist idempotent).
-      this.pcmBuffer = [];
+    PcmStreamPlayer?.stop().catch(() => {});
-      this.pcmBytesCollected = 0;
+    this.pcmStreamActive = false;
-      this.pcmMessageId = '';
+    this.pcmBuffer = [];
-    }
+    this.pcmBytesCollected = 0;
+    this.pcmMessageId = '';
     // Audio-Focus sofort freigeben — User hat explizit abgebrochen
     this._cancelDeferredFocusRelease();
     AudioFocus?.release().catch(() => {});