Improved RemoteImage & image caching

Author: crontab

AsyncMuxDemo/Sources/AppError.swift

@@ -13,6 +13,7 @@ struct AppError: LocalizedError {
 
     static var notImpl: Self { .init(code: "not_implemented", message: "Not implemented yet") }
     static var unknown: Self { .init(code: "unknown_error", message: "Unknown error") }
+    static var cachedFileDamaged: Self { .init(code: "cached_file_damaged", message: "Internal: damaged cached file") }
 
     var errorDescription: String? {
         message ?? "Application error: \(code)"

AsyncMuxDemo/Sources/RemoteImage/ImageCache.swift

@@ -4,7 +4,8 @@
 //  Created by Hovik Melikyan on 28.06.24.
 //
 
-import SwiftUI
+import Foundation
+import UIKit.UIImage
 import AsyncMux
 
 
@@ -13,17 +14,17 @@ private let CacheCapacity = 20
 
 final class ImageCache {
 
-    static func request(_ url: URL) async throws -> Image {
+    static func request(_ url: URL) async throws -> UIImage {
         if let image = loadFromMemory(url) {
             return image
         }
-        let image = try await Self.requestRemote(url)
+        let image = try await requestRemote(url)
         storeToMemory(url: url, image: image)
         return image
     }
 
 
-    static func loadFromMemory(_ url: URL) -> Image? {
+    static func loadFromMemory(_ url: URL) -> UIImage? {
         semaphore.wait()
         defer { semaphore.signal() }
         return memCache.touch(key: url)
@@ -39,26 +40,26 @@ final class ImageCache {
 
     // MARK: - Private part
 
-    private static func storeToMemory(url: URL, image: Image) {
+    private static func storeToMemory(url: URL, image: UIImage) {
         semaphore.wait()
         defer { semaphore.signal() }
         memCache.set(image, forKey: url)
     }
 
 
     @AsyncMediaActor
-    private static func requestRemote(_ url: URL) async throws -> Image {
+    private static func requestRemote(_ url: URL) async throws -> UIImage {
         let localURL = try await AsyncMedia.request(url: url)
-        guard let uiImage = UIImage(contentsOfFile: localURL.path) else {
-            try? FileManager.default.removeItem(at: localURL) // reove the damaged file
-            throw AppError(code: "cached_file_damaged", message: "Internal: cached file damaged")
+        guard let image = UIImage(contentsOfFile: localURL.path) else {
+            try? FileManager.default.removeItem(at: localURL) // remove the damaged file
+            throw AppError.cachedFileDamaged
         }
-        return Image(uiImage: uiImage)
+        return image
     }
 
 
     nonisolated(unsafe)
-    private static var memCache = LRUCache<URL, Image>(capacity: CacheCapacity)
+    private static var memCache = LRUCache<URL, UIImage>(capacity: CacheCapacity)
 
     private static let semaphore = DispatchSemaphore(value: 1)
 }

AsyncMuxDemo/Sources/RemoteImage/RemoteImage.swift

@@ -5,51 +5,35 @@
 //
 
 import SwiftUI
-import AsyncMux
 
 
 struct RemoteImage<P: View, I: View>: View {
+    let url: URL?
+    @ViewBuilder let content: (Image) -> I
+    @ViewBuilder let placeholder: (Error?) -> P
 
-    init(url: URL?, @ViewBuilder content: @escaping (Image) -> I, @ViewBuilder placeholder: @escaping (Error?) -> P) {
-        self.model = url.map { Model(url: $0) }
-        self.content = content
-        self.placeholder = placeholder
-    }
-
-    private let model: Model?
-    @ViewBuilder private let content: (Image) -> I
-    @ViewBuilder private let placeholder: (Error?) -> P
+    @State private var uiImage: UIImage?
+    @State private var error: Error?
 
     var body: some View {
-        if let image = model?.image {
+        if let image = uiImage.map({ Image(uiImage: $0) }) {
             content(image)
         }
-        else if let error = model?.error {
+        else if let error {
             placeholder(error)
         }
         else {
             placeholder(nil)
-        }
-    }
-
-
-    @MainActor
-    @Observable final class Model {
-        var image: Image?
-        var error: Error?
-
-        init(url: URL) {
-            image = ImageCache.loadFromMemory(url)
-            if image == nil {
-                Task {
-                    do {
-                        self.image = try await ImageCache.request(url)
-                    }
-                    catch {
-                        self.error = error
+                .task {
+                    if let url {
+                        do {
+                            self.uiImage = try await ImageCache.request(url)
+                        }
+                        catch {
+                            self.error = error
+                        }
                     }
                 }
-            }
         }
     }
 }