Image Caching en SwiftUI

AsyncImage(url: URL(string: "https://ejemplo.com/imagen.jpg")) { image in
    image.resizable()
} placeholder: {
    ProgressView()
}

import SwiftUI

#if os(macOS)
import AppKit
public typealias PlatformImage = NSImage
#else
import UIKit
public typealias PlatformImage = UIImage
#endif

// Extensión para convertir fácilmente PlatformImage a una View de SwiftUI
extension Image {
    init(platformImage: PlatformImage) {
        #if os(macOS)
        self.init(nsImage: platformImage)
        #else
        self.init(uiImage: platformImage)
        #endif
    }
}

import Foundation

final class ImageCacheManager {
    // Singleton para acceso global
    static let shared = ImageCacheManager()
    
    // Nuestro NSCache. Usamos NSString como clave (la URL) y PlatformImage como valor
    private let memoryCache: NSCache<NSString, PlatformImage>
    
    private init() {
        memoryCache = NSCache<NSString, PlatformImage>()
        // Opcional: Configurar límites para no consumir demasiada RAM
        memoryCache.countLimit = 100 // Máximo 100 imágenes en memoria
        memoryCache.totalCostLimit = 1024 * 1024 * 100 // Límite de ~100 MB
    }
    
    func set(_ image: PlatformImage, forKey key: String) {
        let nsKey = NSString(string: key)
        memoryCache.setObject(image, forKey: nsKey)
    }
    
    func get(forKey key: String) -> PlatformImage? {
        let nsKey = NSString(string: key)
        return memoryCache.object(forKey: nsKey)
    }
}

import Foundation
import Combine

@MainActor // Asegura que los cambios de estado se publiquen en el hilo principal para SwiftUI
class ImageLoader: ObservableObject {
    @Published var image: PlatformImage?
    @Published var isLoading = false
    @Published var error: Error?
    
    private let cache = ImageCacheManager.shared
    
    func load(from urlString: String) async {
        guard let url = URL(string: urlString) else { return }
        
        // 1. Comprobar la caché en memoria primero
        if let cachedImage = cache.get(forKey: urlString) {
            self.image = cachedImage
            return
        }
        
        // 2. Si no está en caché, la descargamos
        isLoading = true
        
        do {
            let (data, response) = try await URLSession.shared.data(from: url)
            
            // Validar la respuesta HTTP
            guard let httpResponse = response as? HTTPURLResponse, 
                  (200...299).contains(httpResponse.statusCode) else {
                throw URLError(.badServerResponse)
            }
            
            // 3. Crear la imagen y guardarla en caché
            if let downloadedImage = PlatformImage(data: data) {
                self.cache.set(downloadedImage, forKey: urlString)
                self.image = downloadedImage
            }
            
        } catch {
            self.error = error
            print("Error descargando la imagen: \(error.localizedDescription)")
        }
        
        isLoading = false
    }
}

import SwiftUI

struct CachedAsyncImage<Content: View, Placeholder: View>: View {
    private let url: String
    private let content: (Image) -> Content
    private let placeholder: () -> Placeholder
    
    @StateObject private var loader = ImageLoader()
    
    // Inicializador que acepta closures para personalizar cómo se ve la imagen y el placeholder
    init(
        url: String,
        @ViewBuilder content: @escaping (Image) -> Content,
        @ViewBuilder placeholder: @escaping () -> Placeholder
    ) {
        self.url = url
        self.content = content
        self.placeholder = placeholder
    }
    
    var body: some View {
        ZStack {
            if let platformImage = loader.image {
                // Usamos nuestra extensión para convertir la PlatformImage a SwiftUI.Image
                content(Image(platformImage: platformImage))
            } else if loader.error != nil {
                // Manejo visual de errores
                Image(systemName: "photo.badge.exclamationmark")
                    .foregroundColor(.red)
            } else {
                placeholder()
            }
        }
        // Usamos .task, que soporta async/await nativamente y se cancela si la vista desaparece
        .task {
            await loader.load(from: url)
        }
    }
}

struct ContentView: View {
    let imageUrls = [
        "https://ejemplo.com/foto1.jpg",
        "https://ejemplo.com/foto2.jpg"
    ]
    
    var body: some View {
        ScrollView {
            VStack {
                ForEach(imageUrls, id: \.self) { urlString in
                    CachedAsyncImage(url: urlString) { image in
                        image
                            .resizable()
                            .scaledToFill()
                            .frame(height: 200)
                            .clipShape(RoundedRectangle(cornerRadius: 15))
                    } placeholder: {
                        ProgressView()
                            .frame(height: 200)
                            .frame(maxWidth: .infinity)
                            .background(Color.gray.opacity(0.2))
                            .clipShape(RoundedRectangle(cornerRadius: 15))
                    }
                    .padding(.horizontal)
                }
            }
        }
        .navigationTitle("Image Caching en SwiftUI")
    }
}

import Foundation

final class ImageCacheManager {
    static let shared = ImageCacheManager()
    private let memoryCache: NSCache<NSString, PlatformImage>
    private let fileManager = FileManager.default
    
    // Directorio donde guardaremos las imágenes en disco
    private var cacheDirectory: URL? {
        fileManager.urls(for: .cachesDirectory, in: .userDomainMask).first
    }
    
    private init() {
        memoryCache = NSCache<NSString, PlatformImage>()
        memoryCache.countLimit = 100
    }
    
    // Función de ayuda para crear un nombre de archivo seguro desde una URL
    private func getFilePath(forKey key: String) -> URL? {
        guard let folder = cacheDirectory, let url = URL(string: key) else { return nil }
        let fileName = url.lastPathComponent // Ej: "foto1.jpg"
        // En una app real, es mejor usar un hash (MD5 o SHA256) del string para evitar colisiones de nombres
        return folder.appendingPathComponent(fileName)
    }
    
    func set(_ image: PlatformImage, forKey key: String) {
        // 1. Guardar en Memoria
        let nsKey = NSString(string: key)
        memoryCache.setObject(image, forKey: nsKey)
        
        // 2. Guardar en Disco de forma asíncrona para no bloquear el hilo principal
        Task.detached(priority: .background) { [weak self] in
            guard let self = self, let fileURL = self?.getFilePath(forKey: key) else { return }
            
            #if os(macOS)
            guard let cgImage = image.cgImage(forProposedRect: nil, context: nil, hints: nil) else { return }
            let bitmapRep = NSBitmapImageRep(cgImage: cgImage)
            let data = bitmapRep.representation(using: .jpeg, properties: [:])
            #else
            let data = image.jpegData(compressionQuality: 0.8)
            #endif
            
            try? data?.write(to: fileURL)
        }
    }
    
    func get(forKey key: String) -> PlatformImage? {
        // 1. Buscar en Memoria primero (es más rápido)
        let nsKey = NSString(string: key)
        if let memoryImage = memoryCache.object(forKey: nsKey) {
            return memoryImage
        }
        
        // 2. Si no está en memoria, buscar en Disco
        if let fileURL = getFilePath(forKey: key),
           let data = try? Data(contentsOf: fileURL),
           let diskImage = PlatformImage(data: data) {
            
            // Si la encontramos en disco, la volvemos a subir a la memoria para futuros accesos rápidos
            memoryCache.setObject(diskImage, forKey: nsKey)
            return diskImage
        }
        
        return nil // No está ni en memoria ni en disco
    }
}