react-native-wakeword-sid 1.1.55

package/wakewords/KeyWordRNBridge.js

@@ -0,0 +1,228 @@
+// KeyWordRNBridge.js
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const { KeyWordRNBridge } = NativeModules;
+const keywordRNBridgeEmitter = new NativeEventEmitter(KeyWordRNBridge);
+
+if (KeyWordRNBridge) {
+    console.log("KeyWordRNBridge is loaded:", KeyWordRNBridge);
+  } else {
+    console.error("KeyWordRNBridge is not linked correctly.");
+  }
+  
+export class KeyWordRNBridgeInstance {
+    instanceId;
+    listeners = [];
+    isFirstInstance = false;
+  
+    constructor(instanceId, isSticky) {
+      this.instanceId = instanceId;
+      this.isSticky = isSticky;
+    }
+  
+    async createInstanceMulti(modelNames, thresholds, bufferCnts, msBetweenCallbacks) {
+        const instance = await KeyWordRNBridge.createInstanceMulti(
+            this.instanceId,
+            modelNames,
+            thresholds,
+            bufferCnts,
+            msBetweenCallbacks
+        );
+
+        if (instance && this.isFirstInstance) {
+            this.isFirstInstance = false;
+            await KeyWordRNBridge.startForegroundService(this.instanceId);
+        }
+
+        return instance;
+    }
+
+    async createInstance(modelName, threshold, bufferCnt) {
+      const instance = await KeyWordRNBridge.createInstance(
+        this.instanceId,
+        modelName,
+        threshold,
+        bufferCnt);
+      if (instance && this.isFirstInstance)
+      {
+        this.isFirstInstance = false;
+        await KeyWordRNBridge.startForegroundService(this.instanceId); 
+      }
+      return instance;
+    }
+
+    // 1) Voice props (parity with VAD)
+    async getVoiceProps() {
+        try {
+            const voiceProps = await KeyWordRNBridge.getVoiceProps(this.instanceId);
+            return {
+            error: voiceProps.error,
+            voiceProbability: voiceProps.voiceProbability,
+            lastTimeHumanVoiceHeard: voiceProps.lastTimeHumanVoiceHeard,
+            };
+        } catch (error) {
+            console.error('Error getting voice properties:', error);
+            throw error;
+        }
+    }
+
+    // 2) Silent VAD control (iOS-only, optional but useful)
+    async startSilentVADDetection() {
+        if (Platform.OS === 'ios') {
+            return await KeyWordRNBridge.startSilentVADDetection(this.instanceId);
+        }
+    }
+
+    async stopSilentVADDetection() {
+        if (Platform.OS === 'ios') {
+            return await KeyWordRNBridge.stopSilentVADDetection(this.instanceId);
+        }
+    }
+
+    // 3) Explicit VAD start/stop (if exposed by your native bridge)
+    async startVADDetection() {
+        return await KeyWordRNBridge.startVADDetection(this.instanceId);
+    }
+    async stopVADDetection() {
+        return await KeyWordRNBridge.stopVADDetection(this.instanceId);
+    }
+
+    // 4) (Optional) VAD event listener if your native layer emits it
+    onVADDetectionEvent(callback) {
+        const listener = keywordRNBridgeEmitter.addListener('onVADDetectionEvent', (event) => {
+            if (event.instanceId === this.instanceId) {
+            callback(event.phrase);
+            }
+        });
+        this.listeners.push(listener);
+        return listener;
+    }
+
+        // Configure VAD runtime parameters
+    async setVADParams(threshold, msWindow) {
+        return await KeyWordRNBridge.setVADParams(this.instanceId, threshold, msWindow);
+    }
+
+    async getVADParams() {
+        // implement only if native exposes it
+        return await KeyWordRNBridge.getVADParams(this.instanceId);
+    }
+
+    async setKeywordDetectionLicense(license) {
+        return await KeyWordRNBridge.setKeywordDetectionLicense(this.instanceId, license);
+    }
+
+    async replaceKeywordDetectionModel(modelName, threshold, bufferCnt) {
+        return KeyWordRNBridge.replaceKeywordDetectionModel(this.instanceId, modelName, threshold, bufferCnt);
+    }
+    /*startForegroundService() {
+        return KeyWordRNBridge.startForegroundService(this.instanceId);
+    }
+
+    stopForegroundService() {
+        return KeyWordRNBridge.stopForegroundService(this.instanceId);
+    }*/
+    async setKeywordLicense(license) {
+        return KeyWordRNBridge.setKeywordLicense(this.instanceId, license);
+    }
+
+    async startKeywordDetection(threshold,
+        setActive = true,
+        duckOthers = false,
+        mixWithOthers = true,
+        defaultToSpeaker = true) {
+    
+        if (Platform.OS === 'ios') {
+            return KeyWordRNBridge.startKeywordDetection(
+                this.instanceId,
+                threshold,
+                setActive,
+                duckOthers,
+                mixWithOthers,
+                defaultToSpeaker
+              );
+        } else {
+            return KeyWordRNBridge.startKeywordDetection(this.instanceId, threshold);
+        }
+    }
+
+    async getRecordingWav() {
+        return await KeyWordRNBridge.getRecordingWav(this.instanceId);
+    }
+
+    async stopKeywordDetection() {
+        return KeyWordRNBridge.stopKeywordDetection(this.instanceId);
+    }
+
+    async destroyInstance() {
+        return KeyWordRNBridge.destroyInstance(this.instanceId);
+    }
+
+    onKeywordDetectionEvent(callback) {
+        const listener = keywordRNBridgeEmitter.addListener('onKeywordDetectionEvent', (event) => {
+            if (event.instanceId === this.instanceId) {
+                console.log("event == .", event);
+                if (Platform.OS === 'ios') {
+                    console.log("event == .", event);
+                    callback(event.info);
+                } else {
+                    callback(event.phrase);
+                }
+            }
+        });
+        this.listeners.push(listener);
+        return listener;
+    }
+
+    removeListeners() {
+        this.listeners.forEach((listener) => listener.remove());
+        this.listeners = [];
+    }
+}
+
+export const removeAllRNBridgeListeners = async () => {
+    keywordRNBridgeEmitter.removeAllListeners('onKeywordDetectionEvent');
+    keywordRNBridgeEmitter.removeAllListeners('onVADDetectionEvent'); // NEW
+}
+
+export const createKeyWordRNBridgeInstance = async (instanceId, isSticky) => {
+    return await new KeyWordRNBridgeInstance(instanceId, isSticky);
+};
+
+export const enableDucking = async () => {
+    if (Platform.OS === 'ios') {
+        await KeyWordRNBridge.enableAggressiveDucking();
+    }
+}
+
+export const disableDucking = async () => {
+    if (Platform.OS === 'ios') {
+        await KeyWordRNBridge.disableDucking();
+    }
+}
+
+export const restartListeningAfterDucking = async () => {
+    if (Platform.OS === 'ios') {
+        await KeyWordRNBridge.restartListeningAfterDucking();
+    }
+}
+
+export const initAudioSessAndDuckManage = async () => {
+    if (Platform.OS === 'ios') {
+        await KeyWordRNBridge.initAudioSessAndDuckManage();
+    }
+}
+
+export const disableDuckingAndCleanup = async () => {
+    if (Platform.OS === 'ios') {
+        await KeyWordRNBridge.disableDuckingAndCleanup();
+    }
+}
+
+// NEW: global audio routing config setter (per package, not per instance)
+export const setWakewordAudioRoutingConfig = async (config) => {
+    if (Platform.OS === 'ios') {
+        // Native: implement KeyWordRNBridge.setAudioRoutingConfig(jsonString)
+        return KeyWordRNBridge.setAudioRoutingConfig(JSON.stringify(config));
+    }
+};

package/wakewords/SpeakerVerificationRNBridge.d.ts

@@ -0,0 +1,32 @@
+export class SpeakerVerificationRNBridgeInstance {
+    constructor(engineId: any);
+    engineId: any;
+    /**
+     * Create the native speaker verifier engine.
+     *
+     * modelPathOrName:
+     *   - absolute path OR "speaker_model.onnx" in the iOS app bundle
+     *   - OR require('./assets/speaker_model.onnx')
+     *
+     * enrollmentJsonPathOrName:
+     *   - absolute path OR "enrollment.json" in the iOS app bundle
+     *   - OR require('./assets/enrollment.json')
+     *
+     * options (optional):
+     *   { decisionThreshold, frameSize, tailSeconds, maxTailSeconds, cmn, expectedLayoutBDT, logLevel }
+     */
+    create(modelPathOrName: any, enrollmentJsonPathOrName: any, options?: {}): Promise<any>;
+    /**
+     * Verify WAV by streaming in native.
+     *
+     * wavPathOrName:
+     *   - absolute path OR "test.wav" in bundle
+     *   - OR require('./assets/test.wav')
+     *
+     * resetState:
+     *   - if true, clears internal streaming state before verification
+     */
+    verifyWavStreaming(wavPathOrName: any, resetState?: boolean): Promise<any>;
+    destroy(): Promise<any>;
+}
+export function createSpeakerVerificationInstance(engineId: any): Promise<SpeakerVerificationRNBridgeInstance>;

package/wakewords/SpeakerVerificationRNBridge.js

@@ -0,0 +1,124 @@
+// wakewords/SpeakerVerificationRNBridge.js
+import { NativeModules, Platform } from 'react-native';
+import resolveAssetSource from 'react-native/Libraries/Image/resolveAssetSource';
+
+// Keep using the SAME native module (KeyWordRNBridge.m already exports these methods)
+const { KeyWordRNBridge } = NativeModules;
+
+function stripFileScheme(uri) {
+  if (!uri) return uri;
+  return uri.startsWith('file://') ? uri.replace('file://', '') : uri;
+}
+
+// Accepts:
+// - string (absolute path OR "name.ext")
+// - require('...') (number) -> resolved to uri/path
+function normalizePathOrName(input) {
+  if (input == null) return input;
+
+  // require(...) returns a number in RN
+  if (typeof input === 'number') {
+    const src = resolveAssetSource(input);
+    // src.uri might be:
+    // - "file:///.../name.onnx" (iOS)
+    // - "asset:/name.onnx" or "assets:/..." (Android)
+    // We pass through; native iOS resolver handles bundle names too.
+    if (src?.uri) return stripFileScheme(src.uri);
+    return input;
+  }
+
+  if (typeof input === 'string') {
+    return stripFileScheme(input);
+  }
+
+  // if someone passes an object accidentally, just stringify it
+  return String(input);
+}
+
+export class SpeakerVerificationRNBridgeInstance {
+  engineId;
+
+  constructor(engineId) {
+    this.engineId = engineId;
+  }
+
+  /**
+   * Create the native speaker verifier engine.
+   *
+   * modelPathOrName:
+   *   - absolute path OR "speaker_model.onnx" in the iOS app bundle
+   *   - OR require('./assets/speaker_model.onnx')
+   *
+   * enrollmentJsonPathOrName:
+   *   - absolute path OR "enrollment.json" in the iOS app bundle
+   *   - OR require('./assets/enrollment.json')
+   *
+   * options (optional):
+   *   { decisionThreshold, frameSize, tailSeconds, maxTailSeconds, cmn, expectedLayoutBDT, logLevel }
+   */
+  async create(modelPathOrName, enrollmentJsonPathOrName, options = {}) {
+    if (!KeyWordRNBridge?.createSpeakerVerifier) {
+      throw new Error('KeyWordRNBridge.createSpeakerVerifier is not available (native not linked / iOS only?)');
+    }
+
+    if (Platform.OS !== 'ios') {
+      throw new Error('Speaker verification bridge is currently implemented for iOS only.');
+    }
+
+    const modelArg = normalizePathOrName(modelPathOrName);
+    const jsonArg = normalizePathOrName(enrollmentJsonPathOrName);
+
+    return await KeyWordRNBridge.createSpeakerVerifier(
+      this.engineId,
+      modelArg,
+      jsonArg,
+      options || {}
+    );
+  }
+
+  /**
+   * Verify WAV by streaming in native.
+   *
+   * wavPathOrName:
+   *   - absolute path OR "test.wav" in bundle
+   *   - OR require('./assets/test.wav')
+   *
+   * resetState:
+   *   - if true, clears internal streaming state before verification
+   */
+  async verifyWavStreaming(wavPathOrName, resetState = true) {
+    if (!KeyWordRNBridge?.verifySpeakerWavStreaming) {
+      throw new Error('KeyWordRNBridge.verifySpeakerWavStreaming is not available (native not linked / iOS only?)');
+    }
+
+    if (Platform.OS !== 'ios') {
+      throw new Error('Speaker verification bridge is currently implemented for iOS only.');
+    }
+
+    const wavArg = normalizePathOrName(wavPathOrName);
+
+    return await KeyWordRNBridge.verifySpeakerWavStreaming(
+      this.engineId,
+      wavArg,
+      !!resetState
+    );
+  }
+
+  async destroy() {
+    if (!KeyWordRNBridge?.destroySpeakerVerifier) {
+      throw new Error('KeyWordRNBridge.destroySpeakerVerifier is not available (native not linked / iOS only?)');
+    }
+
+    if (Platform.OS !== 'ios') {
+      // no-op for now
+      return { ok: true, engineId: this.engineId, noop: true };
+    }
+
+    return await KeyWordRNBridge.destroySpeakerVerifier(this.engineId);
+  }
+}
+
+// Convenience creator (parity with wakeword side)
+export const createSpeakerVerificationInstance = async (engineId) => {
+  return new SpeakerVerificationRNBridgeInstance(engineId);
+};

package/wakewords/audioRoutingConfig.d.ts

@@ -0,0 +1,17 @@
+export type RouteConfigEntry = {
+    category: 'playAndRecord' | 'record' | 'soloAmbient' | 'ambient' | 'playback';
+    mode: 'default' | 'measurement' | 'voiceChat' | 'videoRecording' | 'gameChat';
+    options: ('mixWithOthers' | 'duckOthers' | 'allowBluetooth' | 'allowBluetoothA2DP' | 'allowAirPlay' | 'defaultToSpeaker' | 'overrideMutedMicrophoneInterruption')[];
+    preferredInput: 'none' | 'builtInMic';
+};
+export type AudioRoutingConfig = {
+    default: RouteConfigEntry;
+    byOutputPort: {
+        carAudio?: RouteConfigEntry;
+        builtInReceiver?: RouteConfigEntry;
+        builtInSpeaker?: RouteConfigEntry;
+        bluetoothA2DP?: RouteConfigEntry;
+        bluetoothHFP?: RouteConfigEntry;
+        headphones?: RouteConfigEntry;
+    };
+};

package/wakewords/audioRoutingConfig.ts

@@ -0,0 +1,28 @@
+// wakewords/audioRoutingConfig.ts
+export type RouteConfigEntry = {
+  category: 'playAndRecord' | 'record' | 'soloAmbient' | 'ambient' | 'playback';
+  mode: 'default' | 'measurement' | 'voiceChat' | 'videoRecording' | 'gameChat';
+  options: (
+    | 'mixWithOthers'
+    | 'duckOthers'
+    | 'allowBluetooth'
+    | 'allowBluetoothA2DP'
+    | 'allowAirPlay'
+    | 'defaultToSpeaker'
+    | 'overrideMutedMicrophoneInterruption'
+  )[];
+  preferredInput: 'none' | 'builtInMic'; // nil vs phone mic
+};
+
+export type AudioRoutingConfig = {
+  default: RouteConfigEntry;
+  byOutputPort: {
+    carAudio?: RouteConfigEntry;        // .carAudio (CarPlay)
+    builtInReceiver?: RouteConfigEntry; // .builtInReceiver (earpiece)
+    builtInSpeaker?: RouteConfigEntry;  // .builtInSpeaker
+    bluetoothA2DP?: RouteConfigEntry;   // .bluetoothA2DP
+    bluetoothHFP?: RouteConfigEntry;    // .bluetoothHFP
+    headphones?: RouteConfigEntry;      // .headphones
+    // add more as needed
+  };
+};

package/wakewords/index.d.ts

@@ -0,0 +1,16 @@
+export default useModel;
+import { enableDucking } from './KeyWordRNBridge';
+import { disableDucking } from './KeyWordRNBridge';
+import { initAudioSessAndDuckManage } from './KeyWordRNBridge';
+import { restartListeningAfterDucking } from './KeyWordRNBridge';
+import { removeAllRNBridgeListeners } from './KeyWordRNBridge';
+import { createKeyWordRNBridgeInstance } from './KeyWordRNBridge';
+import { KeyWordRNBridgeInstance } from './KeyWordRNBridge';
+import { setWakewordAudioRoutingConfig } from './KeyWordRNBridge';
+import { createSpeakerVerificationInstance } from './SpeakerVerificationRNBridge';
+import { SpeakerVerificationRNBridgeInstance } from './SpeakerVerificationRNBridge';
+import useModel from './useModel';
+export { enableDucking, disableDucking, initAudioSessAndDuckManage, restartListeningAfterDucking, removeAllRNBridgeListeners, createKeyWordRNBridgeInstance, KeyWordRNBridgeInstance, setWakewordAudioRoutingConfig, createSpeakerVerificationInstance, SpeakerVerificationRNBridgeInstance, useModel };
+
+// Re-export routing types for consumers:
+export type { AudioRoutingConfig, RouteConfigEntry } from './audioRoutingConfig';

package/wakewords/index.js

@@ -0,0 +1,34 @@
+// wakewords/index.js
+
+import useModel from './useModel';
+import {
+    createKeyWordRNBridgeInstance,
+    removeAllRNBridgeListeners,
+    KeyWordRNBridgeInstance,
+    enableDucking,
+    disableDucking,
+    initAudioSessAndDuckManage,
+    restartListeningAfterDucking,
+    setWakewordAudioRoutingConfig,      // ← NEW
+  } from './KeyWordRNBridge';
+
+  // ✅ NEW speaker verification bridge exports
+import {
+  createSpeakerVerificationInstance,
+  SpeakerVerificationRNBridgeInstance,
+} from './SpeakerVerificationRNBridge';
+
+export { enableDucking }
+export { disableDucking }
+export { initAudioSessAndDuckManage }
+export { restartListeningAfterDucking }
+export { removeAllRNBridgeListeners }
+export { createKeyWordRNBridgeInstance }
+export { KeyWordRNBridgeInstance }
+export { setWakewordAudioRoutingConfig }  // ← NEW
+
+export { createSpeakerVerificationInstance };          // ✅ NEW
+export { SpeakerVerificationRNBridgeInstance };        // ✅ NEW
+
+export { useModel }; // Export only useModel
+export default useModel; // Allow default import

package/wakewords/useModel.d.ts

@@ -0,0 +1,19 @@
+interface instanceConfig {
+    id: string;
+    modelName: string;
+    threshold: number;
+    bufferCnt: number;
+    sticky: boolean;
+}
+/**
+ * Custom hook for handling keyword detection using KeyWordRNBridge
+ * @returns An object with functions and state for keyword detection
+ */
+export declare const useModel: () => {
+    isListening: boolean;
+    startListening: () => Promise<void>;
+    loadModel: (useConfigs: instanceConfig[], callback: (phrase: string) => void) => Promise<void>;
+    setKeywordDetectionLicense: (licenseKey: string) => Promise<void>;
+    stopListening: () => Promise<void>;
+};
+export default useModel;