@capgo/capacitor-speech-recognition 8.0.9 → 8.1.0

package/android/src/main/java/app/capgo/speechrecognition/SpeechRecognitionPlugin.java

@@ -5,7 +5,12 @@ import android.app.Activity;
 import android.content.Intent;
 import android.os.Build;
 import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import android.speech.ModelDownloadListener;
 import android.speech.RecognitionListener;
+import android.speech.RecognitionSupport;
+import android.speech.RecognitionSupportCallback;
 import android.speech.RecognizerIntent;
 import android.speech.SpeechRecognizer;
 import androidx.activity.result.ActivityResult;
@@ -23,6 +28,7 @@ import com.getcapacitor.annotation.PermissionCallback;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
+import java.util.concurrent.Executor;
 import java.util.concurrent.locks.ReentrantLock;
 import org.json.JSONArray;
 
@@ -34,24 +40,60 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
 
     public static final String SPEECH_RECOGNITION = "speechRecognition";
     private static final String TAG = "SpeechRecognition";
-    private static final String PLUGIN_VERSION = "7.0.0";
+    private static final String PLUGIN_VERSION = "8.0.10";
+    private static final int FORCE_STOP_TIMEOUT_MS = 1500;
+    private static final int STOP_FALLBACK_TIMEOUT_MS = 500;
+    private static final int CONTINUOUS_RESTART_DELAY_MS = 100;
+
+    private enum ListeningState {
+        IDLE,
+        STARTING,
+        STARTED,
+        STOPPING
+    }
 
     private Receiver languageReceiver;
     private SpeechRecognizer speechRecognizer;
+    private boolean speechRecognizerUsesOnDevice = false;
     private final ReentrantLock lock = new ReentrantLock();
+    private final Handler handler = new Handler(Looper.getMainLooper());
     private boolean listening = false;
     private JSONArray previousPartialResults = new JSONArray();
 
+    private Runnable forceStopRunnable;
+    private boolean forceStopped = false;
+    private boolean pttButtonHeld = false;
+    private boolean continuousPTTMode = false;
+    private boolean popupSessionActive = false;
+    private boolean popupSessionCancelled = false;
+    private StringBuilder accumulatedResults = new StringBuilder();
+
+    private String lastLanguage = Locale.getDefault().toLanguageTag();
+    private int lastMaxResults = MAX_RESULTS;
+    private String lastPrompt;
+    private boolean lastPartialResults = false;
+    private int lastAllowForSilence = 0;
+    private boolean lastUseOnDeviceRecognition = false;
+
+    private PluginCall activeStartCall;
+    private ListeningState state = ListeningState.IDLE;
+    private long sessionId = 0;
+    private long recognizerGeneration = 0;
+    private String pendingStopReason;
+
     @Override
     public void load() {
         super.load();
         bridge
             .getWebView()
             .post(() -> {
-                speechRecognizer = SpeechRecognizer.createSpeechRecognizer(bridge.getActivity());
-                SpeechRecognitionListener listener = new SpeechRecognitionListener();
-                speechRecognizer.setRecognitionListener(listener);
-                Logger.info(getLogTag(), "Instantiated SpeechRecognizer in load()");
+                try {
+                    lock.lock();
+                    recreateIdleRecognizerLocked();
+                    Logger.info(getLogTag(), "Instantiated SpeechRecognizer in load()");
+                } finally {
+                    lock.unlock();
+                }
             });
     }
 
@@ -61,52 +103,323 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
         call.resolve(new JSObject().put("available", val));
     }
 
+    @PluginMethod
+    public void isOnDeviceRecognitionAvailable(PluginCall call) {
+        String language = call.getString("language", Locale.getDefault().toLanguageTag());
+        if (!canUseOnDeviceRecognition()) {
+            call.resolve(new JSObject().put("available", false));
+            return;
+        }
+
+        final SpeechRecognizer supportChecker;
+        try {
+            supportChecker = SpeechRecognizer.createOnDeviceSpeechRecognizer(bridge.getActivity());
+        } catch (UnsupportedOperationException ex) {
+            call.resolve(new JSObject().put("available", false));
+            return;
+        }
+
+        Intent intent = buildRecognizerIntent(language, MAX_RESULTS, null, false, 0, true);
+        supportChecker.checkRecognitionSupport(
+            intent,
+            mainExecutor(),
+            new RecognitionSupportCallback() {
+                @Override
+                public void onSupportResult(RecognitionSupport support) {
+                    boolean available =
+                        isLanguageSupported(language, support.getInstalledOnDeviceLanguages()) ||
+                        isLanguageSupported(language, support.getSupportedOnDeviceLanguages()) ||
+                        isLanguageSupported(language, support.getPendingOnDeviceLanguages());
+                    supportChecker.destroy();
+                    call.resolve(new JSObject().put("available", available));
+                }
+
+                @Override
+                public void onError(int error) {
+                    Logger.warn(TAG, "On-device recognition support check failed: " + getErrorText(error));
+                    supportChecker.destroy();
+                    call.resolve(new JSObject().put("available", false));
+                }
+            }
+        );
+    }
+
     @PluginMethod
     public void start(PluginCall call) {
         if (!SpeechRecognizer.isRecognitionAvailable(bridge.getContext())) {
-            Logger.warn(TAG, "start() called but speech recognizer unavailable");
             call.unavailable(NOT_AVAILABLE);
             return;
         }
 
         if (getPermissionState(SPEECH_RECOGNITION) != PermissionState.GRANTED) {
-            Logger.warn(TAG, "start() missing RECORD_AUDIO permission");
             call.reject(MISSING_PERMISSION);
             return;
         }
 
-        String language = call.getString("language", Locale.getDefault().toString());
+        String language = call.getString("language", Locale.getDefault().toLanguageTag());
         int maxResults = call.getInt("maxResults", MAX_RESULTS);
         String prompt = call.getString("prompt", null);
         boolean partialResults = call.getBoolean("partialResults", false);
         boolean popup = call.getBoolean("popup", false);
+        boolean useOnDeviceRecognition = call.getBoolean("useOnDeviceRecognition", false);
         int allowForSilence = call.getInt("allowForSilence", 0);
+        boolean continuousPTT = call.getBoolean("continuousPTT", false);
+
+        if (useOnDeviceRecognition && popup) {
+            call.reject("On-device recognition is not supported with popup mode on Android.");
+            return;
+        }
+
+        if (continuousPTT && popup) {
+            call.reject("continuousPTT is only supported with inline recognition on Android.");
+            return;
+        }
+
+        if (continuousPTT && !partialResults) {
+            call.reject("continuousPTT requires partialResults: true.");
+            return;
+        }
+
+        if (useOnDeviceRecognition && !canUseOnDeviceRecognition()) {
+            call.unavailable("On-device speech recognition is not available on this device.");
+            return;
+        }
+
+        final long currentSessionId;
+        try {
+            lock.lock();
+            if (state != ListeningState.IDLE) {
+                call.reject("Speech recognition is already running.");
+                return;
+            }
+            cancelPendingForceStopLocked();
+            forceStopped = false;
+            pendingStopReason = null;
+            resetPartialResultsCache();
+            accumulatedResults = new StringBuilder();
+            continuousPTTMode = continuousPTT;
+            popupSessionActive = false;
+            popupSessionCancelled = false;
+            lastLanguage = language;
+            lastMaxResults = maxResults;
+            lastPrompt = prompt;
+            lastPartialResults = partialResults;
+            lastAllowForSilence = allowForSilence;
+            lastUseOnDeviceRecognition = useOnDeviceRecognition;
+            activeStartCall = null;
+            sessionId++;
+            currentSessionId = sessionId;
+            state = ListeningState.STARTING;
+        } finally {
+            lock.unlock();
+        }
+
+        emitListeningState("startingListening", currentSessionId, "userStart", null, null);
+
         Logger.info(
             TAG,
             String.format(
-                "Starting recognition | lang=%s maxResults=%d partial=%s popup=%s allowForSilence=%d",
+                Locale.US,
+                "Starting recognition | sessionId=%d lang=%s maxResults=%d partial=%s popup=%s onDevice=%s allowForSilence=%d continuousPTT=%s",
+                currentSessionId,
                 language,
                 maxResults,
                 partialResults,
                 popup,
-                allowForSilence
+                useOnDeviceRecognition,
+                allowForSilence,
+                continuousPTT
             )
         );
-        beginListening(language, maxResults, prompt, partialResults, popup, call, allowForSilence);
+
+        beginListening(
+            language,
+            maxResults,
+            prompt,
+            partialResults,
+            popup,
+            call,
+            allowForSilence,
+            useOnDeviceRecognition,
+            currentSessionId,
+            false
+        );
     }
 
     @PluginMethod
-    public void stop(final PluginCall call) {
-        Logger.info(TAG, "stop() requested");
+    public void stop(PluginCall call) {
+        final long currentSessionId;
+        final boolean popupActive;
+        PluginCall popupStartCall = null;
         try {
-            stopListening();
-        } catch (Exception ex) {
-            call.reject(ex.getLocalizedMessage());
+            lock.lock();
+            if (state == ListeningState.IDLE && !listening) {
+                call.resolve();
+                return;
+            }
+
+            currentSessionId = sessionId;
+            pendingStopReason = "userStop";
+            if (state != ListeningState.STOPPING) {
+                state = ListeningState.STOPPING;
+                emitListeningState("stoppingListening", currentSessionId, "userStop", null, null);
+            }
+
+            popupActive = popupSessionActive;
+            if (popupActive) {
+                cancelPendingForceStopLocked();
+                popupSessionCancelled = true;
+                popupStartCall = activeStartCall;
+                activeStartCall = null;
+            }
+        } finally {
+            lock.unlock();
+        }
+
+        if (popupStartCall != null) {
+            popupStartCall.reject("Recognition stopped before final results were produced.");
+        }
+
+        if (popupActive) {
+            call.resolve();
             return;
         }
+
+        bridge
+            .getWebView()
+            .post(() -> {
+                try {
+                    lock.lock();
+                    cancelPendingForceStopLocked();
+                    if (speechRecognizer != null) {
+                        try {
+                            speechRecognizer.stopListening();
+                        } catch (Exception ignored) {}
+                    }
+                    listening(false);
+                    scheduleFinishFallbackLocked(currentSessionId, "userStop", null, STOP_FALLBACK_TIMEOUT_MS);
+                } finally {
+                    lock.unlock();
+                }
+            });
         call.resolve();
     }
 
+    @PluginMethod
+    public void forceStop(PluginCall call) {
+        final int timeout = call.getInt("timeout", FORCE_STOP_TIMEOUT_MS);
+        final long currentSessionId;
+        final boolean popupActive;
+        PluginCall popupStartCall = null;
+        try {
+            lock.lock();
+            if (state == ListeningState.IDLE && !listening) {
+                call.resolve();
+                return;
+            }
+
+            currentSessionId = sessionId;
+            pendingStopReason = "forceStop";
+            if (state != ListeningState.STOPPING) {
+                state = ListeningState.STOPPING;
+                emitListeningState("stoppingListening", currentSessionId, "forceStop", null, null);
+            }
+
+            popupActive = popupSessionActive;
+            if (popupActive) {
+                cancelPendingForceStopLocked();
+                popupSessionCancelled = true;
+                popupStartCall = activeStartCall;
+                activeStartCall = null;
+            }
+
+            cancelPendingForceStopLocked();
+            if (!popupActive && speechRecognizer != null) {
+                try {
+                    speechRecognizer.stopListening();
+                } catch (Exception ignored) {}
+            }
+
+            forceStopRunnable = () -> {
+                PluginCall startCallToReject = null;
+                JSObject forcedPayload = null;
+                try {
+                    lock.lock();
+                    if (currentSessionId != sessionId || (state == ListeningState.IDLE && !listening)) {
+                        return;
+                    }
+
+                    forceStopped = true;
+                    startCallToReject = activeStartCall;
+                    activeStartCall = null;
+                    forcedPayload = buildForcedPartialResultLocked();
+                } finally {
+                    lock.unlock();
+                }
+
+                if (startCallToReject != null) {
+                    startCallToReject.reject("Recognition force stopped before final results were produced.");
+                }
+                if (forcedPayload != null) {
+                    notifyListeners(PARTIAL_RESULTS_EVENT, forcedPayload);
+                }
+                finishSession(currentSessionId, "forceStop", null);
+            };
+            if (!popupActive) {
+                handler.postDelayed(forceStopRunnable, timeout);
+            }
+        } finally {
+            lock.unlock();
+        }
+
+        if (popupStartCall != null) {
+            popupStartCall.reject("Recognition force stopped before final results were produced.");
+        }
+
+        if (popupActive) {
+            call.resolve();
+            return;
+        }
+
+        call.resolve();
+    }
+
+    @PluginMethod
+    public void getLastPartialResult(PluginCall call) {
+        try {
+            lock.lock();
+            JSObject result = new JSObject();
+            String text = buildCurrentTranscriptTextLocked();
+            result.put("available", !text.isEmpty());
+            result.put("text", text);
+            if (previousPartialResults.length() > 0) {
+                result.put("matches", previousPartialResults);
+            }
+            call.resolve(result);
+        } catch (Exception ex) {
+            call.reject(ex.getLocalizedMessage());
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @PluginMethod
+    public void setPTTState(PluginCall call) {
+        boolean held = call.getBoolean("held", false);
+        try {
+            lock.lock();
+            pttButtonHeld = held;
+            if (held) {
+                accumulatedResults = new StringBuilder();
+                forceStopped = false;
+                pendingStopReason = null;
+            }
+            call.resolve();
+        } finally {
+            lock.unlock();
+        }
+    }
+
     @PluginMethod
     public void getSupportedLanguages(PluginCall call) {
         if (languageReceiver == null) {
@@ -147,9 +460,7 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
 
     @PluginMethod
     public void getPluginVersion(PluginCall call) {
-        JSObject ret = new JSObject();
-        ret.put("version", PLUGIN_VERSION);
-        call.resolve(ret);
+        call.resolve(new JSObject().put("version", PLUGIN_VERSION));
     }
 
     @PermissionCallback
@@ -160,37 +471,108 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
 
     @ActivityCallback
     private void listeningResult(PluginCall call, ActivityResult result) {
-        if (call == null) {
-            return;
+        long currentSessionId;
+        String finalReason;
+        boolean popupCancelled;
+        try {
+            lock.lock();
+            currentSessionId = sessionId;
+            finalReason = pendingStopReason != null ? pendingStopReason : "results";
+            popupCancelled = popupSessionCancelled;
+            popupSessionActive = false;
+            popupSessionCancelled = false;
+            activeStartCall = null;
+        } finally {
+            lock.unlock();
         }
 
-        int resultCode = result.getResultCode();
-        if (resultCode == Activity.RESULT_OK) {
-            try {
-                ArrayList<String> matchesList = result.getData().getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
-                JSObject resultObj = new JSObject();
-                resultObj.put("matches", new JSArray(matchesList));
-                call.resolve(resultObj);
-            } catch (Exception ex) {
-                call.reject(ex.getMessage());
+        if (call != null && !popupCancelled) {
+            int resultCode = result.getResultCode();
+            if (resultCode == Activity.RESULT_OK) {
+                try {
+                    ArrayList<String> matchesList = result.getData().getStringArrayListExtra(RecognizerIntent.EXTRA_RESULTS);
+                    call.resolve(new JSObject().put("matches", new JSArray(matchesList)));
+                } catch (Exception ex) {
+                    call.reject(ex.getMessage());
+                }
+            } else {
+                call.reject(Integer.toString(resultCode));
             }
-        } else {
-            call.reject(Integer.toString(resultCode));
         }
 
-        lock.lock();
-        listening(false);
-        lock.unlock();
+        finishSession(currentSessionId, finalReason, null);
     }
 
     private void beginListening(
         String language,
         int maxResults,
         String prompt,
-        final boolean partialResults,
+        boolean partialResults,
         boolean showPopup,
         PluginCall call,
-        int allowForSilence
+        int allowForSilence,
+        boolean useOnDeviceRecognition,
+        long currentSessionId,
+        boolean restarting
+    ) {
+        Intent intent = buildRecognizerIntent(language, maxResults, prompt, partialResults, allowForSilence, useOnDeviceRecognition);
+
+        if (showPopup) {
+            try {
+                lock.lock();
+                listening(true);
+                state = ListeningState.STARTED;
+                popupSessionActive = true;
+                popupSessionCancelled = false;
+                activeStartCall = call;
+            } finally {
+                lock.unlock();
+            }
+            emitListeningState("started", currentSessionId, restarting ? "results" : "userStart", null, "started");
+            startActivityForResult(call, intent, "listeningResult");
+            return;
+        }
+
+        bridge
+            .getWebView()
+            .post(() -> {
+                try {
+                    lock.lock();
+                    if (currentSessionId != sessionId) {
+                        return;
+                    }
+
+                    resetPartialResultsCache();
+                    rebuildRecognizerLocked(call, partialResults, useOnDeviceRecognition, currentSessionId);
+                    if (!partialResults && call != null) {
+                        activeStartCall = call;
+                    }
+
+                    if (useOnDeviceRecognition) {
+                        beginOnDeviceListening(intent, language, partialResults, call, currentSessionId, restarting);
+                    } else {
+                        startInlineListening(intent, partialResults, call, currentSessionId, restarting);
+                    }
+                } catch (Exception ex) {
+                    Logger.error(TAG, "Error starting listening", ex);
+                    if (call != null) {
+                        call.reject(ex.getMessage());
+                    }
+                    emitErrorEvent("START_FAILED", ex.getMessage(), currentSessionId);
+                    finishSession(currentSessionId, "error", "START_FAILED");
+                } finally {
+                    lock.unlock();
+                }
+            });
+    }
+
+    private Intent buildRecognizerIntent(
+        String language,
+        int maxResults,
+        String prompt,
+        boolean partialResults,
+        int allowForSilence,
+        boolean useOnDeviceRecognition
     ) {
         Intent intent = new Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH);
         intent.putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL, RecognizerIntent.LANGUAGE_MODEL_FREE_FORM);
@@ -200,6 +582,10 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
         intent.putExtra(RecognizerIntent.EXTRA_PARTIAL_RESULTS, partialResults);
         intent.putExtra("android.speech.extra.DICTATION_MODE", partialResults);
 
+        if (useOnDeviceRecognition) {
+            intent.putExtra(RecognizerIntent.EXTRA_PREFER_OFFLINE, true);
+        }
+
         if (allowForSilence > 0) {
             intent.putExtra(RecognizerIntent.EXTRA_SEGMENTED_SESSION, true);
             intent.putExtra(RecognizerIntent.EXTRA_SPEECH_INPUT_COMPLETE_SILENCE_LENGTH_MILLIS, allowForSilence);
@@ -210,61 +596,361 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
             intent.putExtra(RecognizerIntent.EXTRA_PROMPT, prompt);
         }
 
-        if (showPopup) {
-            startActivityForResult(call, intent, "listeningResult");
+        return intent;
+    }
+
+    private void rebuildRecognizerLocked(PluginCall call, boolean partialResults, boolean useOnDeviceRecognition, long currentSessionId) {
+        if (speechRecognizer != null && speechRecognizerUsesOnDevice != useOnDeviceRecognition) {
+            destroyCurrentRecognizerLocked();
+        }
+
+        if (speechRecognizer == null) {
+            speechRecognizer = useOnDeviceRecognition
+                ? SpeechRecognizer.createOnDeviceSpeechRecognizer(bridge.getActivity())
+                : SpeechRecognizer.createSpeechRecognizer(bridge.getActivity());
+            speechRecognizerUsesOnDevice = useOnDeviceRecognition;
         } else {
-            bridge
-                .getWebView()
-                .post(() -> {
-                    try {
-                        lock.lock();
-
-                        if (speechRecognizer != null) {
-                            speechRecognizer.cancel();
-                            speechRecognizer.destroy();
-                            speechRecognizer = null;
-                        }
+            try {
+                speechRecognizer.cancel();
+            } catch (Exception ignored) {}
+            speechRecognizerUsesOnDevice = useOnDeviceRecognition;
+        }
+
+        recognizerGeneration++;
+        SpeechRecognitionListener listener = new SpeechRecognitionListener(currentSessionId, recognizerGeneration);
+        listener.setCall(call);
+        listener.setPartialResults(partialResults);
+        speechRecognizer.setRecognitionListener(listener);
+    }
+
+    private void beginOnDeviceListening(
+        Intent intent,
+        String language,
+        boolean partialResults,
+        PluginCall call,
+        long currentSessionId,
+        boolean restarting
+    ) {
+        speechRecognizer.checkRecognitionSupport(
+            intent,
+            mainExecutor(),
+            new RecognitionSupportCallback() {
+                @Override
+                public void onSupportResult(RecognitionSupport support) {
+                    boolean installed = isLanguageSupported(language, support.getInstalledOnDeviceLanguages());
+                    boolean supported =
+                        installed ||
+                        isLanguageSupported(language, support.getSupportedOnDeviceLanguages()) ||
+                        isLanguageSupported(language, support.getPendingOnDeviceLanguages());
 
-                        speechRecognizer = SpeechRecognizer.createSpeechRecognizer(bridge.getActivity());
-                        SpeechRecognitionListener listener = new SpeechRecognitionListener();
-                        listener.setCall(call);
-                        listener.setPartialResults(partialResults);
-                        speechRecognizer.setRecognitionListener(listener);
-                        speechRecognizer.startListening(intent);
-                        listening(true);
-                        if (partialResults) {
-                            call.resolve();
+                    if (!supported) {
+                        if (call != null) {
+                            call.reject("On-device recognition is not available for language: " + language);
                         }
-                    } catch (Exception ex) {
-                        call.reject(ex.getMessage());
-                    } finally {
-                        lock.unlock();
+                        emitErrorEvent(
+                            "UNSUPPORTED_LOCALE",
+                            "On-device recognition is not available for language: " + language,
+                            currentSessionId
+                        );
+                        finishSession(currentSessionId, "error", "UNSUPPORTED_LOCALE");
+                        return;
                     }
-                });
+
+                    if (installed) {
+                        startInlineListening(intent, partialResults, call, currentSessionId, restarting);
+                        return;
+                    }
+
+                    triggerOnDeviceModelDownload(intent, partialResults, call, currentSessionId, restarting);
+                }
+
+                @Override
+                public void onError(int error) {
+                    String errorCode = getErrorCode(error);
+                    String message = getErrorText(error);
+                    if (call != null) {
+                        call.reject(message);
+                    }
+                    emitErrorEvent(errorCode, message, currentSessionId);
+                    finishSession(currentSessionId, "error", errorCode);
+                }
+            }
+        );
+    }
+
+    private void triggerOnDeviceModelDownload(
+        Intent intent,
+        boolean partialResults,
+        PluginCall call,
+        long currentSessionId,
+        boolean restarting
+    ) {
+        speechRecognizer.triggerModelDownload(
+            intent,
+            mainExecutor(),
+            new ModelDownloadListener() {
+                @Override
+                public void onProgress(int completedPercent) {}
+
+                @Override
+                public void onSuccess() {
+                    startInlineListening(intent, partialResults, call, currentSessionId, restarting);
+                }
+
+                @Override
+                public void onScheduled() {
+                    String message = "On-device speech model download was scheduled. Try again once it finishes.";
+                    if (call != null) {
+                        call.reject(message);
+                    }
+                    emitErrorEvent("MODEL_DOWNLOAD_SCHEDULED", message, currentSessionId);
+                    finishSession(currentSessionId, "error", "MODEL_DOWNLOAD_SCHEDULED");
+                }
+
+                @Override
+                public void onError(int error) {
+                    String errorCode = getErrorCode(error);
+                    String message = getErrorText(error);
+                    if (call != null) {
+                        call.reject(message);
+                    }
+                    emitErrorEvent(errorCode, message, currentSessionId);
+                    finishSession(currentSessionId, "error", errorCode);
+                }
+            }
+        );
+    }
+
+    private void startInlineListening(Intent intent, boolean partialResults, PluginCall call, long currentSessionId, boolean restarting) {
+        speechRecognizer.startListening(intent);
+        listening(true);
+        state = ListeningState.STARTED;
+        emitListeningState("started", currentSessionId, restarting ? "results" : "userStart", null, "started");
+        if (partialResults && call != null) {
+            activeStartCall = null;
+            call.resolve();
         }
     }
 
-    private void stopListening() {
-        bridge
-            .getWebView()
-            .post(() -> {
+    private void scheduleContinuousRestart(long currentSessionId) {
+        handler.postDelayed(
+            () -> {
                 try {
                     lock.lock();
-                    if (listening) {
-                        Logger.debug(TAG, "Stopping inline recognizer");
-                        speechRecognizer.stopListening();
-                        listening(false);
+                    if (currentSessionId != sessionId || !continuousPTTMode || !pttButtonHeld || pendingStopReason != null) {
+                        return;
                     }
+                } finally {
+                    lock.unlock();
+                }
+
+                beginListening(
+                    lastLanguage,
+                    lastMaxResults,
+                    lastPrompt,
+                    lastPartialResults,
+                    false,
+                    null,
+                    lastAllowForSilence,
+                    lastUseOnDeviceRecognition,
+                    currentSessionId,
+                    true
+                );
+            },
+            CONTINUOUS_RESTART_DELAY_MS
+        );
+    }
+
+    private void finishSession(long finishedSessionId, String explicitReason, String errorCode) {
+        handler.post(() -> {
+            PluginCall startCallToReject = null;
+            boolean emitReady = true;
+            String reason;
+
+            try {
+                lock.lock();
+                if (finishedSessionId != sessionId) {
+                    return;
+                }
+
+                reason = explicitReason != null ? explicitReason : (pendingStopReason != null ? pendingStopReason : "unknown");
+                if (state != ListeningState.STOPPING) {
+                    state = ListeningState.STOPPING;
+                    emitListeningState("stoppingListening", finishedSessionId, reason, errorCode, null);
+                }
+
+                cancelPendingForceStopLocked();
+                listening(false);
+                if (activeStartCall != null && !lastPartialResults && ("userStop".equals(reason) || "forceStop".equals(reason))) {
+                    startCallToReject = activeStartCall;
+                }
+                activeStartCall = null;
+                pendingStopReason = null;
+                continuousPTTMode = false;
+                popupSessionActive = false;
+                popupSessionCancelled = false;
+                forceStopped = false;
+                resetPartialResultsCache();
+                accumulatedResults = new StringBuilder();
+
+                destroyCurrentRecognizerLocked();
+                try {
+                    recreateIdleRecognizerLocked();
                 } catch (Exception ex) {
-                    throw ex;
+                    emitReady = false;
+                    Logger.error(TAG, "Failed to recreate recognizer", ex);
+                    emitErrorEvent("RECREATE_FAILED", ex.getMessage(), finishedSessionId);
+                }
+
+                state = ListeningState.IDLE;
+                if (emitReady) {
+                    notifyListeners(READY_FOR_NEXT_SESSION_EVENT, new JSObject().put("sessionId", finishedSessionId));
+                }
+                emitListeningState("stopped", finishedSessionId, reason, errorCode, "stopped");
+            } finally {
+                lock.unlock();
+            }
+
+            if (startCallToReject != null) {
+                startCallToReject.reject("Recognition stopped before final results were produced.");
+            }
+        });
+    }
+
+    private void recreateIdleRecognizerLocked() {
+        destroyCurrentRecognizerLocked();
+        speechRecognizer = SpeechRecognizer.createSpeechRecognizer(bridge.getActivity());
+        speechRecognizerUsesOnDevice = false;
+        recognizerGeneration++;
+        speechRecognizer.setRecognitionListener(new SpeechRecognitionListener(sessionId, recognizerGeneration));
+    }
+
+    private void destroyCurrentRecognizerLocked() {
+        if (speechRecognizer != null) {
+            try {
+                speechRecognizer.cancel();
+            } catch (Exception ignored) {}
+            try {
+                speechRecognizer.destroy();
+            } catch (Exception ignored) {}
+            speechRecognizer = null;
+        }
+        speechRecognizerUsesOnDevice = false;
+    }
+
+    private void cancelPendingForceStopLocked() {
+        if (forceStopRunnable != null) {
+            handler.removeCallbacks(forceStopRunnable);
+            forceStopRunnable = null;
+        }
+    }
+
+    private void scheduleFinishFallbackLocked(long currentSessionId, String reason, String errorCode, int delayMs) {
+        handler.postDelayed(
+            () -> {
+                boolean shouldFinish;
+                try {
+                    lock.lock();
+                    shouldFinish = currentSessionId == sessionId && state != ListeningState.IDLE;
                 } finally {
                     lock.unlock();
                 }
-            });
+
+                if (shouldFinish) {
+                    finishSession(currentSessionId, reason, errorCode);
+                }
+            },
+            delayMs
+        );
+    }
+
+    private JSObject buildForcedPartialResultLocked() {
+        if (previousPartialResults.length() == 0 && accumulatedResults.length() == 0) {
+            return null;
+        }
+
+        JSObject payload = new JSObject();
+        payload.put("forced", true);
+        if (previousPartialResults.length() > 0) {
+            payload.put("matches", previousPartialResults);
+        }
+        String accumulatedText = buildCurrentTranscriptTextLocked();
+        if (!accumulatedText.isEmpty()) {
+            payload.put("accumulatedText", accumulatedText);
+        }
+        return payload;
+    }
+
+    private String buildCurrentTranscriptTextLocked() {
+        String accumulatedText = accumulatedResults.toString().trim();
+        String latestText = previousPartialResults.length() > 0 ? previousPartialResults.optString(0, "").trim() : "";
+
+        if (accumulatedText.isEmpty()) {
+            return latestText;
+        }
+        if (latestText.isEmpty()) {
+            return accumulatedText;
+        }
+        return accumulatedText + " " + latestText;
     }
 
     private void listening(boolean value) {
-        this.listening = value;
+        listening = value;
+    }
+
+    private void resetPartialResultsCache() {
+        previousPartialResults = new JSONArray();
+    }
+
+    private boolean canUseOnDeviceRecognition() {
+        return (
+            Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && SpeechRecognizer.isOnDeviceRecognitionAvailable(bridge.getContext())
+        );
+    }
+
+    private boolean isLanguageSupported(String requestedLanguage, List<String> candidateLanguages) {
+        if (candidateLanguages == null || candidateLanguages.isEmpty()) {
+            return false;
+        }
+
+        String normalizedRequestedLanguage = normalizeLanguageTag(requestedLanguage);
+        for (String candidateLanguage : candidateLanguages) {
+            if (normalizedRequestedLanguage.equals(normalizeLanguageTag(candidateLanguage))) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private String normalizeLanguageTag(String language) {
+        return language == null ? "" : language.replace('_', '-').toLowerCase(Locale.US);
+    }
+
+    private Executor mainExecutor() {
+        return (command) -> bridge.getActivity().runOnUiThread(command);
+    }
+
+    private void emitListeningState(String stateValue, long currentSessionId, String reason, String errorCode, String status) {
+        JSObject payload = new JSObject();
+        payload.put("state", stateValue);
+        payload.put("sessionId", currentSessionId);
+        payload.put("reason", reason);
+        if (errorCode != null) {
+            payload.put("errorCode", errorCode);
+        }
+        if (status != null) {
+            payload.put("status", status);
+        }
+        notifyListeners(LISTENING_EVENT, payload);
+    }
+
+    private void emitErrorEvent(String errorCode, String message, long currentSessionId) {
+        JSObject payload = new JSObject();
+        payload.put("code", errorCode);
+        payload.put("message", message);
+        payload.put("sessionId", currentSessionId);
+        notifyListeners(ERROR_EVENT, payload);
     }
 
     private String permissionStateValue(PermissionState state) {
@@ -280,11 +966,36 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
         }
     }
 
+    @Override
+    protected void handleOnDestroy() {
+        super.handleOnDestroy();
+        handler.removeCallbacksAndMessages(null);
+        try {
+            lock.lock();
+            destroyCurrentRecognizerLocked();
+            activeStartCall = null;
+            pendingStopReason = null;
+            popupSessionActive = false;
+            popupSessionCancelled = false;
+            listening(false);
+            state = ListeningState.IDLE;
+        } finally {
+            lock.unlock();
+        }
+    }
+
     private class SpeechRecognitionListener implements RecognitionListener {
 
+        private final long listenerSessionId;
+        private final long listenerGeneration;
         private PluginCall call;
         private boolean partialResults;
 
+        SpeechRecognitionListener(long listenerSessionId, long listenerGeneration) {
+            this.listenerSessionId = listenerSessionId;
+            this.listenerGeneration = listenerGeneration;
+        }
+
         public void setCall(PluginCall call) {
             this.call = call;
         }
@@ -297,17 +1008,7 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
         public void onReadyForSpeech(Bundle params) {}
 
         @Override
-        public void onBeginningOfSpeech() {
-            try {
-                lock.lock();
-                JSObject ret = new JSObject();
-                ret.put("status", "started");
-                notifyListeners(LISTENING_EVENT, ret);
-                Logger.debug(TAG, "Listening started");
-            } finally {
-                lock.unlock();
-            }
-        }
+        public void onBeginningOfSpeech() {}
 
         @Override
         public void onRmsChanged(float rmsdB) {}
@@ -316,72 +1017,154 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
         public void onBufferReceived(byte[] buffer) {}
 
         @Override
-        public void onEndOfSpeech() {
-            bridge
-                .getWebView()
-                .post(() -> {
-                    try {
-                        lock.lock();
-                        listening(false);
-
-                        JSObject ret = new JSObject();
-                        ret.put("status", "stopped");
-                        notifyListeners(LISTENING_EVENT, ret);
-                    } finally {
-                        lock.unlock();
-                    }
-                });
-        }
+        public void onEndOfSpeech() {}
 
         @Override
         public void onError(int error) {
-            stopListening();
-            String errorMssg = getErrorText(error);
-            Logger.error(TAG, "Recognizer error: " + errorMssg, null);
+            if (isStale()) {
+                return;
+            }
+
+            String errorCode = getErrorCode(error);
+            String errorMessage = getErrorText(error);
+            emitErrorEvent(errorCode, errorMessage, listenerSessionId);
+
+            boolean restartContinuous;
+            try {
+                lock.lock();
+                restartContinuous =
+                    continuousPTTMode &&
+                    pttButtonHeld &&
+                    pendingStopReason == null &&
+                    (error == SpeechRecognizer.ERROR_NO_MATCH || error == SpeechRecognizer.ERROR_SPEECH_TIMEOUT);
+
+                if (restartContinuous && previousPartialResults.length() > 0) {
+                    String lastPartial = previousPartialResults.optString(0, "").trim();
+                    if (!lastPartial.isEmpty()) {
+                        if (accumulatedResults.length() > 0) {
+                            accumulatedResults.append(" ");
+                        }
+                        accumulatedResults.append(lastPartial);
+                    }
+                    resetPartialResultsCache();
+                    listening(false);
+                }
+            } finally {
+                lock.unlock();
+            }
+
+            if (restartContinuous) {
+                scheduleContinuousRestart(listenerSessionId);
+                return;
+            }
 
-            if (call != null) {
-                call.reject(errorMssg);
+            if (call != null && !partialResults) {
+                call.reject(errorMessage);
             }
+
+            String reason = pendingStopReason != null
+                ? pendingStopReason
+                : (error == SpeechRecognizer.ERROR_NO_MATCH || error == SpeechRecognizer.ERROR_SPEECH_TIMEOUT ? "silence" : "error");
+            finishSession(listenerSessionId, reason, errorCode);
         }
 
         @Override
         public void onResults(Bundle results) {
-            ArrayList<String> matches = results.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
+            if (isStale()) {
+                return;
+            }
+
+            ArrayList<String> matches = buildMatchesWithUnstableText(results);
+            if (matches == null) {
+                matches = new ArrayList<>();
+            }
+            String resultText = matches.isEmpty() ? "" : matches.get(0);
 
+            boolean restartContinuous;
+            JSObject restartPayload = null;
+            JSObject finalPayload = null;
             try {
-                JSArray jsArray = new JSArray(matches);
-                Logger.debug(TAG, "Received final results count=" + (matches == null ? 0 : matches.size()));
+                lock.lock();
+                cancelPendingForceStopLocked();
+                previousPartialResults = new JSONArray(matches);
+                restartContinuous = continuousPTTMode && pttButtonHeld && pendingStopReason == null;
 
-                if (call != null) {
-                    if (!partialResults) {
-                        call.resolve(new JSObject().put("status", "success").put("matches", jsArray));
-                    } else {
-                        JSObject ret = new JSObject();
-                        ret.put("matches", jsArray);
-                        notifyListeners(PARTIAL_RESULTS_EVENT, ret);
+                if (restartContinuous) {
+                    if (!resultText.trim().isEmpty()) {
+                        if (accumulatedResults.length() > 0) {
+                            accumulatedResults.append(" ");
+                        }
+                        accumulatedResults.append(resultText.trim());
+                    }
+                    restartPayload = new JSObject();
+                    restartPayload.put("matches", new JSArray(matches));
+                    restartPayload.put("accumulated", accumulatedResults.toString().trim());
+                    restartPayload.put("isRestarting", true);
+                    resetPartialResultsCache();
+                    listening(false);
+                } else if (partialResults) {
+                    finalPayload = new JSObject();
+                    finalPayload.put("matches", new JSArray(matches));
+                    if (accumulatedResults.length() > 0) {
+                        String accumulatedText = accumulatedResults.toString().trim();
+                        if (!resultText.trim().isEmpty()) {
+                            accumulatedText = accumulatedText + " " + resultText.trim();
+                        }
+                        finalPayload.put("accumulatedText", accumulatedText.trim());
                     }
                 }
-            } catch (Exception ex) {
-                if (call != null) {
-                    call.resolve(new JSObject().put("status", "error").put("message", ex.getMessage()));
+            } finally {
+                lock.unlock();
+            }
+
+            if (restartContinuous) {
+                if (restartPayload != null) {
+                    notifyListeners(PARTIAL_RESULTS_EVENT, restartPayload);
                 }
+                scheduleContinuousRestart(listenerSessionId);
+                return;
             }
+
+            if (call != null && !partialResults) {
+                call.resolve(new JSObject().put("status", "success").put("matches", new JSArray(matches)));
+            } else if (finalPayload != null) {
+                notifyListeners(PARTIAL_RESULTS_EVENT, finalPayload);
+            }
+
+            finishSession(listenerSessionId, pendingStopReason != null ? pendingStopReason : "results", null);
         }
 
         @Override
         public void onPartialResults(Bundle partialResultsBundle) {
-            ArrayList<String> matches = partialResultsBundle.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
-            JSArray matchesJSON = new JSArray(matches);
+            if (isStale() || forceStopped) {
+                return;
+            }
+
+            ArrayList<String> matches = buildMatchesWithUnstableText(partialResultsBundle);
+            if (matches == null || matches.isEmpty()) {
+                return;
+            }
 
+            JSObject payload = null;
             try {
-                if (matches != null && matches.size() > 0 && !previousPartialResults.equals(matchesJSON)) {
-                    previousPartialResults = matchesJSON;
-                    JSObject ret = new JSObject();
-                    ret.put("matches", previousPartialResults);
-                    notifyListeners(PARTIAL_RESULTS_EVENT, ret);
-                    Logger.debug(TAG, "Partial results updated");
+                lock.lock();
+                JSArray matchesJSON = new JSArray(matches);
+                JSONArray nextPartialResults = new JSONArray(matches);
+                if (!previousPartialResults.toString().equals(nextPartialResults.toString())) {
+                    previousPartialResults = nextPartialResults;
+                    payload = new JSObject();
+                    payload.put("matches", matchesJSON);
+                    if (accumulatedResults.length() > 0) {
+                        payload.put("accumulated", accumulatedResults.toString().trim());
+                    }
                 }
-            } catch (Exception ex) {}
+            } finally {
+                lock.unlock();
+            }
+
+            if (payload != null) {
+                notifyListeners(PARTIAL_RESULTS_EVENT, payload);
+            }
         }
 
         @Override
@@ -390,22 +1173,83 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
             if (matches == null) {
                 return;
             }
-            try {
-                JSObject ret = new JSObject();
-                ret.put("matches", new JSArray(matches));
-                notifyListeners(SEGMENT_RESULTS_EVENT, ret);
-                Logger.debug(TAG, "Segment results emitted");
-            } catch (Exception ignored) {}
+            notifyListeners(SEGMENT_RESULTS_EVENT, new JSObject().put("matches", new JSArray(matches)));
         }
 
         @Override
         public void onEndOfSegmentedSession() {
             notifyListeners(END_OF_SEGMENT_EVENT, new JSObject());
-            Logger.debug(TAG, "Segmented session ended");
         }
 
         @Override
         public void onEvent(int eventType, Bundle params) {}
+
+        private boolean isStale() {
+            try {
+                lock.lock();
+                return listenerSessionId != sessionId || listenerGeneration != recognizerGeneration;
+            } finally {
+                lock.unlock();
+            }
+        }
+
+        private ArrayList<String> buildMatchesWithUnstableText(Bundle resultsBundle) {
+            ArrayList<String> matches = resultsBundle.getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION);
+            if (matches == null || matches.isEmpty()) {
+                return matches;
+            }
+
+            String unstableText = resultsBundle.getString("android.speech.extra.UNSTABLE_TEXT");
+            if (unstableText == null) {
+                return matches;
+            }
+
+            String trimmedUnstable = unstableText.trim();
+            if (trimmedUnstable.isEmpty()) {
+                return matches;
+            }
+
+            String firstMatch = matches.get(0);
+            if (firstMatch == null) {
+                return matches;
+            }
+
+            String trimmedFirstMatch = firstMatch.trim();
+            if (trimmedFirstMatch.equals(trimmedUnstable) || trimmedFirstMatch.endsWith(" " + trimmedUnstable)) {
+                return matches;
+            }
+
+            ArrayList<String> mergedMatches = new ArrayList<>(matches);
+            mergedMatches.set(0, trimmedFirstMatch + " " + trimmedUnstable);
+            return mergedMatches;
+        }
+    }
+
+    private String getErrorCode(int errorCode) {
+        switch (errorCode) {
+            case SpeechRecognizer.ERROR_AUDIO:
+                return "AUDIO";
+            case SpeechRecognizer.ERROR_CLIENT:
+                return "CLIENT";
+            case SpeechRecognizer.ERROR_INSUFFICIENT_PERMISSIONS:
+                return "INSUFFICIENT_PERMISSIONS";
+            case SpeechRecognizer.ERROR_NETWORK:
+                return "NETWORK";
+            case SpeechRecognizer.ERROR_NETWORK_TIMEOUT:
+                return "NETWORK_TIMEOUT";
+            case SpeechRecognizer.ERROR_NO_MATCH:
+                return "NO_MATCH";
+            case SpeechRecognizer.ERROR_RECOGNIZER_BUSY:
+                return "RECOGNIZER_BUSY";
+            case SpeechRecognizer.ERROR_SERVER:
+                return "SERVER";
+            case SpeechRecognizer.ERROR_SERVER_DISCONNECTED:
+                return "SERVER_DISCONNECTED";
+            case SpeechRecognizer.ERROR_SPEECH_TIMEOUT:
+                return "SPEECH_TIMEOUT";
+            default:
+                return "UNKNOWN_" + errorCode;
+        }
     }
 
     private String getErrorText(int errorCode) {
@@ -426,10 +1270,12 @@ public class SpeechRecognitionPlugin extends Plugin implements Constants {
                 return "RecognitionService busy";
             case SpeechRecognizer.ERROR_SERVER:
                 return "Error from server";
+            case SpeechRecognizer.ERROR_SERVER_DISCONNECTED:
+                return "Server disconnected";
             case SpeechRecognizer.ERROR_SPEECH_TIMEOUT:
                 return "No speech input";
             default:
-                return "Didn't understand, please try again.";
+                return "Didn't understand, please try again. Error code: " + errorCode;
         }
     }
 }