release: bump version to 0.1.8.8

Wake-Word-Listener nach jeder Konversation

Aus dem Log diagnostiziert: zwei onPlaybackFinished-Listener feuern
direkt hintereinander wenn TTS endet:
  1. mein neuer Listener (Background): endConversation()
     → state=armed, OpenWakeWord.start() (idempotent)
  2. existierender Listener:           stopBargeListening()
     → bargeListening=true → OpenWakeWord.stop()  ← killt re-armed Listener

State zeigte 'armed' (UI: Ohr-Icon ausgefuellt, sieht aktiv aus), aber
das Native-Modul war gestoppt → Stefan's "Computer" verpufft.

Fix: endConversation setzt bargeListening=false BEVOR Native gerufen
wird. stopBargeListening checkt das Flag oben:
  async stopBargeListening() { if (!this.bargeListening) return; ... }
→ wird zum No-Op wenn endConversation schon gelaufen ist.

Bonus: OpenWakeWord.start() darf jetzt auch gerufen werden wenn der
Listener via barge-listening schon lief — Kotlin checkt running.get()
und resolved idempotent. Sicherer als state-vorher-Check.

android/android/app/build.gradle

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

android/package.json

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

android/src/screens/ChatScreen.tsx

@@ -1263,11 +1263,30 @@ const ChatScreen: React.FC = () => {
     return () => { unsubUpdate(); clearTimeout(timer); };
   }, []);
 
-  // Gespraechsmodus: Nach TTS-Wiedergabe automatisch Aufnahme starten
+  // Gespraechsmodus: Nach TTS-Wiedergabe weiter im Multi-Turn (Conversation-
+  // Window) oder zurueck zu armed (Wake-Word lauscht wieder)?
+  //
+  //   Foreground   → resume() oeffnet das Mikro fuer N Sekunden Follow-Up
+  //                  (natuerlicher Dialog moeglich ohne erneutes "Computer")
+  //   Background   → endConversation() — Wake-Word direkt wieder armed.
+  //
+  // Grund: der setTimeout(800ms) in resume() wird im Doze stark verzoegert
+  // (siehe Wake-Detect-Bug von 0.1.7.0). Das hat zwei nervige Folgen:
+  //   1) Wake-Word ist solange "tot" — User kann ARIA nicht mehr triggern
+  //      bis er die App vorholt
+  //   2) Wenn er die App dann vorholt, oeffnet der verspaetete Timer das
+  //      Mikro — sieht aus wie ein Phantom-Wake-Word-Trigger
+  // Background = User nutzt das Handy anderweitig, das Multi-Turn-Konzept
+  // ist da eh nicht nuetzlich. Direkt re-armen ist robust und erwartungs-
+  // konform.
   useEffect(() => {
     const unsubPlayback = audioService.onPlaybackFinished(() => {
-      if (wakeWordService.isActive()) {
+      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(() => {});
       }
     });
     return () => unsubPlayback();

android/src/screens/SettingsScreen.tsx

@@ -497,6 +497,49 @@ const SettingsScreen: React.FC = () => {
         })();
       }
 
+      // Datei-Manager: Einzel-Datei-Download. ChatScreen subscribet auch auf
+      // file_response — der versucht aber nur Chat-Bubble-Attachments zu
+      // patchen und macht nix wenn die requestId nicht zu einer Nachricht
+      // passt. Hier behandeln wir die Manager-initiierten Downloads
+      // (requestId-Praefix 'single-' aus bulkDownload). Schreibt nach
+      // ~/Download/ wie der ZIP-Pfad.
+      if (message.type === ('file_response' as any)) {
+        const p: any = message.payload || {};
+        const reqId = (p.requestId as string) || '';
+        if (!reqId.startsWith('single-')) return; // nicht unsere Anfrage
+        if (p.error) {
+          ToastAndroid.show('Download fehlgeschlagen: ' + p.error, ToastAndroid.LONG);
+          return;
+        }
+        const b64 = (p.base64 as string) || '';
+        if (!b64) return;
+        const fileName = (p.name as string) ||
+                         (p.serverPath as string || '').split('/').pop() ||
+                         'aria-download';
+        (async () => {
+          try {
+            const dir = RNFS.DownloadDirectoryPath;
+            const filePath = `${dir}/${fileName}`;
+            // Falls Datei schon existiert: Suffix anhaengen damit nichts
+            // ueberschrieben wird.
+            let target = filePath;
+            let i = 1;
+            while (await RNFS.exists(target)) {
+              const dot = fileName.lastIndexOf('.');
+              const base = dot > 0 ? fileName.slice(0, dot) : fileName;
+              const ext = dot > 0 ? fileName.slice(dot) : '';
+              target = `${dir}/${base} (${i})${ext}`;
+              i++;
+            }
+            await RNFS.writeFile(target, b64, 'base64');
+            const sizeKb = Math.round(((b64.length * 0.75)) / 1024);
+            ToastAndroid.show(`Gespeichert: ${target.split('/').pop()} (${sizeKb} KB)`, ToastAndroid.LONG);
+          } catch (e: any) {
+            ToastAndroid.show('Speichern fehlgeschlagen: ' + e.message, ToastAndroid.LONG);
+          }
+        })();
+      }
+
       // Voice wurde gespeichert → Liste neu laden + ggf. auswaehlen
       if (message.type === ('xtts_voice_saved' as any)) {
         const name = (message.payload as any).name as string;

android/src/services/audio.ts

@@ -341,8 +341,21 @@ class AudioService {
       try {
         const emitter = new NativeEventEmitter(NativeModules.PcmStreamPlayer as any);
         emitter.addListener('PcmPlaybackFinished', () => {
-          console.log('[Audio] PcmPlaybackFinished — Focus jetzt freigeben');
+          console.log('[Audio] PcmPlaybackFinished — AudioTrack drained');
           this._releaseFocusDeferred();
+          // Erst HIER playbackFinished-Listener feuern — nicht schon beim
+          // Empfang des letzten PCM-Chunks (siehe handlePcmChunk). AudioTrack
+          // braucht nach end() noch 1-2s zum Drainen seines Hardware-Buffers.
+          // Wenn wir die Listener zu frueh feuern, re-armt OpenWakeWord
+          // waehrend ARIA noch hoerbar spricht → ARIAs Stimme verwirrt die
+          // Wake-Word-Detection (kein gemeinsames AEC zwischen AudioTrack-
+          // und AudioRecord-Session). Stefan-Reproduktion: nach jeder ARIA-
+          // Antwort schluckte das Wake-Word den naechsten Trigger.
+          import('./logger').then(m => m.reportAppDebug('audio.playback',
+            'PcmPlaybackFinished native event → fire listeners')).catch(()=>{});
+          this.playbackFinishedListeners.forEach(cb => {
+            try { cb(); } catch (e) { console.warn('[Audio] playbackFinished cb err:', e); }
+          });
         });
       } catch (err) {
         console.warn('[Audio] PcmPlaybackFinished-Subscription fehlgeschlagen:', err);
@@ -1368,12 +1381,13 @@ class AudioService {
         // releasen den AudioFocus NICHT hier — der writer braucht u.U. noch
         // 30+ Sekunden bis der Buffer wirklich abgespielt ist. Den release
         // triggert das native Event "PcmPlaybackFinished" wenn AudioTrack
-        // wirklich am Ende ist (siehe ensurePlaybackFinishedListener).
+        // wirklich am Ende ist (siehe Constructor-PcmPlaybackFinished-Handler).
+        //
+        // playbackFinishedListeners feuern AUCH erst dort — frueher feuerten
+        // sie hier (beim Eintreffen des letzten Chunks), das fuehrte zu
+        // einem Race: OpenWakeWord re-armte waehrend AudioTrack noch hoerbar
+        // ARIAs Stimme abspielte → naechstes Wake-Word ging unter.
         try { await PcmStreamPlayer!.end(); } catch {}
-        // playbackFinished-Listener informieren (UI-Logik)
-        this.playbackFinishedListeners.forEach(cb => {
-          try { cb(); } catch (e) { console.warn('[Audio] playbackFinished cb err:', e); }
-        });
       }
       this.pcmStreamActive = false;
 

android/src/services/wakeword.ts

@@ -344,21 +344,51 @@ class WakeWordService {
   /** Konversation beenden — User hat im Window nichts gesagt.
    *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
    *  Ohne: zurueck zu 'off'.
+   *
+   *  WICHTIG: setzt bargeListening=false BEVOR OpenWakeWord.start() laeuft.
+   *  Grund: wenn endConversation aus dem onPlaybackFinished-Handler kommt,
+   *  feuert direkt danach ein zweiter Listener (stopBargeListening) — der
+   *  wuerde sonst OpenWakeWord.stop() rufen weil bargeListening noch true
+   *  ist, und unseren frisch re-armierten Listener killen.
    */
   async endConversation(): Promise<void> {
-    if (this.state !== 'conversing') return;
+    if (this.state !== 'conversing') {
+      import('./logger').then(m => m.reportAppDebug('wake.end',
+        `endConversation called but state=${this.state} → noop`)).catch(()=>{});
+      return;
+    }
+    const wasBarge = this.bargeListening;
+    // Flag NULLEN bevor wir die Listener triggern. Sonst killt der parallele
+    // stopBargeListening-Listener (TTS-end) gleich danach unseren Native-
+    // OpenWakeWord, weil er bargeListening=true sieht und annimmt er muss
+    // den Listener stoppen.
+    this.bargeListening = false;
+    import('./logger').then(m => m.reportAppDebug('wake.end',
+      `endConversation called, wasBarge=${wasBarge}, nativeReady=${this.nativeReady}`)).catch(()=>{});
     if (this.nativeReady && OpenWakeWord) {
+      // Wenn wakeword schon laeuft (war Barge-Listener waehrend TTS):
+      // OpenWakeWord.start() ist idempotent (Kotlin checkt running.get()
+      // und resolved sofort). Wir koennen es trotzdem rufen — billiger
+      // als state extra zu fragen, garantiert dass nach diesem Pfad
+      // Native auch wirklich an ist falls es out-of-band gestoppt wurde.
       try {
         await OpenWakeWord.start();
-        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
+        console.log('[WakeWord] Konversation zu Ende — zurueck zu armed (wasBarge=%s)', wasBarge);
+        import('./logger').then(m => m.reportAppDebug('wake.end',
+          `OpenWakeWord.start() OK → state=armed, wasBarge=${wasBarge}`)).catch(()=>{});
         ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return;
-      } catch (err) {
+      } catch (err: any) {
         console.warn('[WakeWord] re-arm fehlgeschlagen:', err);
+        import('./logger').then(m => m.reportAppDebug('wake.end',
+          `OpenWakeWord.start() FAIL: ${err?.message || err} → state=off`,
+          )).catch(()=>{});
       }
     }
     console.log('[WakeWord] Konversation zu Ende — Ohr aus');
+    import('./logger').then(m => m.reportAppDebug('wake.end',
+      `fallback: nativeReady=${this.nativeReady} → state=off`)).catch(()=>{});
     ToastAndroid.show('Mikro aus', ToastAndroid.SHORT);
     this.setState('off');
   }