capacitor-microphone 0.0.3 → 0.0.5

package/android/src/main/java/com/eddieagvictoria/capacitor_microphone/CapacitorMicrophonePlugin.java

@@ -11,6 +11,14 @@ import com.getcapacitor.annotation.Permission;
 import com.getcapacitor.annotation.PermissionCallback;
 import com.getcapacitor.PermissionState;
 
+import android.content.Intent;
+import android.os.Bundle;
+import android.speech.RecognitionListener;
+import android.speech.RecognizerIntent;
+import android.speech.SpeechRecognizer;
+
+import java.util.ArrayList;
+
 @CapacitorPlugin(
     name = "CapacitorMicrophone",
     permissions = {
@@ -22,6 +30,9 @@ import com.getcapacitor.PermissionState;
 )
 public class CapacitorMicrophonePlugin extends Plugin {
 
+private SpeechRecognizer speechRecognizer;
+private PluginCall currentCall;
+
     @PluginMethod
     public void checkPermission(PluginCall call) {
         PermissionState state = getPermissionState("microphone");
@@ -89,4 +100,120 @@ public class CapacitorMicrophonePlugin extends Plugin {
     }
 
 
+
+    @PluginMethod
+    public void startListening(PluginCall call) {
+
+    if (speechRecognizer != null) {
+        call.reject("Speech recognition already running");
+        return;
+    }
+
+        if (getPermissionState("microphone") != PermissionState.GRANTED) {
+            call.reject("Microphone permission not granted");
+            return;
+        }
+
+        if (!SpeechRecognizer.isRecognitionAvailable(getContext())) {
+                call.reject("Speech recognition not available on this device");
+                return;
+        }
+
+        currentCall = call;
+
+        speechRecognizer = SpeechRecognizer.createSpeechRecognizer(getContext());
+
+        Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
+        intent.putExtra(
+            RecognizerIntent.EXTRA_LANGUAGE_MODEL,
+            RecognizerIntent.LANGUAGE_MODEL_FREE_FORM
+        );
+        intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE, "es-MX");
+        intent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
+
+        speechRecognizer.setRecognitionListener(new RecognitionListener() {
+
+            @Override
+            public void onResults(Bundle results) {
+                ArrayList<String> matches =
+                    results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
+
+                JSObject ret = new JSObject();
+                ret.put("text", matches != null && !matches.isEmpty() ? matches.get(0) : "");
+                ret.put("isFinal", true);
+                if (currentCall != null) {
+                    currentCall.resolve(ret);
+                    currentCall = null;
+                }
+            }
+
+            @Override
+            public void onPartialResults(Bundle partialResults) {
+                ArrayList<String> matches =
+                    partialResults.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
+
+                if (matches != null && !matches.isEmpty()) {
+                    JSObject ret = new JSObject();
+                    ret.put("text", matches.get(0));
+                    ret.put("isFinal", false);
+
+                    notifyListeners("partialResult", ret);
+                }
+            }
+
+            @Override public void onError(int error) {
+                if (currentCall != null) {
+                    currentCall.reject(mapError(error));
+
+                    currentCall = null;
+                }
+            }
+
+            // Métodos obligatorios (vacíos)
+            @Override public void onReadyForSpeech(Bundle params) {}
+            @Override public void onBeginningOfSpeech() {}
+            @Override public void onRmsChanged(float rmsdB) {}
+            @Override public void onBufferReceived(byte[] buffer) {}
+            @Override public void onEndOfSpeech() {}
+            @Override public void onEvent(int eventType, Bundle params) {}
+        });
+
+        speechRecognizer.startListening(intent);
+    }
+
+    @PluginMethod
+    public void stopListening(PluginCall call) {
+        if (speechRecognizer != null) {
+            speechRecognizer.stopListening();
+            speechRecognizer.destroy();
+            speechRecognizer = null;
+        }
+
+        JSObject ret = new JSObject();
+        ret.put("stopped", true);
+        call.resolve(ret);
+    }
+
+    @Override
+    protected void handleOnDestroy() {
+        if (speechRecognizer != null) {
+            speechRecognizer.destroy();
+            speechRecognizer = null;
+        }
+    }
+
+private String mapError(int error) {
+    switch (error) {
+        case SpeechRecognizer.ERROR_AUDIO: return "Audio error";
+        case SpeechRecognizer.ERROR_NETWORK: return "Network error";
+        case SpeechRecognizer.ERROR_NO_MATCH: return "No speech recognized";
+        case SpeechRecognizer.ERROR_SPEECH_TIMEOUT: return "Speech timeout";
+        default: return "Unknown error";
+    }
+}
+
+
 }
+
+
+

package/ios/Sources/capacitor_microphonePlugin/CapacitorMicrophonePlugin.swift

@@ -1,17 +1,27 @@
 import Foundation
 import Capacitor
 import AVFoundation
+import Speech
+
 
 @objc(CapacitorMicrophonePlugin)
 public class CapacitorMicrophonePlugin: CAPPlugin, CAPBridgedPlugin {
 
+private let audioEngine = AVAudioEngine()
+private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
+private var recognitionTask: SFSpeechRecognitionTask?
+private var speechRecognizer: SFSpeechRecognizer?
+private var currentCall: CAPPluginCall?
+
     public let identifier = "CapacitorMicrophonePlugin"
     public let jsName = "CapacitorMicrophone"
 
     public let pluginMethods: [CAPPluginMethod] = [
         CAPPluginMethod(name: "checkPermission", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "requestPermission", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "checkRequestPermission", returnType: CAPPluginReturnPromise)
+        CAPPluginMethod(name: "checkRequestPermission", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startListening", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "stopListening", returnType: CAPPluginReturnPromise)
     ]
 
     @objc func checkPermission(_ call: CAPPluginCall) {
@@ -71,4 +81,116 @@ public class CapacitorMicrophonePlugin: CAPPlugin, CAPBridgedPlugin {
             ])
         }
     }
+
+    @objc func startListening(_ call: CAPPluginCall) {
+
+    if audioEngine.isRunning {
+        call.reject("Speech recognition already running")
+        return
+    }
+
+    self.currentCall = call
+
+        let lang = call.getString("lang") ?? "es-MX"
+        speechRecognizer = SFSpeechRecognizer(locale: Locale(identifier: lang))
+
+        SFSpeechRecognizer.requestAuthorization { authStatus in
+            if authStatus != .authorized {
+                self.currentCall?.reject("Speech recognition not authorized")
+                self.currentCall = nil
+                return
+            }
+
+            DispatchQueue.main.async {
+                self.startRecognition()
+            }
+        }
+
+    }
+
+    private func startRecognition() {
+
+        recognitionRequest = SFSpeechAudioBufferRecognitionRequest()
+        guard let recognitionRequest = recognitionRequest else {
+            self.currentCall?.reject("Unable to create recognition request")
+            self.currentCall = nil
+            return
+        }
+
+        recognitionRequest.shouldReportPartialResults = true
+
+        let inputNode = audioEngine.inputNode
+
+        recognitionTask = speechRecognizer?.recognitionTask(with: recognitionRequest) { result, error in
+            if let result = result {
+
+                self.notifyListeners("partialResult", data: [
+                    "text": result.bestTranscription.formattedString,
+                    "isFinal": result.isFinal
+                ])
+
+                if result.isFinal, let currentCall = self.currentCall {
+                    currentCall.resolve([
+                        "text": result.bestTranscription.formattedString,
+                        "isFinal": true
+                    ])
+                    self.currentCall = nil
+                    self.stopAudio()
+                }
+            }
+
+            if let error = error, let currentCall = self.currentCall {
+                currentCall.reject(error.localizedDescription)
+                self.currentCall = nil
+                self.stopAudio()
+            }
+        }
+
+        let recordingFormat = inputNode.outputFormat(forBus: 0)
+        inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) {
+            buffer, _ in
+            recognitionRequest.append(buffer)
+        }
+
+        audioEngine.prepare()
+
+        do {
+        let audioSession = AVAudioSession.sharedInstance()
+        try audioSession.setCategory(.record, mode: .measurement, options: .duckOthers)
+        try audioSession.setActive(true, options: .notifyOthersOnDeactivation)
+            try audioEngine.start()
+        } catch {
+            if let currentCall = self.currentCall {
+                currentCall.reject("Audio engine could not start")
+                self.currentCall = nil
+            }
+        }
+    }
+
+
+    @objc func stopListening(_ call: CAPPluginCall) {
+        stopAudio()
+        call.resolve(["stopped": true])
+    }
+
+    private func stopAudio() {
+        if audioEngine.isRunning {
+            audioEngine.stop()
+        }
+        if audioEngine.inputNode.numberOfInputs > 0 {
+            audioEngine.inputNode.removeTap(onBus: 0)
+        }
+        recognitionRequest?.endAudio()
+
+        recognitionTask?.cancel()
+        recognitionTask = nil
+        recognitionRequest = nil
+    }
+
+    override public func handleOnDestroy() {
+        stopAudio()
+    }
+
+
+
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "capacitor-microphone",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "plugin to use the microphone",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",