react-native-davoice-tts 1.0.218 → 1.0.219

package/ios/TTSRNBridge/DavoiceTTS.xcframework/ios-arm64/DavoiceTTS.framework/DaVoiceSTT.swift.bkup

@@ -1,1000 +0,0 @@
-// STT.swift
-// Native iOS Swift version (AEC flow preserved 1:1)
-
-import Foundation
-import UIKit
-import Speech
-import Accelerate
-import AVFAudio   // or import AVFoundation
-
-
-@objc public protocol STTDelegate: AnyObject {
-    @objc func stt(_ stt: STT, didEmitEvent name: String, body: [String: Any]?)
-}
-
-@objcMembers
-public final class STT: NSObject, SFSpeechRecognizerDelegate {
-    public weak var delegate: STTDelegate?
-    public var continuous: Bool = true
-
-    // MARK: - Private
-    private var speechRecognizer: SFSpeechRecognizer?
-    private var recognitionRequest: SFSpeechAudioBufferRecognitionRequest?
-    private var audioEngine: AVAudioEngine?
-    private var recognitionTask: SFSpeechRecognitionTask?
-    private var audioSession: AVAudioSession?
-    private var isTearingDown: Bool = false
-    private var sessionId: String?
-    private var priorAudioCategory: AVAudioSession.Category?
-    private var averagePowerForChannel0: Float = 0
-    private var averagePowerForChannel1: Float = 0
-
-    private var playbackNode: AVAudioPlayerNode?
-    private var seenRealSpeech = false            // flips true after first non-blank token
-    private var engineHotAt: CFTimeInterval = 0   // when engine actually started
-    private let warmupKeepAlive: CFTimeInterval = 4.0 // seconds we’ll keep re-arming in silence
-
-    // Keep-engine-alive helpers
-    private var lastReclaimAttempt: CFAbsoluteTime = 0
-    private let reclaimCooldown: CFTimeInterval = 1.0
-
-    // --- Task health ---
-    private var lastBufferAt: CFTimeInterval = 0       // updated from tap
-    private var lastResultAt: CFTimeInterval = 0       // updated from recognition callback
-    private var lastTaskStartAt: CFTimeInterval = 0
-    private var stallWatchdog: Timer?
-    private var consecutiveStallCount = 0
-    private let stallThreshold: CFTimeInterval = 8.0   // seconds w/o results while engine is hot
-    private let rearmCooldownTask: CFTimeInterval = 2.0
-    private var lastRearmAt: CFTimeInterval = 0
-
-    private var engineHot = false
-    private var hotAt: CFTimeInterval = 0
-
-    // MARK: - Event names (unchanged)
-    public static let supportedEvents: [String] = [
-        "onSpeechResults",
-        "onSpeechStart",
-        "onSpeechPartialResults",
-        "onSpeechError",
-        "onSpeechEnd",
-        "onSpeechRecognized",
-        "onSpeechVolumeChanged"
-    ]
-
-    // MARK: - Public API (native replacements for the former RCT methods)
-
-    public func isSpeechAvailable(_ completion: @escaping (Bool) -> Void) {
-        SFSpeechRecognizer.requestAuthorization { status in
-            switch status {
-            case .authorized: completion(true)
-            default: completion(false)
-            }
-        }
-    }
-
-    public func isRecognizing() -> Bool {
-        guard let task = recognitionTask else { return false }
-        return task.state == .running
-    }
-
-    private func startWatchdog() {
-        stallWatchdog?.invalidate()
-        stallWatchdog = Timer.scheduledTimer(withTimeInterval: 2.0, repeats: true) { [weak self] _ in
-            self?.checkTaskHealth()
-        }
-        RunLoop.main.add(stallWatchdog!, forMode: .common)
-    }
-
-    private func stopWatchdog() {
-        stallWatchdog?.invalidate()
-        stallWatchdog = nil
-    }
-
-    private func rearmTask(reason: String) {
-        // Cancel old task only — keep the engine and tap running.
-        recognitionTask?.cancel()
-        recognitionTask = nil
-
-        seenRealSpeech = false
-        lastTaskStartAt = CACurrentMediaTime()
-        startTask(makeFreshRequest())
-        NSLog("[STT] rearmTask(\(reason)) -> new task started")
-    }
-
-    private func checkTaskHealth() {
-        guard let engine = audioEngine else { return }
-        let now = CACurrentMediaTime()
-
-        // Engine down? Let your existing logic handle it; just bail.
-        if !engine.isRunning { return }
-
-        // If recognizer is globally unavailable, don’t thrash — wait until it flips back.
-        if let rec = speechRecognizer, rec.isAvailable == false {
-            NSLog("[STT] watchdog: recognizer unavailable; waiting…")
-            return
-        }
-
-        // No task at all? Spin one up.
-        if recognitionTask == nil {
-            if now - lastRearmAt > rearmCooldownTask {
-                NSLog("[STT] watchdog: no task -> start fresh request")
-                lastRearmAt = now
-                startTask(makeFreshRequest())
-            }
-            return
-        }
-
-        // If we’ve had buffers recently but no results for a while, assume the task is stuck.
-        let noResultsFor = now - lastResultAt
-        let hadRecentAudio = (now - lastBufferAt) < max(2.0, stallThreshold) // tap is alive
-
-        if hadRecentAudio && noResultsFor > stallThreshold {
-            if now - lastRearmAt > rearmCooldownTask {
-                consecutiveStallCount += 1
-                NSLog("[STT] watchdog: stall detected (no results for \(Int(noResultsFor))s, audio flowing). rearm #\(consecutiveStallCount)")
-
-                rearmTask(reason: "watchdog-stall")
-                lastRearmAt = now
-
-                // If we stall repeatedly, recreate the recognizer itself (server/session could be hosed)
-                if consecutiveStallCount >= 3 {
-                    recreateSpeechRecognizerPreservingLocale()
-                    consecutiveStallCount = 0
-                }
-            }
-        } else if hadRecentAudio {
-            // Healthy path: audio & results are flowing; reset stall counter
-            consecutiveStallCount = 0
-        }
-    }
-
-    public func startSpeech(localeStr: String?) {
-        NSLog("[STT] startSpeech(locale=\(localeStr ?? "nil"))")
-
-        if recognitionTask != nil {
-            sendResult(error: ["code": "already_started", "message": "Speech recognition already started!"],
-                       bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            return
-        }
-
-        SFSpeechRecognizer.requestAuthorization { [weak self] status in
-            guard let self = self else { return }
-            switch status {
-            case .notDetermined:
-                self.sendResult(error: ["message": "Speech recognition not yet authorized"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            case .denied:
-                self.sendResult(error: ["message": "User denied access to speech recognition"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            case .restricted:
-                self.sendResult(error: ["message": "Speech recognition restricted on this device"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            case .authorized:
-                self.setupAndStartRecognizing(localeStr: localeStr)
-            @unknown default:
-                self.sendResult(error: ["message": "Unknown authorization status"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            }
-        }
-    }
-
-    public func stopSpeech(_ completion: ((Bool) -> Void)? = nil) {
-        NSLog("[STT] stopSpeech() requested by app")
-        recognitionTask?.finish()
-        completion?(false)
-    }
-
-    public func cancelSpeech(_ completion: ((Bool) -> Void)? = nil) {
-        NSLog("[STT] cancelSpeech() requested by app")
-
-        recognitionTask?.cancel()
-        completion?(false)
-    }
-
-    public func destroySpeech(_ completion: ((Bool) -> Void)? = nil) {
-        NSLog("[STT] **** destroySpeech!!!")
-        teardown()
-        completion?(false)
-    }
-
-    /// Try to avoide this!!!
-    // Pick the best input and (optionally) prefer speaker only when nothing external is present.
-    private func updateSessionRouting(selectBestInput: Bool = true) {
-        let s = AVAudioSession.sharedInstance()
-
-        let hasExternalOutput = s.currentRoute.outputs.contains {
-            switch $0.portType {
-            case .headphones, .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .airPlay, .carAudio, .usbAudio:
-                return true
-            default:
-                return false
-            }
-        }
-
-        if selectBestInput, let inputs = s.availableInputs {
-            let btHFP = inputs.first { $0.portType == .bluetoothHFP }
-            let btLE  = inputs.first { $0.portType == .bluetoothLE }
-            let wired = inputs.first { $0.portType == .headsetMic }
-            let built = inputs.first { $0.portType == .builtInMic }
-            let best = btHFP ?? btLE ?? wired ?? built
-            if s.preferredInput?.uid != best?.uid { try? s.setPreferredInput(best) }
-
-            if let builtIn = best, builtIn.portType == .builtInMic,
-            let ds = builtIn.dataSources?.first(where: { $0.orientation == .bottom || $0.orientation == .back }) {
-                try? builtIn.setPreferredDataSource(ds)
-            }
-        }
-
-        var opts: AVAudioSession.CategoryOptions = [.allowBluetooth, .allowBluetoothA2DP, .allowAirPlay, .mixWithOthers]
-        if !hasExternalOutput { opts.insert(.defaultToSpeaker) }
-
-        // ✅ keep mode CONSISTENT with setupAudioSession(): .videoChat
-        if s.category != .playAndRecord || s.mode != .videoChat || s.categoryOptions != opts {
-            NSLog("[STT] reapply category: .playAndRecord / .videoChat (opts=\(opts))")
-            try? s.setCategory(.playAndRecord, mode: .videoChat, options: opts)
-        }
-    }
-
-    // MARK: - Core logic (kept intact, including AEC order/steps)
-
-    /// Returns true if no errors occurred (identical flow & calls as ObjC).
-/// Returns true if no errors occurred (identical flow & calls as ObjC) + keep-alive opts.
-    private func setupAudioSession() -> Bool {
-        var err: NSError?
-        let session = AVAudioSession.sharedInstance()
-        self.audioSession = session
-
-        // Build options to match our routing rules
-        // (defaultToSpeaker only when no external output is active)
-        let hasExternalOutput: Bool = session.currentRoute.outputs.contains {
-            switch $0.portType {
-            case .headphones, .bluetoothA2DP, .bluetoothHFP, .bluetoothLE, .airPlay, .carAudio, .usbAudio:
-                return true
-            default:
-                return false
-            }
-        }
-
-        var opts: AVAudioSession.CategoryOptions = [.allowBluetooth, .allowBluetoothA2DP, .allowAirPlay, .mixWithOthers]
-        if !hasExternalOutput { opts.insert(.defaultToSpeaker) }
-        if #available(iOS 14.5, *) {
-            // Prevent muted switch / mic mute from killing our capture pipeline
-            opts.insert(.overrideMutedMicrophoneInterruption)
-        }
-
-        do {
-            try session.setCategory(.playAndRecord, mode: .videoChat, options: opts)
-        } catch { err = error as NSError }
-
-        do { try session.setActive(true) } catch { err = error as NSError }
-
-        if let e = err {
-            NSLog("[STT] setupAudioSession error: \(e.localizedDescription)")
-            sendResult(error: ["code": "audio", "message": e.localizedDescription], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            return false
-        }
-        return true
-    }
-
-    private func currentInputFormat(_ engine: AVAudioEngine) -> AVAudioFormat? {
-        // Prefer whatever CoreAudio currently provides; avoid cached formats.
-        let fmt = engine.inputNode.outputFormat(forBus: 0)
-        if fmt.sampleRate > 0 && fmt.channelCount > 0 { return fmt }
-        // Fallback: build a sane mono format from session if ever needed.
-        let sr = max(8000, AVAudioSession.sharedInstance().sampleRate)
-        return AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: sr, channels: 1, interleaved: false)
-    }
-
-    private func isHeadsetPluggedIn() -> Bool {
-        let route = AVAudioSession.sharedInstance().currentRoute
-        for out in route.outputs {
-            if out.portType == .headphones || out.portType == .bluetoothA2DP {
-                return true
-            }
-        }
-        return false
-    }
-
-    private func isHeadSetBluetooth() -> Bool {
-        for port in AVAudioSession.sharedInstance().availableInputs ?? [] {
-            if port.portType == .bluetoothHFP { return true }
-        }
-        return false
-    }
-
-    private func loadContextualStrings() -> [String] {
-        guard let filePath = Bundle.main.path(forResource: "words_flattened", ofType: "txt") else {
-            NSLog("words_flattened.txt not found in bundle")
-            return []
-        }
-        do {
-            let contents = try String(contentsOfFile: filePath, encoding: .utf8)
-            let rawItems = contents.components(separatedBy: ",")
-            var cleaned: [String] = []
-            cleaned.reserveCapacity(rawItems.count)
-            for item in rawItems {
-                var t = item.trimmingCharacters(in: .whitespacesAndNewlines)
-                t = t.replacingOccurrences(of: "\"", with: "")
-                if !t.isEmpty { cleaned.append(t) }
-            }
-            return cleaned
-        } catch {
-            NSLog("Error reading contextualStrings: \(error)")
-            return []
-        }
-    }
-
-    private func recreateSpeechRecognizerPreservingLocale() {
-        let locale = speechRecognizer?.locale
-        speechRecognizer?.delegate = nil
-        speechRecognizer = nil
-        if let loc = locale { speechRecognizer = SFSpeechRecognizer(locale: loc) }
-        else { speechRecognizer = SFSpeechRecognizer() }
-        speechRecognizer?.delegate = self
-        NSLog("[STT] recreated SFSpeechRecognizer (locale=\(speechRecognizer?.locale.identifier ?? "default"))")
-    }
-
-    // Add helpers
-    private func makeFreshRequest() -> SFSpeechAudioBufferRecognitionRequest {
-        let req = SFSpeechAudioBufferRecognitionRequest()
-        if #available(iOS 16, *) { req.addsPunctuation = true }
-        req.shouldReportPartialResults = true
-        if #available(iOS 13.0, *) { req.taskHint = .dictation }
-        req.contextualStrings = loadContextualStrings()
-        self.recognitionRequest = req
-        NSLog("makeFreshRequest()")
-        return req
-    }
-
-    private func startTask(_ req: SFSpeechAudioBufferRecognitionRequest) {
-        NSLog("starting recognitionTask")
-        lastTaskStartAt = CACurrentMediaTime()
-        lastResultAt = lastTaskStartAt
-        let taskSessionId = self.sessionId
-        self.recognitionTask = self.speechRecognizer?.recognitionTask(with: req) { [weak self] result, error in
-            guard let self = self else { return }
-            if taskSessionId != self.sessionId { NSLog("task session mismatch -> ignore"); return }
-            self.lastResultAt = CACurrentMediaTime()
-
-            func markIfReal(_ r: SFSpeechRecognitionResult?) {
-                guard let r = r else { return }
-                let best = r.bestTranscription.formattedString.trimmingCharacters(in: .whitespacesAndNewlines)
-                if !best.isEmpty ||
-                r.transcriptions.contains(where: { !$0.formattedString.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty }) {
-                    if !self.seenRealSpeech {
-                        self.seenRealSpeech = true
-                        NSLog("first real speech detected -> onSpeechStart to JS")
-                        self.sendEvent(name: "onSpeechStart", body: nil)
-                    }
-                }
-            }
-            markIfReal(result)
-
-            func rearm(_ why: String, delay: TimeInterval = 0.05) {
-                guard self.continuous else { return }
-                NSLog("REARM (\(why))")
-                self.recognitionTask?.cancel()
-                self.recognitionTask = nil
-                DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
-                    self.startTask(self.makeFreshRequest())
-                }
-            }
-
-            if let error = error {
-                NSLog("task error \(error._code): \(error.localizedDescription)")
-                // treat as transient for continuous mode
-                rearmTask(reason: "error")  
-                return
-            }
-
-            guard let result = result else {
-                NSLog("task nil result")
-                rearmTask(reason: "nil-result")
-                return
-            }
-
-            let isFinal = result.isFinal
-            let parts = result.transcriptions.map { $0.formattedString }
-            self.sendResult(error: nil,
-                            bestTranscription: result.bestTranscription.formattedString,
-                            transcriptions: parts,
-                            isFinal: isFinal)
-
-            if isFinal {
-                NSLog("task final -> onSpeechEnd")
-                self.sendEvent(name: "onSpeechEnd", body: nil)
-                if self.continuous {
-                    self.rearmTask(reason: "final")
-                } else {
-                    NSLog("non-continuous final -> teardown")
-                    self.teardown()
-                }
-            }
-        }
-    }
-
-    public func teardown() {
-        NSLog("[STT] teardown() begin")
-        isTearingDown = true
-        stopWatchdog()
-        consecutiveStallCount = 0
-
-        if let task = recognitionTask {
-            task.cancel()
-            recognitionTask = nil
-        }
-        AudioPlaybackHook.engineScheduleFile = nil
-        AudioPlaybackHook.isEngineReady = nil
-
-        if let p = playbackNode {
-            p.stop()
-        }
-        playbackNode = nil
-
-        if let req = recognitionRequest {
-            req.endAudio()
-            recognitionRequest = nil
-        }
-
-        if let engine = audioEngine {
-            if engine.inputNode != nil {
-                engine.inputNode.removeTap(onBus: 0)
-                engine.inputNode.reset()
-            }
-            if engine.isRunning {
-                engine.stop()
-            }
-            engine.reset()
-            audioEngine = nil  // Crucial step!
-        }
-
-        resetAudioSession()
-
-        sessionId = nil
-        isTearingDown = false
-    }
-
-    public func teardown2() {
-        isTearingDown = true
-        recognitionTask?.cancel()
-        recognitionTask = nil
-
-        resetAudioSession()
-
-        recognitionRequest?.endAudio()
-        recognitionRequest = nil
-
-        if let engine = audioEngine {
-            engine.inputNode.removeTap(onBus: 0)
-            engine.inputNode.reset()
-
-            if engine.isRunning {
-                engine.stop()
-                engine.reset()
-                audioEngine = nil
-            }
-        }
-
-        sessionId = nil
-        isTearingDown = false
-    }
-
-    private func resetAudioSession() {
-        if audioSession == nil {
-            audioSession = AVAudioSession.sharedInstance()
-        }
-        guard let session = audioSession else { return }
-
-        // Preserve & compare category exactly as original logic
-        let current = session.category
-        if priorAudioCategory == current { return }
-
-        // do {
-        //     try session.setCategory(priorAudioCategory ?? .soloAmbient,
-        //                             mode: .default,
-        //                             options: [.allowBluetooth,
-        //                                       .allowBluetoothA2DP,
-        //                                       .defaultToSpeaker,
-        //                                       .allowAirPlay,
-        //                                       .mixWithOthers])
-        // } catch {
-        //     // Silent, matching original behavior (no error propagation here)
-        // }
-        audioSession = nil
-    }
-
-    /// Try to keep the capture alive without tearing down recognition.
-    /// 1) If engine exists but not running → try start()
-    /// 2) If start fails or graph became invalid → rebuild graph and start
-    /// 3) If we don’t have a task yet, start one.
-    private func ensureEngineRunning(reason: String) {
-        let now = CFAbsoluteTimeGetCurrent()
-        if (now - lastReclaimAttempt) < reclaimCooldown {
-            NSLog("[STT] ensureEngineRunning(\(reason)) skipped (cooldown)")
-            return
-        }
-        lastReclaimAttempt = now
-
-        if (audioEngine != nil) && !audioEngine!.isRunning {
-            do {
-                // Possibly re-apply your format or re-install taps if the hardware changed sample rates
-                try audioEngine!.start()
-                print("🔄 AVAudioEngine restarted after config change. isRunning=%@", 
-                      audioEngine!.isRunning ? "YES":"NO")
-            } catch {
-                print("❌ Could not re-start after config change: \(error)")
-            }
-        }
-        return
-
-        // BELOW CHATGPT SHIT CODE!!
-
-        guard let engine = audioEngine else {
-            NSLog("[STT] ensureEngineRunning(\(reason)): no engine → rebuild")
-            rebuildEngineGraphAndRestart(reason: reason)
-            return
-        }
-
-        if !engine.isRunning {
-            do {
-                try engine.start()
-                NSLog("[STT] ensureEngineRunning(\(reason)): engine.start() -> running=\(engine.isRunning)")
-            } catch {
-                NSLog("[STT] ensureEngineRunning(\(reason)): engine.start() failed: \(error) → rebuild")
-                rebuildEngineGraphAndRestart(reason: reason)
-                return
-            }
-        }
-
-        // If we have no active task, spin one up against the current request
-        if recognitionTask == nil {
-            if let req = recognitionRequest {
-                NSLog("[STT] ensureEngineRunning(\(reason)): no task -> startTask(existing req)")
-                startTask(req)
-            } else {
-                NSLog("[STT] ensureEngineRunning(\(reason)): no req -> makeFreshRequest + startTask")
-                startTask(makeFreshRequest())
-            }
-        }
-    }
-
-    /// Rebuilds AVAudioEngine graph (mic→mute mixer, player→mainMixer), reinstalls tap,
-    /// and restarts the engine. Does NOT nuke the current recognitionRequest/task unless required.
-    private func rebuildEngineGraphAndRestart(reason: String) {
-        NSLog("[STT] 🔄 rebuildEngineGraphAndRestart (\(reason))")
-
-        // Keep current request if present; we'll keep appending into it
-        let existingReq = self.recognitionRequest
-
-        // Tear down engine ONLY (keep session, request)
-        if let engine = audioEngine {
-            if engine.inputNode != nil {
-                engine.inputNode.removeTap(onBus: 0)
-                engine.inputNode.reset()
-            }
-            if engine.isRunning { engine.stop() }
-            engine.reset()
-        }
-
-        // Recreate engine and graph
-        let newEngine = AVAudioEngine()
-        self.audioEngine = newEngine
-
-        let inputNode = newEngine.inputNode
-        do {
-            try inputNode.setVoiceProcessingEnabled(true)
-        } catch {
-            NSLog("[STT] rebuild: failed to enable voice processing: \(error)")
-        }
-        if #available(iOS 17.0, *) {
-            var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
-            duck.enableAdvancedDucking = false
-            duck.duckingLevel = .min
-            inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
-        }
-
-        let recordingFormat = inputNode.outputFormat(forBus: 0)
-
-        // mic → mute mixer → mainMixer
-        let micMixer = AVAudioMixerNode()
-        newEngine.attach(micMixer)
-        newEngine.connect(inputNode, to: micMixer, format: recordingFormat)
-        newEngine.connect(micMixer, to: newEngine.mainMixerNode, format: recordingFormat)
-        micMixer.outputVolume = 0.0
-
-        // TTS player → mainMixer (keep same player if possible, else recreate)
-        if playbackNode == nil { playbackNode = AVAudioPlayerNode() }
-        if let player = playbackNode {
-            if player.engine == nil { newEngine.attach(player) }
-            newEngine.connect(player, to: newEngine.mainMixerNode, format: nil)
-        }
-
-        // Reinstall tap to feed (existing or new) recognition request
-        inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { [weak self] buffer, _ in
-            guard let self = self else { return }
-
-            // (same level metering as your current code)
-            let frames: vDSP_Length = vDSP_Length(buffer.frameLength)
-            let LP: Float = 0.5
-
-            if buffer.format.channelCount > 0, let ch0 = buffer.floatChannelData?[0] {
-                var peak0: Float = 0
-                vDSP_maxmgv(ch0, 1, &peak0, frames)
-                let db0: Float = (peak0 == 0) ? -100 : 20.0 * log10f(peak0)
-                let sm0 = LP * db0 + (1 - LP) * self.averagePowerForChannel0
-                self.averagePowerForChannel0 = sm0
-                self.averagePowerForChannel1 = sm0
-            }
-            if buffer.format.channelCount > 1, let ch1 = buffer.floatChannelData?[1] {
-                var peak1: Float = 0
-                vDSP_maxmgv(ch1, 1, &peak1, frames)
-                let db1: Float = (peak1 == 0) ? -100 : 20.0 * log10f(peak1)
-                let sm1 = LP * db1 + (1 - LP) * self.averagePowerForChannel1
-                self.averagePowerForChannel1 = sm1
-            }
-            self.averagePowerForChannel1 = Float(self._normalizedPowerLevelFromDecibels(CGFloat(self.averagePowerForChannel1)) * 10.0)
-            self.sendEvent(name: "onSpeechVolumeChanged", body: ["value": self.averagePowerForChannel1])
-
-            self.recognitionRequest?.append(buffer)
-        }
-
-        newEngine.prepare()
-        do {
-            try newEngine.start()
-            NSLog("[STT] rebuild: engine.start() ok, running=\(newEngine.isRunning)")
-        } catch {
-            NSLog("[STT] rebuild: engine.start() failed: \(error)")
-        }
-
-        // If we lost the request during rebuild, recreate + start task.
-        if self.recognitionRequest == nil {
-            if let old = existingReq {
-                self.recognitionRequest = old
-            } else {
-                self.recognitionRequest = makeFreshRequest()
-            }
-        }
-        if self.recognitionTask == nil {
-            startTask(self.recognitionRequest!)
-        }
-    }
-
-    @objc private func handleEngineConfigChange(_ note: Notification) {
-        NSLog("[STT] ⚙️ AVAudioEngineConfigurationChange: ensuring engine running")
-        ensureEngineRunning(reason: "engine-config-change")
-    }
-
-    @objc private func handleMediaServicesReset(_ note: Notification) {
-        NSLog("[STT] 📺 Media services were RESET: reclaiming mic & session")
-        // Re-apply audio session and try to rebuild graph if needed
-        _ = setupAudioSession()
-        ensureEngineRunning(reason: "media-services-reset")
-    }
-
-    @objc private func handleRouteChange(_ note: Notification) {
-        let info = note.userInfo ?? [:]
-        NSLog("[STT] 🔀 route change: \(info)")
-
-        guard let reasonVal = info[AVAudioSessionRouteChangeReasonKey] as? UInt,
-            let reason = AVAudioSession.RouteChangeReason(rawValue: reasonVal) else {
-            ensureEngineRunning(reason: "route-change-unknown")
-            return
-        }
-
-        // On any meaningful route change, reclaim mic
-        switch reason {
-        case .oldDeviceUnavailable, .newDeviceAvailable, .categoryChange, .routeConfigurationChange, .override:
-            ensureEngineRunning(reason: "route-change-\(reason.rawValue)")
-        default:
-            break
-        }
-    }
-
-    // Call once, right after you create the engine (or inside setupAudioSession)
-    // Call once after engine is created
-    private func installEngineObservers() {
-        let nc = NotificationCenter.default
-
-        if let engine = audioEngine {
-            nc.addObserver(self,
-                        selector: #selector(handleEngineConfigChange(_:)),
-                        name: .AVAudioEngineConfigurationChange,
-                        object: engine)
-        }
-
-        nc.addObserver(self,
-                    selector: #selector(handleSessionInterruption(_:)),
-                    name: AVAudioSession.interruptionNotification,
-                    object: AVAudioSession.sharedInstance())
-
-        nc.addObserver(self,
-                    selector: #selector(handleRouteChange(_:)),
-                    name: AVAudioSession.routeChangeNotification,
-                    object: AVAudioSession.sharedInstance())
-
-        nc.addObserver(self,
-                    selector: #selector(handleMediaServicesReset(_:)),
-                    name: AVAudioSession.mediaServicesWereResetNotification,
-                    object: nil)
-    }
-
-    @objc private func handleSessionInterruption(_ note: Notification) {
-        guard
-            let info = note.userInfo,
-            let typeVal = info[AVAudioSessionInterruptionTypeKey] as? UInt,
-            let type = AVAudioSession.InterruptionType(rawValue: typeVal)
-        else { return }
-
-        if type == .ended {
-            // On real “render err” Core Audio posts an interruption END
-            NSLog("Session interruption ended (possible render err):")
-        }
-    }
-
-    private func setupAndStartRecognizing(localeStr: String?) {
-        NSLog("[STT] setupAndStartRecognizing begin")
-
-        audioSession = AVAudioSession.sharedInstance()
-        guard let session = audioSession else { return }
-        var err: NSError?
-
-        priorAudioCategory = session.category
-
-        // Tear down resources before starting speech recognition..
-        NSLog("[STT] pre-teardown")
-        teardown()
-
-        sessionId = UUID().uuidString
-
-        let locale: Locale? = {
-            if let s = localeStr, !s.isEmpty { return Locale(identifier: s) }
-            return nil
-        }()
-
-        if let loc = locale {
-            speechRecognizer = SFSpeechRecognizer(locale: loc)
-        } else {
-            speechRecognizer = SFSpeechRecognizer()
-        }
-        speechRecognizer?.delegate = self
-
-        // Start audio session...
-        NSLog("[STT] setupAudioSession()")
-        guard setupAudioSession() else {
-            NSLog("[STT] ERROR ERROR ******** setupAudioSession()")
-            teardown()
-            return
-        }
-        installEngineObservers()
-
-        let request = SFSpeechAudioBufferRecognitionRequest()
-        recognitionRequest = request
-
-        if #available(iOS 16, *) {
-            request.addsPunctuation = true
-        } else {
-            // Fallback on earlier versions
-        }
-        request.shouldReportPartialResults = true
-        if #available(iOS 13.0, *) { request.taskHint = .dictation }
-        request.contextualStrings = loadContextualStrings()
-
-        guard recognitionRequest != nil else {
-            sendResult(error: ["code": "recognition_init"], bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            teardown()
-            return
-        }
-
-        if audioEngine == nil {
-            audioEngine = AVAudioEngine()
-        }	
-        do {
-            guard let engine = audioEngine else { throw NSError(domain: "voice.audio", code: -1) }
-            let inputNode = engine.inputNode
-            let _ = inputNode // presence check
-
-            // Enable voice processing (AEC)
-            do {
-                try inputNode.setVoiceProcessingEnabled(true)
-            } catch {
-                NSLog("Failed to enable voice processing for AEC on input node: \(error)")
-            }
-
-            if #available(iOS 17.0, *) {
-                var duck = AVAudioVoiceProcessingOtherAudioDuckingConfiguration()
-                duck.enableAdvancedDucking = false   // disable advanced (VAD-based) ducking
-                duck.duckingLevel = .min             // “as loud as possible” for other audio
-                inputNode.voiceProcessingOtherAudioDuckingConfiguration = duck
-            }
-
-            // if output node voice processing is ever needed, keep commented as in original:
-            // do { try engine.outputNode.setVoiceProcessingEnabled(true) } catch { ... }
-
-            NSLog("[STT] AEC enable done")
-
-            let recordingFormat = inputNode.outputFormat(forBus: 0)
-
-            // engine.connect(inputNode, to: engine.mainMixerNode, format: recordingFormat)
-            // engine.connect(engine.mainMixerNode, to: engine.outputNode, format: recordingFormat)
-            // engine.mainMixerNode.outputVolume = 0.0
-
-            // 1) Mute only the mic path, not the whole main mixer
-            let micMixer = AVAudioMixerNode()
-            engine.attach(micMixer)
-            engine.connect(inputNode, to: micMixer, format: recordingFormat)
-            engine.connect(micMixer, to: engine.mainMixerNode, format: recordingFormat)
-            micMixer.outputVolume = 0.0  // ← you won't hear your own mic
-
-            // 2) Prepare a player node for TTS inside the SAME engine/graph
-            let player = AVAudioPlayerNode()
-            self.playbackNode = player
-            engine.attach(player)
-            // Use nil format so the mixer handles sample-rate conversion (e.g., 48k TTS)
-            engine.connect(player, to: engine.mainMixerNode, format: nil)
-
-            NSLog("[STT] graph connected (mic->mute mixer, player->mainMixer)")
-            
-            var tapFrames: UInt64 = 0
-            // Start recording and append recording buffer to speech recognizer
-            inputNode.installTap(onBus: 0, bufferSize: 1024, format: recordingFormat) { [weak self] buffer, _ in
-                // Strongify self once
-                guard let self = self else { return }
-                tapFrames &+= UInt64(buffer.frameLength)
-                if tapFrames % (44100 * 2) < 1024 {  // ~every ~2s at 44.1k
-                    NSLog("[STT] tap alive, totalFrames=\(tapFrames)")
-                }
-
-                let frames: vDSP_Length = vDSP_Length(buffer.frameLength)
-                let LEVEL_LOWPASS_TRIG: Float = 0.5
-
-                // CH0
-                if buffer.format.channelCount > 0, let ch0 = buffer.floatChannelData?[0] {
-                    var peak0: Float = 0
-                    vDSP_maxmgv(ch0, 1, &peak0, frames)
-                    let db0: Float = (peak0 == 0) ? -100 : 20.0 * log10f(peak0)
-
-                    let smoothed0 = LEVEL_LOWPASS_TRIG * db0
-                                + (1 - LEVEL_LOWPASS_TRIG) * self.averagePowerForChannel0
-                    self.averagePowerForChannel0 = smoothed0
-                    self.averagePowerForChannel1 = smoothed0
-                }
-
-                // CH1
-                if buffer.format.channelCount > 1, let ch1 = buffer.floatChannelData?[1] {
-                    var peak1: Float = 0
-                    vDSP_maxmgv(ch1, 1, &peak1, frames)
-                    let db1: Float = (peak1 == 0) ? -100 : 20.0 * log10f(peak1)
-
-                    let smoothed1 = LEVEL_LOWPASS_TRIG * db1
-                                + (1 - LEVEL_LOWPASS_TRIG) * self.averagePowerForChannel1
-                    self.averagePowerForChannel1 = smoothed1
-                }
-
-                // Normalize 0–10 and emit
-                self.averagePowerForChannel1 = Float(self._normalizedPowerLevelFromDecibels(CGFloat(self.averagePowerForChannel1)) * 10.0)
-                let value = self.averagePowerForChannel1
-                self.sendEvent(name: "onSpeechVolumeChanged", body: ["value": value])
-
-                // Append to recognition
-                self.recognitionRequest?.append(buffer)
-
-                // inside inputNode.installTap { buffer, _ in
-                self.lastBufferAt = CACurrentMediaTime()
-            }
-
-            engine.prepare()
-            NSLog("[STT] audioEngine prepare")
-            var audioSessionError: NSError?
-            do {
-                try engine.start()
-            } catch {
-                audioSessionError = error as NSError
-            }
-
-            // after engine.start() success:
-            engineHotAt = CACurrentMediaTime()
-            seenRealSpeech = false
-            NSLog("engine HOT at \(engineHotAt)")
-            sendEvent(name: "onSpeechStart", body: nil) // engine hot signal (keep if you want)
-            startTask(makeFreshRequest())
-
-            // Engine is up; expose readiness
-            AudioPlaybackHook.isEngineReady = { [weak self] in
-                guard let eng = self?.audioEngine else { return false }
-                return eng.isRunning
-            }
-            
-            startWatchdog()
-
-            // After engine.start() succeeds:
-            AudioPlaybackHook.engineScheduleFile = { [weak self] url, done in
-                guard
-                    let self = self,
-                    let engine = self.audioEngine,
-                    let player = self.playbackNode
-                else { return false }
-
-                do {
-                    let file = try AVAudioFile(forReading: url)
-                    if !player.isPlaying { player.play() }   // engine is already running
-                    player.scheduleFile(file, at: nil) {
-                        DispatchQueue.main.async { done() }
-                    }
-                    return true
-                } catch {
-                    print("engineScheduleFile error:", error)
-                    return false
-                }
-            }
-
-            NSLog("audioEngine startAndReturnError")
-            if let audioSessionError = audioSessionError {
-                NotificationCenter.default.addObserver(self,
-                                                       selector: #selector(self.handleEngineConfigChange(_:)),
-                                                       name: .AVAudioEngineConfigurationChange,
-                                                       object: engine)
-                NSLog("audioEngine audioSessionError!=nil")
-                self.sendResult(error: ["code": "audio", "message": audioSessionError.localizedDescription],
-                                bestTranscription: nil, transcriptions: nil, isFinal: nil)
-                NSLog("[STT] self sendResult")
-                // self.teardown()
-                NSLog("[STT] Removed self teardown")
-                return
-            }
-            NSLog("After Start recording and append recording")
-            DispatchQueue.main.asyncAfter(deadline: .now() + 3.0) { [weak self] in
-                guard let self = self else { return }
-                let running = self.audioEngine?.isRunning ?? false
-                let taskState = self.recognitionTask?.state.rawValue ?? -1
-                NSLog("[STT] health: engineRunning=\(running) taskState=\(taskState)")
-            }
-
-            NSLog("After if audioSessionError != nil")
-        } catch let e as NSError {
-            sendResult(error: ["code": "start_recording", "message": e.localizedDescription],
-                       bestTranscription: nil, transcriptions: nil, isFinal: nil)
-            NSLog("End of init...")
-            return
-        }
-    }
-
-    // MARK: - Helpers
-
-    private func _normalizedPowerLevelFromDecibels(_ decibels: CGFloat) -> CGFloat {
-        if decibels < -80.0 || decibels == 0.0 { return 0.0 }
-        let minDb: Float = -80.0
-        let pow10_min = powf(10.0, 0.05 * minDb)
-        let pow10_db  = powf(10.0, 0.05 * Float(decibels))
-        let power = powf((pow10_db - pow10_min) * (1.0 / (1.0 - pow10_min)), 1.0 / 2.0)
-        if power < 1.0 { return CGFloat(power) } else { return 1.0 }
-    }
-
-    private func sendEvent(name: String, body: [String: Any]?) {
-        delegate?.stt(self, didEmitEvent: name, body: body)
-    }
-
-    /// Exact event behavior preserved from ObjC `sendResult`.
-    private func sendResult(error: [String: Any]?,
-                            bestTranscription: String?,
-                            transcriptions: [String]?,
-                            isFinal: Bool?) {
-        if let error = error {
-            sendEvent(name: "onSpeechError", body: ["error": error])
-        }
-        if let best = bestTranscription {
-            sendEvent(name: "onSpeechResults", body: ["value": [best]])
-        }
-        if let trans = transcriptions {
-            sendEvent(name: "onSpeechPartialResults", body: ["value": trans])
-        }
-        if let isFinal = isFinal {
-            sendEvent(name: "onSpeechRecognized", body: ["isFinal": isFinal])
-        }
-    }
-
-    // MARK: - SFSpeechRecognizerDelegate
-
-    public func speechRecognizer(_ speechRecognizer: SFSpeechRecognizer, availabilityDidChange available: Bool) {
-        if available == false {
-            sendResult(error: ["message": "Speech recognition is not available now"],
-                       bestTranscription: nil, transcriptions: nil, isFinal: nil)
-        }
-    }
-}