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

feat(app): Wake-Word komplett on-device via openWakeWord (ONNX)

Browse Source 
Picovoice/Porcupine raus — neuer Stack ist openWakeWord (Apache 2.0,
on-device, ONNX Runtime). Kein API-Key, keine Lizenzgebuehren, Audio
verlaesst das Geraet nicht. Eigene Wake-Words sind via openWakeWord-
Notebook gratis trainierbar.

Pipeline (alles im OpenWakeWordModule.kt):
  1. AudioRecord 16kHz mono int16 in 1280-Sample-Chunks (80ms)
  2. melspectrogram.onnx → 32-mel Frames (mel/10 + 2 wie in Python)
  3. embedding_model.onnx, 76-Frame Sliding Window (stride 8) → 96-dim
  4. hey_jarvis.onnx (oder anderes Keyword) auf letzten 16 Embeddings
  5. Sigmoid-Score, threshold/patience/debounce-Filter
  6. RN-Event "WakeWordDetected" raus

Mitgelieferte Modelle in assets/openwakeword/: hey_jarvis (Default),
alexa, hey_mycroft, hey_rhasspy. Externe Service-API (start/stop/
configure/onWakeWord/...) bleibt identisch — ChatScreen unveraendert.

build.gradle: com.microsoft.onnxruntime:onnxruntime-android:1.17.1
package.json: @picovoice/porcupine-react-native + voice-processor raus
SettingsScreen: AccessKey-Feld weg, neue Keyword-Liste mit Labels
README: Wake-Word-Sektion komplett umgeschrieben (kein Picovoice mehr)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
duffyduck
2026-04-26 12:56:33 +02:00
parent a4d3449e3a
commit 55cfb752a2
14 changed files with 532 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files
android/src/screens/SettingsScreen.tsx
+14 -40
View File
@@ -41,9 +41,9 @@ import {
TTS_SPEED_STORAGE_KEY,
} from '../services/audio';
import wakeWordService, {
BUILTIN_KEYWORDS,
WAKE_KEYWORDS,
KEYWORD_LABELS,
DEFAULT_KEYWORD,
WAKE_ACCESS_KEY_STORAGE,
WAKE_KEYWORD_STORAGE,
} from '../services/wakeword';
import ModeSelector from '../components/ModeSelector';
@@ -103,8 +103,6 @@ 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);
@@ -164,11 +162,8 @@ 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) setWakeKeyword(saved);
if (saved && (WAKE_KEYWORDS as readonly string[]).includes(saved)) setWakeKeyword(saved);
});
AsyncStorage.getItem('aria_xtts_voice').then(saved => {
if (saved) setXttsVoice(saved);
@@ -678,44 +673,23 @@ const SettingsScreen: React.FC = () => {
</View>
</View>
{/* === Wake-Word (geraetelokal) === */}
{/* === Wake-Word (komplett on-device, openWakeWord) === */}
<Text style={styles.sectionTitle}>Wake-Word</Text>
<View style={styles.card}>
<Text style={styles.toggleHint}>
Wenn ein Picovoice-Access-Key eingetragen ist, hoert die App passiv
auf das gewaehlte Wake-Word — du kannst dich mit anderen unterhalten,
Musik laufen lassen und mit "{wakeKeyword}" eine Konversation mit
ARIA starten. Ohne Key oder bei Fehlschlag startet das Ohr direkt
eine Konversation (klassischer Modus).
Lokale Erkennung via openWakeWord (ONNX, on-device). Kein API-Key,
kein Cloud-Roundtrip — Audio verlaesst das Geraet nicht. Wenn das Ohr
aktiv ist, hoerst du normal mit; sagst du das Wake-Word, startet eine
Konversation mit ARIA.
</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}>
Built-In: sofort verwendbar. "ARIA" als Custom-Keyword kommt spaeter
ueber Diagnostic-Upload.
Eigene Wake-Words via openWakeWord-Notebook trainierbar (gratis).
Custom-Upload ueber Diagnostic kommt in einer spaeteren Version.
</Text>
<View style={{flexDirection: 'row', flexWrap: 'wrap', gap: 6, marginTop: 8}}>
{BUILTIN_KEYWORDS.map(kw => (
{WAKE_KEYWORDS.map(kw => (
<TouchableOpacity
key={kw}
style={[
@@ -728,7 +702,7 @@ const SettingsScreen: React.FC = () => {
styles.keywordChipText,
wakeKeyword === kw && styles.keywordChipTextActive,
]}>
{kw}
{KEYWORD_LABELS[kw]}
</Text>
</TouchableOpacity>
))}
@@ -740,8 +714,8 @@ const SettingsScreen: React.FC = () => {
onPress={async () => {
setWakeStatus('Initialisiere...');
try {
const ok = await wakeWordService.configure(wakeAccessKey, wakeKeyword);
setWakeStatus(ok ? `✅ "${wakeKeyword}" bereit` : '❌ Fehlgeschlagen — Access Key pruefen');
const ok = await wakeWordService.configure(wakeKeyword);
setWakeStatus(ok ? `✅ "${KEYWORD_LABELS[wakeKeyword as keyof typeof KEYWORD_LABELS]}" bereit` : '❌ Init-Fehler — Logs pruefen');
} catch (err: any) {
setWakeStatus('❌ ' + String(err?.message || err).slice(0, 80));
}
android/src/services/wakeword.ts
+104 -113
View File
@@ -1,142 +1,138 @@
/**
* 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, 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),
* armed — Ohr aktiv, openWakeWord hoert passiv auf das Wake-Word.
* Das Mikro ist von OpenWakeWord belegt; AudioRecorder ist aus.
* conversing — Wake-Word getriggert (oder Ohr-Tap manuell):
* aktive Konversation. OpenWakeWord 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.
*
* Wake-Word fallback: ist kein Picovoice-Access-Key gesetzt, geht 'start'
* direkt in 'conversing' (klassischer Gespraechsmodus). 'endConversation'
* geht dann nach 'off' statt 'armed'.
* Faellt das Native-Modul aus (alte App-Version, ONNX-Init-Fehler), geht
* 'start' direkt in 'conversing' (klassischer Direkt-Aufnahme-Modus).
*/
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';
/** 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',
/** Verfuegbare Wake-Words — entsprechen den .onnx Dateien in
* android/app/src/main/assets/openwakeword/. Custom-Keywords (eigenes
* Training via openwakeword Notebook) muessen aktuell als Asset eingebaut
* werden — Diagnostic-Upload ist Phase 2. */
export const WAKE_KEYWORDS = [
'hey_jarvis',
'alexa',
'hey google',
'ok google',
'hey siri',
'hey_mycroft',
'hey_rhasspy',
] as const;
export type BuiltinKeyword = typeof BUILTIN_KEYWORDS[number];
export const DEFAULT_KEYWORD: BuiltinKeyword = 'jarvis';
export type WakeKeyword = typeof WAKE_KEYWORDS[number];
export const DEFAULT_KEYWORD: WakeKeyword = 'hey_jarvis';
/** Hilfs-Mapping fuer die Anzeige im UI. */
export const KEYWORD_LABELS: Record<WakeKeyword, string> = {
hey_jarvis: 'Hey Jarvis',
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[] = [];
// 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 keyword: WakeKeyword = DEFAULT_KEYWORD;
private nativeReady: boolean = false;
private initInProgress: Promise<boolean> | null = null;
private eventSub: { remove: () => void } | null = null;
/** Beim App-Start aufrufen — laedt Settings, baut Porcupine wenn Key da ist. */
/** Beim App-Start aufrufen — laedt Settings, baut Native-Modul. */
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();
}
const wt = (w || DEFAULT_KEYWORD).trim() as WakeKeyword;
this.keyword = (WAKE_KEYWORDS as readonly string[]).includes(wt) ? wt : DEFAULT_KEYWORD;
await this.initNative();
} 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);
/** Settings-Wechsel: anderes Wake-Word. Re-Init des Native-Moduls. */
async configure(keyword: string): Promise<boolean> {
const next: WakeKeyword = (WAKE_KEYWORDS as readonly string[]).includes(keyword)
? (keyword as WakeKeyword)
: DEFAULT_KEYWORD;
this.keyword = next;
await AsyncStorage.setItem(WAKE_KEYWORD_STORAGE, next);
// Laufende Instanz stoppen
await this.disposePorcupine();
if (!this.accessKey) {
console.warn('[WakeWord] configure: kein Access Key gesetzt');
return false;
}
// Neu initialisieren
const ok = await this.initPorcupine();
// Laufende Instanz stoppen + neu initialisieren
await this.disposeNative();
const ok = await this.initNative();
if (!ok) {
ToastAndroid.show(
`Wake-Word "${this.keyword}" konnte nicht initialisiert werden — Logs pruefen`,
`Wake-Word "${KEYWORD_LABELS[next]}" konnte nicht initialisiert werden — Logs pruefen`,
ToastAndroid.LONG,
);
}
return ok;
}
private async initPorcupine(): Promise<boolean> {
private async initNative(): 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 {
const porcupineRN = require('@picovoice/porcupine-react-native');
const { PorcupineManager, BuiltInKeywords } = porcupineRN;
// Manche Porcupine-Versionen wollen das BuiltInKeywords-Enum (Objekt
// mit keys wie JARVIS, COMPUTER, HEY_GOOGLE), andere akzeptieren
// den String direkt. Mappen mit Fallback auf String:
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);
await OpenWakeWord.init(this.keyword, DEFAULT_THRESHOLD, DEFAULT_PATIENCE, DEFAULT_DEBOUNCE_MS);
// Subscribe nur einmal
if (!this.eventSub) {
const emitter = new NativeEventEmitter(NativeModules.OpenWakeWord);
this.eventSub = emitter.addListener('WakeWordDetected', () => {
console.log('[WakeWord] Native Detection-Event empfangen');
this.onWakeDetected().catch(err =>
console.warn('[WakeWord] onWakeDetected crashed:', err));
},
// Error handler (wenn Porcupine im Background-Thread crashed,
// z.B. beim Audio-Engine-Konflikt mit audio-recorder-player)
(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');
});
}
this.nativeReady = true;
console.log('[WakeWord] Init OK (model=%s)', this.keyword);
return true;
} catch (err: any) {
console.warn('[WakeWord] Porcupine init fehlgeschlagen:', err?.message || err);
console.warn('[WakeWord] err details:', JSON.stringify({
name: err?.name, code: err?.code, stack: err?.stack?.slice(0, 200),
}));
this.porcupine = null;
console.warn('[WakeWord] Init fehlgeschlagen:', err?.message || err);
this.nativeReady = false;
return false;
} finally {
this.initInProgress = null;
@@ -145,27 +141,24 @@ class WakeWordService {
return this.initInProgress;
}
private async disposePorcupine() {
if (this.porcupine) {
try { await this.porcupine.stop(); } catch {}
try { await this.porcupine.delete(); } catch {}
this.porcupine = null;
}
private async disposeNative(): Promise<void> {
if (!OpenWakeWord) return;
try { await OpenWakeWord.dispose(); } catch {}
this.nativeReady = false;
}
/** Ohr-Button gedrueckt — startet passives Lauschen oder direkt Konversation. */
async start(): Promise<boolean> {
if (this.state !== 'off') return true;
if (this.porcupine) {
// Passives Lauschen via Porcupine
if (this.nativeReady && OpenWakeWord) {
try {
await this.porcupine.start();
console.log('[WakeWord] armed — warte auf Wake Word "%s"', this.keyword);
ToastAndroid.show(`Lausche auf "${this.keyword}"`, ToastAndroid.SHORT);
await OpenWakeWord.start();
console.log('[WakeWord] armed — warte auf "%s"', this.keyword);
ToastAndroid.show(`Lausche auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
this.setState('armed');
return true;
} catch (err: any) {
console.warn('[WakeWord] Porcupine start fehlgeschlagen — Fallback Direkt-Konversation:',
console.warn('[WakeWord] start fehlgeschlagen — Fallback Direkt-Aufnahme:',
err?.message || err);
ToastAndroid.show(
`Wake-Word-Start failed: ${err?.message || err}`,
@@ -173,14 +166,13 @@ class WakeWordService {
);
}
} else {
// Kein Porcupine init → User explicit informieren
console.warn('[WakeWord] Porcupine nicht initialisiert — Access Key fehlt? Fallback Direkt-Aufnahme');
console.warn('[WakeWord] Native-Modul nicht bereit — Direkt-Aufnahme-Fallback');
ToastAndroid.show(
'Wake-Word nicht aktiv — direkte Aufnahme startet (Mikro hoert mit)',
ToastAndroid.LONG,
);
}
// Fallback: direkt in die Konversation (Mikro AKTIV, nicht passive)
// Fallback: direkt in Konversation
console.log('[WakeWord] Direkt-Aufnahme startet (kein Wake-Word)');
this.setState('conversing');
setTimeout(() => {
@@ -194,21 +186,20 @@ class WakeWordService {
/** Komplett ausschalten (Ohr abschalten) */
async stop(): Promise<void> {
console.log('[WakeWord] Ohr deaktiviert');
if (this.porcupine) {
try { await this.porcupine.stop(); } catch {}
if (this.nativeReady && OpenWakeWord) {
try { await OpenWakeWord.stop(); } catch {}
}
this.setState('off');
}
/** Wake-Word getriggert: Porcupine pausieren, Konversation starten. */
/** Wake-Word getriggert: Native-Modul pausieren, Konversation starten. */
private async onWakeDetected(): Promise<void> {
console.log('[WakeWord] Wake-Word "%s" erkannt!', this.keyword);
ToastAndroid.show(`Wake-Word "${this.keyword}" erkannt — sprich jetzt`, ToastAndroid.SHORT);
if (this.porcupine) {
try { await this.porcupine.stop(); } catch {}
ToastAndroid.show(`Wake-Word "${KEYWORD_LABELS[this.keyword]}" erkannt — sprich jetzt`, ToastAndroid.SHORT);
if (this.nativeReady && OpenWakeWord) {
try { await OpenWakeWord.stop(); } catch {}
}
this.setState('conversing');
// kurz warten damit Mikrofon frei ist
setTimeout(() => {
if (this.state === 'conversing') {
this.wakeCallbacks.forEach(cb => cb());
@@ -217,16 +208,16 @@ class WakeWordService {
}
/** Konversation beenden — User hat im Window nichts gesagt.
* Mit Wake-Word: zurueck zu 'armed' (Porcupine wieder an).
* Mit Wake-Word: zurueck zu 'armed' (Listener wieder an).
* Ohne: zurueck zu 'off'.
*/
async endConversation(): Promise<void> {
if (this.state !== 'conversing') return;
if (this.porcupine && this.accessKey) {
if (this.nativeReady && OpenWakeWord) {
try {
await this.porcupine.start();
await OpenWakeWord.start();
console.log('[WakeWord] Konversation zu Ende — zurueck zu armed');
ToastAndroid.show(`Lausche wieder auf "${this.keyword}"`, ToastAndroid.SHORT);
ToastAndroid.show(`Lausche wieder auf "${KEYWORD_LABELS[this.keyword]}"`, ToastAndroid.SHORT);
this.setState('armed');
return;
} catch (err) {
@@ -259,10 +250,10 @@ class WakeWordService {
}
hasWakeWord(): boolean {
return !!this.porcupine;
return this.nativeReady;
}
getKeyword(): string {
getKeyword(): WakeKeyword {
return this.keyword;
}