react-native-vad/vad/VADRNBridge.js

VAD / Voice activation detection library for React Native

// VADRNBridge.js
import { NativeModules, NativeEventEmitter, Platform } from 'react-native';

const { VADRNBridge } = NativeModules;
const VADRNBridgeEmitter = new NativeEventEmitter(VADRNBridge);

if (VADRNBridge) {
    console.log("VADRNBridge is loaded:", VADRNBridge);
  } else {
    console.error("VADRNBridge is not linked correctly.");
  }
  
export class VADRNBridgeInstance {
    instanceId;
    listeners = [];
    isFirstInstance = false;
  
    constructor(instanceId, isSticky) {
      this.instanceId = instanceId;
      this.isSticky = isSticky;
    }
  
    async createInstance(threshold, msWindow) {
      instance = await VADRNBridge.createInstance(
        this.instanceId, threshold, msWindow);
      if (instance && this.isFirstInstance)
      {
        this.isFirstInstance = false;
        await VADRNBridge.startForegroundService(this.instanceId); 
      }
      return instance;
    }

    async setVADDetectionLicense(license) {
        return await VADRNBridge.setVADDetectionLicense(this.instanceId, license);
    }

    async startSilentVADDetection() {
        if (Platform.OS === 'ios') {
            return await VADRNBridge.startSilentVADDetection(this.instanceId);
        }
    }

    async stopSilentVADDetection() {
        if (Platform.OS === 'ios') {
            return await VADRNBridge.stopSilentVADDetection(this.instanceId);
        }
    }

    async startVADDetection() {
        return await VADRNBridge.startVADDetection(this.instanceId);
    }

    async stopVADDetection() {
        return VADRNBridge.stopVADDetection(this.instanceId);
    }

    async destroyInstance() {
        return VADRNBridge.destroyInstance(this.instanceId);
    }

    async getVoiceProps() {
      try {
          const voiceProps = await VADRNBridge.getVoiceProps(this.instanceId);
          return {
              error: voiceProps.error,
              voiceProbability: voiceProps.voiceProbability,
              lastTimeHumanVoiceHeard: voiceProps.lastTimeHumanVoiceHeard,
          };
      } catch (error) {
          console.error('Error getting voice properties:', error);
          throw error;
      }
    }
  
    onVADDetectionEvent(callback) {
        const listener = VADRNBridgeEmitter.addListener('onVADDetectionEvent', (event) => {
            if (event.instanceId === this.instanceId) {
                callback(event.phrase);
            }
        });
        this.listeners.push(listener);
        return listener;
    }

    removeListeners() {
        this.listeners.forEach((listener) => listener.remove());
        this.listeners = [];
    }
}

export const removeAllRNBridgeListeners = async () => {
    VADRNBridgeEmitter.removeAllListeners('onVADDetectionEvent');
}

export const createVADRNBridgeInstance = async (instanceId, isSticky) => {
    return new VADRNBridgeInstance(instanceId, isSticky);
};