Repository Public License
1//2// ORIX Audio3// File: ORIXAudio/Services/RecorderController.swift4// Description: Recording session lifecycle: permissions, start/pause/resume/stop, interruptions, route changes, Live Activity, finalization.5//6// Author: Simon-Pierre Boucher7// Contact: contact@spboucher.ai8//9import ActivityKit10import AVFoundation11import Foundation12import Observation13import ORIXAudioCore14import SwiftData15import UIKit1617@MainActor @Observable18final class RecorderController {19 enum State: Equatable { case idle, recording, paused, interrupted, finishing }2021 private(set) var state: State = .idle22 private(set) var elapsed: Double = 023 private(set) var capturedBytes: Int64 = 024 private(set) var markers: [Marker] = []25 private(set) var route: ActiveRoute?26 private(set) var captureFormat: CaptureFormat?27 private(set) var statusMessage: String?28 private(set) var liveTranscript = ""29 private(set) var liveTranscriptVolatile = ""30 private(set) var liveTranscriptionActive = false31 private(set) var finishingProgress: Double = 032 private(set) var droppedSamples = 033 var lastError: String?34 var title = ""35 var participants = ""36 var preset: RecordingPreset = .voice3738 /// The engine is exposed so views can read live visuals directly from its lock-protected store.39 private(set) var engine: AudioCaptureEngine?40 private var sidecar: CaptureSidecar?41 private var ticker: Task<Void, Never>?42 private var observers: [NSObjectProtocol] = []43 private var activity: Activity<RecordingActivityAttributes>?44 private var liveTranscriber: LiveTranscriber?45 private var backgroundTask: UIBackgroundTaskIdentifier = .invalid46 private let settings: AppSettings47 /// Set by the app: stores the finished recording and starts post-processing.48 var onFinished: ((FinalizedRecording, CaptureSidecar) -> Void)?4950 var isActive: Bool { state != .idle }51 var activeSessionID: UUID? { sidecar?.id }5253 init(settings: AppSettings) {54 self.settings = settings55 preset = settings.defaultPreset56 RecordingIntentBridge.togglePause = { [weak self] in self?.togglePause() }57 RecordingIntentBridge.addMarker = { [weak self] in self?.addMarker() }58 installSessionObservers()59 }6061 // MARK: Control6263 func start() async {64 guard state == .idle else { return }65 lastError = nil; statusMessage = nil66 #if DEBUG67 let needsMicrophone = AudioCaptureEngine.debugInputFile == nil68 #else69 let needsMicrophone = true70 #endif71 if needsMicrophone, !(await ensureMicrophoneAccess()) { lastError = AudioSessionError.microphoneDenied.errorDescription; return }72 guard LibraryFiles.freeDiskSpace() > AudioCaptureEngine.minimumFreeBytes * 2 else {73 lastError = String(localized: "There isn't enough free storage to start a recording."); return74 }75 do {76 try AudioSessionManager.shared.activateForRecording(stereo: preset.prefersStereo, allowBluetoothMicrophone: settings.allowBluetoothMicrophone,77 rawInput: settings.rawInput, preferredInputID: settings.preferredInputID)78 let id = UUID()79 let name = title.trimmingCharacters(in: .whitespaces)80 let sidecar = CaptureSidecar(id: id, title: name.isEmpty ? Self.defaultTitle(for: preset.kind) : name, startedAt: .now, preset: preset, markers: [],81 participants: participants, localeIdentifier: settings.transcriptionLocaleIdentifier)82 let engine = try AudioCaptureEngine(url: sidecar.cafURL, preset: preset)83 engine.spectrumConfiguration.withLock { $0 = settings.spectrumConfiguration }84 engine.onFailure = { [weak self] message in Task { @MainActor in self?.statusMessage = message; await self?.stop() } }85 sidecar.save()86 try engine.start()87 self.engine = engine; self.sidecar = sidecar88 captureFormat = engine.format89 markers = []; elapsed = 0; capturedBytes = 0; liveTranscript = ""; liveTranscriptVolatile = ""; droppedSamples = 090 route = AudioSessionManager.shared.activeRoute91 state = .recording92 startTicker()93 startLiveActivity(title: sidecar.title)94 if settings.liveTranscription { await startLiveTranscription(engine: engine) }95 UIImpactFeedbackGenerator(style: .medium).impactOccurred()96 } catch {97 lastError = error.localizedDescription98 sidecar?.remove(); sidecar = nil; engine = nil99 AudioSessionManager.shared.deactivate()100 }101 }102103 func togglePause() {104 switch state {105 case .recording: pause()106 case .paused, .interrupted: resume()107 default: break108 }109 }110111 func pause() {112 guard state == .recording, let engine else { return }113 engine.pause()114 state = .paused115 updateLiveActivity()116 UIImpactFeedbackGenerator(style: .light).impactOccurred()117 }118119 func resume() {120 guard state == .paused || state == .interrupted, let engine else { return }121 do {122 try AudioSessionManager.shared.activateForRecording(stereo: preset.prefersStereo, allowBluetoothMicrophone: settings.allowBluetoothMicrophone,123 rawInput: settings.rawInput, preferredInputID: settings.preferredInputID)124 if engine.currentPhase == .recording { engine.pause() }125 try engine.resume()126 state = .recording; statusMessage = nil127 route = AudioSessionManager.shared.activeRoute128 updateLiveActivity()129 UIImpactFeedbackGenerator(style: .light).impactOccurred()130 } catch {131 statusMessage = String(localized: "Recording can't resume yet: \(error.localizedDescription)")132 }133 }134135 func addMarker(label: String? = nil) {136 guard isActive, state != .finishing, let engine else { return }137 let marker = Marker(time: engine.duration, label: label ?? String(localized: "Marker \(markers.filter { !$0.label.hasPrefix("⚠︎") }.count + 1)"))138 markers.append(marker)139 sidecar?.markers = markers; sidecar?.save()140 updateLiveActivity()141 UINotificationFeedbackGenerator().notificationOccurred(.success)142 }143144 func renameMarker(_ id: UUID, to label: String) {145 guard let i = markers.firstIndex(where: { $0.id == id }) else { return }146 markers[i].label = label147 sidecar?.markers = markers; sidecar?.save()148 }149150 func stop() async {151 guard isActive, state != .finishing, let engine, var sidecar else { return }152 state = .finishing; finishingProgress = 0153 ticker?.cancel()154 backgroundTask = UIApplication.shared.beginBackgroundTask(withName: "ORIX finalize") { [weak self] in self?.endBackgroundTask() }155 let name = title.trimmingCharacters(in: .whitespaces)156 if !name.isEmpty { sidecar.title = name }157 sidecar.participants = participants; sidecar.markers = markers; sidecar.save()158 if let liveTranscriber { _ = await liveTranscriber.stop(); self.liveTranscriber = nil; liveTranscriptionActive = false }159 await Task.detached(priority: .userInitiated) { engine.stop() }.value160 elapsed = Double(engine.framesWritten) / engine.format.sampleRate161 droppedSamples = engine.droppedSamples162 let finalSidecar = sidecar163 do {164 let result = try await Task.detached(priority: .userInitiated) { [weak self] in165 try RecordingFinalizer.finalize(finalSidecar) { p in Task { @MainActor in self?.finishingProgress = p } }166 }.value167 onFinished?(result, finalSidecar)168 UINotificationFeedbackGenerator().notificationOccurred(.success)169 } catch FinalizeError.empty {170 finalSidecar.remove()171 statusMessage = FinalizeError.empty.errorDescription172 } catch {173 // The master is still on disk and will be offered for recovery.174 lastError = error.localizedDescription175 }176 await endLiveActivity()177 self.engine = nil; self.sidecar = nil178 title = ""; participants = ""; markers = []179 state = .idle180 AudioSessionManager.shared.deactivate()181 endBackgroundTask()182 }183184 private func endBackgroundTask() {185 if backgroundTask != .invalid { UIApplication.shared.endBackgroundTask(backgroundTask); backgroundTask = .invalid }186 }187188 static func defaultTitle(for kind: RecordingKind) -> String {189 let stamp = Date.now.formatted(date: .abbreviated, time: .shortened)190 switch kind {191 case .meeting: return String(localized: "Meeting · \(stamp)")192 case .lecture: return String(localized: "Lecture · \(stamp)")193 case .interview: return String(localized: "Interview · \(stamp)")194 default: return String(localized: "Recording · \(stamp)")195 }196 }197198 private func ensureMicrophoneAccess() async -> Bool {199 switch AudioSessionManager.shared.microphonePermission {200 case .granted: true201 case .undetermined: await AudioSessionManager.shared.requestMicrophoneAccess()202 default: false203 }204 }205206 private func startTicker() {207 ticker?.cancel()208 ticker = Task { [weak self] in209 while !Task.isCancelled {210 guard let self, let engine = self.engine else { return }211 self.elapsed = engine.duration212 self.capturedBytes = Int64(CAFWriter.headerSize + engine.framesWritten * engine.format.bytesPerFrame)213 self.droppedSamples = engine.droppedSamples214 try? await Task.sleep(for: .milliseconds(100))215 }216 }217 }218219 // MARK: Interruptions and routes220221 private func installSessionObservers() {222 let center = NotificationCenter.default223 observers.append(center.addObserver(forName: AVAudioSession.interruptionNotification, object: nil, queue: .main) { [weak self] note in224 let type = (note.userInfo?[AVAudioSessionInterruptionTypeKey] as? UInt).flatMap(AVAudioSession.InterruptionType.init)225 let options = AVAudioSession.InterruptionOptions(rawValue: note.userInfo?[AVAudioSessionInterruptionOptionKey] as? UInt ?? 0)226 Task { @MainActor in self?.handleInterruption(type: type, shouldResume: options.contains(.shouldResume)) }227 })228 observers.append(center.addObserver(forName: AVAudioSession.routeChangeNotification, object: nil, queue: .main) { [weak self] _ in229 Task { @MainActor in if self?.isActive == true { self?.route = AudioSessionManager.shared.activeRoute } }230 })231 observers.append(center.addObserver(forName: AVAudioSession.mediaServicesWereResetNotification, object: nil, queue: .main) { [weak self] _ in232 Task { @MainActor in233 guard let self, self.isActive else { return }234 self.statusMessage = String(localized: "The system audio service restarted. The recording was saved up to that point.")235 await self.stop()236 }237 })238 }239240 private func handleInterruption(type: AVAudioSession.InterruptionType?, shouldResume: Bool) {241 guard let engine, state == .recording || state == .interrupted || state == .paused else { return }242 switch type {243 case .began:244 guard state == .recording else { return }245 // A phone call, alarm or another app took the microphone. Everything captured so far is already on disk.246 engine.pause()247 state = .interrupted248 markers.append(Marker(time: engine.duration, label: "⚠︎ " + String(localized: "Interrupted")))249 sidecar?.markers = markers; sidecar?.save()250 statusMessage = String(localized: "Recording was interrupted by the system. It resumes automatically when possible.")251 updateLiveActivity()252 case .ended:253 guard state == .interrupted else { return }254 if shouldResume { resume() }255 if state == .interrupted { statusMessage = String(localized: "Interrupted. Tap resume to continue recording.") }256 default: break257 }258 }259260 // MARK: Live Activity261262 private func activityState() -> RecordingActivityAttributes.ContentState {263 let status: String = switch state {264 case .paused: String(localized: "Paused")265 case .interrupted: String(localized: "Interrupted")266 case .finishing: String(localized: "Saving…")267 default: captureFormat.map { "\(Formatters.sampleRate($0.sampleRate)) · \($0.channels == 2 ? String(localized: "Stereo") : String(localized: "Mono"))" } ?? ""268 }269 return .init(isPaused: state != .recording, elapsed: engine?.duration ?? elapsed, updatedAt: .now, markerCount: markers.count, statusText: status)270 }271272 private func startLiveActivity(title: String) {273 guard ActivityAuthorizationInfo().areActivitiesEnabled else { return }274 activity = try? Activity.request(attributes: RecordingActivityAttributes(title: title), content: .init(state: activityState(), staleDate: nil))275 }276277 private func updateLiveActivity() {278 guard let activity else { return }279 let content = ActivityContent(state: activityState(), staleDate: nil)280 nonisolated(unsafe) let target = activity281 Task { await target.update(content) }282 }283284 private func endLiveActivity() async {285 guard let activity else { return }286 nonisolated(unsafe) let target = activity287 self.activity = nil288 await Task.detached { await target.end(nil, dismissalPolicy: .immediate) }.value289 }290291 /// Ends Live Activities left over from a previous process (the app was terminated while recording).292 static func endStaleActivities() {293 Task { for a in Activity<RecordingActivityAttributes>.activities { await a.end(nil, dismissalPolicy: .immediate) } }294 }295296 // MARK: Live transcription (optional, never required for capture)297298 private func startLiveTranscription(engine: AudioCaptureEngine) async {299 guard let format = AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: engine.format.sampleRate, channels: 1, interleaved: false) else { return }300 let transcriber = LiveTranscriber()301 let locale = Locale(identifier: settings.transcriptionLocaleIdentifier)302 let started = await transcriber.start(locale: locale, inputFormat: format) { [weak self] update in303 Task { @MainActor in self?.liveTranscript = update.finalized; self?.liveTranscriptVolatile = update.volatile }304 }305 guard started else { liveTranscriptionActive = false; return }306 liveTranscriber = transcriber; liveTranscriptionActive = true307 engine.onMonoChunk = { samples, _ in308 guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: AVAudioFrameCount(samples.count)) else { return }309 buffer.frameLength = AVAudioFrameCount(samples.count)310 samples.withUnsafeBufferPointer { buffer.floatChannelData![0].update(from: $0.baseAddress!, count: samples.count) }311 nonisolated(unsafe) let sendable = buffer312 Task { await transcriber.feed(sendable) }313 }314 }315}316