react-native-wakeword-sid 1.1.70

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

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

package/android/src/main/java/com/davoice/speakeridrn/SpeakerIdRNBridgePackage.java

@@ -0,0 +1,24 @@
+package com.davoice.speakeridrn;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SpeakerIdRNBridgePackage implements ReactPackage {
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new SpeakerIdRNBridge(reactContext));
+        return modules;
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/app.plugin.js

@@ -0,0 +1,60 @@
+// app.plugin.js
+const { withAndroidManifest, withProjectBuildGradle } = require('@expo/config-plugins');
+
+function withReactNativeWakeword(config) {
+  //
+  // 1. Add necessary permissions to AndroidManifest (if needed).
+  //    For example, if `react-native-wakeword` needs RECORD_AUDIO.
+  //
+  config = withAndroidManifest(config, (config) => {
+    const androidManifest = config.modResults;
+
+    // Ensure 'uses-permission' array exists
+    if (!androidManifest.manifest['uses-permission']) {
+      androidManifest.manifest['uses-permission'] = [];
+    }
+
+    const permissions = androidManifest.manifest['uses-permission'];
+    const hasRecordAudio = permissions.some(
+      (permission) => permission.$['android:name'] === 'android.permission.RECORD_AUDIO'
+    );
+
+    // Add RECORD_AUDIO permission if not present
+    if (!hasRecordAudio) {
+      permissions.push({ $: { 'android:name': 'android.permission.RECORD_AUDIO' } });
+    }
+
+    return config;
+  });
+
+  //
+  // 2. Insert Maven repository or other Gradle config in the project's
+  //    top-level build.gradle (only if your library requires custom artifacts).
+  //
+  config = withProjectBuildGradle(config, (config) => {
+    const buildGradle = config.modResults.contents;
+
+    // This snippet references a local "libs" folder inside your library package.
+    // Adjust the path if your artifacts are elsewhere or not needed.
+    const wakewordMaven = `
+        // react-native-wakeword added
+        maven { url("$rootDir/../node_modules/react-native-wakeword/libs") }
+        // End react-native-wakeword added
+    `;
+
+    // Only add the snippet once
+    if (!buildGradle.includes('react-native-wakeword added')) {
+      config.modResults.contents = buildGradle.replace(
+        /repositories\s*{/,
+        `repositories {\n${wakewordMaven}`
+      );
+    }
+
+    return config;
+  });
+
+  return config;
+}
+
+module.exports = withReactNativeWakeword;
+

package/ios/KeyWordRNBridge/KeyWordDetection.xcframework/Info.plist

@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>AvailableLibraries</key>
+	<array>
+		<dict>
+			<key>BinaryPath</key>
+			<string>KeyWordDetection.framework/KeyWordDetection</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64_x86_64-simulator</string>
+			<key>LibraryPath</key>
+			<string>KeyWordDetection.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+				<string>x86_64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+			<key>SupportedPlatformVariant</key>
+			<string>simulator</string>
+		</dict>
+		<dict>
+			<key>BinaryPath</key>
+			<string>KeyWordDetection.framework/KeyWordDetection</string>
+			<key>LibraryIdentifier</key>
+			<string>ios-arm64</string>
+			<key>LibraryPath</key>
+			<string>KeyWordDetection.framework</string>
+			<key>SupportedArchitectures</key>
+			<array>
+				<string>arm64</string>
+			</array>
+			<key>SupportedPlatform</key>
+			<string>ios</string>
+		</dict>
+	</array>
+	<key>CFBundlePackageType</key>
+	<string>XFWK</string>
+	<key>XCFrameworkFormatVersion</key>
+	<string>1.0</string>
+</dict>
+</plist>