SPB Git

Repository Public

Dictation.swift 12.0 KB 295 lines swift

1// SP Notes iOS2// File: Features/Voice/Dictation.swift3// Description: « Dictée »: live speech-to-text into a text field, on the device only (Speech framework on the microphone4//              buffers, partial results). Distinct from a voice note: no audio is kept unless the user asks (« Garder l’audio »).5//              Stops on pause, on interruption, when the app leaves the foreground and after a silence.6//7// Author: Simon-Pierre Boucher8// Contact: contact@spboucher.ai9import AVFoundation10import Foundation11import Observation12import Speech13import UIKit1415enum DictationStop: Equatable, Sendable {16    case user, silence, interruption, background17    case failed(String)18}1920enum DictationFailure: Error, Equatable {21    case microphone(restricted: Bool)22    case speech(restricted: Bool)23    case unavailable(language: String)24    case engine(String)25}2627/// A live recogniser. Implemented by `SystemDictation`; faked in the unit tests.28@MainActor29protocol SpeechDictating: AnyObject {30    /// The whole text recognised since `start` (it is revised as the recogniser hears more).31    var onText: ((String) -> Void)? { get set }32    /// The recogniser ended by itself.33    var onEnd: ((DictationStop) -> Void)? { get set }34    /// - Parameter audioURL: when set, the microphone audio is also written there (m4a).35    func start(keepingAudioAt audioURL: URL?) async throws36    /// Returns the seconds of audio written (0 when none was kept).37    @discardableResult func stop() -> Double38}3940@MainActor41@Observable42final class DictationModel {43    enum Phase: Equatable {44        case idle, starting, listening45        case stopped(DictationStop)46        case microphoneDenied(restricted: Bool)47        case speechDenied(restricted: Bool)48        case unavailable(language: String)49    }5051    private(set) var phase: Phase = .idle52    /// What this session recognised so far.53    private(set) var spoken = ""54    /// The audio kept, when the user asked for it.55    private(set) var keptAudio: RecordedAudio?56    var keepsAudio = false5758    @ObservationIgnored private let engine: any SpeechDictating59    @ObservationIgnored private var base = ""60    @ObservationIgnored private var audioURL: URL?61    @ObservationIgnored private var startedAt = Date()62    @ObservationIgnored private var silence: Task<Void, Never>?63    @ObservationIgnored private var backgroundObserver: NSObjectProtocol?64    @ObservationIgnored private let silenceTimeout: Duration?65    /// Receives the text field's new value at each revision.66    @ObservationIgnored var onUpdate: (String) -> Void = { _ in }6768    init(engine: any SpeechDictating, silenceTimeout: Duration? = .seconds(30)) {69        self.engine = engine70        self.silenceTimeout = silenceTimeout71        engine.onText = { [weak self] in self?.receive($0) }72        engine.onEnd = { [weak self] in self?.ended($0) }73        backgroundObserver = NotificationCenter.default.addObserver(forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: .main) { [weak self] _ in74            MainActor.assumeIsolated { self?.finish(.background) }75        }76    }7778    var isListening: Bool { phase == .listening || phase == .starting }7980    /// The text of the field: what was there before, then what was dictated.81    static func merged(base: String, spoken: String) -> String {82        let said = spoken.trimmingCharacters(in: .whitespacesAndNewlines)83        guard !said.isEmpty else { return base }84        guard !base.isEmpty else { return said }85        return base + (base.last?.isWhitespace == true ? "" : " ") + said86    }8788    /// Starts listening; what is recognised is appended to `existing`.89    func start(appendingTo existing: String) async {90        guard !isListening else { return }91        base = existing92        spoken = ""93        keptAudio = nil94        phase = .starting95        audioURL = keepsAudio ? try? MediaTemp.newFileURL(named: VoiceRecorderModel.filename(for: Date())) : nil96        startedAt = Date()97        do {98            try await engine.start(keepingAudioAt: audioURL)99            phase = .listening100            armSilence()101        } catch let failure as DictationFailure {102            switch failure {103            case .microphone(let restricted): phase = .microphoneDenied(restricted: restricted)104            case .speech(let restricted): phase = .speechDenied(restricted: restricted)105            case .unavailable(let language): phase = .unavailable(language: language)106            case .engine(let reason): phase = .stopped(.failed(reason))107            }108            discardAudio()109        } catch {110            phase = .stopped(.failed(error.localizedDescription))111            discardAudio()112        }113    }114115    func stop() { finish(.user) }116117    func reset() { if !isListening { phase = .idle; spoken = "" } }118119    /// The kept audio was handed to a capture (or thrown away).120    func releaseAudio(discard: Bool) {121        if discard, let keptAudio { MediaTemp.discard(keptAudio.fileURL) }122        keptAudio = nil123    }124125    private func receive(_ text: String) {126        guard phase == .listening else { return }127        spoken = text128        onUpdate(Self.merged(base: base, spoken: text))129        armSilence()130    }131132    private func ended(_ reason: DictationStop) { finish(reason) }133134    private func finish(_ reason: DictationStop) {135        guard isListening else { return }136        silence?.cancel()137        let seconds = engine.stop()138        if let audioURL, seconds > 0.2 { keptAudio = RecordedAudio(fileURL: audioURL, duration: seconds, startedAt: startedAt) } else { discardAudio() }139        audioURL = nil140        phase = .stopped(reason)141    }142143    private func discardAudio() { if let audioURL { MediaTemp.discard(audioURL) }; audioURL = nil }144145    private func armSilence() {146        silence?.cancel()147        guard let silenceTimeout else { return }148        silence = Task { [weak self] in149            try? await Task.sleep(for: silenceTimeout)150            guard !Task.isCancelled else { return }151            self?.finish(.silence)152        }153    }154}155156// MARK: - System157158/// AVAudioEngine → `SFSpeechAudioBufferRecognitionRequest`, on-device recognition required.159@MainActor160final class SystemDictation: SpeechDictating {161    var onText: ((String) -> Void)?162    var onEnd: ((DictationStop) -> Void)?163164    private let engine = AVAudioEngine()165    private var request: SFSpeechAudioBufferRecognitionRequest?166    private var task: SFSpeechRecognitionTask?167    private var writer: AudioTapWriter?168    private var observers: [NSObjectProtocol] = []169    private var running = false170171    func start(keepingAudioAt audioURL: URL?) async throws {172        let microphone = SystemMicrophoneAuthorizer()173        switch await microphone.request() {174        case .granted: break175        case .restricted: throw DictationFailure.microphone(restricted: true)176        default: throw DictationFailure.microphone(restricted: false)177        }178        let speech = await withCheckedContinuation { (continuation: CheckedContinuation<SFSpeechRecognizerAuthorizationStatus, Never>) in179            SFSpeechRecognizer.requestAuthorization { continuation.resume(returning: $0) }180        }181        switch speech {182        case .authorized: break183        case .restricted: throw DictationFailure.speech(restricted: true)184        default: throw DictationFailure.speech(restricted: false)185        }186        guard let recognizer = OnDeviceTranscriber.preferredLocales().lazy.compactMap({ SFSpeechRecognizer(locale: $0) }).first(where: { $0.supportsOnDeviceRecognition && $0.isAvailable }) else {187            throw DictationFailure.unavailable(language: Locale.current.identifier(.bcp47))188        }189        do {190            let session = AVAudioSession.sharedInstance()191            try session.setCategory(.record, mode: .measurement, options: [.duckOthers])192            try session.setActive(true, options: .notifyOthersOnDeactivation)193            let request = SFSpeechAudioBufferRecognitionRequest()194            request.requiresOnDeviceRecognition = true195            request.shouldReportPartialResults = true196            request.addsPunctuation = true197            let input = engine.inputNode198            let format = input.outputFormat(forBus: 0)199            guard format.sampleRate > 0, format.channelCount > 0 else { throw DictationFailure.engine("format") }200            let writer = try audioURL.map { try AudioTapWriter(url: $0, format: format) }201            let sink = TapSink(request: request, writer: writer)202            input.removeTap(onBus: 0)203            input.installTap(onBus: 0, bufferSize: 2048, format: format) { buffer, _ in sink.receive(buffer) }204            engine.prepare()205            try engine.start()206            self.request = request207            self.writer = writer208            running = true209            task = recognizer.recognitionTask(with: request) { [weak self] result, error in210                let text = result?.bestTranscription.formattedString211                let failed = error != nil212                Task { @MainActor in213                    guard let self, self.running else { return }214                    if let text { self.onText?(text) }215                    if failed { self.onEnd?(.failed(String(localized: "la reconnaissance s’est arrêtée"))) }216                }217            }218            observe()219        } catch let failure as DictationFailure {220            teardown()221            throw failure222        } catch {223            teardown()224            throw DictationFailure.engine(error.localizedDescription)225        }226    }227228    func stop() -> Double {229        let seconds = writer?.seconds ?? 0230        teardown()231        return seconds232    }233234    private func teardown() {235        running = false236        engine.inputNode.removeTap(onBus: 0)237        if engine.isRunning { engine.stop() }238        request?.endAudio()239        task?.cancel()240        request = nil; task = nil241        writer?.close()242        writer = nil243        observers.forEach(NotificationCenter.default.removeObserver)244        observers = []245        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)246    }247248    private func observe() {249        observers.append(NotificationCenter.default.addObserver(forName: AVAudioSession.interruptionNotification, object: nil, queue: .main) { [weak self] note in250            let began = (note.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt) == AVAudioSession.InterruptionType.began.rawValue251            guard began else { return }252            MainActor.assumeIsolated { self?.onEnd?(.interruption) }253        })254    }255}256257/// The audio thread's side of the tap: feeds the recogniser and, when asked, the file.258private final class TapSink: @unchecked Sendable {259    private let request: SFSpeechAudioBufferRecognitionRequest260    private let writer: AudioTapWriter?261    init(request: SFSpeechAudioBufferRecognitionRequest, writer: AudioTapWriter?) { self.request = request; self.writer = writer }262    func receive(_ buffer: AVAudioPCMBuffer) {263        request.append(buffer)264        writer?.write(buffer)265    }266}267268/// Writes the tapped buffers as AAC (same container as the recorder), at the input's own sample rate.269final class AudioTapWriter: @unchecked Sendable {270    private let lock = NSLock()271    private var file: AVAudioFile?272    private var frames: AVAudioFramePosition = 0273    private let sampleRate: Double274275    init(url: URL, format: AVAudioFormat) throws {276        var settings = SystemAudioRecorder.settings277        settings[AVSampleRateKey] = format.sampleRate278        settings[AVNumberOfChannelsKey] = Int(format.channelCount)279        file = try AVAudioFile(forWriting: url, settings: settings, commonFormat: format.commonFormat, interleaved: format.isInterleaved)280        sampleRate = format.sampleRate281    }282283    func write(_ buffer: AVAudioPCMBuffer) {284        lock.withLock {285            guard let file else { return }286            if (try? file.write(from: buffer)) != nil { frames += AVAudioFramePosition(buffer.frameLength) }287        }288    }289290    var seconds: Double { lock.withLock { sampleRate > 0 ? Double(frames) / sampleRate : 0 } }291292    /// Releasing the file finishes the container.293    func close() { lock.withLock { file = nil } }294}295
Files main
Menu

Theme