applogical-startup-x

importSwiftUIimportUIKitimportImageIOimportCryptoKitimportCombineimportos.log// MARK: - CORE PIPELINE// --------------------------------------------------------// Zentraler Actor für Ressourcen-Orchestrierung.// Vermeidet Race Conditions durch strikte Isolation.fileprivate let logger = Logger(subsystem: "com.core.pipeline", category: "IO") actorAsyncImagePipeline { static let shared = AsyncImagePipeline() // MARK: L1 Cache (RAM)// NSCache leert sich automatisch bei Memory Pressure Events vom OS.// Speichert fertig dekomprimierte UIImages.private let memoryCache: NSCache<NSString, UIImage> = { let cache = NSCache<NSString, UIImage>() cache.countLimit = 300 cache.totalCostLimit = 1024 * 1024 * 200// 200 MB Hard Limitreturn cache }() // MARK: L2 Cache (Disk)private let fileManager = FileManager.default private let cacheDirectory: URL// Serial Queue für Disk-Writes verhindert Blocking des Main Threads.private let ioQueue = DispatchQueue(label: "com.core.io", qos: .utility) // MARK: Request Deduplication// Verhindert redundante Netzwerk-Requests für dieselbe Ressource (Thundering Herd).private var activeTasks: [String: Task<UIImage, Error>] = [:] private var cancelBag = Set<AnyCancellable>() private init() { let paths = fileManager.urls(for: .cachesDirectory, in: .userDomainMask) cacheDirectory = paths[0].appendingPathComponent("PipelineCache_v1") if !fileManager.fileExists(atPath: cacheDirectory.path) { try? fileManager.createDirectory(at: cacheDirectory, withIntermediateDirectories: true) } NotificationCenter.default.publisher(for: UIApplication.didReceiveMemoryWarningNotification) .sink { [weakself] _ inTask { await self?.purgeCache() } } .store(in: &cancelBag) } // MARK: - API/// Synchroner Lookup für UI-Binding (kein await).nonisolated funccachedImage(for url: URL, size: CGSize, scale: CGFloat) ->UIImage? { let key = cacheKey(for: url, size: quantized(size), scale: scale) return memoryCache.object(forKey: key asNSString) } /// Core Load Logic: RAM -> Active Task -> Disk -> Network.funcimage(for url: URL, size: CGSize, scale: CGFloat) async throws ->UIImage { let qSize = quantized(size) let key = cacheKey(for: url, size: qSize, scale: scale) let fileURL = diskFileURL(for: url) // 1. Fast Pathif let memoryImage = memoryCache.object(forKey: key asNSString) { return memoryImage } // 2. Deduplicationif let existingTask = activeTasks[key] { return try await existingTask.value } // 3. Executionlet task = Task<UIImage, Error> { // A. Disk Readif fileManager.fileExists(atPath: fileURL.path) { return try awaitImageProcessor.downsample(source: .disk(fileURL), to: qSize, scale: scale) } // B. Network IOvar request = URLRequest(url: url, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 30) request.httpShouldUsePipelining = truelet (data, response) = try awaitURLSession.shared.data(for: request) guard let http = response as?HTTPURLResponse, 200...299 ~= http.statusCode else { throwURLError(.badServerResponse) } // C. Async Disk Commit ioQueue.async { try? data.write(to: fileURL, options: .atomic) } // D. Decoding & Resizereturn try awaitImageProcessor.downsample(source: .memory(data), to: qSize, scale: scale) } activeTasks[key] = task do { let image = try await task.value memoryCache.setObject(image, forKey: key asNSString, cost: image.memoryCost) activeTasks[key] = nilreturn image } catch { activeTasks[key] = nilthrow error } } funcpurgeCache() { logger.warning("Memory Warning - Purging L1 Cache") memoryCache.removeAllObjects() } } // MARK: - OFF-MAIN THREAD PROCESSINGstructImageProcessor { static funcdownsample(source: ImageSource, to size: CGSize, scale: CGFloat) async throws ->UIImage { // Detached Task verhindert Main Thread Blocking während der ImageIO Operation.return try awaitTask.detached(priority: .userInitiated) { let options = [kCGImageSourceShouldCache: false] asCFDictionary// ... (ImageIO Implementation) ...guard let cgImage = CGImageSourceCreateThumbnailAtIndex(src, 0, downsampleOptions) else { throwURLError(.cannotDecodeRawData) } returnUIImage(cgImage: cgImage) }.value } }