Repository Public
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