release: bump version to 0.0.9.0

Test mit 96000B (2s) Padding zeigte: AudioTrack stallt immer noch mit
pos=0/48000. Ab 8 Worten (~2.5s) geht's — der Hard-Threshold liegt also
zwischen 2s und 3s. Padding auf 3s, Buffer auf 4s.

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 806
+        versionCode 900
-        versionName "0.0.8.6"
+        versionName "0.0.9.0"
         // 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,16 +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
+                                // Bei kurzem Text NICHT hier play() callen — erst nach
-                                if (!playbackStarted) {
+                                // Trailing-Silence + Padding (siehe Block nach mainLoop),
-                                    try {
+                                // damit AudioTrack mit komplett gefuelltem Buffer startet.
-                                        t.play()
+                                // OnePlus A12: AudioTrack startet nicht zuverlaessig wenn
-                                        playbackStarted = true
+                                // play() bei dünnem Buffer gerufen wird.
-                                        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
                             }
                             // Underrun-Schutz: Stille reinfuettern wenn der AudioTrack-
@@ -228,6 +226,31 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                         }
                         bytesBuffered += silence.size
                     }
+                    // Bei kurzem Text (play() noch nicht gestartet): Buffer auf min.
+                    // 3s padden + DANN play(). Auf OnePlus A12 startet AudioTrack
+                    // bei < 3s Buffer-Inhalt nicht — pos bleibt auf 0 stehen.
+                    // (2s war zu wenig, 8 Worte ~2.5s gingen, 3 Worte ~1s nicht.)
+                    if (!playbackStarted && !writerShouldStop) {
+                        val minStartBytes = bytesPerSecond * 3
+                        if (bytesBuffered < minStartBytes) {
+                            val padBytes = (minStartBytes - bytesBuffered.toInt()) and 0x7FFFFFFE
+                            val pad = ByteArray(padBytes)
+                            var padOff = 0
+                            while (padOff < pad.size && !writerShouldStop) {
+                                val w = t.write(pad, padOff, pad.size - padOff)
+                                if (w <= 0) break
+                                padOff += w
+                            }
+                            bytesBuffered += pad.size
+                        }
+                        try {
+                            t.play()
+                            playbackStarted = true
+                            Log.i(TAG, "Playback gestartet (kurzer Text, ${bytesBuffered}B komplett gepuffert)")
+                        } catch (e: Exception) {
+                            Log.w(TAG, "play() short-text failed: ${e.message}")
+                        }
+                    }
                 } catch (e: Exception) {
                     Log.w(TAG, "Writer-Thread Fehler: ${e.message}")
                 } finally {
@@ -237,12 +260,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.6",
+  "version": "0.0.9.0",
   "private": true,
   "scripts": {
     "android": "react-native run-android",

android/src/services/phoneCall.ts

@@ -126,13 +126,24 @@ class PhoneCallService {
     }
   }
 
-  /** AudioFocus-Loss = irgendeine andere App hat das Mikro/die Audio-Pipeline
+  /** AudioFocus-Loss = irgendeine andere App hat den Focus uebernommen.
-   *  uebernommen — typisch VoIP-Apps bei eingehendem Anruf, aber auch System-
+   *  Das passiert bei VoIP-Anrufen (was wir wollen) ABER auch bei normalen
-   *  Voice-Assistants etc. */
+   *  Audio-Playern (anderer Player startet, Notification-Sound, sogar
-  private _onFocusChanged(type: 'loss' | 'loss_transient' | 'gain'): void {
+   *  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