iOS Clean Architecture SwiftUI · TCA · async/await · SwiftData

actor NetworkClient {
    private let session:  URLSession
    private let crypto:   CryptoService
    private let keychain: KeychainService
    private let baseURL:  URL

    func request<T: Decodable>(
        _ endpoint: Endpoint
    ) async throws -> T {
        var req = endpoint.urlRequest(baseURL: baseURL)

        // Attach Bearer token
        if let token = try? keychain.getAccessToken() {
            req.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
        }

        // Encrypt request body (AES-256-GCM)
        if let body = req.httpBody {
            let encrypted = try crypto.encrypt(body)
            req.httpBody   = encrypted.ciphertext
            req.setValue(encrypted.ivBase64, forHTTPHeaderField: "X-IV")
        }

        let (data, response) = try await session.data(for: req)

        guard let http = response as? HTTPURLResponse else {
            throw AppError.unknown
        }

        switch http.statusCode {
        case 200...299:
            let decrypted = try crypto.decrypt(
                data,
                ivBase64: http.value(forHTTPHeaderField: "X-IV") ?? ""
            )
            return try JSONDecoder().decode(T.self, from: decrypted)
        case 401:  throw AppError.unauthorized
        default:   throw AppError.serverError(statusCode: http.statusCode, message: "")
        }
    }
}

struct Endpoint {
    let path:    String
    let method:  HTTPMethod
    let body:    (any Encodable)?
    let headers: [String: String]

    static func get(_ path: String) -> Endpoint {
        Endpoint(path: path, method: .get, body: nil, headers: [:])
    }
    static func post<B: Encodable>(_ path: String, body: B) -> Endpoint {
        Endpoint(path: path, method: .post, body: body, headers: [:])
    }
}

// Cancellable request — Task-based
class ProductsViewModel {
    private var searchTask: Task<Void, Never>?

    func search(_ query: String) {
        searchTask?.cancel()     // cancel previous in-flight
        searchTask = Task {
            do {
                try Task.checkCancellation()
                let results: [Product] = try await networkClient.request(
                    .get("/products?q=\(query)")
                )
                // Only update UI if not cancelled
                guard !Task.isCancelled else { return }
                await MainActor.run { self.products = results }
            } catch is CancellationError {
                // Expected — swallow silently
            } catch { handleError(error) }
        }
    }

    deinit { searchTask?.cancel() }
}

import Speech
import AVFoundation

@Observable
@MainActor
final class SpeechToTextService: NSObject {
    private let recognizer    = SFSpeechRecognizer(locale: .current)
    private let audioEngine   = AVAudioEngine()
    private var request:        SFSpeechAudioBufferRecognitionRequest?
    private var recognitionTask: SFSpeechRecognitionTask?

    var transcript = ""
    var isListening = false

    func requestPermission() async -> Bool {
        await withCheckedContinuation { cont in
            SFSpeechRecognizer.requestAuthorization { status in
                cont.resume(returning: status == .authorized)
            }
        }
    }

    func startListening() throws {
        stopListening()
        let session = AVAudioSession.sharedInstance()
        try session.setCategory(.record, mode: .measurement, options: .duckOthers)
        try session.setActive(true, options: .notifyOthersOnDeactivation)

        request = SFSpeechAudioBufferRecognitionRequest()
        request?.shouldReportPartialResults = true

        let inputNode = audioEngine.inputNode
        request!.addAudioPCMBuffer // installed below

        recognitionTask = recognizer?.recognitionTask(with: request!) { [weak self] result, err in
            if let result { self?.transcript = result.bestTranscription.formattedString }
        }

        let fmt = inputNode.outputFormat(forBus: 0)
        inputNode.installTap(onBus: 0, bufferSize: 1024, format: fmt) { [weak self] buf, _ in
            self?.request?.append(buf)
        }
        try audioEngine.start()
        isListening = true
    }

    func stopListening() {
        audioEngine.stop()
        audioEngine.inputNode.removeTap(onBus: 0)
        recognitionTask?.cancel()
        isListening = false
    }
}

import AVFoundation

@Observable
final class TextToSpeechService: NSObject, AVSpeechSynthesizerDelegate {
    private let synthesizer = AVSpeechSynthesizer()
    var isSpeaking = false

    override init() {
        super.init()
        synthesizer.delegate = self
    }

    func speak(
        _ text: String,
        rate:   Float = AVSpeechUtteranceDefaultSpeechRate,
        voice:  AVSpeechSynthesisVoice? = .init(language: "en-US")
    ) {
        stop()
        let utterance     = AVSpeechUtterance(string: text)
        utterance.rate    = rate
        utterance.voice   = voice
        utterance.pitchMultiplier = 1.0
        synthesizer.speak(utterance)
    }

    func stop() {
        synthesizer.stopSpeaking(at: .immediate)
    }

    // AVSpeechSynthesizerDelegate
    func speechSynthesizer(_ s: AVSpeechSynthesizer,
                            didStart u: AVSpeechUtterance) {
        isSpeaking = true
    }
    func speechSynthesizer(_ s: AVSpeechSynthesizer,
                            didFinish u: AVSpeechUtterance) {
        isSpeaking = false
    }
}

import Network
import Foundation

@Observable
@MainActor
final class WebSocketService {
    private var connection: NWConnection?
    private var retryCount  = 0
    private let maxRetries  = 5

    var messages: [ChatMessage] = []
    var isConnected = false

    func connect(url: URL, token: String) {
        let params   = NWParameters.tls
        let wsOpts   = NWProtocolWebSocket.Options()
        wsOpts.setAdditionalHeaders([("Authorization", "Bearer \(token)")])
        params.defaultProtocolStack.applicationProtocols.insert(
            NWProtocolWebSocket.Options(), at: 0
        )

        connection = NWConnection(
            to: .url(url), using: params
        )
        connection?.stateUpdateHandler = { [weak self] state in
            switch state {
            case .ready:
                self?.isConnected = true
                self?.retryCount  = 0
                self?.receiveLoop()
            case .failed, .cancelled:
                self?.isConnected = false
                self?.scheduleReconnect(url: url, token: token)
            default: break
            }
        }
        connection?.start(queue: .main)
    }

    func send(_ message: ChatMessage) {
        guard let data = try? JSONEncoder().encode(message) else { return }
        let metadata = NWProtocolWebSocket.Metadata(opcode: .text)
        let ctx      = NWConnection.ContentContext(identifier: "msg", metadata: [metadata])
        connection?.send(content: data, contentContext: ctx, completion: .idempotent)
    }

    private func receiveLoop() {
        connection?.receiveMessage { [weak self] data, ctx, _, err in
            if let data, let msg = try? JSONDecoder().decode(ChatMessage.self, from: data) {
                self?.messages.append(msg)
            }
            self?.receiveLoop()   // recursive receive
        }
    }

    private func scheduleReconnect(url: URL, token: String) {
        guard retryCount < maxRetries else { return }
        let delay = TimeInterval(pow(2.0, Double(retryCount)))
        retryCount += 1
        Task { try? await Task.sleep(for: .seconds(delay)); connect(url: url, token: token) }
    }
}