Reorganized the Recording package target into folders.

2026-07-04 00:07:42 +02:00
parent fe08548b08
commit aa9ec01611
19 changed files with 103 additions and 112 deletions
@@ -0,0 +1,264 @@
+import Observation
+import SwiftUI
+
+extension RecordingView {
+
+    /// The observable model that drives ``RecordingView``.
+    ///
+    /// The model implements the recording flow as a ``State`` machine: it exposes the visibility and icon of the view's controls for the current state, counts the
+    /// elapsed recording time, and processes the recorded input once it is sent. The audio capture and its transcription are delegated to the
+    /// ``RecordingService`` and ``TranscribingService`` attached at initialization; when either of them fails, the model falls back to the not-recording state.
+    @MainActor
+    @Observable
+    final class Model {
+
+        // MARK: Properties
+
+        /// The current state of the recording flow.
+        var state: State = .notRecording
+
+        /// The number of seconds spent recording, excluding any time spent paused.
+        private(set) var elapsedSeconds: Int = 0
+        
+        /// The transcription of the last processed recording, or `nil` when none has been processed yet.
+        private(set) var textTranscription: String?
+
+        /// The service that captures the audio from a microphone.
+        @ObservationIgnored
+        private let recorder: any RecordingService
+
+        /// The task that increments ``elapsedSeconds`` every second while recording.
+        @ObservationIgnored
+        private var taskTimer: Task<Void, Never>?
+
+        /// The service that transcribes the recorded audio into text.
+        @ObservationIgnored
+        private let transcriber: any TranscribingService
+
+        // MARK: Initializers
+
+        /// Creates a model attached to the given recording and transcribing services.
+        ///
+        /// - Parameters:
+        ///   - recorder: The service that captures the audio from a microphone. Defaults to ``DummyRecordingService``.
+        ///   - transcriber: The service that transcribes the recorded audio into text. Defaults to ``DummyTranscribingService``.
+        init(
+            recorder: any RecordingService = DummyRecordingService(),
+            transcriber: any TranscribingService = DummyTranscribingService()
+        ) {
+            self.recorder = recorder
+            self.transcriber = transcriber
+        }
+
+        // MARK: Computed
+
+        /// The image resource for the main button: a pause icon while recording, a record icon otherwise.
+        var iconMain: ImageResource {
+            switch state {
+            case .notRecording, .paused, .processing: .Icon.record
+            case .recording: .Icon.pause
+            }
+        }
+
+        /// The image resource for the send button while paused, or `nil` when the button should show a progress indicator instead.
+        var iconSend: ImageResource? {
+            switch state {
+            case .paused: .Icon.send
+            default: nil
+            }
+        }
+
+        /// Whether the recorded input is currently being processed.
+        var isProcessing: Bool {
+            state == .processing
+        }
+
+        /// Whether the main button should be disabled.
+        var shouldDisableMain: Bool {
+            state == .processing
+        }
+
+        /// Whether the send button should be visible.
+        var shouldShowSend: Bool {
+            state != .notRecording
+                && state != .recording
+        }
+
+        /// Whether the timer label should be visible.
+        var shouldShowTimer: Bool {
+            state != .notRecording
+        }
+
+        /// The elapsed recording time, formatted as `mm:ss` for the timer label.
+        var textTimer: String {
+            Duration
+                .seconds(elapsedSeconds)
+                .formatted(.time(pattern: .minuteSecond(padMinuteToLength: 2)))
+        }
+
+        // MARK: Methods
+
+        /// Handles a press of the main button.
+        ///
+        /// Starts a recording when idle, pauses an ongoing recording, or resumes
+        /// a paused one. Does nothing while the input is being processed.
+        func pressedMain() {
+            guard state != .processing else {
+                return
+            }
+
+            switch state {
+            case .notRecording:
+                state = .recording
+            case .recording:
+                state = .paused
+            case .paused:
+                state = .recording
+            case .processing:
+                break
+            }
+        }
+
+        /// Handles a press of the send button.
+        ///
+        /// Moves a paused recording into processing. Does nothing in any other state.
+        func pressedSend() {
+            guard state == .paused else {
+                return
+            }
+
+            switch state {
+            case .paused:
+                state = .processing
+            default:
+                break
+            }
+        }
+
+        /// Reacts to a change of ``state``, expected to be called from the view whenever it observes one.
+        ///
+        /// Starts the timer and the audio capture when a recording begins or resumes, stops the timer in every other state — pausing the capture
+        /// while paused — and kicks off ``processInput()`` when the input is sent.
+        ///
+        /// - Parameter shouldRestartTimer: Whether ``elapsedSeconds`` should be reset to zero before the timer starts, which is the case for
+        /// a new recording as opposed to one resuming from a pause.
+        func updatedState(
+            shouldRestartTimer: Bool
+        ) {
+            switch state {
+            case .recording:
+                startTimer(shouldRestartTimer)
+                startRecorder(shouldRestartTimer)
+            case .paused:
+                stopTimer()
+
+                Task {
+                    try? await recorder.pause()
+                }
+            case .processing:
+                stopTimer()
+
+                Task {
+                    await processInput()
+                }
+            case .notRecording:
+                stopTimer()
+            }
+        }
+
+    }
+}
+
+// MARK: - Helpers
+
+private extension RecordingView.Model {
+
+    // MARK: Methods
+
+    /// Processes the recorded input: it stops the audio capture, transcribes the captured audio, and publishes the result in ``textTranscription``;
+    /// when finished — or when either service fails — it resets ``elapsedSeconds`` and returns the model to the not-recording state.
+    func processInput() async {
+        guard state == .processing else {
+            return
+        }
+
+        do {
+            let audio = try await recorder.stop()
+
+            textTranscription = try await transcriber.transcribe(audio)
+        } catch {
+            textTranscription = nil
+        }
+
+        elapsedSeconds = 0
+        state = .notRecording
+    }
+
+    /// Starts the audio capture through the attached ``RecordingService``, falling back to the not-recording state when the service fails.
+    ///
+    /// - Parameter isNewRecording: Whether a new recording should be started, as opposed to a paused one being resumed.
+    func startRecorder(
+        _ isNewRecording: Bool
+    ) {
+        Task {
+            do {
+                isNewRecording
+                    ? try await recorder.start()
+                    : try await recorder.resume()
+            } catch {
+                stopTimer()
+
+                state = .notRecording
+            }
+        }
+    }
+
+    /// Starts the timer task, which increments ``elapsedSeconds`` once per second until it is cancelled. Any previously running timer task is cancelled first.
+    ///
+    /// - Parameter shouldRestartTimer: Whether ``elapsedSeconds`` and ``textTranscription`` should be cleared before the timer starts,
+    /// which is the case for a new recording as opposed to one resuming from a pause.
+    func startTimer(
+        _ shouldRestartTimer: Bool
+    ) {
+        if shouldRestartTimer {
+            elapsedSeconds = 0
+            textTranscription = nil
+        }
+
+        taskTimer?.cancel()
+        taskTimer = Task { [weak self] in
+            while !Task.isCancelled {
+                try? await Task.sleep(for: .seconds(1))
+
+                guard let self, !Task.isCancelled else {
+                    return
+                }
+
+                self.elapsedSeconds += 1
+            }
+        }
+    }
+
+    /// Stops the timer task, if any, keeping ``elapsedSeconds`` at its current value.
+    func stopTimer() {
+        taskTimer?.cancel()
+        taskTimer = nil
+    }
+
+}
+
+// MARK: - States
+
+extension RecordingView.Model {
+    /// The states of the recording flow.
+    enum State {
+        /// No recording is in progress.
+        case notRecording
+        /// A recording is in progress and the timer is running.
+        case recording
+        /// The recording is paused, and can be either resumed or sent.
+        case paused
+        /// The recorded input is being processed.
+        case processing
+    }
+}