README.md

@@ -380,7 +380,6 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 - Text-Chat mit ARIA
 - **Sprachaufnahme**: Push-to-Talk (halten) oder Tap-to-Talk (tippen, Auto-Stop bei Stille)
 - **Gespraechsmodus** (Ohr-Button): Nach jeder ARIA-Antwort startet automatisch die Aufnahme — wie ein natuerliches Gespraech hin und her
-- **Wake-Word** (on-device, openWakeWord ONNX): "Hey Jarvis", "Alexa", "Hey Mycroft", "Hey Rhasspy" — Mikrofon hoert passiv mit, Konversation startet beim Schluesselwort. Komplett on-device via ONNX Runtime, kein API-Key, kein Cloud-Roundtrip, Audio verlaesst das Geraet nicht.
 - **VAD (Voice Activity Detection)**: Konfigurierbare Stille-Toleranz (1.0–8.0s, Default 2.8s) bevor Auto-Stop greift. Max-Aufnahme 120s.
 - **Speech Gate**: Aufnahme wird verworfen wenn keine Sprache erkannt
 - **STT (Speech-to-Text)**: 16kHz mono → Bridge → Gamebox-Whisper (CUDA) → Text im Chat. Fast in Echtzeit.
@@ -399,45 +398,6 @@ API-Endpoint fuer andere Services: `GET http://localhost:3001/api/session`
 - GPS-Position (optional)
 - QR-Code Scanner fuer Token-Pairing
 
-### Wake-Word (openWakeWord, on-device)
-
-Wake-Word-Erkennung laeuft komplett **on-device** ueber [openWakeWord](https://github.com/dscripka/openWakeWord)
-mit ONNX Runtime — kein API-Key, kein Cloud-Roundtrip, kein Cent Lizenzgebuehren,
-und das Audio verlaesst das Geraet nie.
-
-**Mitgelieferte Wake-Words** (ONNX-Dateien in `android/android/app/src/main/assets/openwakeword/`):
-- `Hey Jarvis` (Default, openWakeWord-Original)
-- `Computer` (Star-Trek-Style, Community-Modell)
-- `Alexa`, `Hey Mycroft`, `Hey Rhasspy` (openWakeWord-Originale)
-
-Community-Modelle stammen aus [fwartner/home-assistant-wakewords-collection](https://github.com/fwartner/home-assistant-wakewords-collection).
-
-**Bedienung:**
-- App → **Einstellungen** → **Wake-Word** → gewuenschtes Keyword waehlen → **Speichern + Aktivieren**
-- **Ohr-Button (👂)** in der Statusleiste tippen → Wake-Word ist scharf, App hoert passiv mit
-- Wake-Word sagen → Symbol wechselt auf 🎙️, Konversation laeuft
-- Nach jeder ARIA-Antwort oeffnet sich das Mikro nochmal — Stille → zurueck zu 👂
-- Erneut tippen → Ohr aus (🔇)
-
-**Eigene Wake-Words trainieren** (gratis, ~30 Min):
-
-1. openWakeWord Trainings-Notebook auf Colab oeffnen (Link im
-   [openWakeWord Repo](https://github.com/dscripka/openWakeWord) unter "Training Custom Models")
-2. Wake-Word-Phrase eingeben (z.B. "ARIA", "Hey Stefan"), Notebook ausfuehren —
-   das Notebook generiert synthetische Trainings-Beispiele und trainiert das Modell.
-3. Resultierende `.onnx`-Datei runterladen
-4. Datei in `android/android/app/src/main/assets/openwakeword/` ablegen
-5. In `android/src/services/wakeword.ts` den Dateinamen (ohne `.onnx`) zur
-   `WAKE_KEYWORDS`-Liste hinzufuegen
-6. APK neu bauen
-
-*(Diagnostic-Upload fuer Custom-`.onnx` ohne Rebuild kommt spaeter.)*
-
-**Tuning** (in [wakeword.ts](android/src/services/wakeword.ts)):
-- `DEFAULT_THRESHOLD = 0.5` — Score-Schwelle (raise auf 0.6–0.7 bei False-Positives)
-- `DEFAULT_PATIENCE = 2` — wie viele Frames ueber Threshold noetig
-- `DEFAULT_DEBOUNCE_MS = 1500` — Mindestabstand zwischen zwei Triggern
-
 ### Ersteinrichtung (Dev-Maschine, einmalig)
 
 ```bash
@@ -784,10 +744,8 @@ docker exec aria-core ssh aria-wohnung hostname
 - **Proxy Cold Start**: Jede Nachricht spawnt einen neuen `claude --print` Prozess.
   Dadurch ist ARIA langsamer als die direkte Claude CLI. Timeout ist auf 900s (15 Min).
 - **Kein Streaming zur App**: Die App zeigt erst die fertige Antwort, keine Streaming-Tokens.
-- **Wake-Word in der App nur eingebaute Keywords**: `Hey Jarvis`, `Alexa`, `Hey Mycroft`,
+- **Wake Word nur auf VM**: Die Bridge hoert auf "ARIA" ueber das lokale Mikrofon der VM.
-  `Hey Rhasspy` funktionieren sofort, eigene Wake-Words muessen aktuell noch als
+  In der App gibt es Energy-basierte Erkennung (Phase 1). On-device "ARIA"-Keyword (Porcupine) ist Phase 2.
-  `.onnx`-Datei ins App-Bundle gelegt + zur Liste in `wakeword.ts` hinzugefuegt werden.
-  Die Diagnostic-Upload-UI ist Phase 2.
 - **Audio-Format**: App nimmt AAC/MP4 auf, Bridge konvertiert via FFmpeg zu 16kHz PCM.
 - **RVS Zombie-Connections**: WebSocket-Verbindungen sterben gelegentlich ohne Fehlermeldung.
   Bridge hat Ping-Check (5s), Diagnostic nutzt frische Verbindungen pro Request.
@@ -842,7 +800,6 @@ docker exec aria-core ssh aria-wohnung hostname
 - [x] Audio-Pause statt Ducking (TRANSIENT statt MAY_DUCK) + release-Timing fix
 - [x] VAD-Stille-Toleranz und Max-Aufnahme einstellbar (1-8s, 120s)
 - [x] Disk-Voll Banner in Diagnostic mit copy-baren Cleanup-Befehlen
-- [x] Wake-Word on-device via openWakeWord (ONNX Runtime, kein API-Key) + State-Icon
 
 ### Phase 2 — ARIA wird produktiv
 
@@ -858,5 +815,5 @@ docker exec aria-core ssh aria-wohnung hostname
 - [ ] STARFACE Telefonie-Skill
 - [ ] Desktop Client (Tauri)
 - [ ] bKVM Remote IT-Support
-- [ ] Custom-`.onnx`-Upload fuer Wake-Word ueber Diagnostic (ohne App-Rebuild)
+- [ ] Porcupine Wake Word (on-device "ARIA" in der App)
 - [ ] Claude Vision direkt (Bildanalyse ohne Dateipfad-Umweg)

android/android/app/build.gradle

@@ -79,8 +79,8 @@ android {
         applicationId "com.ariacockpit"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 609
+        versionCode 603
-        versionName "0.0.6.9"
+        versionName "0.0.6.3"
         // Fallback fuer Libraries mit Product Flavors
         missingDimensionStrategy 'react-native-camera', 'general'
     }
@@ -104,19 +104,6 @@ android {
             proguardFiles getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro"
         }
     }
-
-    // ABI-Split: nur arm64-v8a (jedes Android-Phone seit ~2017). Bringt die
-    // APK von ~136 MB auf ~35 MB — relevant weil ONNX Runtime + die anderen
-    // Native-Libs sonst pro Architektur dazukommen. Wer 32-bit oder Emulator
-    // braucht, kann hier "armeabi-v7a", "x86_64" etc. ergaenzen.
-    splits {
-        abi {
-            enable true
-            reset()
-            include "arm64-v8a"
-            universalApk false
-        }
-    }
 }
 
 dependencies {
@@ -124,9 +111,6 @@ dependencies {
     implementation("com.facebook.react:react-android")
     implementation("com.facebook.react:flipper-integration")
 
-    // ONNX Runtime fuer on-device Wake-Word (openWakeWord ONNX-Modelle in assets/openwakeword/)
-    implementation("com.microsoft.onnxruntime:onnxruntime-android:1.17.1")
-
     if (hermesEnabled.toBoolean()) {
         implementation("com.facebook.react:hermes-android")
     } else {

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

@@ -21,7 +21,6 @@ class MainApplication : Application(), ReactApplication {
               add(ApkInstallerPackage())
               add(AudioFocusPackage())
               add(PcmStreamPlayerPackage())
-              add(OpenWakeWordPackage())
             }
 
         override fun getJSMainModuleName(): String = "index"

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

@@ -1,369 +0,0 @@
-package com.ariacockpit
-
-import ai.onnxruntime.OnnxTensor
-import ai.onnxruntime.OrtEnvironment
-import ai.onnxruntime.OrtSession
-import android.Manifest
-import android.content.pm.PackageManager
-import android.media.AudioFormat
-import android.media.AudioRecord
-import android.media.MediaRecorder
-import android.util.Log
-import androidx.core.content.ContextCompat
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.modules.core.DeviceEventManagerModule
-import java.nio.FloatBuffer
-import java.util.concurrent.atomic.AtomicBoolean
-
-/**
- * Wake-Word Erkennung on-device via openWakeWord (https://github.com/dscripka/openWakeWord).
- *
- * Drei-stufige ONNX Pipeline:
- *   1. Audio (16kHz mono int16, 1280-Sample-Chunks) → Melspectrogram → 32-mel Frames
- *   2. 76 Mel-Frames Sliding Window (stride 8) → Speech-Embedding → 96-dim Vektor
- *   3. Letzte 16 Embeddings (~1.28s Kontext) → Wake-Word-Klassifikator → Sigmoid-Score
- *
- *  Modelle liegen in assets/openwakeword/ (mel + embedding shared, plus pro Keyword
- *  ein eigenes .onnx). Erkennung feuert nach `patience` aufeinanderfolgenden
- *  Frames ueber `threshold` und unterdrueckt Wiederholungen fuer `debounceMs`.
- *
- *  Emittiert "WakeWordDetected" als RN-Event wenn ein Trigger erkannt wurde.
- */
-class OpenWakeWordModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) {
-    override fun getName() = "OpenWakeWord"
-
-    companion object {
-        private const val TAG = "OpenWakeWord"
-        private const val SAMPLE_RATE = 16000
-        private const val CHUNK_SAMPLES = 1280               // 80ms @ 16kHz
-        private const val MEL_FRAMES_PER_EMBEDDING = 76      // Embedding-Fenster
-        private const val EMBEDDING_STRIDE = 8               // Slide um 8 Mel-Frames
-        private const val EMBEDDING_DIM = 96
-        private const val MEL_BINS = 32
-        private const val DEFAULT_WW_INPUT_FRAMES = 16       // Fallback wenn Modell-Metadata fehlt
-    }
-
-    private val env: OrtEnvironment = OrtEnvironment.getEnvironment()
-    private var melSession: OrtSession? = null
-    private var embSession: OrtSession? = null
-    private var wwSession: OrtSession? = null
-
-    private var melInputName: String = "input"
-    private var embInputName: String = "input_1"
-    private var wwInputName: String = "input"
-    // Anzahl Embedding-Frames die der Wake-Word-Klassifikator pro Inferenz erwartet —
-    // hey_jarvis hat 16, andere Community-Modelle koennen abweichen (z.B. 28).
-    // Wird beim init() aus den Modell-Metadaten gelesen.
-    private var wwInputFrames: Int = DEFAULT_WW_INPUT_FRAMES
-
-    // Konfiguration
-    private var threshold: Float = 0.5f
-    private var patience: Int = 2
-    private var debounceMs: Long = 1500
-    private var modelName: String = "hey_jarvis"
-
-    // Audio-Capture-Thread
-    private var audioRecord: AudioRecord? = null
-    private val running = AtomicBoolean(false)
-    private var captureThread: Thread? = null
-
-    // Inferenz-State
-    private val melBuffer: ArrayList<FloatArray> = ArrayList(256)   // Liste von 32-dim Frames
-    private var melProcessedIdx: Int = 0
-    private val embBuffer: ArrayDeque<FloatArray> = ArrayDeque(32)  // Ringpuffer letzter Embeddings
-    private var consecutiveAboveThreshold: Int = 0
-    private var lastDetectionMs: Long = 0L
-
-    /**
-     *  Initialisiert die ONNX-Sessions fuer ein bestimmtes Wake-Word.
-     *  modelName: dateiname ohne Suffix (z.B. "hey_jarvis", "alexa", "hey_mycroft", "hey_rhasspy")
-     */
-    @ReactMethod
-    fun init(modelName: String, threshold: Double, patience: Int, debounceMs: Int, promise: Promise) {
-        try {
-            disposeSessions()
-            this.modelName = modelName
-            this.threshold = threshold.toFloat()
-            this.patience = patience.coerceAtLeast(1)
-            this.debounceMs = debounceMs.toLong()
-
-            val ctx = reactApplicationContext
-            val melBytes = ctx.assets.open("openwakeword/melspectrogram.onnx").use { it.readBytes() }
-            val embBytes = ctx.assets.open("openwakeword/embedding_model.onnx").use { it.readBytes() }
-            val wwBytes = ctx.assets.open("openwakeword/$modelName.onnx").use { it.readBytes() }
-
-            val opts = OrtSession.SessionOptions()
-            melSession = env.createSession(melBytes, opts)
-            embSession = env.createSession(embBytes, opts)
-            wwSession = env.createSession(wwBytes, opts)
-
-            melInputName = melSession!!.inputNames.first()
-            embInputName = embSession!!.inputNames.first()
-            wwInputName = wwSession!!.inputNames.first()
-
-            // WW-Input-Frame-Count aus dem Modell lesen — variiert pro Keyword.
-            // Erwartete Form: (1, N, 96), N steht in der Modell-Metadaten.
-            val wwInputInfo = wwSession!!.inputInfo[wwInputName]
-            val wwShape = (wwInputInfo?.info as? ai.onnxruntime.TensorInfo)?.shape
-            wwInputFrames = wwShape?.getOrNull(1)?.toInt()?.takeIf { it > 0 } ?: DEFAULT_WW_INPUT_FRAMES
-
-            Log.i(TAG, "Init OK: model=$modelName wwFrames=$wwInputFrames threshold=$threshold patience=$patience " +
-                    "debounce=${debounceMs}ms (inputs: mel=$melInputName emb=$embInputName ww=$wwInputName)")
-            promise.resolve(true)
-        } catch (e: Exception) {
-            Log.e(TAG, "Init fehlgeschlagen: ${e.message}", e)
-            disposeSessions()
-            promise.reject("INIT_FAILED", e.message ?: "Unbekannter Fehler", e)
-        }
-    }
-
-    @ReactMethod
-    fun start(promise: Promise) {
-        if (running.get()) {
-            promise.resolve(true)
-            return
-        }
-        if (melSession == null || embSession == null || wwSession == null) {
-            promise.reject("NOT_INITIALIZED", "init() muss vor start() aufgerufen werden")
-            return
-        }
-        // Berechtigung pruefen — der App-Code holt die ueblicherweise schon vorher,
-        // aber wir bestehen hier explizit darauf damit AudioRecord nicht stumm
-        // failt.
-        val perm = ContextCompat.checkSelfPermission(reactApplicationContext, Manifest.permission.RECORD_AUDIO)
-        if (perm != PackageManager.PERMISSION_GRANTED) {
-            promise.reject("NO_MIC_PERMISSION", "RECORD_AUDIO Permission fehlt")
-            return
-        }
-
-        try {
-            val minBuf = AudioRecord.getMinBufferSize(
-                SAMPLE_RATE,
-                AudioFormat.CHANNEL_IN_MONO,
-                AudioFormat.ENCODING_PCM_16BIT,
-            ).coerceAtLeast(CHUNK_SAMPLES * 2 * 4)
-
-            val record = AudioRecord(
-                MediaRecorder.AudioSource.MIC,
-                SAMPLE_RATE,
-                AudioFormat.CHANNEL_IN_MONO,
-                AudioFormat.ENCODING_PCM_16BIT,
-                minBuf,
-            )
-            if (record.state != AudioRecord.STATE_INITIALIZED) {
-                record.release()
-                promise.reject("AUDIO_INIT", "AudioRecord nicht initialisiert (Mikro belegt?)")
-                return
-            }
-            audioRecord = record
-            resetInferenceState()
-            running.set(true)
-            record.startRecording()
-
-            captureThread = Thread({ captureLoop() }, "OpenWakeWordCapture").apply {
-                isDaemon = true
-                start()
-            }
-
-            Log.i(TAG, "Lauschen gestartet (model=$modelName)")
-            promise.resolve(true)
-        } catch (e: Exception) {
-            Log.e(TAG, "start fehlgeschlagen", e)
-            running.set(false)
-            audioRecord?.release()
-            audioRecord = null
-            promise.reject("START_FAILED", e.message ?: "Unbekannter Fehler", e)
-        }
-    }
-
-    @ReactMethod
-    fun stop(promise: Promise) {
-        running.set(false)
-        try {
-            captureThread?.join(1500)
-        } catch (_: InterruptedException) {}
-        captureThread = null
-        try { audioRecord?.stop() } catch (_: Exception) {}
-        try { audioRecord?.release() } catch (_: Exception) {}
-        audioRecord = null
-        Log.i(TAG, "Lauschen gestoppt")
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun dispose(promise: Promise) {
-        running.set(false)
-        try { captureThread?.join(1000) } catch (_: InterruptedException) {}
-        captureThread = null
-        try { audioRecord?.stop() } catch (_: Exception) {}
-        try { audioRecord?.release() } catch (_: Exception) {}
-        audioRecord = null
-        disposeSessions()
-        promise.resolve(true)
-    }
-
-    @ReactMethod
-    fun isAvailable(promise: Promise) {
-        // Wake-Word ist immer verfuegbar (kein API-Key, alles on-device)
-        promise.resolve(true)
-    }
-
-    // RN-Event-Subscriptions — RN-Konvention, sonst Warnung im Debug-Build
-    @ReactMethod fun addListener(eventName: String) {}
-    @ReactMethod fun removeListeners(count: Int) {}
-
-    private fun disposeSessions() {
-        try { melSession?.close() } catch (_: Exception) {}
-        try { embSession?.close() } catch (_: Exception) {}
-        try { wwSession?.close() } catch (_: Exception) {}
-        melSession = null
-        embSession = null
-        wwSession = null
-    }
-
-    private fun resetInferenceState() {
-        melBuffer.clear()
-        melProcessedIdx = 0
-        embBuffer.clear()
-        consecutiveAboveThreshold = 0
-        lastDetectionMs = 0L
-    }
-
-    private fun emitDetected() {
-        val params = com.facebook.react.bridge.Arguments.createMap().apply {
-            putString("model", modelName)
-        }
-        try {
-            reactApplicationContext
-                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-                .emit("WakeWordDetected", params)
-        } catch (e: Exception) {
-            Log.w(TAG, "emit fehlgeschlagen: ${e.message}")
-        }
-    }
-
-    private fun captureLoop() {
-        val buf = ShortArray(CHUNK_SAMPLES)
-        val record = audioRecord ?: return
-        Log.i(TAG, "Capture-Loop gestartet")
-        while (running.get()) {
-            var read = 0
-            while (read < CHUNK_SAMPLES && running.get()) {
-                val n = record.read(buf, read, CHUNK_SAMPLES - read)
-                if (n <= 0) {
-                    Log.w(TAG, "AudioRecord.read returned $n — Loop ende")
-                    running.set(false)
-                    return
-                }
-                read += n
-            }
-            if (!running.get()) break
-            try {
-                processChunk(buf)
-            } catch (e: Exception) {
-                Log.w(TAG, "processChunk: ${e.message}")
-            }
-        }
-        Log.i(TAG, "Capture-Loop beendet")
-    }
-
-    /** Verarbeitet einen 1280-Sample int16 Audio-Chunk. */
-    private fun processChunk(audio: ShortArray) {
-        // 1) Audio → mel (output (1, 1, frames, 32))
-        val floats = FloatArray(audio.size) { audio[it].toFloat() }
-        val melTensor = OnnxTensor.createTensor(
-            env,
-            FloatBuffer.wrap(floats),
-            longArrayOf(1L, audio.size.toLong()),
-        )
-        val melResult = melSession!!.run(mapOf(melInputName to melTensor))
-        val melOut = melResult.get(0).value
-        melTensor.close()
-        @Suppress("UNCHECKED_CAST")
-        val mel4 = melOut as Array<Array<Array<FloatArray>>>
-        val frames = mel4[0][0]
-        // openWakeWord wendet `mel/10 + 2` an, bevor es ans Embedding-Modell geht
-        for (frame in frames) {
-            val scaled = FloatArray(frame.size) { frame[it] / 10f + 2f }
-            melBuffer.add(scaled)
-        }
-        melResult.close()
-
-        // 2) Sliding window: alle vollstaendigen 76-Frame-Fenster verarbeiten
-        while (melBuffer.size >= melProcessedIdx + MEL_FRAMES_PER_EMBEDDING) {
-            val flat = FloatArray(MEL_FRAMES_PER_EMBEDDING * MEL_BINS)
-            var pos = 0
-            for (i in 0 until MEL_FRAMES_PER_EMBEDDING) {
-                val src = melBuffer[melProcessedIdx + i]
-                System.arraycopy(src, 0, flat, pos, MEL_BINS)
-                pos += MEL_BINS
-            }
-            val embIn = OnnxTensor.createTensor(
-                env,
-                FloatBuffer.wrap(flat),
-                longArrayOf(1L, MEL_FRAMES_PER_EMBEDDING.toLong(), MEL_BINS.toLong(), 1L),
-            )
-            val embRes = embSession!!.run(mapOf(embInputName to embIn))
-            val embOut = embRes.get(0).value
-            embIn.close()
-            // Erwartete Output-Form: (1, 1, 1, 96) — rank-4, NICHT (1, 96).
-            // Die Google-Embedding-Pipeline behaelt extra Dimensionen.
-            @Suppress("UNCHECKED_CAST")
-            val embArr = embOut as Array<Array<Array<FloatArray>>>
-            embBuffer.addLast(embArr[0][0][0].copyOf())
-            while (embBuffer.size > wwInputFrames) embBuffer.removeFirst()
-            embRes.close()
-
-            melProcessedIdx += EMBEDDING_STRIDE
-        }
-        // Mel-Buffer trimmen — verhindert Memory-Wachstum
-        if (melProcessedIdx > MEL_FRAMES_PER_EMBEDDING) {
-            val keepFrom = melProcessedIdx - MEL_FRAMES_PER_EMBEDDING
-            val newList = ArrayList<FloatArray>(melBuffer.size - keepFrom)
-            for (i in keepFrom until melBuffer.size) newList.add(melBuffer[i])
-            melBuffer.clear()
-            melBuffer.addAll(newList)
-            melProcessedIdx = MEL_FRAMES_PER_EMBEDDING
-        }
-
-        // 3) Klassifikation — sobald wir 16 Embeddings haben
-        if (embBuffer.size < wwInputFrames) return
-        val flatEmb = FloatArray(wwInputFrames * EMBEDDING_DIM)
-        var p = 0
-        // Letzte wwInputFrames Embeddings nehmen (embBuffer ist auf wwInputFrames begrenzt)
-        for (e in embBuffer) {
-            System.arraycopy(e, 0, flatEmb, p, EMBEDDING_DIM)
-            p += EMBEDDING_DIM
-        }
-        val wwIn = OnnxTensor.createTensor(
-            env,
-            FloatBuffer.wrap(flatEmb),
-            longArrayOf(1L, wwInputFrames.toLong(), EMBEDDING_DIM.toLong()),
-        )
-        val wwRes = wwSession!!.run(mapOf(wwInputName to wwIn))
-        val wwOut = wwRes.get(0).value
-        wwIn.close()
-        // Erwartete Output-Form: (1, 1) → Array<FloatArray>
-        @Suppress("UNCHECKED_CAST")
-        val score = (wwOut as Array<FloatArray>)[0][0]
-        wwRes.close()
-
-        if (score >= threshold) {
-            consecutiveAboveThreshold++
-            if (consecutiveAboveThreshold >= patience) {
-                val now = System.currentTimeMillis()
-                if (now - lastDetectionMs >= debounceMs) {
-                    lastDetectionMs = now
-                    consecutiveAboveThreshold = 0
-                    Log.i(TAG, "Wake-Word erkannt! score=$score model=$modelName")
-                    emitDetected()
-                }
-            }
-        } else {
-            consecutiveAboveThreshold = 0
-        }
-    }
-}

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

@@ -1,16 +0,0 @@
-package com.ariacockpit
-
-import com.facebook.react.ReactPackage
-import com.facebook.react.bridge.NativeModule
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
-
-class OpenWakeWordPackage : ReactPackage {
-    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-        return listOf(OpenWakeWordModule(reactContext))
-    }
-
-    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-        return emptyList()
-    }
-}

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

@@ -137,17 +137,6 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                             Log.w(TAG, "play() sofort failed: ${e.message}")
                         }
                     }
-                    // Idle-Cutoff: wenn endRequested NICHT kam aber 30s nichts mehr
-                    // reinkommt, brechen wir ab (Bridge-Crash, verlorener final).
-                    var idleMs = 0L
-                    val maxIdleMs = 30_000L
-                    // Zielpufferfuellung — unter diesem Wasserstand fuettern wir
-                    // Stille rein damit AudioTrack nicht underrunt waehrend die
-                    // Bridge den naechsten Satz rendert. Spotify/YouTube reagieren
-                    // sonst mit eigenmaechtiger Wiederaufnahme nach ~10s Stille.
-                    val underrunGuardFrames = sampleRate / 10  // ~100ms
-                    val silenceFillFrames = sampleRate / 20    // ~50ms pro Refill
-
                     mainLoop@ while (!writerShouldStop) {
                         val data = queue.poll(50, java.util.concurrent.TimeUnit.MILLISECONDS)
                         if (data == null) {
@@ -164,33 +153,8 @@ class PcmStreamPlayerModule(reactContext: ReactApplicationContext) : ReactContex
                                 }
                                 break@mainLoop
                             }
-                            // Underrun-Schutz: Stille reinfuettern wenn der AudioTrack-
-                            // Puffer leerzulaufen droht. Spotify resumed sonst nach
-                            // ~10s Pause auf eigene Faust, obwohl wir den Fokus halten.
-                            if (playbackStarted) {
-                                val framesWritten = bytesBuffered / streamBytesPerFrame
-                                val framesPlayed = t.playbackHeadPosition.toLong()
-                                val framesInBuffer = framesWritten - framesPlayed
-                                if (framesInBuffer < underrunGuardFrames) {
-                                    val fillBytes = silenceFillFrames * streamBytesPerFrame
-                                    val silence = ByteArray(fillBytes)
-                                    var silOff = 0
-                                    while (silOff < silence.size && !writerShouldStop) {
-                                        val w = t.write(silence, silOff, silence.size - silOff)
-                                        if (w <= 0) break
-                                        silOff += w
-                                    }
-                                    bytesBuffered += silence.size
-                                }
-                            }
-                            idleMs += 50L
-                            if (idleMs >= maxIdleMs) {
-                                Log.w(TAG, "Idle-Cutoff: ${maxIdleMs}ms keine Daten — Stream wird beendet")
-                                break@mainLoop
-                            }
                             continue@mainLoop
                         }
-                        idleMs = 0L
 
                         // Pre-Roll Check: play() erst wenn genug gepuffert
                         if (!playbackStarted && bytesBuffered + data.size >= prerollBytes) {

android/build.sh

@@ -167,23 +167,10 @@ export CI=true
 
 if [ "$MODE" = "debug" ]; then
     ./gradlew assembleDebug
-    OUT_DIR="app/build/outputs/apk/debug"
+    APK_PATH="app/build/outputs/apk/debug/app-debug.apk"
 else
     ./gradlew assembleRelease
-    OUT_DIR="app/build/outputs/apk/release"
+    APK_PATH="app/build/outputs/apk/release/app-release.apk"
-fi
-
-# Mit ABI-Splits heisst die APK z.B. app-arm64-v8a-release.apk statt
-# app-release.apk. arm64-v8a-Variante zuerst probieren (das ist unser
-# Standard), Universal-APK als Fallback falls Splits deaktiviert sind.
-if [ -f "$OUT_DIR/app-arm64-v8a-${MODE}.apk" ]; then
-    APK_PATH="$OUT_DIR/app-arm64-v8a-${MODE}.apk"
-elif [ -f "$OUT_DIR/app-${MODE}.apk" ]; then
-    APK_PATH="$OUT_DIR/app-${MODE}.apk"
-else
-    echo -e "${RED}Keine passende APK in $OUT_DIR gefunden${NC}"
-    cd ..
-    exit 1
 fi
 
 cd ..

android/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aria-cockpit",
-  "version": "0.0.6.9",
+  "version": "0.0.6.3",
   "private": true,
   "scripts": {
     "android": "react-native run-android",
@@ -24,7 +24,9 @@
     "react-native-camera-kit": "^13.0.0",
     "@react-native-async-storage/async-storage": "^1.21.0",
     "react-native-fs": "^2.20.0",
-    "react-native-audio-recorder-player": "^3.6.7"
+    "react-native-audio-recorder-player": "^3.6.7",
+    "@picovoice/porcupine-react-native": "3.0.5",
+    "@picovoice/react-native-voice-processor": "1.2.3"
   },
   "devDependencies": {
     "typescript": "^5.3.3",

android/src/components/MessageText.tsx

@@ -72,28 +72,13 @@ interface Props {
 const MessageText: React.FC<Props> = ({ text, style }) => {
   const segments = React.useMemo(() => tokenize(text), [text]);
   return (
-    <Text
+    <Text style={style} selectable>
-      style={style}
-      selectable
-      // dataDetectorType ist Android-only und macht Phone/URL/Email zusaetzlich
-      // ueber System-Detection klickbar — als Fallback falls unsere Regex-
-      // Tokens nicht passen.
-      dataDetectorType="all"
-    >
       {segments.map((seg, i) => {
         if (seg.kind === 'text') {
-          return <Text key={i} selectable>{seg.text}</Text>;
+          return <Text key={i}>{seg.text}</Text>;
         }
         return (
-          <Text
+          <Text key={i} style={LINK_STYLE} onPress={() => onPress(seg)}>
-            key={i}
-            selectable
-            style={LINK_STYLE}
-            onPress={() => onPress(seg)}
-            // Long-Press soll an den Parent durch fuer Selection
-            onLongPress={undefined}
-            suppressHighlighting={false}
-          >
             {seg.text}
           </Text>
         );

android/src/screens/ChatScreen.tsx

@@ -619,8 +619,6 @@ const ChatScreen: React.FC = () => {
       base64: result.base64,
       durationMs: result.durationMs,
       mimeType: result.mimeType,
-      voice: localXttsVoiceRef.current,
-      speed: ttsSpeedRef.current,
       ...(location && { location }),
     });
   }, [getCurrentLocation]);

android/src/screens/SettingsScreen.tsx

@@ -41,9 +41,9 @@ import {
   TTS_SPEED_STORAGE_KEY,
 } from '../services/audio';
 import wakeWordService, {
-  WAKE_KEYWORDS,
+  BUILTIN_KEYWORDS,
-  KEYWORD_LABELS,
   DEFAULT_KEYWORD,
+  WAKE_ACCESS_KEY_STORAGE,
   WAKE_KEYWORD_STORAGE,
 } from '../services/wakeword';
 import ModeSelector from '../components/ModeSelector';
@@ -103,6 +103,8 @@ const SettingsScreen: React.FC = () => {
   const [vadSilenceSec, setVadSilenceSec] = useState<number>(VAD_SILENCE_DEFAULT_SEC);
   const [convWindowSec, setConvWindowSec] = useState<number>(CONV_WINDOW_DEFAULT_SEC);
   const [ttsSpeed, setTtsSpeed] = useState<number>(TTS_SPEED_DEFAULT);
+  const [wakeAccessKey, setWakeAccessKey] = useState<string>('');
+  const [wakeAccessKeyVisible, setWakeAccessKeyVisible] = useState(false);
   const [wakeKeyword, setWakeKeyword] = useState<string>(DEFAULT_KEYWORD);
   const [wakeStatus, setWakeStatus] = useState<string>('');
   const [editingPath, setEditingPath] = useState(false);
@@ -162,8 +164,11 @@ const SettingsScreen: React.FC = () => {
         if (isFinite(n) && n >= TTS_SPEED_MIN && n <= TTS_SPEED_MAX) setTtsSpeed(n);
       }
     });
+    AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE).then(saved => {
+      if (saved) setWakeAccessKey(saved);
+    });
     AsyncStorage.getItem(WAKE_KEYWORD_STORAGE).then(saved => {
-      if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
+      if (saved) setWakeKeyword(saved);
     });
     AsyncStorage.getItem('aria_xtts_voice').then(saved => {
       if (saved) setXttsVoice(saved);
@@ -673,23 +678,44 @@ const SettingsScreen: React.FC = () => {
         </View>
       </View>
 
-      {/* === Wake-Word (komplett on-device, openWakeWord) === */}
+      {/* === Wake-Word (geraetelokal) === */}
       <Text style={styles.sectionTitle}>Wake-Word</Text>
       <View style={styles.card}>
         <Text style={styles.toggleHint}>
-          Lokale Erkennung via openWakeWord (ONNX, on-device). Kein API-Key,
+          Wenn ein Picovoice-Access-Key eingetragen ist, hoert die App passiv
-          kein Cloud-Roundtrip — Audio verlaesst das Geraet nicht. Wenn das Ohr
+          auf das gewaehlte Wake-Word — du kannst dich mit anderen unterhalten,
-          aktiv ist, hoerst du normal mit; sagst du das Wake-Word, startet eine
+          Musik laufen lassen und mit "{wakeKeyword}" eine Konversation mit
-          Konversation mit ARIA.
+          ARIA starten. Ohne Key oder bei Fehlschlag startet das Ohr direkt
+          eine Konversation (klassischer Modus).
         </Text>
 
+        <Text style={[styles.toggleLabel, {marginTop: 16}]}>Picovoice Access Key</Text>
+        <View style={{flexDirection: 'row', alignItems: 'center', gap: 8, marginTop: 6}}>
+          <TextInput
+            style={[styles.input, {flex: 1}]}
+            value={wakeAccessKey}
+            onChangeText={setWakeAccessKey}
+            placeholder="kostenlos auf console.picovoice.ai"
+            placeholderTextColor="#666680"
+            secureTextEntry={!wakeAccessKeyVisible}
+            autoCapitalize="none"
+            autoCorrect={false}
+          />
+          <TouchableOpacity
+            onPress={() => setWakeAccessKeyVisible(v => !v)}
+            style={{padding: 8}}
+          >
+            <Text style={{fontSize: 18}}>{wakeAccessKeyVisible ? '🙈' : '👁'}</Text>
+          </TouchableOpacity>
+        </View>
+
         <Text style={[styles.toggleLabel, {marginTop: 16}]}>Wake-Word</Text>
         <Text style={styles.toggleHint}>
-          Eigene Wake-Words via openWakeWord-Notebook trainierbar (gratis).
+          Built-In: sofort verwendbar. "ARIA" als Custom-Keyword kommt spaeter
-          Custom-Upload ueber Diagnostic kommt in einer spaeteren Version.
+          ueber Diagnostic-Upload.
         </Text>
         <View style={{flexDirection: 'row', flexWrap: 'wrap', gap: 6, marginTop: 8}}>
-          {WAKE_KEYWORDS.map(kw => (
+          {BUILTIN_KEYWORDS.map(kw => (
             <TouchableOpacity
               key={kw}
               style={[
@@ -702,7 +728,7 @@ const SettingsScreen: React.FC = () => {
                 styles.keywordChipText,
                 wakeKeyword === kw && styles.keywordChipTextActive,
               ]}>
-                {KEYWORD_LABELS[kw]}
+                {kw}
               </Text>
             </TouchableOpacity>
           ))}
@@ -714,8 +740,8 @@ const SettingsScreen: React.FC = () => {
             onPress={async () => {
               setWakeStatus('Initialisiere...');
               try {
-                const ok = await wakeWordService.configure(wakeKeyword);
+                const ok = await wakeWordService.configure(wakeAccessKey, wakeKeyword);
-                setWakeStatus(ok ? `✅ "${KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS]}" bereit` : '❌ Init-Fehler — Logs pruefen');
+                setWakeStatus(ok ? `✅ "${wakeKeyword}" bereit` : '❌ Fehlgeschlagen — Access Key pruefen');
               } catch (err: any) {
                 setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
               }

android/src/services/audio.ts

@@ -191,13 +191,6 @@ class AudioService {
   private pcmBytesCollected: number = 0;
   private readonly PCM_MAX_CACHE_BYTES = 30 * 1024 * 1024; // 30MB
 
-  // AudioFocus wird verzoegert freigegeben — wenn ARIA eine zweite Antwort
-  // direkt hinterherschickt (oder ein neuer Stream startet), bleibt Spotify
-  // pausiert. Ohne diese Verzoegerung springt Spotify im Mikro-Sekunden-Gap
-  // zwischen zwei Streams kurz wieder an.
-  private focusReleaseTimer: ReturnType<typeof setTimeout> | null = null;
-  private readonly FOCUS_RELEASE_DELAY_MS = 800;
-
   // VAD State
   private vadEnabled: boolean = false;
   private lastSpeechTime: number = 0;
@@ -212,24 +205,6 @@ class AudioService {
     this.recorder.setSubscriptionDuration(0.1); // 100ms Metering-Updates
   }
 
-  /** AudioFocus mit kleiner Verzoegerung freigeben — Spotify/YouTube
-   *  springen sonst im Gap zwischen zwei TTS-Streams (oder wenn ARIA
-   *  eine zweite Antwort direkt hinterherschickt) kurz wieder an. */
-  private _releaseFocusDeferred(): void {
-    this._cancelDeferredFocusRelease();
-    this.focusReleaseTimer = setTimeout(() => {
-      this.focusReleaseTimer = null;
-      AudioFocus?.release().catch(() => {});
-    }, this.FOCUS_RELEASE_DELAY_MS);
-  }
-
-  private _cancelDeferredFocusRelease(): void {
-    if (this.focusReleaseTimer) {
-      clearTimeout(this.focusReleaseTimer);
-      this.focusReleaseTimer = null;
-    }
-  }
-
   // --- Berechtigungen ---
 
   async requestMicrophonePermission(): Promise<boolean> {
@@ -330,7 +305,6 @@ class AudioService {
       this.setState('recording');
 
       // Andere Apps waehrend der Aufnahme pausieren (Musik, Videos etc.)
-      this._cancelDeferredFocusRelease();
       AudioFocus?.requestExclusive().catch(() => {});
 
       // VAD aktivieren — Stille-Dauer aus AsyncStorage (Settings-konfigurierbar).
@@ -413,9 +387,8 @@ class AudioService {
       await this.recorder.stopRecorder();
       this.recorder.removeRecordBackListener();
 
-      // Audio-Focus verzoegert freigeben — gleich kommt die TTS-Antwort,
+      // Audio-Focus freigeben — andere Apps duerfen wieder
-      // im Gap soll Spotify nicht hochkommen.
+      AudioFocus?.release().catch(() => {});
-      this._releaseFocusDeferred();
 
       const durationMs = Date.now() - this.recordingStartTime;
       const hadSpeech = this.speechDetected;
@@ -562,7 +535,6 @@ class AudioService {
           this.pcmStreamActive = false;
           return '';
         }
-        this._cancelDeferredFocusRelease();
         AudioFocus?.requestDuck().catch(() => {});
       }
     }
@@ -581,12 +553,11 @@ class AudioService {
     if (isFinal) {
       if (!silent) {
         // end() resolved jetzt erst wenn der native Writer-Thread fertig
-        // ist (alle Samples ausgespielt) — danach AudioFocus verzoegert
+        // ist (alle Samples ausgespielt) — danach erst AudioFocus freigeben,
-        // freigeben, damit Spotify/YouTube nicht im Mikro-Gap zwischen zwei
+        // damit Spotify/YouTube nicht waehrend des Pre-Roll-Ausklangs
-        // ARIA-Antworten wieder hochdrehen. Wenn ein neuer Stream innerhalb
+        // wieder aufdrehen.
-        // FOCUS_RELEASE_DELAY_MS startet, wird das Release abgebrochen.
         try { await PcmStreamPlayer!.end(); } catch {}
-        this._releaseFocusDeferred();
+        AudioFocus?.release().catch(() => {});
       }
       this.pcmStreamActive = false;
 
@@ -690,9 +661,8 @@ class AudioService {
   private async _playNext(): Promise<void> {
     if (this.audioQueue.length === 0) {
       this.isPlaying = false;
-      // Audio-Focus verzoegert abgeben → wenn gleich noch eine Antwort kommt,
+      // Audio-Focus abgeben → andere Apps volle Lautstaerke
-      // bleibt Spotify pausiert.
+      AudioFocus?.release().catch(() => {});
-      this._releaseFocusDeferred();
       // Alle Audio-Teile abgespielt → Listener benachrichtigen
       this.playbackFinishedListeners.forEach(cb => cb());
       return;
@@ -700,7 +670,6 @@ class AudioService {
 
     // Beim ersten Playback-Start: andere Apps ducken
     if (!this.isPlaying) {
-      this._cancelDeferredFocusRelease();
       AudioFocus?.requestDuck().catch(() => {});
     }
     this.isPlaying = true;
@@ -786,8 +755,7 @@ class AudioService {
       this.pcmBytesCollected = 0;
       this.pcmMessageId = '';
     }
-    // Audio-Focus sofort freigeben — User hat explizit abgebrochen
+    // Audio-Focus freigeben
-    this._cancelDeferredFocusRelease();
     AudioFocus?.release().catch(() => {});
   }
 

android/src/services/wakeword.ts

@@ -1,140 +1,142 @@
 /**
  * Gespraechsmodus / Wake Word Service
  *
- * Wake-Word-Engine: openWakeWord (https://github.com/dscripka/openWakeWord),
- * komplett on-device via ONNX Runtime in Native-Kotlin (siehe
- * OpenWakeWordModule.kt + assets/openwakeword/). Kein API-Key, kein Cloud-
- * Roundtrip, kein Cent Lizenzgebuehren.
- *
  * Drei Zustaende:
  *   off        — Ohr aus, nichts laeuft
- *   armed      — Ohr aktiv, openWakeWord hoert passiv auf das Wake-Word.
+ *   armed      — Ohr aktiv, Porcupine hoert passiv auf das Wake-Word.
- *                Das Mikro ist von OpenWakeWord belegt; AudioRecorder ist aus.
+ *                Das Mikro ist von Porcupine belegt; AudioRecorder ist aus.
- *   conversing — Wake-Word getriggert (oder Ohr-Tap manuell):
+ *   conversing — Wake-Word getriggert (oder Ohr-Tap ohne Wake-Word):
- *                aktive Konversation. OpenWakeWord pausiert (gibt Mikro frei),
+ *                aktive Konversation. Porcupine pausiert (gibt Mikro frei),
  *                AudioRecorder uebernimmt fuer die Aufnahme.
  *                Nach jeder ARIA-Antwort oeffnet das Mikro fuer X Sekunden
  *                (Conversation-Window). Stille im Fenster → zurueck zu armed.
  *
- * Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
+ * Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
- * 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
+ * direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
+ * geht dann nach 'off' statt 'armed'.
  */
 
-import { NativeEventEmitter, NativeModules, ToastAndroid } from 'react-native';
 import AsyncStorage from '@react-native-async-storage/async-storage';
+import { ToastAndroid } from 'react-native';
 
 type WakeWordCallback = () => void;
 type StateCallback = (state: WakeWordState) => void;
 
 export type WakeWordState = 'off' | 'armed' | 'conversing';
 
+export const WAKE_ACCESS_KEY_STORAGE = 'aria_wake_access_key';
 export const WAKE_KEYWORD_STORAGE = 'aria_wake_keyword';
 
-/** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
+/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
- *  android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
+ *  Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
- *  Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
+ *  Console — wird spaeter ueber Diagnostic uploadbar. */
- *  werden — Diagnostic-Upload ist Phase 2. */
+export const BUILTIN_KEYWORDS = [
-export const WAKE_KEYWORDS = [
+  'jarvis',
-  'hey_jarvis',
   'computer',
+  'picovoice',
+  'porcupine',
+  'bumblebee',
+  'terminator',
   'alexa',
-  'hey_mycroft',
+  'hey google',
-  'hey_rhasspy',
+  'ok google',
+  'hey siri',
 ] as const;
-export type WakeKeyword = typeof WAKE_KEYWORDS[number];
+export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
-export const DEFAULT_KEYWORD: WakeKeyword = 'hey_jarvis';
+export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
-
-/** Hilfs-Mapping fuer die Anzeige im UI. */
-export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
-  hey_jarvis: 'Hey Jarvis',
-  computer: 'Computer',
-  alexa: 'Alexa',
-  hey_mycroft: 'Hey Mycroft',
-  hey_rhasspy: 'Hey Rhasspy',
-};
-
-// Detection-Tuning — kann in Settings spaeter konfigurierbar werden.
-const DEFAULT_THRESHOLD = 0.5;
-const DEFAULT_PATIENCE = 2;
-const DEFAULT_DEBOUNCE_MS = 1500;
-
-interface OpenWakeWordModule {
-  init(modelName: string, threshold: number, patience: number, debounceMs: number): Promise<boolean>;
-  start(): Promise<boolean>;
-  stop(): Promise<boolean>;
-  dispose(): Promise<boolean>;
-  isAvailable(): Promise<boolean>;
-}
-
-const { OpenWakeWord } = NativeModules as { OpenWakeWord?: OpenWakeWordModule };
 
 class WakeWordService {
   private state: WakeWordState = 'off';
   private wakeCallbacks: WakeWordCallback[] = [];
   private stateCallbacks: StateCallback[] = [];
 
-  private keyword: WakeKeyword = DEFAULT_KEYWORD;
+  // Picovoice Manager (lazy, da Native Module nicht in jedem Build verfuegbar ist)
-  private nativeReady: boolean = false;
+  private porcupine: any = null;
+  private accessKey: string = '';
+  private keyword: string = DEFAULT_KEYWORD;
   private initInProgress: Promise<boolean> | null = null;
-  private eventSub: { remove: () => void } | null = null;
 
-  /** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
+  /** Beim App-Start aufrufen — laedt Settings, baut Porcupine wenn Key da ist. */
   async loadFromStorage(): Promise<void> {
     try {
+      const k = await AsyncStorage.getItem(WAKE_ACCESS_KEY_STORAGE);
       const w = await AsyncStorage.getItem(WAKE_KEYWORD_STORAGE);
-      const wt = (w || DEFAULT_KEYWORD).trim() as WakeKeyword;
+      this.accessKey = (k || '').trim();
-      this.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
+      this.keyword = (w || DEFAULT_KEYWORD).trim();
-      await this.initNative();
+      if (this.accessKey) {
+        // Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
+        await this.initPorcupine();
+      }
     } catch (err) {
       console.warn('[WakeWord] loadFromStorage', err);
     }
   }
 
-  /** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
+  /** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
-  async configure(keyword: string): Promise<boolean> {
+  async configure(accessKey: string, keyword: string): Promise<boolean> {
-    const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
+    this.accessKey = (accessKey || '').trim();
-      ? (keyword as WakeKeyword)
+    this.keyword = (keyword || DEFAULT_KEYWORD).trim();
-      : DEFAULT_KEYWORD;
+    await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
-    this.keyword = next;
+    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);
-    await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, next);
 
-    // Laufende Instanz stoppen + neu initialisieren
+    // Laufende Instanz stoppen
-    await this.disposeNative();
+    await this.disposePorcupine();
-    const ok = await this.initNative();
+    if (!this.accessKey) {
+      console.warn('[WakeWord] configure: kein Access Key gesetzt');
+      return false;
+    }
+
+    // Neu initialisieren
+    const ok = await this.initPorcupine();
     if (!ok) {
       ToastAndroid.show(
-        `Wake-Word "${KEYWORD_LABELS[next]}" konnte nicht initialisiert werden — Logs pruefen`,
+        `Wake-Word "${this.keyword}" konnte nicht initialisiert werden — Logs pruefen`,
         ToastAndroid.LONG,
       );
     }
     return ok;
   }
 
-  private async initNative(): Promise<boolean> {
+  private async initPorcupine(): Promise<boolean> {
-    if (!OpenWakeWord) {
-      console.warn('[WakeWord] OpenWakeWord Native-Modul nicht verfuegbar — Direkt-Aufnahme-Fallback aktiv');
-      this.nativeReady = false;
-      return false;
-    }
     if (this.initInProgress) return this.initInProgress;
     this.initInProgress = (async () => {
       try {
-        await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
+        const porcupineRN = require('@picovoice/porcupine-react-native');
-        // Subscribe nur einmal
+        const { PorcupineManager, BuiltInKeywords } = porcupineRN;
-        if (!this.eventSub) {
+        // Manche Porcupine-Versionen wollen das BuiltInKeywords-Enum (Objekt
-          const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
+        // mit keys wie JARVIS, COMPUTER, HEY_GOOGLE), andere akzeptieren
-          this.eventSub = emitter.addListener('WakeWordDetected', () => {
+        // den String direkt. Mappen mit Fallback auf String:
-            console.log('[WakeWord] Native Detection-Event empfangen');
+        const enumKey = this.keyword.toUpperCase().replace(/\s+/g, '_');
+        const kw = (BuiltInKeywords && BuiltInKeywords[enumKey]) || this.keyword;
+        console.log('[WakeWord] Porcupine init: keyword=%s (resolved=%s)',
+                    this.keyword, typeof kw === 'string' ? kw : '[enum]');
+        this.porcupine = await PorcupineManager.fromBuiltInKeywords(
+          this.accessKey,
+          [kw],
+          (keywordIndex: number) => {
+            console.log('[WakeWord] Porcupine callback fired (index=%d)', keywordIndex);
             this.onWakeDetected().catch(err =>
               console.warn('[WakeWord] onWakeDetected crashed:', err));
-          });
+          },
-        }
+          // Error handler (wenn Porcupine im Background-Thread crashed,
-        this.nativeReady = true;
+          // z.B. beim Audio-Engine-Konflikt mit audio-recorder-player)
-        console.log('[WakeWord] Init OK (model=%s)', this.keyword);
+          (error: any) => {
+            console.warn('[WakeWord] Porcupine runtime error:', error?.message || error);
+            // Nicht in Loop crashen — state zurueck auf off damit der User
+            // mit dem Aufnahme-Button wieder normal arbeiten kann
+            this.setState('off');
+            this.disposePorcupine().catch(() => {});
+          },
+        );
+        console.log('[WakeWord] Porcupine init OK (keyword=%s, manager=%s)',
+                    this.keyword, this.porcupine ? 'created' : 'NULL');
         return true;
       } catch (err: any) {
-        console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
+        console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err?.message || err);
-        this.nativeReady = false;
+        console.warn('[WakeWord] err details:', JSON.stringify({
+          name: err?.name, code: err?.code, stack: err?.stack?.slice(0, 200),
+        }));
+        this.porcupine = null;
         return false;
       } finally {
         this.initInProgress = null;
@@ -143,24 +145,27 @@ class WakeWordService {
     return this.initInProgress;
   }
 
-  private async disposeNative(): Promise<void> {
+  private async disposePorcupine() {
-    if (!OpenWakeWord) return;
+    if (this.porcupine) {
-    try { await OpenWakeWord.dispose(); } catch {}
+      try { await this.porcupine.stop(); } catch {}
-    this.nativeReady = false;
+      try { await this.porcupine.delete(); } catch {}
+      this.porcupine = null;
+    }
   }
 
   /** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
   async start(): Promise<boolean> {
     if (this.state !== 'off') return true;
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine) {
+      // Passives Lauschen via Porcupine
       try {
-        await OpenWakeWord.start();
+        await this.porcupine.start();
-        console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
+        console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
-        ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        ToastAndroid.show(`Lausche auf "${this.keyword}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return true;
       } catch (err: any) {
-        console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
+        console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:',
                      err?.message || err);
         ToastAndroid.show(
           `Wake-Word-Start failed: ${err?.message || err}`,
@@ -168,13 +173,14 @@ class WakeWordService {
         );
       }
     } else {
-      console.warn('[WakeWord] Native-Modul nicht bereit — Direkt-Aufnahme-Fallback');
+      // Kein Porcupine init → User explicit informieren
+      console.warn('[WakeWord] Porcupine nicht initialisiert — Access Key fehlt? Fallback Direkt-Aufnahme');
       ToastAndroid.show(
         'Wake-Word nicht aktiv — direkte Aufnahme startet (Mikro hoert mit)',
         ToastAndroid.LONG,
       );
     }
-    // Fallback: direkt in Konversation
+    // Fallback: direkt in die Konversation (Mikro AKTIV, nicht passive)
     console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
     this.setState('conversing');
     setTimeout(() => {
@@ -188,20 +194,21 @@ class WakeWordService {
   /** Komplett ausschalten (Ohr abschalten) */
   async stop(): Promise<void> {
     console.log('[WakeWord] Ohr deaktiviert');
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine) {
-      try { await OpenWakeWord.stop(); } catch {}
+      try { await this.porcupine.stop(); } catch {}
     }
     this.setState('off');
   }
 
-  /** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
+  /** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
   private async onWakeDetected(): Promise<void> {
     console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
-    ToastAndroid.show(`Wake-Word "${KEYWORD_LABELS[this.keyword]}" erkannt — sprich jetzt`, ToastAndroid.SHORT);
+    ToastAndroid.show(`Wake-Word "${this.keyword}" erkannt — sprich jetzt`, ToastAndroid.SHORT);
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine) {
-      try { await OpenWakeWord.stop(); } catch {}
+      try { await this.porcupine.stop(); } catch {}
     }
     this.setState('conversing');
+    // kurz warten damit Mikrofon frei ist
     setTimeout(() => {
       if (this.state === 'conversing') {
         this.wakeCallbacks.forEach(cb => cb());
@@ -210,16 +217,16 @@ class WakeWordService {
   }
 
   /** Konversation beenden — User hat im Window nichts gesagt.
-   *  Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
+   *  Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
    *  Ohne: zurueck zu 'off'.
    */
   async endConversation(): Promise<void> {
     if (this.state !== 'conversing') return;
-    if (this.nativeReady && OpenWakeWord) {
+    if (this.porcupine && this.accessKey) {
       try {
-        await OpenWakeWord.start();
+        await this.porcupine.start();
         console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
-        ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
+        ToastAndroid.show(`Lausche wieder auf "${this.keyword}"`, ToastAndroid.SHORT);
         this.setState('armed');
         return;
       } catch (err) {
@@ -252,10 +259,10 @@ class WakeWordService {
   }
 
   hasWakeWord(): boolean {
-    return this.nativeReady;
+    return !!this.porcupine;
   }
 
-  getKeyword(): WakeKeyword {
+  getKeyword(): string {
     return this.keyword;
   }
 

bridge/aria_bridge.py

@@ -907,13 +907,18 @@ class ARIABridge:
             logger.info("[core] TTS unterdrueckt (Modus: %s)", self.current_mode.config.name)
             return
 
-        # Voice bestimmen: App-Override (gesetzt durch letzten chat-Event) > globale
+        # Voice bestimmen: App-Override fuer diesen Request > globale Default-Voice
-        # Default-Voice. Der Override wird NICHT pro Antwort verbraucht — sonst nutzt
-        # eine Multi-Turn-Antwort von ARIA (Tool-Use + finale Antwort) ab dem zweiten
-        # TTS-Call wieder die alte Default-Stimme. Der Override bleibt gueltig bis
-        # zum naechsten chat-Event, wo er entweder ueberschrieben oder geloescht wird.
         xtts_voice = self._next_voice_override or getattr(self, 'xtts_voice', '')
+        # Override verbrauchen (gilt nur fuer genau diese naechste Antwort)
+        if self._next_voice_override:
+            logger.info("[core] Nutze Voice-Override: %s", self._next_voice_override)
+            self._next_voice_override = None
+
+        # Speed ebenfalls aus App-Override nehmen (fallback 1.0)
         xtts_speed = self._next_speed_override or 1.0
+        if self._next_speed_override:
+            logger.info("[core] Nutze Speed-Override: %.2fx", self._next_speed_override)
+            self._next_speed_override = None
 
         tts_text = tts_text_preview or text
         if not tts_text:
@@ -1164,22 +1169,18 @@ class ARIABridge:
             if sender in ("aria", "stt"):
                 return
             text = payload.get("text", "")
-            # Voice-Override fuer Folgenachrichten setzen — gilt bis zum naechsten
+            # Voice-Override fuer die naechste ARIA-Antwort merken
-            # chat-Event. Leerer String "" = explizit Default-Voice (override loeschen).
+            voice_override = payload.get("voice", "")
-            # Field nicht gesendet = vorherigen Override unveraendert lassen (z.B. wenn
+            if voice_override:
-            # cancel_request oder anderer Service die App umgeht).
+                self._next_voice_override = voice_override
-            if "voice" in payload:
+                logger.info("[rvs] Voice-Override fuer naechste Antwort: %s", voice_override)
-                voice_override = payload.get("voice", "") or ""
-                self._next_voice_override = voice_override or None
-                logger.info("[rvs] Voice fuer Antworten: %s",
-                            self._next_voice_override or "(Default)")
             # Speed-Override (TTS-Wiedergabegeschwindigkeit, pro Geraet)
-            if "speed" in payload:
+            try:
-                try:
+                speed = float(payload.get("speed", 0) or 0)
-                    speed = float(payload.get("speed", 0) or 0)
+                if 0.1 <= speed <= 5.0:
-                    self._next_speed_override = speed if 0.1 <= speed <= 5.0 else None
+                    self._next_speed_override = speed
-                except (TypeError, ValueError):
+            except (TypeError, ValueError):
-                    self._next_speed_override = None
+                pass
             if text:
                 logger.info("[rvs] App-Chat: '%s'", text[:80])
                 await self.send_to_core(text, source="app")
@@ -1443,18 +1444,17 @@ class ARIABridge:
             if not audio_b64:
                 logger.warning("[rvs] Audio ohne Daten empfangen")
                 return
-            # Voice-Override fuer Folgenachrichten — gleiche Semantik wie beim chat-Event.
+            # Voice-Override fuer die kommende ARIA-Antwort (App-lokal gewaehlt)
-            if "voice" in payload:
+            voice_override = payload.get("voice", "")
-                voice_override = payload.get("voice", "") or ""
+            if voice_override:
-                self._next_voice_override = voice_override or None
+                self._next_voice_override = voice_override
-                logger.info("[rvs] Voice fuer Antworten (via Audio): %s",
+                logger.info("[rvs] Voice-Override (via Audio): %s", voice_override)
-                            self._next_voice_override or "(Default)")
+            try:
-            if "speed" in payload:
+                speed = float(payload.get("speed", 0) or 0)
-                try:
+                if 0.1 <= speed <= 5.0:
-                    speed = float(payload.get("speed", 0) or 0)
+                    self._next_speed_override = speed
-                    self._next_speed_override = speed if 0.1 <= speed <= 5.0 else None
+            except (TypeError, ValueError):
-                except (TypeError, ValueError):
+                pass
-                    self._next_speed_override = None
             logger.info("[rvs] Audio empfangen: %s, %dms, %dKB",
                         mime_type, duration_ms, len(audio_b64) // 1365)
             asyncio.create_task(self._process_app_audio(audio_b64, mime_type))

xtts/f5tts/bridge.py

@@ -239,8 +239,6 @@ class F5Runner:
 
     def _infer_blocking(self, gen_text: str, ref_wav: str, ref_text: str,
                         speed: float = 1.0) -> tuple[np.ndarray, int]:
-        logger.info("infer() text=%d chars, speed=%.2f, cfg=%.2f, nfe=%d",
-                    len(gen_text), speed, self.cfg_strength, self.nfe_step)
         wav, sr, _ = self.model.infer(
             ref_file=ref_wav,
             ref_text=ref_text,