capacitor-microphone 0.1.9 → 0.1.11

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

@@ -319,33 +319,178 @@ private void startListeningInternal(PluginCall call, String lang) {
 
     @PluginMethod
     public void restartListening(PluginCall call) {
-        if (!isListening) {
-            call.reject("Cannot restart - not currently listening");
+        // 1. Verificar si hay sesión activa
+        if (!isListening || currentCall == null) {
+            call.reject("No active listening session to restart");
             return;
         }
 
-        // Obtener el lenguaje actual
-        String currentLang = "es-MX";
-        if (currentCall != null) {
-            currentLang = currentCall.getString("lang", "es-MX");
-        }
+        // 2. Guardar el lenguaje actual
+        final String currentLang = currentCall.getString("lang", "es-MX");
+
+        // 3. Detener completamente la sesión actual
+        isListening = false;
+        isDestroyed = true;
 
-        // Guardar referencia al call actual
-        PluginCall existingCall = currentCall;
+        // Limpiar runnables pendientes
+        if (delayedStartRunnable != null) {
+            getActivity().runOnUiThread(() -> {
+                getActivity()
+                    .getWindow()
+                    .getDecorView()
+                    .removeCallbacks(delayedStartRunnable);
+            });
+            delayedStartRunnable = null;
+        }
 
-        // Detener escucha
-        stopListening(existingCall);
+        // 4. Destruir el recognizer actual inmediatamente
+        getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    if (speechRecognizer != null) {
+                        speechRecognizer.cancel();
+                        speechRecognizer.setRecognitionListener(null);
+                        speechRecognizer.destroy();
+                        speechRecognizer = null;
+                    }
+
+                    // 5. Resetear todo el estado
+                    speechIntent = null;
+                    lastStopTime = System.currentTimeMillis();
+
+                    // 6. Crear NUEVO intent para evitar acumulación
+                    final Intent newIntent = new Intent(
+                        RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
+                    newIntent.putExtra(
+                        RecognizerIntent.EXTRA_LANGUAGE_MODEL,
+                        RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
+                    newIntent.putExtra(
+                        RecognizerIntent.EXTRA_LANGUAGE, currentLang);
+                    newIntent.putExtra(
+                        RecognizerIntent.EXTRA_PARTIAL_RESULTS, true);
+
+                    // IMPORTANTE: Agregar esta línea para NO acumular resultados
+                    newIntent.putExtra(
+                        RecognizerIntent.EXTRA_MAX_RESULTS, 1);
+                    newIntent.putExtra(
+                        RecognizerIntent.EXTRA_PREFER_OFFLINE, false);
+
+                    // 7. Reiniciar con nueva sesión limpia
+                    getActivity()
+                        .getWindow()
+                        .getDecorView()
+                        .postDelayed(new Runnable() {
+                            @Override
+                            public void run() {
+                                // Resetear flags
+                                isDestroyed = false;
+                                isListening = true;
+
+                                // Iniciar nueva sesión limpia
+                                startFreshSession(currentCall, currentLang, newIntent);
+                                call.resolve();
+                            }
+                        }, RESTART_COOLDOWN_MS);
+
+                } catch (Exception e) {
+                    call.reject("Failed to restart: " + e.getMessage());
+                }
+            }
+        });
+    }
 
-        // Programar reinicio después del cooldown
-        getActivity().runOnUiThread(() -> {
-            getActivity()
-                .getWindow()
-                .getDecorView()
-                .postDelayed(() -> {
-                    // Iniciar nueva sesión
-                    startListeningInternal(existingCall, currentLang);
-                    call.resolve();
-                }, RESTART_COOLDOWN_MS);
+    // Método auxiliar para iniciar sesión completamente nueva
+    private void startFreshSession(PluginCall call, String lang, Intent intent) {
+        if (isDestroyed || !isListening) return;
+
+        getActivity().runOnUiThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    // Crear NUEVO speech recognizer
+                    speechRecognizer = SpeechRecognizer.createSpeechRecognizer(getActivity());
+                    speechRecognizer.setRecognitionListener(new RecognitionListener() {
+                        // ... (el mismo listener que ya tienes)
+                        // Copia exactamente tu listener actual aquí
+
+                        @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 onError(int error) {
+                            if (isDestroyed || !isListening) return;
+
+                            if (error == SpeechRecognizer.ERROR_NO_MATCH ||
+                                error == SpeechRecognizer.ERROR_SPEECH_TIMEOUT) {
+
+                                if (!isDestroyed && isListening && speechRecognizer != null) {
+                                    speechRecognizer.startListening(intent);
+                                }
+                                return;
+                            }
+
+                            stopSpeech();
+                        }
+
+                        @Override
+                        public void onResults(Bundle results) {
+                            if (!isListening) return;
+
+                            ArrayList<String> matches =
+                                results.getStringArrayList(
+                                    SpeechRecognizer.RESULTS_RECOGNITION);
+
+                            if (matches != null && !matches.isEmpty()) {
+                                // Enviar solo el texto NUEVO
+                                notifyListeners(
+                                    "partialResult",
+                                    new JSObject()
+                                        .put("text", matches.get(0))
+                                        .put("isFinal", true)
+                                );
+                            }
+
+                            if (!isDestroyed && isListening && speechRecognizer != null) {
+                                speechRecognizer.startListening(intent);
+                            }
+                        }
+
+                        @Override
+                        public void onPartialResults(Bundle partialResults) {
+                            if (!isListening || isDestroyed) return;
+
+                            ArrayList<String> matches =
+                                partialResults.getStringArrayList(
+                                    SpeechRecognizer.RESULTS_RECOGNITION);
+
+                            if (matches != null && !matches.isEmpty()) {
+                                // Enviar solo texto nuevo
+                                notifyListeners(
+                                    "partialResult",
+                                    new JSObject()
+                                        .put("text", matches.get(0))
+                                        .put("isFinal", false)
+                                );
+                            }
+                        }
+
+                        @Override public void onEvent(int eventType, Bundle params) {}
+                    });
+
+                    // Iniciar con el NUEVO intent
+                    speechIntent = intent;
+                    speechRecognizer.startListening(intent);
+
+                } catch (Exception e) {
+                    if (call != null) {
+                        call.reject(e.getMessage());
+                    }
+                }
+            }
         });
     }
 

package/package.json

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