SPB Git

Repository Public License

RecorderController.swift 15.1 KB 316 lines swift

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
Files main
Menu

Theme