[#223] 웹페이지 썸네일에 대한 용량 처리를 개선한다 (#224)

* feat: 웹페이지 컨텐츠를 제거할 때, 로컬에 저장된 이미지도 제거

* feat: 재 fetch 시 기존 데이터를 덮어씌우도록 구현

* feat: 사용하지 않는 이미지 파일에 대해 백그라운드 스레드에서 제거하는 로직 구현

* fix: 웹페이지 썸네일 캐시 복구 로직 수정 및 삭제 시 캐시 정리

* refactor: 보안 상 Firestore에 저장된 로컬 URL을 바로 신뢰하지 않고 일련의 검사를 하도록 개선

Author: opficdev

DevLog/Data/Repository/WebPageRepositoryImpl.swift

@@ -6,6 +6,7 @@
 //
 
 import Foundation
+import UIKit
 
 final class WebPageRepositoryImpl: WebPageRepository {
     private let webPageService: WebPageService
@@ -25,8 +26,12 @@ final class WebPageRepositoryImpl: WebPageRepository {
         pages.reserveCapacity(responses.count)
 
         for response in responses {
-            if needsImageRestore(response), let restored = try? await restoreWebPage(response) {
-                pages.append(restored)
+            if await needsImageRestore(response) {
+                if let restored = try? await restoreWebPage(response) {
+                    pages.append(restored)
+                } else if let page = try? responseWithoutImage(response).toDomain() {
+                    pages.append(page)
+                }
                 continue
             }
             if let page = try? response.toDomain() {
@@ -50,17 +55,40 @@ final class WebPageRepositoryImpl: WebPageRepository {
 
     func delete(_ urlString: String) async throws {
         try await webPageService.deleteWebPage(urlString)
+        await metadataService.removeCachedImage(for: urlString)
     }
 }
 
 private extension WebPageRepositoryImpl {
-    func needsImageRestore(_ response: WebPageResponse) -> Bool {
+    func needsImageRestore(_ response: WebPageResponse) async -> Bool {
         guard !response.imageURL.isEmpty,
-              let url = URL(string: response.imageURL),
-              url.isFileURL else {
+              let imageURL = URL(string: response.imageURL),
+              imageURL.isFileURL else {
             return false
         }
-        return !FileManager.default.fileExists(atPath: url.path)
+
+        let expectedImageURL: URL
+        do {
+            expectedImageURL = try metadataService.cachedImageURL(for: response.url)
+        } catch {
+            return true
+        }
+
+        if imageURL.standardizedFileURL != expectedImageURL.standardizedFileURL {
+            return true
+        }
+
+        return await Task.detached(priority: .utility) {
+            guard FileManager.default.fileExists(atPath: imageURL.path) else {
+                return true
+            }
+
+            guard let imageData = try? Data(contentsOf: imageURL) else {
+                return true
+            }
+
+            return UIImage(data: imageData) == nil
+        }.value
     }
 
     func restoreWebPage(_ response: WebPageResponse) async throws -> WebPage? {
@@ -83,4 +111,14 @@ private extension WebPageRepositoryImpl {
 
         return try? newResponse.toDomain()
     }
+
+    func responseWithoutImage(_ response: WebPageResponse) -> WebPageResponse {
+        WebPageResponse(
+            id: response.id,
+            title: response.title,
+            url: response.url,
+            displayURL: response.displayURL,
+            imageURL: ""
+        )
+    }
 }

DevLog/Infra/Service/WebPageMetadataService.swift

@@ -11,6 +11,7 @@ import UIKit
 
 final class WebPageMetadataService {
     private let logger = Logger(category: "WebPageMetadataService")
+
     func fetchMetadata(from urlString: String) async throws -> WebPageMetadataResponse {
         logger.info("Fetching metadata for URL: \(urlString)")
 
@@ -38,6 +39,36 @@ final class WebPageMetadataService {
         }
     }
 
+    func removeCachedImage(for urlString: String) async {
+        guard let url = URL(string: urlString) else {
+            logger.error("Invalid URL for cached image removal: \(urlString)")
+            return
+        }
+
+        do {
+            let removed = try await Task.detached(priority: .utility) {
+                let fileURL = try Self.cacheFileURL(for: url)
+                guard FileManager.default.fileExists(atPath: fileURL.path) else { return false }
+                try FileManager.default.removeItem(at: fileURL)
+                return true
+            }.value
+
+            if removed {
+                logger.info("Removed cached image for URL: \(urlString)")
+            }
+        } catch {
+            logger.error("Failed to remove cached image", error: error)
+        }
+    }
+
+    func cachedImageURL(for urlString: String) throws -> URL {
+        guard let url = URL(string: urlString) else {
+            throw URLError(.badURL)
+        }
+
+        return try Self.cacheFileURL(for: url)
+    }
+
     private func extractImageURL(from imageProvider: NSItemProvider?, url: URL) async throws -> URL? {
         guard let imageProvider else { return nil }
 
@@ -58,13 +89,6 @@ final class WebPageMetadataService {
                     let fileURL = try Self.cacheFileURL(for: url)
                     Task.detached { [data, fileURL] in
                         do {
-                            if FileManager.default.fileExists(atPath: fileURL.path) {
-                                if let existingData = try? Data(contentsOf: fileURL),
-                                   UIImage(data: existingData) != nil {
-                                    continuation.resume(returning: fileURL)
-                                    return
-                                }
-                            }
                             try data.write(to: fileURL, options: [.atomic])
                             continuation.resume(returning: fileURL)
                         } catch {
@@ -79,6 +103,17 @@ final class WebPageMetadataService {
     }
 
     private static func cacheFileURL(for url: URL) throws -> URL {
+        let imageDir = try imageDirectoryURL()
+
+        let fileName = url.absoluteString
+            .addingPercentEncoding(withAllowedCharacters: .alphanumerics) ?? UUID().uuidString
+
+        return imageDir
+            .appendingPathComponent(fileName)
+            .appendingPathExtension("jpeg")
+    }
+
+    private static func imageDirectoryURL() throws -> URL {
         let cachesDir = try FileManager.default.url(
             for: .cachesDirectory,
             in: .userDomainMask,
@@ -90,11 +125,6 @@ final class WebPageMetadataService {
             try FileManager.default.createDirectory(at: imageDir, withIntermediateDirectories: true)
         }
 
-        let fileName = url.absoluteString
-            .addingPercentEncoding(withAllowedCharacters: .alphanumerics) ?? UUID().uuidString
-
         return imageDir
-            .appendingPathComponent(fileName)
-            .appendingPathExtension("jpeg")
     }
 }

DevLog/UI/Common/Component/WebItemRow.swift

@@ -15,11 +15,7 @@ struct WebItemRow: View {
 
     var body: some View {
         HStack {
-            CacheableImage(url: item.imageURL) {
-                Image(systemName: "globe")
-                    .resizable()
-                    .scaledToFit()
-            }
+            thumbnail
             .frame(width: sceneWidth / 10, height: sceneWidth / 10)
             .clipShape(RoundedRectangle(cornerRadius: 10))
 
@@ -41,4 +37,30 @@ struct WebItemRow: View {
         }
         .padding(.vertical, 4)
     }
+
+    @ViewBuilder
+    private var thumbnail: some View {
+        if let imageURL = item.imageURL {
+            AsyncImage(url: imageURL) { phase in
+                switch phase {
+                case .success(let image):
+                    image
+                        .resizable()
+                        .scaledToFill()
+                case .empty:
+                    ProgressView()
+                default:
+                    placeholderImage
+                }
+            }
+        } else {
+            placeholderImage
+        }
+    }
+
+    private var placeholderImage: some View {
+        Image(systemName: "globe")
+            .resizable()
+            .scaledToFit()
+    }
 }