react-native-wakeword 1.1.77 → 1.1.79

package/ios/KeyWordRNBridge/KeyWordRNBridge.m

@@ -1,6 +1,7 @@
 //ios/KeyWordRNBridge.m
 
 #import "KeyWordRNBridge.h"
+#import <AVFoundation/AVFoundation.h>
 #import <React/RCTBridge.h>
 #import <React/RCTLog.h>
 #import <React/RCTEventEmitter.h>
@@ -383,6 +384,11 @@ static NSDictionary * _Nullable SVVerifyWav(id engine, NSString *wavPath, BOOL r
     return msgSend(c, sel, engine, wavPath, reset, error);
 }
 
+static BOOL KWRNBHasMicPermission(void) {
+    AVAudioSessionRecordPermission permission = [[AVAudioSession sharedInstance] recordPermission];
+    return permission == AVAudioSessionRecordPermissionGranted;
+}
+
 @interface KeyWordRNBridge () <RCTBridgeModule>
 
 @property (nonatomic, strong) NSMutableDictionary *instances;
@@ -913,6 +919,54 @@ RCT_EXPORT_METHOD(disableDuckingAndCleanup:(RCTPromiseResolveBlock)resolve rejec
   resolve(@"disabled");
 }
 
+RCT_EXPORT_METHOD(hasMicPermissions:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    resolve(@(KWRNBHasMicPermission()));
+}
+
+RCT_EXPORT_METHOD(requestMicPermissions:(nonnull NSNumber *)wait_timeout
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+{
+    dispatch_async(dispatch_get_main_queue(), ^{
+        AVAudioSession *audioSession = [AVAudioSession sharedInstance];
+        AVAudioSessionRecordPermission permission = audioSession.recordPermission;
+        if (permission == AVAudioSessionRecordPermissionGranted) {
+            resolve(@YES);
+            return;
+        }
+
+        if (permission == AVAudioSessionRecordPermissionDenied) {
+            resolve(@NO);
+            return;
+        }
+
+        NSTimeInterval timeoutSeconds = MAX(wait_timeout.doubleValue, 0.0) / 1000.0;
+        __block BOOL didResolve = NO;
+        void (^finish)(BOOL) = ^(BOOL granted) {
+            if (didResolve) {
+                return;
+            }
+            didResolve = YES;
+            resolve(@(granted));
+        };
+
+        if (timeoutSeconds > 0.0) {
+            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(timeoutSeconds * NSEC_PER_SEC)),
+                           dispatch_get_main_queue(), ^{
+                finish(KWRNBHasMicPermission());
+            });
+        }
+
+        [audioSession requestRecordPermission:^(BOOL granted) {
+            dispatch_async(dispatch_get_main_queue(), ^{
+                finish(granted);
+            });
+        }];
+    });
+}
+
 RCT_EXPORT_METHOD(setKeywordDetectionLicense:(NSString *)instanceId licenseKey:(NSString *)licenseKey resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
 {
     KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "react-native-wakeword",
-    "version": "1.1.77",
+    "version": "1.1.79",
     "description": "Voice/Wake-word detection library for React Native",
     "main": "wakewords/index.js",
     "types": "wakewords/index.d.ts",

package/wakewords/KeyWordRNBridge.d.ts

@@ -47,5 +47,7 @@ export function enableDucking(): Promise<void>;
 export function disableDucking(): Promise<void>;
 export function restartListeningAfterDucking(): Promise<void>;
 export function initAudioSessAndDuckManage(): Promise<void>;
+export function hasIOSMicPermissions(): Promise<any>;
+export function requestIOSMicPermissions(wait_timeout: any): Promise<any>;
 export function disableDuckingAndCleanup(): Promise<void>;
 export function setWakewordAudioRoutingConfig(config: any): Promise<any>;

package/wakewords/KeyWordRNBridge.js

@@ -275,6 +275,14 @@ export const initAudioSessAndDuckManage = async () => {
     }
 }
 
+export const hasIOSMicPermissions = async () => {
+    return await KeyWordRNBridge.hasMicPermissions();
+}
+
+export const requestIOSMicPermissions = async (wait_timeout) => {
+    return await KeyWordRNBridge.requestMicPermissions(wait_timeout);
+}
+
 export const disableDuckingAndCleanup = async () => {
     if (Platform.OS === 'ios') {
         await KeyWordRNBridge.disableDuckingAndCleanup();

package/android/src/main/java/com/davoice/speakeridrn/SpeakerIdRNBridge.java_not_used_yet

@@ -1,588 +0,0 @@
-package com.davoice.speakeridrn;
-
-import com.facebook.react.bridge.*;
-import com.facebook.react.modules.core.DeviceEventManagerModule;
-import androidx.annotation.Nullable;
-
-import android.content.Context;
-import android.net.Uri;
-import android.os.Handler;
-import android.os.Looper;
-
-import ai.onnxruntime.OrtEnvironment;
-import ai.onnxruntime.OrtException;
-
-import com.davoice.speakerid.*;
-
-import java.io.File;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.*;
-import android.content.res.AssetManager;
-import java.io.InputStream;
-import java.io.BufferedInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.util.Locale;
-import android.util.Log;
-
-/**
- * React Native bridge for the speaker-id Android library.
- * It wraps SpeakerIdApi: onboarding (mic/stream/wav) + verification (mic/stream/wav).
- */
-public class SpeakerIdRNBridge extends ReactContextBaseJavaModule {
-
-    private static final String REACT_CLASS = "SpeakerIdRNBridge";
-    private static ReactApplicationContext reactContext;
-
-    // Keep multiple instances if you want (keyed by id)
-    private final Map<String, SpeakerIdApi> instances = new HashMap<>();
-
-    // Streaming onboarding per instance
-    private final Map<String, SpeakerIdApi.OnboardingStream> onboardingStreams = new HashMap<>();
-
-    // Run heavy calls off the UI thread
-    private final ExecutorService exec = Executors.newCachedThreadPool();
-    private final Handler main = new Handler(Looper.getMainLooper());
-
-    public SpeakerIdRNBridge(ReactApplicationContext context) {
-        super(context);
-        reactContext = context;
-    }
-
-    @Override public String getName() { return REACT_CLASS; }
-
-    // -------------------- Helpers --------------------
-
-    private static WritableMap toJs(OnboardingResult r) {
-        WritableMap m = Arguments.createMap();
-        m.putInt("clusterSize", r.clusterSize);
-        m.putInt("embeddingDim", r.embDim);
-        return m;
-    }
-
-    private static WritableMap toJs(VerificationResult r) {
-        WritableMap m = Arguments.createMap();
-        m.putDouble("fullSec", r.fullSec);
-        m.putDouble("voicedSec", r.voicedSec);
-        m.putDouble("bestScore", r.bestScore);
-        m.putString("bestStrategy", r.bestStrategy);
-        m.putString("bestTargetLabel", r.bestTargetLabel);
-
-        // Flatten perTargetStrategy -> { strategyKey: { label: score } }
-        WritableMap strat = Arguments.createMap();
-        if (r.perTargetStrategy != null) {
-            for (Map.Entry<String, Map<String, Float>> e : r.perTargetStrategy.entrySet()) {
-                WritableMap col = Arguments.createMap();
-                for (Map.Entry<String, Float> colE : e.getValue().entrySet()) {
-                    col.putDouble(colE.getKey(), colE.getValue());
-                }
-                strat.putMap(e.getKey(), col);
-            }
-        }
-        m.putMap("perTargetStrategy", strat);
-        return m;
-    }
-
-    private static File fileFromPath(String path) {
-        return new File(path);
-    }
-
-    // -------------------- Lifecycle / Creation --------------------
-
-    /**
-     * Create a SpeakerIdApi instance.
-     * @param instanceId unique id you choose
-     */
-    @ReactMethod
-    public void createInstance(String instanceId, Promise promise) {
-        if (instances.containsKey(instanceId)) {
-            promise.reject("InstanceExists", "Instance already exists: " + instanceId);
-            return;
-        }
-        exec.submit(() -> {
-            try {
-                SpeakerIdApi api = SpeakerIdApi.create(reactContext); // <-- resolves speaker_id.dm + layer1.dm internally
-                synchronized (instances) { instances.put(instanceId, api); }
-                main.post(() -> promise.resolve(true));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("CreateError", e.getMessage(), e));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void initVerificationUsingCurrentConfig(String instanceId, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        try {
-            boolean ok = api.initVerificationUsingCurrentConfig();
-            promise.resolve(ok);
-        } catch (Throwable t) {
-            promise.reject("E_INIT_CHECK", t);
-        }
-    }
-
-    // ======= External-audio cluster API (RN) =======
-
-    @ReactMethod
-    public void initCluster(String instanceId, int numOfEmb, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                int cid = api.initCluster(numOfEmb);
-                main.post(() -> promise.resolve(cid));
-            } catch (Throwable t) {
-                main.post(() -> promise.reject("InitClusterError", t.getMessage(), t));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void createAndPushEmbeddingsToCluster(String instanceId, int clusterId, ReadableArray pcmI16, int length, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        // Convert RN int[] -> short[]
-        int n = Math.min(length, pcmI16.size());
-        final short[] block = new short[n];
-        for (int i = 0; i < n; i++) block[i] = (short) pcmI16.getInt(i);
-
-        exec.submit(() -> {
-            try {
-                api.createAndPushEmbeddingsToCluster(clusterId, block, n);
-                main.post(() -> promise.resolve(null));
-            } catch (Throwable t) {
-                main.post(() -> promise.reject("PushClusterError", t.getMessage(), t));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void createAndVerifyEmbeddingsFromCluster(String instanceId, int clusterId, ReadableArray pcmI16, int length, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        int n = Math.min(length, pcmI16.size());
-        final short[] block = new short[n];
-        for (int i = 0; i < n; i++) block[i] = (short) pcmI16.getInt(i);
-
-        exec.submit(() -> {
-            try {
-                float score = api.createAndVerifyEmbeddingsFromCluster(clusterId, block, n);
-                main.post(() -> promise.resolve(score));
-            } catch (Throwable t) {
-                main.post(() -> promise.reject("VerifyClusterError", t.getMessage(), t));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void destroyInstance(String instanceId, Promise promise) {
-        SpeakerIdApi api;
-        synchronized (instances) { api = instances.remove(instanceId); }
-        if (api != null) {
-            try { api.close(); } catch (Exception ignore) {}
-            onboardingStreams.remove(instanceId);
-            promise.resolve(true);
-        } else {
-            promise.reject("InstanceNotFound", "No such instance: " + instanceId);
-        }
-    }
-
-    // -------------------- Verification init (targets) --------------------
-
-    @ReactMethod
-    public void initVerificationUsingDefaults(String instanceId, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        promise.resolve(api.initVerificationUsingDefaults(reactContext));
-    }
-
-    /**
-     * Use explicit files for mean & cluster (paths to .npy files).
-     */
-    @ReactMethod
-    public void initVerificationWithFiles(String instanceId,
-                                          String meanEmbPath,
-                                          String clusterPath,
-                                          Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        boolean ok = api.initVerificationWithFiles(fileFromPath(meanEmbPath),
-                                                   fileFromPath(clusterPath));
-        promise.resolve(ok);
-    }
-
-    // -------------------- Onboarding: Microphone --------------------
-
-    /**
-     * Opens mic, captures first VAD-delimited utterance, enrolls.
-     * JS must have RECORD_AUDIO permission granted beforehand.
-     * @param maxMillis timeout in ms
-     */
-    @ReactMethod
-    public void onboardFromMicrophone(String instanceId, double maxMillis, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-
-        exec.submit(() -> {
-            try {
-                OnboardingResult r = api.onboardFromMicrophone((long)maxMillis);
-                WritableMap out = toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (SecurityException se) {
-                main.post(() -> promise.reject("MicPermission", "RECORD_AUDIO permission missing", se));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("OnboardMicError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // -------------------- Onboarding: Stream --------------------
-
-    @ReactMethod
-    public void startOnboardingStream(String instanceId, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        SpeakerIdApi.OnboardingStream stream = api.startOnboardingStream();
-        onboardingStreams.put(instanceId, stream);
-        promise.resolve(true);
-    }
-
-    /**
-     * Feed PCM16 block (short[]) as a base64 string? RN doesn’t pass short[] directly.
-     * For simplicity here, pass an int array of 16-bit values (range -32768..32767).
-     */
-    @ReactMethod
-    public void feedOnboardingStream(String instanceId, ReadableArray pcmI16, Promise promise) {
-        SpeakerIdApi.OnboardingStream stream = onboardingStreams.get(instanceId);
-        if (stream == null) { promise.reject("StreamNotStarted", instanceId); return; }
-
-        short[] block = new short[pcmI16.size()];
-        for (int i = 0; i < pcmI16.size(); i++) block[i] = (short) pcmI16.getInt(i);
-
-        exec.submit(() -> {
-            try {
-                OnboardingResult r = stream.feed(block);
-                if (r != null) {
-                    onboardingStreams.remove(instanceId);
-                    WritableMap out = toJs(r);
-                    main.post(() -> promise.resolve(out));
-                } else {
-                    main.post(() -> promise.resolve(null)); // not done yet
-                }
-            } catch (Exception e) {
-                main.post(() -> promise.reject("OnboardFeedError", e.getMessage(), e));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void finishOnboardingStream(String instanceId, Promise promise) {
-        SpeakerIdApi.OnboardingStream stream = onboardingStreams.remove(instanceId);
-        if (stream == null) { promise.reject("StreamNotStarted", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                OnboardingResult r = stream.finish();
-                WritableMap out = (r == null) ? null : toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("OnboardFinishError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // -------------------- Onboarding: WAV --------------------
-
-    @ReactMethod
-    public void onboardFromWav(String instanceId, String wavPath, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-
-        exec.submit(() -> {
-            try {
-                OnboardingResult r = api.onboardFromWav(fileFromPath(wavPath));
-                WritableMap out = toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("OnboardWavError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // -------------------- Verification: Microphone --------------------
-
-    @ReactMethod
-    public void verifyFromMicrophone(String instanceId, double maxMillis, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                VerificationResult r = api.verifyFromMicrophone((long)maxMillis);
-                WritableMap out = (r == null) ? null : toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (SecurityException se) {
-                main.post(() -> promise.reject("MicPermission", "RECORD_AUDIO permission missing", se));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("VerifyMicError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // -------------------- Verification: Stream --------------------
-
-    @ReactMethod
-    public void verifyStreamPush(String instanceId, ReadableArray pcmI16, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        short[] block = new short[pcmI16.size()];
-        for (int i = 0; i < pcmI16.size(); i++) block[i] = (short) pcmI16.getInt(i);
-        exec.submit(() -> {
-            try {
-                VerificationResult r = api.verifyStreamPush(block);
-                WritableMap out = (r == null) ? null : toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("VerifyStreamPushError", e.getMessage(), e));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void verifyStreamFinish(String instanceId, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                VerificationResult r = api.verifyStreamFinish();
-                WritableMap out = (r == null) ? null : toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("VerifyStreamFinishError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // -------------------- Verification: WAV --------------------
-
-    @ReactMethod
-    public void verifyFromWav(String instanceId, String wavPath, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                VerificationResult r = api.verifyFromWav(fileFromPath(wavPath));
-                WritableMap out = (r == null) ? null : toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("VerifyWavError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // ======= WWD: create instance tuned for wake-word =======
-
-    private static final boolean DEBUG_SID_ASSETS = true; // set false for production
-
-    @ReactMethod
-    public void createInstanceWWD(String instanceId, Promise promise) {
-        if (instances.containsKey(instanceId)) {
-            promise.reject("InstanceExists", "Instance already exists: " + instanceId);
-            return;
-        }
-        Log.d("WWD DEBUG", "createInstanceWWD");
-
-        exec.submit(() -> {
-            try {
-        Log.d("WWD DEBUG", "createInstanceWWD2");
-                SpeakerIdApi api = SpeakerIdApi.createWWD(reactContext);
-        Log.d("WWD DEBUG", "createInstanceWWD3");
-                synchronized (instances) { instances.put(instanceId, api); }
-        Log.d("WWD DEBUG", "createInstanceWWD4");
-                main.post(() -> promise.resolve(true));
-                // Then run debug async if enabled
-                if (DEBUG_SID_ASSETS) {
-                    Log.d("WWD DEBUG", "Calling debugOnAssetsWWD");
-                    exec.submit(() -> debugOnAssetsWWD(instanceId));
-                }
-
-            } catch (Exception e) {
-                main.post(() -> promise.reject("CreateWWDError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // ======= WWD: onboard from mic (embNum x 1s) =======
-    @ReactMethod
-    public void onboardFromMicrophoneWWD(String instanceId, int embNum, double maxMillis, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                OnboardingResult r = api.onboardFromMicrophoneWWD(embNum, (long)maxMillis);
-                WritableMap out = toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (SecurityException se) {
-                main.post(() -> promise.reject("MicPermission", "RECORD_AUDIO permission missing", se));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("OnboardWWDError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // ======= WWD: verify from mic (exactly 1s) =======
-    @ReactMethod
-    public void verifyFromMicrophoneWWD(String instanceId, double maxMillis, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                VerificationResult r = api.verifyFromMicrophoneWWD((long)maxMillis);
-                WritableMap out = (r == null) ? null : toJs(r);
-                main.post(() -> promise.resolve(out));
-            } catch (SecurityException se) {
-                main.post(() -> promise.reject("MicPermission", "RECORD_AUDIO permission missing", se));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("VerifyWWDError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // -------------------- Export helpers --------------------
-
-    @ReactMethod
-    public void exportDefaultClusterToDownloads(String instanceId, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                Uri uri = api.exportDefaultClusterToDownloads(reactContext);
-                main.post(() -> promise.resolve(uri.toString()));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("ExportClusterError", e.getMessage(), e));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void exportDefaultMeanToDownloads(String instanceId, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                Uri uri = api.exportDefaultMeanToDownloads(reactContext);
-                main.post(() -> promise.resolve(uri.toString()));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("ExportMeanError", e.getMessage(), e));
-            }
-        });
-    }
-
-    @ReactMethod
-    public void exportDefaultMeanCountToDownloads(String instanceId, Promise promise) {
-        SpeakerIdApi api = instances.get(instanceId);
-        if (api == null) { promise.reject("InstanceNotFound", instanceId); return; }
-        exec.submit(() -> {
-            try {
-                Uri uri = api.exportDefaultMeanCountToDownloads(reactContext);
-                main.post(() -> promise.resolve(uri.toString()));
-            } catch (Exception e) {
-                main.post(() -> promise.reject("ExportMeanCountError", e.getMessage(), e));
-            }
-        });
-    }
-
-    // RN event helpers (if you later want to emit async events)
-    private void sendEvent(String eventName, @Nullable WritableMap params) {
-        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
-                .emit(eventName, params);
-    }
-
-    // No-op listener hooks
-    @ReactMethod public void addListener(String eventName) {}
-    @ReactMethod public void removeListeners(Integer count) {}
-
-    @Override
-    public void onCatalystInstanceDestroy() {
-        for (SpeakerIdApi api : instances.values()) try { api.close(); } catch (Exception ignore) {}
-        instances.clear();
-        onboardingStreams.clear();
-        exec.shutdownNow();
-        super.onCatalystInstanceDestroy();
-    }
-
-    // ======= DEBUG harness (assets) =======
-
-    private void emitDebug(String msg) {
-        Log.d("WWD DEBUG", msg);
-        WritableMap m = Arguments.createMap();
-        m.putString("line", msg);
-        sendEvent("SpeakerIdDebug", m);
-    }
-
-    private void debugOnAssetsWWD(String instanceId) {
-        try {
-            SpeakerIdApi api = instances.get(instanceId);
-            if (api == null) { emitDebug("debugOnAssetsWWD: instance gone: " + instanceId); return; }
-
-            // 1) Init a small FIFO cluster (K=3)
-            final int K = 3;
-            int clusterId = api.initCluster(K);
-            emitDebug("WWD DEBUG: initCluster -> " + clusterId + " (K=" + K + ")");
-
-            // 2) Onboarding from assets
-            String[] onboard = new String[] {
-                    "onboard1.raw","onboard2.raw","onboard3.raw","onboard4.raw"
-            };
-            for (int i = 0; i < onboard.length; i++) {
-                short[] pcm = readPcm16LeRawAsset(onboard[i]);
-                api.createAndPushEmbeddingsToCluster(clusterId, pcm, pcm.length);
-                String line = String.format(Locale.US, "WWD DEBUG: push #%d '%s' samples=%d", i+1, onboard[i], pcm.length);
-                emitDebug(line);
-            }
-            emitDebug("WWD DEBUG: onboarding done; cluster+mean saved.");
-
-            // 3) Verification from assets
-            String[] tests = new String[] {
-                    "test1.raw","test2.raw","test3.raw","test4.raw","test5.raw","test6.raw","test7.raw"
-            };
-            for (String tf : tests) {
-                short[] pcm = readPcm16LeRawAsset(tf);
-                float score = api.createAndVerifyEmbeddingsFromCluster(clusterId, pcm, pcm.length);
-                String line = String.format(Locale.US, "WWD DEBUG: verify '%s' samples=%d -> score=%.4f",
-                        tf, pcm.length, score);
-                emitDebug(line);
-            }
-            emitDebug("WWD DEBUG: verification pass completed.");
-        } catch (Throwable t) {
-            emitDebug("WWD DEBUG ERROR: " + t.getMessage());
-        }
-    }
-
-    /** Read RAW little-endian PCM16 asset → short[] (exactly your requested method) */
-    private short[] readPcm16LeRawAsset(String assetName) throws IOException {
-        AssetManager am = reactContext.getAssets();
-        try (InputStream in = am.open(assetName);
-            BufferedInputStream bis = new BufferedInputStream(in);
-            ByteArrayOutputStream baos = new ByteArrayOutputStream(32 * 1024)) {
-
-            byte[] buf = new byte[8192];
-            int n;
-            while ((n = bis.read(buf)) != -1) {
-                baos.write(buf, 0, n);
-            }
-            byte[] all = baos.toByteArray();
-            if ((all.length & 1) != 0) {
-                throw new IOException("Asset RAW has odd byte length: " + assetName + " (" + all.length + " bytes)");
-            }
-            int samples = all.length / 2;
-            short[] pcm = new short[samples];
-            for (int i = 0, s = 0; i < all.length; i += 2, s++) {
-                int lo = (all[i] & 0xFF);
-                int hi = (all[i + 1] << 8);
-                pcm[s] = (short) (hi | lo);
-            }
-            return pcm;
-        }
-    }
-}

package/ios/KeyWordRNBridge/KeyWordRNBridge.mm

@@ -1,416 +0,0 @@
-//ios/KeyWordRNBridge.m
-
-#import "KeyWordRNBridge.h"
-#import <React/RCTBridge.h>
-#import <React/RCTLog.h>
-#import <React/RCTEventEmitter.h>
-//#import "KeyWordsDetection.h" // Import your KeyWordsDetection library header
-
-// Ensure the protocol is correctly imported or declared
-// Assuming the protocol is named 'KeywordDetectionRNDelegate'
-@interface KeyWordsDetectionWrapper : NSObject <KeywordDetectionRNDelegate>
-
-@property (nonatomic, strong) KeyWordsDetection *keyWordsDetection;
-@property (nonatomic, strong) NSString *instanceId;
-@property (nonatomic, weak) KeyWordRNBridge *bridge;
-
-- (instancetype)initWithInstanceId:(NSString *)instanceId
-                         modelName:(NSString *)modelName
-                         threshold:(float)threshold
-                         bufferCnt:(NSInteger)bufferCnt
-                            bridge:(KeyWordRNBridge *)bridge
-                             error:(NSError **)error;
-
-- (instancetype)initWithInstanceId:(NSString *)instanceId
-                        modelNames:(NSArray<NSString *> *)modelNames
-                        thresholds:(NSArray<NSNumber *> *)thresholds
-                        bufferCnts:(NSArray<NSNumber *> *)bufferCnts
-                 msBetweenCallback:(NSArray<NSNumber *> *)msBetweenCallback
-                            bridge:(KeyWordRNBridge *)bridge
-                             error:(NSError **)error;
-
-@end
-
-@implementation KeyWordsDetectionWrapper
-
-- (instancetype)initWithInstanceId:(NSString *)instanceId
-                         modelName:(NSString *)modelName
-                         threshold:(float)threshold
-                         bufferCnt:(NSInteger)bufferCnt
-                            bridge:(KeyWordRNBridge *)bridge
-                             error:(NSError **)error
-{
-    if (self = [super init]) {
-        _instanceId = instanceId;
-        _bridge = bridge;
-        _keyWordsDetection = [[KeyWordsDetection alloc] initWithModelPath:modelName threshold:threshold bufferCnt:bufferCnt error:error];
-        if (*error) {
-            return nil;
-        }
-        _keyWordsDetection.delegate = self;
-    }
-    return self;
-}
-
-- (instancetype)initWithInstanceId:(NSString *)instanceId
-                        modelNames:(NSArray<NSString *> *)modelNames
-                        thresholds:(NSArray<NSNumber *> *)thresholds
-                        bufferCnts:(NSArray<NSNumber *> *)bufferCnts
-                 msBetweenCallback:(NSArray<NSNumber *> *)msBetweenCallback
-                            bridge:(KeyWordRNBridge *)bridge
-                             error:(NSError **)error {
-    if (self = [super init]) {
-        _instanceId = instanceId;
-        _bridge = bridge;
-
-        NSMutableArray<NSNumber *> *floatThresholds = [NSMutableArray array];
-        for (NSNumber *num in thresholds) {
-            [floatThresholds addObject:@(num.floatValue)];
-        }
-
-        _keyWordsDetection = [[KeyWordsDetection alloc] initWithModelPaths:modelNames
-                                                                thresholds:floatThresholds
-                                                                bufferCnts:bufferCnts
-                                                         msBetweenCallback:msBetweenCallback
-                                                                      error:error];
-        if (*error) return nil;
-        _keyWordsDetection.delegate = self;
-    }
-    return self;
-}
-
-// Implement the delegate method
-- (void)KeywordDetectionDidDetectEvent:(NSDictionary *)eventInfo {
-    NSMutableDictionary *mutableEventInfo = [eventInfo mutableCopy];
-    mutableEventInfo[@"instanceId"] = self.instanceId;
-    [_bridge sendEventWithName:@"onKeywordDetectionEvent" body:mutableEventInfo];
-}
-
-@end
-
-@interface KeyWordRNBridge () <RCTBridgeModule>
-
-@property (nonatomic, strong) NSMutableDictionary *instances;
-
-@end
-
-@implementation KeyWordRNBridge
-
-RCT_EXPORT_MODULE();
-
-- (instancetype)init {
-    if (self = [super init]) {
-        _instances = [NSMutableDictionary new];
-    }
-    return self;
-}
-
-+ (BOOL)requiresMainQueueSetup
-{
-    return YES;
-}
-
-- (NSArray<NSString *> *)supportedEvents {
-    return @[@"onKeywordDetectionEvent",
-             @"onVADDetectionEvent"];  // NEW
-}
-
-RCT_EXPORT_METHOD(createInstanceMulti:(NSString *)instanceId
-                  modelPaths:(NSArray<NSString *> *)modelPaths
-                  thresholds:(NSArray<NSNumber *> *)thresholds
-                  bufferCnts:(NSArray<NSNumber *> *)bufferCnts
-                  msBetweenCallback:(NSArray<NSNumber *> *)msBetweenCallback
-                  resolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject) {
-    if (self.instances[instanceId]) {
-        reject(@"InstanceExists", [NSString stringWithFormat:@"Instance already exists with ID: %@", instanceId], nil);
-        return;
-    }
-
-    NSError *error = nil;
-    KeyWordsDetectionWrapper *wrapper = [[KeyWordsDetectionWrapper alloc]
-        initWithInstanceId:instanceId
-               modelNames:modelPaths
-               thresholds:thresholds
-               bufferCnts:bufferCnts
-        msBetweenCallback:msBetweenCallback
-                   bridge:self
-                    error:&error];
-    if (error) {
-        reject(@"CreateError", [NSString stringWithFormat:@"Failed to create multi-model instance: %@", error.localizedDescription], nil);
-    } else {
-        self.instances[instanceId] = wrapper;
-        resolve([NSString stringWithFormat:@"Multi-model instance created with ID: %@", instanceId]);
-    }
-}
-
-RCT_EXPORT_METHOD(createInstance:(NSString *)instanceId modelName:(NSString *)modelName threshold:(float)threshold bufferCnt:(NSInteger)bufferCnt resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    if (self.instances[instanceId]) {
-        reject(@"InstanceExists", [NSString stringWithFormat:@"Instance already exists with ID: %@", instanceId], nil);
-        return;
-    }
-
-    NSError *error = nil;
-    KeyWordsDetectionWrapper *wrapper = [[KeyWordsDetectionWrapper alloc] initWithInstanceId:instanceId modelName:modelName threshold:threshold bufferCnt:bufferCnt bridge:self error:&error];
-    if (error) {
-        reject(@"CreateError", [NSString stringWithFormat:@"Failed to create instance: %@", error.localizedDescription], nil);
-    } else {
-        self.instances[instanceId] = wrapper;
-        resolve([NSString stringWithFormat:@"Instance created with ID: %@", instanceId]);
-    }
-}
-
-// NEW: receive global wakeword audio routing config from JS
-RCT_EXPORT_METHOD(setAudioRoutingConfig:(NSString *)jsonConfig
-                  resolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-{
-  @try {
-    // Hand off to your audio/session manager (you implement this)
-    // e.g. in AudioSessionAndDuckingManager:
-    // - (void)setWakewordAudioRoutingConfigFromJSONString:(NSString *)jsonConfig;
-    [AudioSessionAndDuckingManager.shared setWakewordAudioRoutingConfigFromJSONString:jsonConfig];
-
-    NSLog(@"[KeyWordRNBridge] setAudioRoutingConfig JSON = %@", jsonConfig);
-    resolve(@"ok");
-  }
-  @catch (NSException *e) {
-    reject(@"AudioRoutingConfigError",
-           [NSString stringWithFormat:@"Failed to set audio routing config: %@", e.reason],
-           nil);
-  }
-}
-
-RCT_EXPORT_METHOD(disableDucking:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-  [AudioSessionAndDuckingManager.shared disableDucking];
-  resolve(@"enabled");
-}
-
-RCT_EXPORT_METHOD(initAudioSessAndDuckManage:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-  [AudioSessionAndDuckingManager.shared initAudioSessAndDuckManage];
-  resolve(@"enabled");
-}
-
-RCT_EXPORT_METHOD(restartListeningAfterDucking:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-  [AudioSessionAndDuckingManager.shared restartListeningAfterDucking];
-  resolve(@"disabled");
-}
-
-RCT_EXPORT_METHOD(enableAggressiveDucking:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-  [AudioSessionAndDuckingManager.shared enableAggressiveDucking];
-  resolve(@"enabled");
-}
-
-RCT_EXPORT_METHOD(disableDuckingAndCleanup:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-  [AudioSessionAndDuckingManager.shared disableDuckingAndCleanup];
-  resolve(@"disabled");
-}
-
-RCT_EXPORT_METHOD(setKeywordDetectionLicense:(NSString *)instanceId licenseKey:(NSString *)licenseKey resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    KeyWordsDetection *instance = wrapper.keyWordsDetection;
-    BOOL isLicensed = NO;
-    if (instance) {
-        isLicensed = [instance setLicenseWithLicenseKey:licenseKey];
-        NSLog(@"License is valid?: %@", isLicensed ? @"YES" : @"NO");
-        resolve(@(isLicensed)); // Wrap BOOL in NSNumber
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-RCT_EXPORT_METHOD(replaceKeywordDetectionModel:(NSString *)instanceId modelName:(NSString *)modelName threshold:(float)threshold bufferCnt:(NSInteger)bufferCnt resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    KeyWordsDetection *instance = wrapper.keyWordsDetection;
-    if (instance) {
-        NSError *error = nil;
-        [instance replaceKeywordDetectionModelWithModelPath:modelName threshold:threshold bufferCnt:bufferCnt error:&error];
-        if (error) {
-            reject(@"ReplaceError", [NSString stringWithFormat:@"Failed to replace model: %@", error.localizedDescription], nil);
-        } else {
-            resolve([NSString stringWithFormat:@"Instance ID: %@ changed model to %@", instanceId, modelName]);
-        }
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-RCT_EXPORT_METHOD(startKeywordDetection:(NSString *)instanceId 
-    threshold:(float)threshold 
-    noExternalActivation:(BOOL)noExternalActivation
-    duckOthers:(BOOL)duckOthers
-    mixWithOthers:(BOOL)mixWithOthers
-    defaultToSpeaker:(BOOL)defaultToSpeaker
-    resolver:(RCTPromiseResolveBlock)resolve 
-    rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    KeyWordsDetection *instance = wrapper.keyWordsDetection;
-    if (instance) {
-        BOOL success = [instance startListeningWithNoExternalActivation:noExternalActivation
-                                                  duckOthers:duckOthers
-                                              mixWithOthers:mixWithOthers
-                                           defaultToSpeaker:defaultToSpeaker];
-        if (success == false) {
-            reject(@"StartError", [NSString stringWithFormat:@"Failed to start detection"], nil);
-        } else {
-            resolve([NSString stringWithFormat:@"Started detection for instance: %@", instanceId]);
-        }
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-RCT_EXPORT_METHOD(stopKeywordDetection:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    KeyWordsDetection *instance = wrapper.keyWordsDetection;
-    if (instance) {
-        [instance stopListening];
-        resolve([NSString stringWithFormat:@"Stopped detection for instance: %@", instanceId]);
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-RCT_EXPORT_METHOD(destroyInstance:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    if (wrapper) {
-        [wrapper.keyWordsDetection stopListening];
-        [self.instances removeObjectForKey:instanceId];
-        resolve([NSString stringWithFormat:@"Destroyed instance: %@", instanceId]);
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-// Keeping all APIs even if not called in JS yet
-
-RCT_EXPORT_METHOD(getKeywordDetectionModel:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    KeyWordsDetection *instance = wrapper.keyWordsDetection;
-    if (instance) {
-        NSString *modelName = [instance getKeywordDetectionModel];
-        resolve(modelName);
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-RCT_EXPORT_METHOD(getRecordingWav:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    KeyWordsDetection *instance = wrapper.keyWordsDetection;
-    if (instance) {
-        NSString *recWavPath = [instance getRecordingWav];
-        resolve(recWavPath);
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-RCT_EXPORT_METHOD(getVoiceProps:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    KeyWordsDetection *instance = wrapper.keyWordsDetection;
-    if (instance) {
-        @try {
-            NSDictionary *voiceProps = [instance getVoiceProps];
-            NSMutableDictionary *result = [NSMutableDictionary dictionary];
-            result[@"error"] = voiceProps[@"error"] ?: @"No Error";
-            result[@"voiceProbability"] = @([voiceProps[@"voiceProbability"] floatValue]);
-            result[@"lastTimeHumanVoiceHeard"] = @([voiceProps[@"lastTimeHumanVoiceHeard"] longLongValue]);
-            resolve(result);
-        } @catch (NSException *exception) {
-            reject(@"VoicePropsError", [NSString stringWithFormat:@"Failed to get voice properties: %@", exception.reason], nil);
-        }
-    } else {
-        reject(@"InstanceNotFound", [NSString stringWithFormat:@"No instance found with ID: %@", instanceId], nil);
-    }
-}
-
-// Start/stop silent VAD (iOS only)
-RCT_EXPORT_METHOD(startSilentVADDetection:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    if (wrapper && wrapper.keyWordsDetection) {
-        BOOL success = [wrapper.keyWordsDetection startSilentListening];
-        success ? resolve(@"Started silent VAD detection") :
-                  reject(@"StartError", @"Failed to start silent VAD detection", nil);
-    } else {
-        reject(@"InstanceNotFound", @"No instance found", nil);
-    }
-}
-
-RCT_EXPORT_METHOD(stopSilentVADDetection:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    if (wrapper && wrapper.keyWordsDetection) {
-        [wrapper.keyWordsDetection stopSilentListening];
-        resolve(@"Stopped silent VAD detection");
-    } else {
-        reject(@"InstanceNotFound", @"No instance found", nil);
-    }
-}
-
-// Start/stop explicit VAD
-RCT_EXPORT_METHOD(startVADDetection:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    if (wrapper && wrapper.keyWordsDetection) {
-        BOOL success = [wrapper.keyWordsDetection startVADListening];
-        success ? resolve(@"Started VAD detection") :
-                  reject(@"StartError", @"Failed to start VAD detection", nil);
-    } else {
-        reject(@"InstanceNotFound", @"No instance found", nil);
-    }
-}
-
-RCT_EXPORT_METHOD(stopVADDetection:(NSString *)instanceId resolver:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
-{
-    KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-    if (wrapper && wrapper.keyWordsDetection) {
-        [wrapper.keyWordsDetection stopVADListening];
-        resolve(@"Stopped VAD detection");
-    } else {
-        reject(@"InstanceNotFound", @"No instance found", nil);
-    }
-}
-
-RCT_EXPORT_METHOD(setVADParams:(NSString *)instanceId
-                  threshold:(float)threshold
-                  msWindow:(NSInteger)msWindow
-                  resolver:(RCTPromiseResolveBlock)resolve
-                  rejecter:(RCTPromiseRejectBlock)reject)
-{
-  KeyWordsDetectionWrapper *wrapper = self.instances[instanceId];
-  if (wrapper && wrapper.keyWordsDetection) {
-    NSError *err = nil;
-    BOOL ok = [wrapper.keyWordsDetection setVADParamsWithThreshold:threshold
-                                                          msWindow:msWindow
-                                                             error:&err];
-    if (!ok || err) {
-      reject(@"VADParamsError",
-             err ? err.localizedDescription : @"Failed to set VAD params",
-             err);
-    } else {
-      resolve(@"VAD params updated");
-    }
-  } else {
-    reject(@"InstanceNotFound", @"No instance found", nil);
-  }
-}
-
-// You can add more methods here as needed, ensuring they use the instanceId
-
-@end