react-native-wakeword-sid 1.1.55

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

@@ -0,0 +1,588 @@
+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/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>