@capgo/capacitor-speech-recognition 8.0.9 → 8.1.0

package/ios/Sources/SpeechRecognitionPlugin/SpeechRecognitionPlugin.swift

@@ -9,15 +9,29 @@ private enum PermissionState: String {
     case prompt
 }
 
+private enum ListeningReason: String {
+    case userStart
+    case userStop
+    case forceStop
+    case results
+    case silence
+    case error
+    case unknown
+}
+
 @objc(SpeechRecognitionPlugin)
 public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
-    private let pluginVersion: String = "8.0.9"
+    private let pluginVersion = "8.0.10"
     public let identifier = "SpeechRecognitionPlugin"
     public let jsName = "SpeechRecognition"
     public let pluginMethods: [CAPPluginMethod] = [
         CAPPluginMethod(name: "available", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isOnDeviceRecognitionAvailable", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "start", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "stop", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "forceStop", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getLastPartialResult", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setPTTState", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "getSupportedLanguages", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "isListening", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
@@ -29,11 +43,22 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
     private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
     private var recognitionTask: SFSpeechRecognitionTask?
     private var speechRecognizer: SFSpeechRecognizer?
+    private var modernRecognitionSession: AnyObject?
     private var activeCall: CAPPluginCall?
     private var currentOptions: RecognitionOptions?
     private var hasInstalledTap = false
+    private var latestPartialMatches: [String] = []
+    private var pttButtonHeld = false
+    private var nextSessionId = 0
+    private var activeSessionId: Int?
+    private var pendingStopReason: ListeningReason?
+    private var emittedStoppingSessionId: Int?
+    private var accumulatedTranscript = ""
+    private var pendingContinuousRestartSessionId: Int?
+    private var continuousRestartWorkItem: DispatchWorkItem?
 
     private let maxDefaultResults = 5
+    private let continuousRestartDelay: TimeInterval = 0.1
 
     @objc func available(_ call: CAPPluginCall) {
         let locale = Locale(identifier: call.getString("language") ?? Locale.current.identifier)
@@ -41,15 +66,26 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
         call.resolve(["available": recognizer?.isAvailable ?? false])
     }
 
+    @objc func isOnDeviceRecognitionAvailable(_ call: CAPPluginCall) {
+        let locale = Locale(identifier: call.getString("language") ?? Locale.current.identifier)
+        if #available(iOS 26.0, *) {
+            Task { @MainActor in
+                let isAvailable = await SpeechAnalyzerRecognitionSupport.supports(locale: locale)
+                call.resolve(["available": isAvailable])
+            }
+            return
+        }
+
+        call.resolve(["available": false])
+    }
+
     @objc func start(_ call: CAPPluginCall) {
-        if self.audioEngine.isRunning || recognitionTask != nil {
-            CAPLog.print("[SpeechRecognition] Attempted to start while already running")
+        if activeSessionId != nil || isRecognitionActive {
             call.reject("Speech recognition is already running.")
             return
         }
 
         guard isSpeechPermissionGranted else {
-            CAPLog.print("[SpeechRecognition] Missing speech permission, rejecting start()")
             call.reject("Missing speech recognition permission.")
             return
         }
@@ -58,43 +94,138 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
             language: call.getString("language") ?? Locale.current.identifier,
             maxResults: call.getInt("maxResults") ?? maxDefaultResults,
             partialResults: call.getBool("partialResults") ?? false,
-            addPunctuation: call.getBool("addPunctuation") ?? false
+            addPunctuation: call.getBool("addPunctuation") ?? false,
+            useOnDeviceRecognition: call.getBool("useOnDeviceRecognition") ?? false,
+            continuousPTT: call.getBool("continuousPTT") ?? false
         )
 
-        self.activeCall = call
-        self.currentOptions = options
-        CAPLog.print("[SpeechRecognition] Starting session | language=\(options.language) partialResults=\(options.partialResults) punctuation=\(options.addPunctuation)")
+        if options.continuousPTT && !options.partialResults {
+            call.reject("continuousPTT requires partialResults: true.")
+            return
+        }
+
+        nextSessionId += 1
+        let sessionId = nextSessionId
+        activeSessionId = sessionId
+        activeCall = call
+        currentOptions = options
+        latestPartialMatches = []
+        accumulatedTranscript = ""
+        pendingStopReason = nil
+        emittedStoppingSessionId = nil
+        cancelPendingContinuousRestart()
+
+        emitListeningState(
+            state: "startingListening",
+            sessionId: sessionId,
+            reason: .userStart
+        )
 
         AVAudioSession.sharedInstance().requestRecordPermission { granted in
             guard granted else {
-                CAPLog.print("[SpeechRecognition] Microphone permission denied by user")
                 DispatchQueue.main.async {
-                    call.reject("User denied microphone access.")
-                    self.cleanupRecognition(notifyStop: false)
+                    guard self.activeSessionId == sessionId else {
+                        return
+                    }
+                    self.emitErrorEvent(
+                        code: "MICROPHONE_PERMISSION_DENIED",
+                        message: "User denied microphone access.",
+                        sessionId: sessionId
+                    )
+                    self.activeCall?.reject("User denied microphone access.")
+                    self.activeCall = nil
+                    self.finishSessionIfNeeded(sessionId: sessionId, reason: .error, errorCode: "MICROPHONE_PERMISSION_DENIED")
                 }
                 return
             }
 
             DispatchQueue.main.async {
-                self.beginRecognition(call: call, options: options)
+                self.beginRecognition(call: call, options: options, sessionId: sessionId, restarting: false)
             }
         }
     }
 
     @objc func stop(_ call: CAPPluginCall) {
-        CAPLog.print("[SpeechRecognition] stop() invoked")
-        cleanupRecognition(notifyStop: true)
+        guard let sessionId = activeSessionId else {
+            call.resolve()
+            return
+        }
+
+        pendingStopReason = .userStop
+        emitStoppingIfNeeded(sessionId: sessionId, reason: .userStop, errorCode: nil)
+        rejectPendingStartCallIfNeeded(message: "Recognition stopped before final results were produced.")
+
+        if #available(iOS 26.0, *), let modernSession = modernRecognitionSession as? SpeechAnalyzerRecognitionSession {
+            Task { @MainActor in
+                await modernSession.stop()
+                self.finishSessionIfNeeded(sessionId: sessionId, reason: .userStop, errorCode: nil, sessionAlreadyStopped: true)
+                call.resolve()
+            }
+            return
+        }
+
+        clearLegacyRecognitionResources()
+        finishSessionIfNeeded(sessionId: sessionId, reason: .userStop, errorCode: nil, sessionAlreadyStopped: true)
+        call.resolve()
+    }
+
+    @objc func forceStop(_ call: CAPPluginCall) {
+        guard let sessionId = activeSessionId else {
+            call.resolve()
+            return
+        }
+
+        pendingStopReason = .forceStop
+        emitStoppingIfNeeded(sessionId: sessionId, reason: .forceStop, errorCode: nil)
+        rejectPendingStartCallIfNeeded(message: "Recognition force stopped before final results were produced.")
+
+        if !latestPartialMatches.isEmpty || !accumulatedTranscriptText().isEmpty {
+            emitPartialResultEvent(matches: latestPartialMatches, forced: true, includeAccumulatedText: true)
+        }
+
+        if #available(iOS 26.0, *), let modernSession = modernRecognitionSession as? SpeechAnalyzerRecognitionSession {
+            Task { @MainActor in
+                await modernSession.stop()
+                self.finishSessionIfNeeded(sessionId: sessionId, reason: .forceStop, errorCode: nil, sessionAlreadyStopped: true)
+                call.resolve()
+            }
+            return
+        }
+
+        clearLegacyRecognitionResources()
+        finishSessionIfNeeded(sessionId: sessionId, reason: .forceStop, errorCode: nil, sessionAlreadyStopped: true)
+        call.resolve()
+    }
+
+    @objc func getLastPartialResult(_ call: CAPPluginCall) {
+        let text = currentTranscriptText()
+        call.resolve([
+            "available": !text.isEmpty,
+            "text": text,
+            "matches": latestPartialMatches
+        ])
+    }
+
+    @objc func setPTTState(_ call: CAPPluginCall) {
+        let held = call.getBool("held") ?? false
+        pttButtonHeld = held
+        if held {
+            latestPartialMatches = []
+            accumulatedTranscript = ""
+            pendingStopReason = nil
+            cancelPendingContinuousRestart()
+        }
         call.resolve()
     }
 
     @objc func isListening(_ call: CAPPluginCall) {
-        call.resolve(["listening": audioEngine.isRunning])
+        call.resolve(["listening": isRecognitionActive])
     }
 
     @objc func getSupportedLanguages(_ call: CAPPluginCall) {
         let identifiers = SFSpeechRecognizer
             .supportedLocales()
-            .map { $0.identifier }
+            .map(\.identifier)
             .sorted()
         call.resolve(["languages": identifiers])
     }
@@ -129,16 +260,51 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
-    private func beginRecognition(call: CAPPluginCall, options: RecognitionOptions) {
-        guard let recognizer = SFSpeechRecognizer(locale: Locale(identifier: options.language)) else {
-            call.reject("Unsupported locale: \(options.language)")
-            cleanupRecognition(notifyStop: false)
+    @objc func getPluginVersion(_ call: CAPPluginCall) {
+        call.resolve(["version": pluginVersion])
+    }
+
+    private func beginRecognition(call: CAPPluginCall?, options: RecognitionOptions, sessionId: Int, restarting: Bool) {
+        Task { @MainActor in
+            guard activeSessionId == sessionId else {
+                return
+            }
+
+            let locale = Locale(identifier: options.language)
+            if #available(iOS 26.0, *),
+               options.useOnDeviceRecognition,
+               await SpeechAnalyzerRecognitionSupport.supports(locale: locale) {
+                beginModernRecognition(call: call, options: options, locale: locale, sessionId: sessionId, restarting: restarting)
+            } else {
+                beginLegacyRecognition(call: call, options: options, locale: locale, sessionId: sessionId, restarting: restarting)
+            }
+        }
+    }
+
+    private func beginLegacyRecognition(
+        call: CAPPluginCall?,
+        options: RecognitionOptions,
+        locale: Locale,
+        sessionId: Int,
+        restarting: Bool
+    ) {
+        guard activeSessionId == sessionId else {
+            return
+        }
+
+        guard let recognizer = SFSpeechRecognizer(locale: locale) else {
+            call?.reject("Unsupported locale: \(options.language)")
+            emitErrorEvent(code: "UNSUPPORTED_LOCALE", message: "Unsupported locale: \(options.language)", sessionId: sessionId)
+            activeCall = nil
+            finishSessionIfNeeded(sessionId: sessionId, reason: .error, errorCode: "UNSUPPORTED_LOCALE")
             return
         }
 
         guard recognizer.isAvailable else {
-            call.reject("Speech recognizer is currently unavailable.")
-            cleanupRecognition(notifyStop: false)
+            call?.reject("Speech recognizer is currently unavailable.")
+            emitErrorEvent(code: "RECOGNIZER_UNAVAILABLE", message: "Speech recognizer is currently unavailable.", sessionId: sessionId)
+            activeCall = nil
+            finishSessionIfNeeded(sessionId: sessionId, reason: .error, errorCode: "RECOGNIZER_UNAVAILABLE")
             return
         }
 
@@ -147,8 +313,10 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
         do {
             try configureAudioSession()
         } catch {
-            call.reject("Failed to configure audio session: \(error.localizedDescription)")
-            cleanupRecognition(notifyStop: false)
+            call?.reject("Failed to configure audio session: \(error.localizedDescription)")
+            emitErrorEvent(code: "AUDIO_SESSION_FAILED", message: error.localizedDescription, sessionId: sessionId)
+            activeCall = nil
+            finishSessionIfNeeded(sessionId: sessionId, reason: .error, errorCode: "AUDIO_SESSION_FAILED")
             return
         }
 
@@ -171,38 +339,164 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
 
         do {
             try audioEngine.start()
-            notifyListeners("listeningState", data: ["status": "started"])
+            emitListeningState(state: "started", sessionId: sessionId, reason: restarting ? .results : .userStart, status: "started")
         } catch {
-            call.reject("Unable to start audio engine: \(error.localizedDescription)")
-            cleanupRecognition(notifyStop: false)
+            call?.reject("Unable to start audio engine: \(error.localizedDescription)")
+            emitErrorEvent(code: "AUDIO_ENGINE_START_FAILED", message: error.localizedDescription, sessionId: sessionId)
+            activeCall = nil
+            finishSessionIfNeeded(sessionId: sessionId, reason: .error, errorCode: "AUDIO_ENGINE_START_FAILED")
             return
         }
 
-        if options.partialResults {
+        if options.partialResults, let call {
             call.resolve()
+            activeCall = nil
         }
 
         recognitionTask = recognizer.recognitionTask(with: recognitionRequest) { [weak self] result, error in
-            guard let self else { return }
-            if let result {
-                let matches = self.buildMatches(from: result, maxResults: options.maxResults)
-                if options.partialResults {
-                    DispatchQueue.main.async {
-                        self.notifyListeners("partialResults", data: ["matches": matches])
-                    }
-                } else if result.isFinal {
-                    DispatchQueue.main.async {
-                        self.activeCall?.resolve(["matches": matches])
+            guard let self else {
+                return
+            }
+
+            DispatchQueue.main.async {
+                guard self.activeSessionId == sessionId else {
+                    return
+                }
+
+                if let result {
+                    let matches = self.buildMatches(from: result, maxResults: options.maxResults)
+                    self.latestPartialMatches = matches
+
+                    if result.isFinal {
+                        if self.prepareContinuousRestartIfNeeded(matches: matches, sessionId: sessionId) {
+                            self.clearLegacyRecognitionResources()
+                            self.scheduleContinuousRestart(sessionId: sessionId)
+                            return
+                        }
+
+                        if options.partialResults {
+                            self.emitPartialResultEvent(
+                                matches: matches,
+                                includeAccumulatedText: !self.accumulatedTranscriptText().isEmpty
+                            )
+                        } else {
+                            let startCall = self.activeCall
+                            self.activeCall = nil
+                            startCall?.resolve(["matches": matches])
+                        }
+
+                        self.finishSessionIfNeeded(
+                            sessionId: sessionId,
+                            reason: self.pendingStopReason ?? .results,
+                            errorCode: nil
+                        )
+                    } else if options.partialResults {
+                        self.emitPartialResultEvent(matches: matches)
                     }
                 }
 
-                if result.isFinal {
-                    self.cleanupRecognition(notifyStop: true)
+                if let error {
+                    self.handleRecognitionError(error, sessionId: sessionId)
+                }
+            }
+        }
+    }
+
+    @available(iOS 26.0, *)
+    @MainActor
+    private func beginModernRecognition(
+        call: CAPPluginCall?,
+        options: RecognitionOptions,
+        locale: Locale,
+        sessionId: Int,
+        restarting: Bool
+    ) {
+        let session = SpeechAnalyzerRecognitionSession(
+            locale: locale,
+            maxResults: options.maxResults,
+            includePartialResults: options.partialResults
+        )
+        modernRecognitionSession = session
+
+        session.onListeningStarted = { [weak self, weak session] in
+            guard let self, let session, self.modernRecognitionSession === session, self.activeSessionId == sessionId else {
+                return
+            }
+
+            self.emitListeningState(state: "started", sessionId: sessionId, reason: restarting ? .results : .userStart, status: "started")
+        }
+
+        session.onListeningStopped = { [weak self, weak session] in
+            guard let self, let session, self.modernRecognitionSession === session, self.activeSessionId == sessionId else {
+                return
+            }
+
+            if self.pendingContinuousRestartSessionId == sessionId {
+                self.modernRecognitionSession = nil
+                self.scheduleContinuousRestart(sessionId: sessionId)
+                return
+            }
+
+            self.finishSessionIfNeeded(
+                sessionId: sessionId,
+                reason: self.pendingStopReason ?? .results,
+                errorCode: nil,
+                sessionAlreadyStopped: true
+            )
+        }
+
+        session.onResult = { [weak self, weak session] matches, isFinal in
+            guard let self, let session, self.modernRecognitionSession === session, self.activeSessionId == sessionId else {
+                return
+            }
+
+            self.latestPartialMatches = matches
+
+            if isFinal {
+                if self.prepareContinuousRestartIfNeeded(matches: matches, sessionId: sessionId) {
+                    return
+                }
+
+                if options.partialResults {
+                    self.emitPartialResultEvent(
+                        matches: matches,
+                        includeAccumulatedText: !self.accumulatedTranscriptText().isEmpty
+                    )
+                } else {
+                    let startCall = self.activeCall
+                    self.activeCall = nil
+                    startCall?.resolve(["matches": matches])
                 }
+                self.pendingStopReason = self.pendingStopReason ?? .results
+            } else if options.partialResults {
+                self.emitPartialResultEvent(matches: matches)
             }
+        }
 
-            if let error {
-                self.handleRecognitionError(error)
+        session.onError = { [weak self, weak session] error in
+            guard let self, let session, self.modernRecognitionSession === session, self.activeSessionId == sessionId else {
+                return
+            }
+
+            self.handleRecognitionError(error, sessionId: sessionId)
+        }
+
+        Task { @MainActor [weak self, weak session] in
+            guard let self, let session, self.modernRecognitionSession === session, self.activeSessionId == sessionId else {
+                return
+            }
+
+            do {
+                try await session.start()
+                if options.partialResults, let call {
+                    call.resolve()
+                    self.activeCall = nil
+                }
+            } catch {
+                call?.reject(error.localizedDescription)
+                self.emitErrorEvent(code: "MODERN_START_FAILED", message: error.localizedDescription, sessionId: sessionId)
+                self.activeCall = nil
+                self.finishSessionIfNeeded(sessionId: sessionId, reason: .error, errorCode: "MODERN_START_FAILED")
             }
         }
     }
@@ -214,38 +508,91 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
         try session.setActive(true, options: .notifyOthersOnDeactivation)
     }
 
-    private func cleanupRecognition(notifyStop: Bool) {
-        DispatchQueue.main.async {
-            CAPLog.print("[SpeechRecognition] Cleaning up recognition resources")
-            if self.audioEngine.isRunning {
-                self.audioEngine.stop()
-            }
+    private func clearLegacyRecognitionResources() {
+        if audioEngine.isRunning {
+            audioEngine.stop()
+        }
 
-            if self.hasInstalledTap {
-                self.audioEngine.inputNode.removeTap(onBus: 0)
-                self.hasInstalledTap = false
-            }
+        if hasInstalledTap {
+            audioEngine.inputNode.removeTap(onBus: 0)
+            hasInstalledTap = false
+        }
 
-            self.recognitionRequest?.endAudio()
-            self.recognitionRequest = nil
-            self.recognitionTask?.cancel()
-            self.recognitionTask = nil
-            self.speechRecognizer = nil
-            self.currentOptions = nil
-            self.activeCall = nil
+        recognitionRequest?.endAudio()
+        recognitionRequest = nil
+        recognitionTask?.cancel()
+        recognitionTask = nil
+        speechRecognizer = nil
+    }
+
+    private func finishSessionIfNeeded(
+        sessionId: Int,
+        reason: ListeningReason,
+        errorCode: String?,
+        sessionAlreadyStopped: Bool = false
+    ) {
+        guard activeSessionId == sessionId else {
+            return
+        }
 
-            if notifyStop {
-                self.notifyListeners("listeningState", data: ["status": "stopped"])
+        emitStoppingIfNeeded(sessionId: sessionId, reason: reason, errorCode: errorCode)
+
+        activeSessionId = nil
+        currentOptions = nil
+        pendingStopReason = nil
+        emittedStoppingSessionId = nil
+        cancelPendingContinuousRestart()
+
+        if #available(iOS 26.0, *),
+           let modernSession = modernRecognitionSession as? SpeechAnalyzerRecognitionSession,
+           !sessionAlreadyStopped {
+            Task { @MainActor in
+                await modernSession.stop()
+                if self.modernRecognitionSession === modernSession {
+                    self.modernRecognitionSession = nil
+                }
+                self.finalizeFinishedSession(sessionId: sessionId, reason: reason, errorCode: errorCode)
             }
+            return
+        }
+
+        if #available(iOS 26.0, *),
+           let modernSession = modernRecognitionSession as? SpeechAnalyzerRecognitionSession,
+           sessionAlreadyStopped,
+           modernRecognitionSession === modernSession {
+            modernRecognitionSession = nil
         }
+
+        finalizeFinishedSession(sessionId: sessionId, reason: reason, errorCode: errorCode)
     }
 
-    private func handleRecognitionError(_ error: Error) {
-        DispatchQueue.main.async {
-            CAPLog.print("[SpeechRecognition] Error from recognizer: \(error.localizedDescription)")
-            self.cleanupRecognition(notifyStop: true)
-            self.activeCall?.reject(error.localizedDescription)
+    private func rejectPendingStartCallIfNeeded(message: String) {
+        guard let startCall = activeCall else {
+            return
         }
+
+        activeCall = nil
+        startCall.reject(message)
+    }
+
+    private func handleRecognitionError(_ error: Error, sessionId: Int) {
+        guard activeSessionId == sessionId else {
+            return
+        }
+
+        if pendingContinuousRestartSessionId == sessionId, pendingStopReason == nil {
+            return
+        }
+
+        let code = errorCode(for: error)
+        emitErrorEvent(code: code, message: error.localizedDescription, sessionId: sessionId)
+
+        if let startCall = activeCall, !(currentOptions?.partialResults ?? false) {
+            activeCall = nil
+            startCall.reject(error.localizedDescription)
+        }
+
+        finishSessionIfNeeded(sessionId: sessionId, reason: pendingStopReason ?? .error, errorCode: code)
     }
 
     private func buildMatches(from result: SFSpeechRecognitionResult, maxResults: Int) -> [String] {
@@ -256,6 +603,197 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
         return matches
     }
 
+    private func finalizeFinishedSession(sessionId: Int, reason: ListeningReason, errorCode: String?) {
+        clearLegacyRecognitionResources()
+        resetContinuousPTTState()
+        notifyListeners("readyForNextSession", data: ["sessionId": sessionId])
+        emitListeningState(state: "stopped", sessionId: sessionId, reason: reason, errorCode: errorCode, status: "stopped")
+    }
+
+    private func prepareContinuousRestartIfNeeded(matches: [String], sessionId: Int) -> Bool {
+        guard shouldRestartContinuousPTT(sessionId: sessionId) else {
+            return false
+        }
+
+        if let text = matches.first?.trimmingCharacters(in: .whitespacesAndNewlines), !text.isEmpty {
+            appendToAccumulatedTranscript(text)
+        }
+
+        pendingContinuousRestartSessionId = sessionId
+        emitPartialResultEvent(matches: matches, isRestarting: true)
+        latestPartialMatches = []
+        return true
+    }
+
+    private func shouldRestartContinuousPTT(sessionId: Int) -> Bool {
+        activeSessionId == sessionId &&
+            currentOptions?.continuousPTT == true &&
+            pttButtonHeld &&
+            pendingStopReason == nil
+    }
+
+    private func scheduleContinuousRestart(sessionId: Int) {
+        guard activeSessionId == sessionId, let options = currentOptions else {
+            pendingContinuousRestartSessionId = nil
+            return
+        }
+
+        cancelPendingContinuousRestart()
+
+        let workItem = DispatchWorkItem { [weak self] in
+            guard let self else {
+                return
+            }
+            guard self.pendingContinuousRestartSessionId == sessionId,
+                  self.shouldRestartContinuousPTT(sessionId: sessionId)
+            else {
+                self.pendingContinuousRestartSessionId = nil
+                return
+            }
+
+            self.pendingContinuousRestartSessionId = nil
+            self.beginRecognition(call: nil, options: options, sessionId: sessionId, restarting: true)
+        }
+
+        continuousRestartWorkItem = workItem
+        DispatchQueue.main.asyncAfter(deadline: .now() + continuousRestartDelay, execute: workItem)
+    }
+
+    private func cancelPendingContinuousRestart() {
+        continuousRestartWorkItem?.cancel()
+        continuousRestartWorkItem = nil
+    }
+
+    private func resetContinuousPTTState() {
+        cancelPendingContinuousRestart()
+        pendingContinuousRestartSessionId = nil
+        accumulatedTranscript = ""
+        latestPartialMatches = []
+    }
+
+    private func emitPartialResultEvent(
+        matches: [String],
+        isRestarting: Bool = false,
+        forced: Bool = false,
+        includeAccumulatedText: Bool = false
+    ) {
+        var payload: [String: Any] = [:]
+
+        if !matches.isEmpty {
+            payload["matches"] = matches
+        }
+
+        if includeAccumulatedText {
+            let text = currentTranscriptText(currentMatches: matches)
+            if !text.isEmpty {
+                payload["accumulatedText"] = text
+            }
+        } else {
+            let accumulated = accumulatedTranscriptText()
+            if !accumulated.isEmpty {
+                payload["accumulated"] = accumulated
+            }
+        }
+
+        if isRestarting {
+            payload["isRestarting"] = true
+        }
+
+        if forced {
+            payload["forced"] = true
+        }
+
+        guard !payload.isEmpty else {
+            return
+        }
+
+        notifyListeners("partialResults", data: payload)
+    }
+
+    private func appendToAccumulatedTranscript(_ text: String) {
+        let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !trimmed.isEmpty else {
+            return
+        }
+
+        if accumulatedTranscript.isEmpty {
+            accumulatedTranscript = trimmed
+        } else {
+            accumulatedTranscript += " " + trimmed
+        }
+    }
+
+    private func accumulatedTranscriptText() -> String {
+        accumulatedTranscript.trimmingCharacters(in: .whitespacesAndNewlines)
+    }
+
+    private func currentTranscriptText(currentMatches: [String]? = nil) -> String {
+        let accumulated = accumulatedTranscriptText()
+        let current = (currentMatches ?? latestPartialMatches)
+            .first?
+            .trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
+
+        if accumulated.isEmpty {
+            return current
+        }
+        if current.isEmpty {
+            return accumulated
+        }
+        return accumulated + " " + current
+    }
+
+    private func emitListeningState(
+        state: String,
+        sessionId: Int,
+        reason: ListeningReason,
+        errorCode: String? = nil,
+        status: String? = nil
+    ) {
+        var payload: [String: Any] = [
+            "state": state,
+            "sessionId": sessionId,
+            "reason": reason.rawValue
+        ]
+        if let errorCode {
+            payload["errorCode"] = errorCode
+        }
+        if let status {
+            payload["status"] = status
+        }
+        notifyListeners("listeningState", data: payload)
+    }
+
+    private func emitStoppingIfNeeded(sessionId: Int, reason: ListeningReason, errorCode: String?) {
+        guard emittedStoppingSessionId != sessionId else {
+            return
+        }
+
+        emittedStoppingSessionId = sessionId
+        emitListeningState(
+            state: "stoppingListening",
+            sessionId: sessionId,
+            reason: reason,
+            errorCode: errorCode
+        )
+    }
+
+    private func emitErrorEvent(code: String, message: String, sessionId: Int) {
+        notifyListeners("error", data: [
+            "code": code,
+            "message": message,
+            "sessionId": sessionId
+        ])
+    }
+
+    private func errorCode(for error: Error) -> String {
+        let nsError = error as NSError
+        let sanitizedDomain = nsError.domain
+            .replacingOccurrences(of: "[^A-Za-z0-9]+", with: "_", options: .regularExpression)
+            .trimmingCharacters(in: CharacterSet(charactersIn: "_"))
+            .uppercased()
+        return sanitizedDomain.isEmpty ? "IOS_\(nsError.code)" : "\(sanitizedDomain)_\(nsError.code)"
+    }
+
     private var isSpeechPermissionGranted: Bool {
         switch SFSpeechRecognizer.authorizationStatus() {
         case .authorized:
@@ -267,6 +805,22 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
         }
     }
 
+    private var isRecognitionActive: Bool {
+        if activeSessionId != nil {
+            return true
+        }
+
+        if audioEngine.isRunning || recognitionTask != nil {
+            return true
+        }
+
+        if #available(iOS 26.0, *), modernRecognitionSession != nil {
+            return true
+        }
+
+        return false
+    }
+
     private var permissionState: PermissionState {
         let speechStatus = SFSpeechRecognizer.authorizationStatus()
         let micStatus = AVAudioSession.sharedInstance().recordPermission
@@ -281,10 +835,6 @@ public final class SpeechRecognitionPlugin: CAPPlugin, CAPBridgedPlugin {
 
         return .granted
     }
-
-    @objc func getPluginVersion(_ call: CAPPluginCall) {
-        call.resolve(["version": pluginVersion])
-    }
 }
 
 private struct RecognitionOptions {
@@ -292,4 +842,6 @@ private struct RecognitionOptions {
     let maxResults: Int
     let partialResults: Bool
     let addPunctuation: Bool
+    let useOnDeviceRecognition: Bool
+    let continuousPTT: Bool
 }