release: bump version to 0.0.2.7

fix: XTTS groups sentences into ~250 char chunks for consistent voice quality
- 2-3 sentences per chunk (more context = stable voice/volume) - Max 250 chars per chunk (keeps WebSocket packets manageable) - Dots re-added between sentences within a chunk (natural pauses) Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
2026-04-10 02:24:58 +02:00 · 2026-04-10 02:23:29 +02:00 · 2026-04-10 02:21:19 +02:00
5 changed files with 93 additions and 41 deletions
@@ -79,8 +79,8 @@ android {
        applicationId "com.ariacockpit"
        minSdkVersion rootProject.ext.minSdkVersion
        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 206
-        versionName "0.0.2.6"
+        versionCode 207
+        versionName "0.0.2.7"
        // Fallback fuer Libraries mit Product Flavors
        missingDimensionStrategy 'react-native-camera', 'general'
    }
@@ -1,6 +1,6 @@
 {
  "name": "aria-cockpit",
-  "version": "0.0.2.6",
+  "version": "0.0.2.7",
  "private": true,
  "scripts": {
    "android": "react-native run-android",
@@ -748,7 +748,7 @@ const SettingsScreen: React.FC = () => {
      <Text style={styles.sectionTitle}>{'\u00DC'}ber</Text>
      <View style={styles.card}>
        <Text style={styles.aboutTitle}>ARIA Cockpit</Text>
-        <Text style={styles.aboutVersion}>Version 0.0.2.6 </Text>
+        <Text style={styles.aboutVersion}>Version 0.0.2.7 </Text>
        <Text style={styles.aboutInfo}>
          Stefans Kommandozentrale f{'\u00FC'}r ARIA.{'\n'}
          Gebaut mit React Native + TypeScript.
@@ -58,6 +58,8 @@ class AudioService {
  // Audio-Queue fuer sequentielle TTS-Wiedergabe
  private audioQueue: string[] = [];
  private isPlaying: boolean = false;
+  private preloadedSound: Sound | null = null;
+  private preloadedPath: string = '';

  // VAD State
  private vadEnabled: boolean = false;
@@ -220,35 +222,62 @@ class AudioService {
    }

    this.isPlaying = true;
-    const base64Data = this.audioQueue.shift()!;

-    try {
-      const tmpPath = `${RNFS.CachesDirectoryPath}/aria_tts_${Date.now()}.wav`;
-      await RNFS.writeFile(tmpPath, base64Data, 'base64');
+    // Preloaded Sound verwenden wenn verfuegbar, sonst neu laden
+    let sound: Sound;
+    let soundPath: string;

-      this.currentSound = new Sound(tmpPath, '', (error) => {
-        if (error) {
-          console.error('[Audio] Fehler beim Laden:', error);
-          RNFS.unlink(tmpPath).catch(() => {});
-          this._playNext();
-          return;
-        }
-        this.currentSound?.play((success) => {
-          if (success) {
-            console.log('[Audio] Wiedergabe abgeschlossen');
-          } else {
-            console.warn('[Audio] Wiedergabe fehlgeschlagen');
-          }
-          this.currentSound?.release();
-          this.currentSound = null;
-          RNFS.unlink(tmpPath).catch(() => {});
-          // Naechstes Audio abspielen
-          this._playNext();
+    if (this.preloadedSound) {
+      sound = this.preloadedSound;
+      soundPath = this.preloadedPath;
+      this.preloadedSound = null;
+      this.preloadedPath = '';
+      // Daten aus Queue entfernen (wurde schon preloaded)
+      this.audioQueue.shift();
+    } else {
+      const base64Data = this.audioQueue.shift()!;
+      try {
+        soundPath = `${RNFS.CachesDirectoryPath}/aria_tts_${Date.now()}.wav`;
+        await RNFS.writeFile(soundPath, base64Data, 'base64');
+        sound = await new Promise<Sound>((resolve, reject) => {
+          const s = new Sound(soundPath, '', (err) => err ? reject(err) : resolve(s));
        });
-      });
-    } catch (err) {
-      console.error('[Audio] Wiedergabefehler:', err);
+      } catch (err) {
+        console.error('[Audio] Laden fehlgeschlagen:', err);
+        this._playNext();
+        return;
+      }
+    }
+
+    this.currentSound = sound;
+
+    // Naechstes Audio schon vorbereiten waehrend dieses abspielt
+    this._preloadNext();
+
+    sound.play((success) => {
+      if (!success) console.warn('[Audio] Wiedergabe fehlgeschlagen');
+      sound.release();
+      this.currentSound = null;
+      RNFS.unlink(soundPath).catch(() => {});
      this._playNext();
+    });
+  }
+
+  /** Naechstes Audio im Hintergrund vorladen (verhindert Stottern) */
+  private async _preloadNext(): Promise<void> {
+    if (this.audioQueue.length === 0 || this.preloadedSound) return;
+
+    const base64Data = this.audioQueue[0]; // Nicht shift — bleibt in Queue
+    try {
+      const tmpPath = `${RNFS.CachesDirectoryPath}/aria_tts_pre_${Date.now()}.wav`;
+      await RNFS.writeFile(tmpPath, base64Data, 'base64');
+      this.preloadedSound = await new Promise<Sound>((resolve, reject) => {
+        const s = new Sound(tmpPath, '', (err) => err ? reject(err) : resolve(s));
+      });
+      this.preloadedPath = tmpPath;
+    } catch {
+      this.preloadedSound = null;
+      this.preloadedPath = '';
    }
  }

@@ -261,6 +290,12 @@ class AudioService {
      this.currentSound.release();
      this.currentSound = null;
    }
+    if (this.preloadedSound) {
+      this.preloadedSound.release();
+      this.preloadedSound = null;
+      if (this.preloadedPath) RNFS.unlink(this.preloadedPath).catch(() => {});
+      this.preloadedPath = '';
+    }
  }

  // --- Status & Callbacks ---
@@ -100,25 +100,42 @@ async function handleTTSRequest(payload) {
  // Markdown entfernen
  const cleanText = text.replace(/\*\*([^*]+)\*\*/g, "$1").trim();

-  // Text in Saetze aufteilen (sequentiell rendern fuer korrekte Reihenfolge)
-  const sentences = cleanText.split(/(?<=[.!?])\s+/).map(s => s.trim()).filter(s => s.length > 0);
-  if (sentences.length === 0) return;
+  // Text in Saetze aufteilen, dann zu Chunks von 2-3 Saetzen zusammenfassen
+  // (mehr Kontext = konsistentere Stimme/Lautstaerke, aber nicht zu lang fuer WebSocket)
+  const sentences = cleanText.split(/(?<=[.!?])\s+/)
+    .map(s => s.trim())
+    .filter(s => s.length > 0)
+    .map(s => s.replace(/[.]+$/, '')); // Punkt am Ende entfernen

-  log(`TTS-Request: "${cleanText.slice(0, 60)}..." (${sentences.length} Saetze, voice: ${voice || "default"}, lang: ${language || "de"})`);
+  const MAX_CHUNK_CHARS = 250; // Max ~250 Zeichen pro Chunk
+  const chunks = [];
+  let currentChunk = '';
+  for (const sentence of sentences) {
+    if (currentChunk && (currentChunk.length + sentence.length + 2) > MAX_CHUNK_CHARS) {
+      chunks.push(currentChunk);
+      currentChunk = sentence;
+    } else {
+      currentChunk = currentChunk ? currentChunk + '. ' + sentence : sentence;
+    }
+  }
+  if (currentChunk) chunks.push(currentChunk);
+  if (chunks.length === 0) return;
+
+  log(`TTS-Request: "${cleanText.slice(0, 60)}..." (${sentences.length} Saetze → ${chunks.length} Chunks, voice: ${voice || "default"}, lang: ${language || "de"})`);

  try {
    const voiceSample = voice ? path.join(VOICES_DIR, `${voice}.wav`) : null;
    const hasCustomVoice = voiceSample && fs.existsSync(voiceSample);

-    // Jeden Satz sequentiell rendern und sofort senden
-    for (let i = 0; i < sentences.length; i++) {
-      const sentence = sentences[i];
+    // Jeden Chunk sequentiell rendern und sofort senden
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = chunks[i];
      try {
-        const audioBuffer = await callXTTSAPI(sentence, language || "de", hasCustomVoice ? voiceSample : null);
+        const audioBuffer = await callXTTSAPI(chunk, language || "de", hasCustomVoice ? voiceSample : null);

        if (audioBuffer && audioBuffer.length > 100) {
          const base64 = audioBuffer.toString("base64");
-          log(`TTS [${i + 1}/${sentences.length}]: ${audioBuffer.length} bytes (${(audioBuffer.length / 1024).toFixed(0)}KB) — "${sentence.slice(0, 40)}..."`);
+          log(`TTS [${i + 1}/${chunks.length}]: ${audioBuffer.length} bytes (${(audioBuffer.length / 1024).toFixed(0)}KB) — "${chunk.slice(0, 50)}..."`);

          sendToRVS({
            type: "xtts_response",
@@ -132,12 +149,12 @@ async function handleTTSRequest(payload) {
            timestamp: Date.now(),
          });
        }
-      } catch (sentenceErr) {
-        log(`TTS [${i + 1}/${sentences.length}] Fehler: ${sentenceErr.message} — ueberspringe`);
+      } catch (chunkErr) {
+        log(`TTS [${i + 1}/${chunks.length}] Fehler: ${chunkErr.message} — ueberspringe`);
      }
    }

-    log(`TTS komplett: ${sentences.length} Saetze gerendert`);
+    log(`TTS komplett: ${chunks.length} Chunks gerendert`);
  } catch (err) {
    log(`TTS Fehler: ${err.message}`);
    sendToRVS({