react-native-wakeword-sid 1.1.70

package/speakerid/SpeakerIdRNBridge.js

@@ -0,0 +1,169 @@
+// speakerid/SpeakerIdRNBridge.js
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const { SpeakerIdRNBridge } = NativeModules;
+const speakerIdEmitter = new NativeEventEmitter(SpeakerIdRNBridge);
+
+if (!SpeakerIdRNBridge) {
+  console.error('SpeakerIdRNBridge is not linked.');
+}
+
+/**
+ * Helpers
+ */
+const ensureAndroid = () => {
+  if (Platform.OS !== 'android') {
+    throw new Error('SpeakerIdRNBridge is Android-only');
+  }
+};
+
+export class SpeakerIdInstance {
+  instanceId;
+  listeners = [];
+
+  constructor(instanceId) {
+    this.instanceId = instanceId;
+  }
+
+  /**
+   * Lifecycle
+   */
+  async createInstance() {
+    ensureAndroid();
+    return SpeakerIdRNBridge.createInstance(this.instanceId);
+  }
+
+  async destroyInstance() {
+    ensureAndroid();
+    return SpeakerIdRNBridge.destroyInstance(this.instanceId);
+  }
+
+  /**
+   * Onboarding
+   */
+  async onboardFromMicrophone(maxMillis = 15000) {
+    ensureAndroid();
+    // Resolves to { clusterSize, embDim }
+    return SpeakerIdRNBridge.onboardFromMicrophone(this.instanceId, maxMillis);
+  }
+
+  // Streaming onboarding: feed Int16 blocks repeatedly; finish when you’re done.
+  async onboardingStreamStart() {
+    ensureAndroid();
+    return SpeakerIdRNBridge.onboardingStreamStart(this.instanceId);
+  }
+  async onboardingStreamFeed(blockInt16) {
+    ensureAndroid();
+    // RN passes arrays of numbers; provide Int16 values (range -32768..32767)
+    return SpeakerIdRNBridge.onboardingStreamFeed(this.instanceId, Array.from(blockInt16));
+  }
+  async onboardingStreamFinish() {
+    ensureAndroid();
+    // Resolves to { clusterSize, embDim } when enrollment completes, or null if not enough speech
+    return SpeakerIdRNBridge.onboardingStreamFinish(this.instanceId);
+  }
+
+  async onboardFromWav(absPath) {
+    ensureAndroid();
+    // Resolves to { clusterSize, embDim }
+    return SpeakerIdRNBridge.onboardFromWav(this.instanceId, String(absPath));
+  }
+
+  /**
+   * Verification init
+   */
+  async initVerificationUsingDefaults() {
+    ensureAndroid();
+    // Resolves to boolean
+    return SpeakerIdRNBridge.initVerificationUsingDefaults(this.instanceId);
+  }
+
+  async initVerificationWithFiles(meanNpyPath, clusterNpyPath) {
+    ensureAndroid();
+    // Resolves to boolean
+    return SpeakerIdRNBridge.initVerificationWithFiles(this.instanceId, String(meanNpyPath), String(clusterNpyPath));
+  }
+
+  /**
+   * Verification
+   */
+  async verifyFromMicrophone(maxMillis = 15000) {
+    ensureAndroid();
+    // Resolves to { fullSec, voicedSec, bestScore, bestStrategy, bestTargetLabel, perTargetStrategy }
+    return SpeakerIdRNBridge.verifyFromMicrophone(this.instanceId, maxMillis);
+  }
+
+  async verifyFromWav(absPath) {
+    ensureAndroid();
+    return SpeakerIdRNBridge.verifyFromWav(this.instanceId, String(absPath));
+  }
+
+  // Streaming verification
+  async verifyStreamPush(blockInt16) {
+    ensureAndroid();
+    // May resolve to null (no finalized segment yet) OR a result object (same shape as verifyFromMicrophone)
+    return SpeakerIdRNBridge.verifyStreamPush(this.instanceId, Array.from(blockInt16));
+  }
+  async verifyStreamFinish() {
+    ensureAndroid();
+    return SpeakerIdRNBridge.verifyStreamFinish(this.instanceId);
+  }
+
+  /**
+   * Export helpers (Downloads/)
+   */
+  async exportDefaultClusterToDownloads() {
+    ensureAndroid();
+    // Resolves to { uri }
+    return SpeakerIdRNBridge.exportDefaultClusterToDownloads(this.instanceId);
+  }
+  async exportDefaultMeanToDownloads() {
+    ensureAndroid();
+    return SpeakerIdRNBridge.exportDefaultMeanToDownloads(this.instanceId);
+  }
+  async exportDefaultMeanCountToDownloads() {
+    ensureAndroid();
+    return SpeakerIdRNBridge.exportDefaultMeanCountToDownloads(this.instanceId);
+  }
+
+  /**
+   * Optional: subscribe to an event fired when a segment is finalized during mic verification
+   * Native side will emit { instanceId, result: {...same fields as verify...} }
+   */
+  onVerificationEvent(callback) {
+    const sub = speakerIdEmitter.addListener('onSpeakerVerificationEvent', (event) => {
+      if (event?.instanceId === this.instanceId) {
+        callback(event.result);
+      }
+    });
+    this.listeners.push(sub);
+    return sub;
+  }
+
+  removeListeners() {
+    this.listeners.forEach((l) => l.remove());
+    this.listeners = [];
+  }
+}
+
+/** Factory to mirror your wakewords helper */
+export const createSpeakerIdInstance = async (instanceId) => {
+  return new SpeakerIdInstance(instanceId);
+};
+
+/** Optional: bulk remove listeners if you use global events */
+export const removeAllSpeakerIdListeners = async () => {
+  speakerIdEmitter.removeAllListeners('onSpeakerVerificationEvent');
+};
+
+/**
+ * Utilities for converting audio to Int16 arrays for streaming APIs
+ */
+export const float32ToInt16 = (f32) => {
+  const out = new Int16Array(f32.length);
+  for (let i = 0; i < f32.length; i++) {
+    let s = Math.max(-1, Math.min(1, f32[i]));
+    out[i] = s < 0 ? s * 32768 : s * 32767;
+  }
+  return out;
+};

package/wakewords/KeyWordRNBridge.d.ts

@@ -0,0 +1,37 @@
+export class KeyWordRNBridgeInstance {
+    constructor(instanceId: any, isSticky: any);
+    instanceId: any;
+    listeners: any[];
+    isFirstInstance: boolean;
+    isSticky: any;
+    createInstanceMulti(modelNames: any, thresholds: any, bufferCnts: any, msBetweenCallbacks: any): Promise<any>;
+    createInstance(modelName: any, threshold: any, bufferCnt: any): Promise<any>;
+    getVoiceProps(): Promise<{
+        error: any;
+        voiceProbability: any;
+        lastTimeHumanVoiceHeard: any;
+    }>;
+    startSilentVADDetection(): Promise<any>;
+    stopSilentVADDetection(): Promise<any>;
+    startVADDetection(): Promise<any>;
+    stopVADDetection(): Promise<any>;
+    onVADDetectionEvent(callback: any): import("react-native").EmitterSubscription;
+    setVADParams(threshold: any, msWindow: any): Promise<any>;
+    getVADParams(): Promise<any>;
+    setKeywordDetectionLicense(license: any): Promise<any>;
+    replaceKeywordDetectionModel(modelName: any, threshold: any, bufferCnt: any): Promise<any>;
+    setKeywordLicense(license: any): Promise<any>;
+    startKeywordDetection(threshold: any, setActive?: boolean, duckOthers?: boolean, mixWithOthers?: boolean, defaultToSpeaker?: boolean): Promise<any>;
+    getRecordingWav(): Promise<any>;
+    stopKeywordDetection(): Promise<any>;
+    destroyInstance(): Promise<any>;
+    onKeywordDetectionEvent(callback: any): import("react-native").EmitterSubscription;
+    removeListeners(): void;
+}
+export function removeAllRNBridgeListeners(): Promise<void>;
+export function createKeyWordRNBridgeInstance(instanceId: any, isSticky: any): Promise<KeyWordRNBridgeInstance>;
+export function enableDucking(): Promise<void>;
+export function disableDucking(): Promise<void>;
+export function restartListeningAfterDucking(): Promise<void>;
+export function initAudioSessAndDuckManage(): Promise<void>;
+export function disableDuckingAndCleanup(): Promise<void>;

package/wakewords/KeyWordRNBridge.js

@@ -0,0 +1,221 @@
+// 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();
+    }
+}
+

package/wakewords/index.d.ts

@@ -0,0 +1,10 @@
+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 useModel from './useModel';
+export { enableDucking, disableDucking, initAudioSessAndDuckManage, restartListeningAfterDucking, removeAllRNBridgeListeners, createKeyWordRNBridgeInstance, KeyWordRNBridgeInstance, useModel };

package/wakewords/index.js

@@ -0,0 +1,21 @@
+import useModel from './useModel';
+import {
+    createKeyWordRNBridgeInstance,
+    removeAllRNBridgeListeners,
+    KeyWordRNBridgeInstance,
+    enableDucking,
+    disableDucking,
+    initAudioSessAndDuckManage,
+    restartListeningAfterDucking,
+  } from './KeyWordRNBridge';
+
+
+export { enableDucking }
+export { disableDucking }
+export { initAudioSessAndDuckManage }
+export { restartListeningAfterDucking }
+export { removeAllRNBridgeListeners }
+export { createKeyWordRNBridgeInstance }
+export { KeyWordRNBridgeInstance }
+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;