Hacker-Software/ARIA-AGENT
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 82 Wiki Activity

feat: Porcupine Wake-Word Integration (Built-In Keywords, "Jarvis" default)

Browse Source 
WakeWordService wrappt jetzt Picovoice Porcupine:
  - loadFromStorage(): Access Key + Keyword aus AsyncStorage, init Porcupine
  - configure(key, keyword): Settings-Wechsel, Re-Init
  - start(): wenn Porcupine bereit → 'armed' (passives Lauschen),
    sonst Fallback auf direktes 'conversing' (klassischer Modus)
  - onWakeDetected: Porcupine pausieren → 'conversing' → wakeCallback
  - endConversation: Porcupine wieder starten → 'armed' (Wake-Word weiter
    aktiv im Hintergrund, kein erneuter Tap noetig)
  - Pro Geraet eigene Wahl: jeder User kann sein eigenes Wake-Word haben

Settings: neuer Bereich "Wake-Word"
  - Picovoice Access Key Input (mit Eye-Toggle), kostenlos auf
    console.picovoice.ai
  - Built-In Keyword Chips: jarvis, computer, picovoice, porcupine,
    bumblebee, terminator, alexa, hey google, ok google, hey siri
  - "Speichern + Aktivieren" Button mit Status-Feedback
  - Hinweis dass "ARIA" Custom-Keyword spaeter via Diagnostic kommt

ChatScreen: ruft wakeWordService.loadFromStorage() beim Mount.

package.json: @picovoice/porcupine-react-native + react-native-voice-processor
hinzugefuegt — npm install + native rebuild noetig.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
duffyduck
2026-04-24 15:23:51 +02:00
parent 1b8a51aad0
commit 22fa4b3ccf
4 changed files with 289 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files
android/src/services/wakeword.ts
+165 -39
View File
@@ -3,69 +3,188 @@
*
* Drei Zustaende:
* off — Ohr aus, nichts laeuft
* armed — Ohr aktiv, wartet auf Wake Word ("ARIA"). Mikro IST AUS.
* (Sobald Porcupine integriert ist, hoert hier der Wake-Word-
* Detektor passiv mit. Aktuell ist das gleichbedeutend mit "off"
* bis der User wieder tippt — Stub fuer spaeter.)
* conversing — Wake Word getriggert / Ohr-Tap ohne Wake Word: aktive Konvers-
* ation mit ARIA. Mikro oeffnet nach jeder ARIA-Antwort fuer X
* Sekunden (Conversation-Window). Spricht der User nichts in dem
* Fenster → zurueck auf armed (kein erneuter Tap noetig sobald
* Porcupine drin ist).
* armed — Ohr aktiv, Porcupine hoert passiv auf das Wake-Word.
* Das Mikro ist von Porcupine belegt; AudioRecorder ist aus.
* conversing — Wake-Word getriggert (oder Ohr-Tap ohne Wake-Word):
* 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.
*
* Aktuell ohne Porcupine: armed wird nur als Lifecycle-State gefuehrt; bei
* Conversation-Ende geht's direkt auf 'off' damit User klares Feedback bekommt.
* Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
* direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
* geht dann nach 'off' statt 'armed'.
*/
import AsyncStorage from '@react-native-async-storage/async-storage';
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';
/** Built-In Keywords von Picovoice — pre-trained, sofort einsetzbar.
* Custom Keywords (z.B. "ARIA") brauchen ein .ppn File aus der Picovoice
* Console — wird spaeter ueber Diagnostic uploadbar. */
export const BUILTIN_KEYWORDS = [
'jarvis',
'computer',
'picovoice',
'porcupine',
'bumblebee',
'terminator',
'alexa',
'hey google',
'ok google',
'hey siri',
] as const;
export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
class WakeWordService {
private state: WakeWordState = 'off';
private wakeCallbacks: WakeWordCallback[] = [];
private stateCallbacks: StateCallback[] = [];
private wakeWordSupported: boolean = false; // wird gesetzt wenn Porcupine spaeter integriert ist
/** Ohr-Button gedrueckt — startet Konversation (oder armed wenn Wake-Word verfuegbar) */
// Picovoice Manager (lazy, da Native Module nicht in jedem Build verfuegbar ist)
private porcupine: any = null;
private accessKey: string = '';
private keyword: string = DEFAULT_KEYWORD;
private initInProgress: Promise<boolean> | null = null;
/** 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);
this.accessKey = (k || '').trim();
this.keyword = (w || DEFAULT_KEYWORD).trim();
if (this.accessKey) {
// Vorinitialisieren — wirft sich nicht durch wenn etwas fehlt
await this.initPorcupine();
}
} catch (err) {
console.warn('[WakeWord] loadFromStorage', err);
}
}
/** Settings-Wechsel — neuer Key oder Keyword. Re-Init Porcupine. */
async configure(accessKey: string, keyword: string): Promise<boolean> {
this.accessKey = (accessKey || '').trim();
this.keyword = (keyword || DEFAULT_KEYWORD).trim();
await AsyncStorage.setItem(WAKE_ACCESS_KEY_STORAGE, this.accessKey);
await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, this.keyword);
// Laufende Instanz stoppen
await this.disposePorcupine();
if (!this.accessKey) return false;
// Neu initialisieren
return this.initPorcupine();
}
private async initPorcupine(): Promise<boolean> {
if (this.initInProgress) return this.initInProgress;
this.initInProgress = (async () => {
try {
const { PorcupineManager } = require('@picovoice/porcupine-react-native');
// Built-In Keyword-Identifier sind lower-case strings im SDK
this.porcupine = await PorcupineManager.fromBuiltInKeywords(
this.accessKey,
[this.keyword],
(_keywordIndex: number) => this.onWakeDetected(),
);
console.log('[WakeWord] Porcupine init OK (keyword=%s)', this.keyword);
return true;
} catch (err) {
console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err);
this.porcupine = null;
return false;
} finally {
this.initInProgress = null;
}
})();
return this.initInProgress;
}
private async disposePorcupine() {
if (this.porcupine) {
try { await this.porcupine.stop(); } catch {}
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.wakeWordSupported) {
// Spaeter: Porcupine starten und auf "ARIA" warten
console.log('[WakeWord] armed — warte auf Wake Word');
this.setState('armed');
} else {
// Heute: direkt in die Konversation
console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
this.setState('conversing');
setTimeout(() => {
if (this.state === 'conversing') {
this.wakeCallbacks.forEach(cb => cb());
}
}, 500);
if (this.porcupine) {
// Passives Lauschen via Porcupine
try {
await this.porcupine.start();
console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
this.setState('armed');
return true;
} catch (err) {
console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:', err);
}
}
// Fallback: direkt in die Konversation
console.log('[WakeWord] Konversation startet sofort (kein Wake-Word)');
this.setState('conversing');
setTimeout(() => {
if (this.state === 'conversing') {
this.wakeCallbacks.forEach(cb => cb());
}
}, 500);
return true;
}
/** Komplett ausschalten (Ohr abschalten) */
stop(): void {
async stop(): Promise<void> {
console.log('[WakeWord] Ohr deaktiviert');
if (this.porcupine) {
try { await this.porcupine.stop(); } catch {}
}
this.setState('off');
}
/** Konversation beenden — User hat im Window nichts gesagt.
* Mit Porcupine: zurueck zu 'armed'. Ohne: zurueck zu 'off'.
*/
endConversation(): void {
if (this.state !== 'conversing') return;
if (this.wakeWordSupported) {
console.log('[WakeWord] Konversation zu Ende — zurueck zu armed (warte auf Wake Word)');
this.setState('armed');
} else {
console.log('[WakeWord] Konversation zu Ende — Ohr aus (kein Wake Word verfuegbar)');
this.setState('off');
/** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
private async onWakeDetected(): Promise<void> {
console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
if (this.porcupine) {
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());
}
}, 200);
}
/** Konversation beenden — User hat im Window nichts gesagt.
* Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
* Ohne: zurueck zu 'off'.
*/
async endConversation(): Promise<void> {
if (this.state !== 'conversing') return;
if (this.porcupine && this.accessKey) {
try {
await this.porcupine.start();
console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
this.setState('armed');
return;
} catch (err) {
console.warn('[WakeWord] re-arm fehlgeschlagen:', err);
}
}
console.log('[WakeWord] Konversation zu Ende — Ohr aus');
this.setState('off');
}
/** Nach ARIA-Antwort (TTS fertig): naechste Aufnahme im Conversation-Window starten */
@@ -84,11 +203,18 @@ class WakeWordService {
return this.state !== 'off';
}
/** True wenn gerade aktiv aufgenommen / mit ARIA gesprochen wird. */
isConversing(): boolean {
return this.state === 'conversing';
}
hasWakeWord(): boolean {
return !!this.porcupine;
}
getKeyword(): string {
return this.keyword;
}
// --- Callbacks ---
onWakeWord(callback: WakeWordCallback): () => void {