react-native-wakeword 1.0.22

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 frymanofer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+DaVoice.io Voice commands / Wake words / keyword detection npm for Android and IOS.
+
+Contact us at info@DaVoice.io
+
+## Installation
+npm install react-native-wakeword
+
+Checkout examples on:
+https://github.com/frymanofer/ReactNative_WakeWordDetection

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Sun Nov 17 16:24:00 IST 2024
+gradle.version=8.9

package/android/build.gradle

@@ -0,0 +1,45 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 33
+
+    defaultConfig {
+        minSdkVersion 21
+        targetSdkVersion 33
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+
+    sourceSets {
+        main {
+            assets.srcDirs = ['src/main/assets']
+            jniLibs.srcDirs = ['src/main/jniLibs'] // Add this line if needed
+        }
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+    flatDir {
+        dirs 'src/main/libs' // Update this line
+    }
+    maven {
+        url 'https://maven.pkg.github.com/microsoft/onnxruntime'
+    }
+    mavenLocal()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    implementation 'com.microsoft.onnxruntime:onnxruntime-android:1.13.1'
+    implementation 'ai.picovoice:android-voice-processor:1.0.2'
+    implementation fileTree(dir: "src/main/libs", include: ["*.aar"])
+ //   implementation(name: 'MyLibrary-release', ext: 'aar') // Add this line
+}
+
+// Run this once to be able to run the application with BUCK
+// puts all compile dependencies into folder libs for BUCK to use
+task copyDownloadableDepsToLibs(type: Copy) { 
+    from configurations.implementation
+    into 'libs'
+}

package/android/settings.gradle

@@ -0,0 +1 @@
+include ':app'

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,13 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.davoice.keywordspotting">
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE"/>
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
+    <uses-permission android:name="android.permission.WAKE_LOCK"/>
+
+</manifest>
+

package/android/src/main/java/com/davoice/keywordspotting/KeyWordRNBridge.java

@@ -0,0 +1,168 @@
+package com.davoice.keywordspotting;
+
+import com.davoice.keywordsdetection.keywordslibrary.KeyWordsDetection;
+import com.facebook.react.bridge.*;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+import androidx.annotation.Nullable;
+import ai.onnxruntime.*;
+import android.util.Log;
+import java.util.HashMap;
+import java.util.Map;
+
+public class KeyWordRNBridge extends ReactContextBaseJavaModule {
+
+    private final String TAG = "KeyWordsDetection";
+    private static final String REACT_CLASS = "KeyWordRNBridge";
+    private static ReactApplicationContext reactContext;
+
+    // Map to hold multiple instances
+    private Map<String, KeyWordsDetection> instances = new HashMap<>();
+
+    public KeyWordRNBridge(ReactApplicationContext context) {
+        super(context);
+        reactContext = context;
+    }
+
+    @Override
+    public String getName() {
+        return REACT_CLASS;
+    }
+
+    @ReactMethod
+    public Boolean setKeywordDetectionLicense(String instanceId, String licenseKey, Promise promise) {
+        KeyWordsDetection instance = instances.get(instanceId);
+        Log.d(TAG, "setKeywordDetectionLicense()");
+
+        Boolean isLicesed = false;
+        if (instance != null) {
+            isLicesed = instance.setLicenseKey(licenseKey);
+        }
+        Log.d(TAG, "setKeywordDetectionLicense(): " + (isLicesed ? "Licensed" : "Not Licensed"));
+
+        promise.resolve(isLicesed);
+        return isLicesed;
+    }
+
+    // Create a new instance
+    @ReactMethod
+    public void createInstance(String instanceId, String modelName, float threshold, int bufferCnt, Promise promise) {
+        if (instances.containsKey(instanceId)) {
+            promise.reject("InstanceExists", "Instance already exists with ID: " + instanceId);
+            return;
+        }
+
+        try {
+            KeyWordsDetection keyWordsDetection = new KeyWordsDetection(reactContext, modelName, threshold, bufferCnt);
+            keyWordsDetection.initialize(detected -> onKeywordDetected(instanceId, detected));
+            instances.put(instanceId, keyWordsDetection);
+            promise.resolve("Instance created with ID: " + instanceId);
+        } catch (Exception e) {
+            promise.reject("CreateError", "Failed to create instance: " + e.getMessage());
+        }
+    }
+
+    // Create a new instance
+    @ReactMethod
+    public void replaceKeywordDetectionModel(String instanceId, String modelName, float threshold, int bufferCnt, Promise promise) {
+        KeyWordsDetection instance = instances.get(instanceId);
+        if (instance == null) {
+            promise.reject("Instance not Exists", "Instance does not exists with ID: " + instanceId);
+            return;
+        }
+
+        try {
+            instance.replaceKeywordDetectionModel(reactContext, modelName, threshold, bufferCnt);
+            promise.resolve("Instance ID: " + instanceId + " change model " + modelName);
+        } catch (Exception e) {
+            promise.reject("CreateError", "Failed to create instance: " + e.getMessage());
+        }
+    }
+
+    // Start detection for a specific instance
+    @ReactMethod
+    public void startKeywordDetection(String instanceId, float threshold, Promise promise) throws OrtException {
+        KeyWordsDetection instance = instances.get(instanceId);
+        if (instance != null) {
+            instance.startListening(threshold);
+            promise.resolve("Started detection for instance: " + instanceId);
+        } else {
+            promise.reject("InstanceNotFound", "No instance found with ID: " + instanceId);
+        }
+    }
+
+    // Stop detection for a specific instance
+    @ReactMethod
+    public void stopForegroundService(String instanceId, Promise promise) {
+        KeyWordsDetection instance = instances.get(instanceId);
+        if (instance != null) {
+            instance.stopForegroundService();
+            promise.resolve("stopForegroundService" + instanceId);
+        } else {
+            promise.reject("stopForegroundService", "No instance found with ID: " + instanceId);
+        }
+    }
+    
+    // Stop detection for a specific instance
+    @ReactMethod
+    public void startForegroundService(String instanceId, Promise promise) {
+        KeyWordsDetection instance = instances.get(instanceId);
+        if (instance != null) {
+            instance.startForegroundService();
+            promise.resolve("startForegroundService" + instanceId);
+        } else {
+            promise.reject("startForegroundService", "No instance found with ID: " + instanceId);
+        }
+    }
+
+    // Stop detection for a specific instance
+    @ReactMethod
+    public void stopKeywordDetection(String instanceId, Promise promise) {
+        KeyWordsDetection instance = instances.get(instanceId);
+        if (instance != null) {
+            instance.stopListening();
+            promise.resolve("Stopped detection for instance: " + instanceId);
+        } else {
+            promise.reject("InstanceNotFound", "No instance found with ID: " + instanceId);
+        }
+    }
+
+    // Destroy an instance
+    @ReactMethod
+    public void destroyInstance(String instanceId, Promise promise) {
+        KeyWordsDetection instance = instances.remove(instanceId);
+        if (instance != null) {
+            instance.stopListening();
+            // Additional cleanup if necessary
+            promise.resolve("Destroyed instance: " + instanceId);
+        } else {
+            promise.reject("InstanceNotFound", "No instance found with ID: " + instanceId);
+        }
+    }
+
+    // Handle keyword detection event
+    private void onKeywordDetected(String instanceId, Boolean detected) {
+        if (detected) {
+            WritableMap params = Arguments.createMap();
+            params.putString("instanceId", instanceId);
+            params.putString("phrase", instanceId);
+            sendEvent("onKeywordDetectionEvent", params);
+        }
+    }
+
+    // Send event to JavaScript
+    private void sendEvent(String eventName, @Nullable WritableMap params) {
+        reactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+            .emit(eventName, params);
+    }
+
+    @ReactMethod
+    public void addListener(String eventName) {
+        // Set up any upstream listeners or background tasks as necessary
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        // Remove upstream listeners, stop unnecessary background tasks
+    }
+    // Implement other methods as needed, ensuring to use instanceId
+}

package/android/src/main/java/com/davoice/keywordspotting/KeyWordRNBridgePackage.java

@@ -0,0 +1,25 @@
+package com.davoice.keywordspotting;
+
+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 KeyWordRNBridgePackage implements ReactPackage {
+
+    @Override
+    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new KeyWordRNBridge(reactContext));
+        return modules;
+    }
+
+    @Override
+    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+    "name": "react-native-wakeword",
+    "version": "1.0.22",
+    "description": "Voice/Wake-word detection library for React Native",
+    "main": "wakewords/index.js",
+    "types": "wakewords/index.d.ts",
+    "files": [
+        "wakewords/",
+        "android/",
+        "react-native.config.js"
+    ],
+    "react-native": {
+        "android": "android"
+    },
+    "scripts": {
+        "build": "gradlew assembleRelease"
+    },
+    "devDependencies": {
+        "@types/react": "^18.3.12",
+        "typescript": "^4.0.0"
+    },
+    "peerDependencies": {
+        "react": "^18.3.1",
+        "react-native": "^0.75.2"
+    },
+    "keywords": [
+        "react-native",
+        "voice commands",
+        "wake word",
+        "keyword detection",
+        "keyword spotting",
+        "phrase spotting"
+    ],
+    "author": "Davoice.io",
+    "license": "MIT"
+}

package/react-native.config.js

@@ -0,0 +1,14 @@
+module.exports = {
+    dependencies: {
+        'react-native-wakeword': {
+            platforms: {
+                android: {
+                    sourceDir: './android',
+                    packageImportPath: 'import com.davoice.keywordspotting.KeyWordRNBridgePackage;',
+                    packageInstance: 'new KeyWordRNBridgePackage()',
+                },
+            },
+        },
+    },
+};
+

package/wakewords/KeyWordRNBridge.d.ts

@@ -0,0 +1,17 @@
+export class KeyWordRNBridgeInstance {
+    constructor(instanceId: any, isSticky: any);
+    instanceId: any;
+    listeners: any[];
+    isFirstInstance: boolean;
+    isSticky: any;
+    createInstance(modelName: any, threshold: any, bufferCnt: any): any;
+    setKeywordDetectionLicense(license: any): any;
+    replaceKeywordDetectionModel(modelName: any, threshold: any, bufferCnt: any): any;
+    setKeywordLicense(license: any): any;
+    startKeywordDetection(threshold: any): any;
+    stopKeywordDetection(): any;
+    destroyInstance(): any;
+    onKeywordDetectionEvent(callback: any): void;
+    removeListeners(): void;
+}
+export function createKeyWordRNBridgeInstance(instanceId: any, isSticky: any): Promise<KeyWordRNBridgeInstance>;

package/wakewords/KeyWordRNBridge.js

@@ -0,0 +1,89 @@
+// KeyWordRNBridge.js
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+const { KeyWordRNBridge } = NativeModules;
+const keywordRNBridgeEmitter = new NativeEventEmitter(KeyWordRNBridge);
+
+if (KeyWordRNBridge) {
+    console.log("KeyWordRNBridge is loaded:", KeyWordRNBridge);
+  } else {
+    console.error("KeyWordRNBridge is not linked correctly.");
+  }
+  
+export class KeyWordRNBridgeInstance {
+    instanceId;
+    listeners = [];
+    isFirstInstance = false;
+  
+    constructor(instanceId, isSticky) {
+      this.instanceId = instanceId;
+      this.isSticky = isSticky;
+    }
+  
+    createInstance(
+      modelName,
+      threshold,
+      bufferCnt) 
+      {
+      instance = KeyWordRNBridge.createInstance(
+        this.instanceId,
+        modelName,
+        threshold,
+        bufferCnt
+      );
+      if (instance && this.isFirstInstance)
+      {
+        this.isFirstInstance = false;
+        KeyWordRNBridge.startForegroundService(this.instanceId); 
+      }
+      return instance;
+    }
+
+    setKeywordDetectionLicense(license) {
+        return KeyWordRNBridge.setKeywordDetectionLicense(this.instanceId, license);
+    }
+
+    replaceKeywordDetectionModel(modelName, threshold, bufferCnt) {
+        return KeyWordRNBridge.replaceKeywordDetectionModel(this.instanceId, modelName, threshold, bufferCnt);
+    }
+    /*startForegroundService() {
+        return KeyWordRNBridge.startForegroundService(this.instanceId);
+    }
+
+    stopForegroundService() {
+        return KeyWordRNBridge.stopForegroundService(this.instanceId);
+    }*/
+    setKeywordLicense(license) {
+        return KeyWordRNBridge.setKeywordLicense(this.instanceId, license);
+    }
+
+    startKeywordDetection(threshold) {
+        return KeyWordRNBridge.startKeywordDetection(this.instanceId, threshold);
+    }
+
+    stopKeywordDetection() {
+        return KeyWordRNBridge.stopKeywordDetection(this.instanceId);
+    }
+
+    destroyInstance() {
+        return KeyWordRNBridge.destroyInstance(this.instanceId);
+    }
+
+    onKeywordDetectionEvent(callback) {
+        const listener = keywordRNBridgeEmitter.addListener('onKeywordDetectionEvent', (event) => {
+            if (event.instanceId === this.instanceId) {
+                callback(event.phrase);
+            }
+        });
+        this.listeners.push(listener);
+    }
+
+    removeListeners() {
+        this.listeners.forEach((listener) => listener.remove());
+        this.listeners = [];
+    }
+}
+
+export const createKeyWordRNBridgeInstance = async (instanceId, isSticky) => {
+    return new KeyWordRNBridgeInstance(instanceId, isSticky);
+};

package/wakewords/index.d.ts

@@ -0,0 +1,3 @@
+export { useModel };
+export default useModel;
+import useModel from "./useModel";

package/wakewords/index.d.ts.chat_idiot

@@ -0,0 +1,2 @@
+export { useModel };
+export default useModel;

package/wakewords/index.js

@@ -0,0 +1,4 @@
+import useModel from './useModel';
+
+export { useModel }; // Export only useModel
+export default useModel; // Allow default import

package/wakewords/useModel.d.ts

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

package/wakewords/useModel.tsx

@@ -0,0 +1,227 @@
+import { useState, useEffect, useCallback } from "react";
+import {
+    createKeyWordRNBridgeInstance,
+    KeyWordRNBridgeInstance,
+  } from './KeyWordRNBridge';
+import { Platform } from "react-native";
+  
+type DetectionCallback = (event: any) => void;
+
+var license = "MTczMjkxNzYwMDAwMA==-DDwBWs914KpHbWBBSqi28vhiM4l5CYG+YgS2n9Z3DMI=";
+interface keyWordRNBridgeInstanceConfig {
+    id: string;
+    instance: KeyWordRNBridgeInstance;
+}
+
+interface instanceConfig {
+    id: string;
+    modelName: string;
+    threshold: number;
+    bufferCnt: number;
+    sticky: boolean;
+}
+
+const keyWordRNBridgeInstances: keyWordRNBridgeInstanceConfig[] = [];
+function findInstanceById(id: string): keyWordRNBridgeInstanceConfig | undefined {
+    return keyWordRNBridgeInstances.find(config => config.id === id);
+}
+
+// Create an array of instance configurations
+const instanceConfigs:instanceConfig[] = [
+    { id: 'need_help_now', modelName: 'need_help_now.onnx', threshold: 0.9999, bufferCnt: 3 , sticky: false },
+    { id: 'default', modelName: "", threshold: 0.9999, bufferCnt: 2 , sticky: false }
+];
+
+// Function to add a new instance dynamically
+//async function addInstance(
+//    conf: instanceConfig) 
+async function addInstance(
+    conf: instanceConfig,
+    callback: (phrase: string) => void
+): Promise<KeyWordRNBridgeInstance | null> {
+    const id = conf.id;
+    const instanceConf = findInstanceById(id);
+    if (instanceConf != null) {
+        console.log("Found Instance: ", id, "starting to listen");
+        const instance = instanceConf.instance;
+        instance.startKeywordDetection(conf.threshold);
+        return instance;
+    }
+    const instance = await createKeyWordRNBridgeInstance(id, conf.sticky);
+    let isLicesed = false;
+  
+    if (!instance) {
+        console.error(`Failed to create instance ${id}`);
+        return null;
+    }
+    console.log(`Instance ${id} created ${instance}`);
+    await instance.createInstance(conf.modelName, conf.threshold, conf.bufferCnt);
+    console.log(`Instance ${id} createInstance() called`);
+
+    isLicesed = await instance.setKeywordDetectionLicense(license);
+    console.log(`Instance ${id} created ${instance} and licensed ${isLicesed}`);
+  
+    keyWordRNBridgeInstances.push({ id, instance });
+      // Set up event listener
+    instance.onKeywordDetectionEvent((phrase: string) => {
+      console.log(`Instance ${id} detected: ${id} with phrase`, phrase);
+      // callback(phrase); Does not work on IOS
+      callback(id);
+    });
+    console.log(`Instance ${id} calling startKeywordDetection()`);
+    instance.startKeywordDetection(conf.threshold);
+    console.log(`Instance ${id} started Keyword Detection`);
+    return instance;
+  }
+  
+  // Function to remove an instance dynamically
+function removeInstance(id: string): void {
+    const instanceIndex = keyWordRNBridgeInstances.findIndex((item) => item.id === id);
+  
+    if (instanceIndex !== -1) {
+      const { instance } = keyWordRNBridgeInstances[instanceIndex];
+  
+      instance
+        .stopKeywordDetection()
+        .then(() => instance.destroyInstance())
+        .then(() => {
+          instance.removeListeners();
+          console.log(`Instance ${id} stopped and destroyed`);
+          keyWordRNBridgeInstances.splice(instanceIndex, 1);
+        })
+        .catch((error: Error) =>
+          console.error(`Error stopping instance ${id}: ${error.message}`)
+        );
+    } else {
+      console.error(`Instance ${id} not found`);
+    }
+  }
+  
+/**
+ * Custom hook for handling keyword detection using KeyWordRNBridge
+ * @returns An object with functions and state for keyword detection
+ */
+export const useModel = () => {
+    // State to track whether the keyword detection is currently active
+    const [isListening, setIsListening] = useState(false);
+    let currentEventListener: any[] = [];
+    /**
+     * Set the keyword detection license
+     * @param licenseKey - The license key
+     */
+    // const setLicense = useCallback(async (licenseKey: any) => {
+    //     try {
+    //         await KeyWordRNBridge.setKeywordDetectionLicense(licenseKey);
+    //     } catch (error) {
+    //         console.error("[useModel] Error setting license:", error);
+    //     }
+    // }, []);
+
+        /**
+     * Sets the keyword detection license
+     * @param licenseKey - The linceseKey
+     */
+    const setKeywordDetectionLicense = useCallback(        
+        async (licenseKey: string): Promise<void> => {
+        license = licenseKey;
+    }, []);
+
+    
+    /**
+     * Load the keyword detection model
+     * @param modelFileName - The name of the model file to load
+     * @param threshold - The detection threshold
+     * @param bufferCount - The number of audio buffers
+     */
+    const loadModel = useCallback(
+        async (models: [string], callback: (phrase: string) => void): Promise<void> => {
+
+        console.log("loadModel()");
+        let searchIds = models;
+        let element:any = null;
+        console.log("loadModel() - models == ", models)
+        try {
+            stopListening();
+            searchIds.forEach(sId => {
+                element = instanceConfigs.find(element => element.id === sId.split(".")[0]);
+                if (element == null || element == undefined) {
+                    //console.error('element id' + sId + " not found in instanceConfigs");
+                    //return;
+                }
+                else {
+                    element = Object.assign({}, instanceConfigs.find(element => element.id === 'default'));
+                    element.modelName = sId;
+                    element.id = sId.split(".")[0];
+                }
+                console.log('element:', element);
+                const id = addInstance(element, callback);
+            });
+        } catch (error) {
+            console.error("[useModel] Error loading model:", error);
+        }
+    }, []);
+
+    /**
+     * Stop listening for the keyword
+     */
+    const startListening = useCallback(async () => {
+        try {
+            keyWordRNBridgeInstances.forEach(element => {
+                const instance = element.instance;
+                instance.startKeywordDetection();
+                /*if (instance.isSticky == false) {
+                    instance.stopKeywordDetection();
+                } else if (Platform.OS != 'ios') {
+                    instance.stopKeywordDetection();
+                }*/
+            }); 
+            setIsListening(true);
+        } catch (error) {
+            console.error("Error starting keyword detection:", error);
+        }
+    }, []);
+    
+    /**
+     * Stop listening for the keyword
+     */
+    const stopListening = useCallback(async () => {
+        try {
+            keyWordRNBridgeInstances.forEach(element => {
+                const instance = element.instance;
+                instance.stopKeywordDetection();
+                /*if (instance.isSticky == false) {
+                    instance.stopKeywordDetection();
+                } else if (Platform.OS != 'ios') {
+                    instance.stopKeywordDetection();
+                }*/
+            }); 
+            setIsListening(false);
+        } catch (error) {
+            console.error("Error stopping keyword detection:", error);
+        }
+    }, []);
+
+    /**
+     * Cleanup effect to stop listening when the component unmounts
+     * or when the isListening state changes
+     */
+    useEffect(() => {
+        console.log("isListening updated:", isListening);
+        return () => {
+            if (isListening) {
+                stopListening();
+            }
+        };
+    }, [isListening, stopListening]);
+
+    // Return an object with the necessary functions and state
+    return {
+        isListening,
+        startListening,
+        loadModel,
+        setKeywordDetectionLicense,
+        stopListening,
+    };
+};
+
+export default useModel; // Add this line to allow default import