refactor: WebPageImageStore 파일 I/O를 백그라운드 실행으로 분리

Author: opficdev

DevLog/Storage/Persistence/WebPageImageStore.swift

@@ -9,56 +9,90 @@ import CryptoKit
 import Foundation
 
 actor WebPageImageStore {
-    private let fileManager: FileManager
+    func cachedImageURL(for url: URL) async throws -> URL {
+        return try await Task.detached(priority: .utility) {
+            return try Self.cachedImageURL(for: url)
+        }.value
+    }
+
+    func saveImage(_ data: Data, for url: URL) async throws -> URL {
+        return try await Task.detached(priority: .utility) {
+            return try Self.saveImage(data, for: url)
+        }.value
+    }
+
+    func dirSizeInBytes() async -> Int64 {
+        do {
+            return try await Task.detached(priority: .utility) {
+                return try Self.dirSizeInBytes()
+            }.value
+        } catch {
+            return 0
+        }
+    }
+
+    func clearDirectory() async throws {
+        try await Task.detached(priority: .utility) {
+            try Self.clearDirectory()
+        }.value
+    }
 
-    init(fileManager: FileManager = .default) {
-        self.fileManager = fileManager
+    func removeImage(for url: URL) async throws -> Bool {
+        return try await Task.detached(priority: .utility) {
+            return try Self.removeImage(for: url)
+        }.value
     }
+}
 
-    func cachedImageURL(for url: URL) throws -> URL {
-        let imageDirectoryURL = try self.imageDirectoryURL(create: true)
+private extension WebPageImageStore {
+    static func hashedFileName(for url: URL) -> String {
+        let hashValue = SHA256.hash(data: Data(url.absoluteString.utf8))
+        return hashValue.map { String(format: "%02x", $0) }.joined()
+    }
+
+    static func cachedImageURL(for url: URL) throws -> URL {
+        let fileManager = FileManager.default
+        let imageDirectoryURL = try imageDirectoryURL(create: true, fileManager: fileManager)
         let fileName = hashedFileName(for: url)
 
         return imageDirectoryURL
             .appendingPathComponent(fileName)
             .appendingPathExtension("jpeg")
     }
 
-    func saveImage(_ data: Data, for url: URL) throws -> URL {
+    static func saveImage(_ data: Data, for url: URL) throws -> URL {
         let fileURL = try cachedImageURL(for: url)
         try data.write(to: fileURL, options: [.atomic])
         return fileURL
     }
 
-    func dirSizeInBytes() -> Int64 {
-        do {
-            let imageDirectoryURL = try self.imageDirectoryURL(create: false)
-            guard fileManager.fileExists(atPath: imageDirectoryURL.path) else { return 0 }
-            guard let enumerator = fileManager.enumerator(
-                at: imageDirectoryURL,
-                includingPropertiesForKeys: [.isRegularFileKey, .fileSizeKey],
-                options: [.skipsHiddenFiles]
-            ) else {
-                return 0
-            }
+    static func dirSizeInBytes() throws -> Int64 {
+        let fileManager = FileManager.default
+        let imageDirectoryURL = try imageDirectoryURL(create: false, fileManager: fileManager)
+        guard fileManager.fileExists(atPath: imageDirectoryURL.path) else { return 0 }
+        guard let enumerator = fileManager.enumerator(
+            at: imageDirectoryURL,
+            includingPropertiesForKeys: [.isRegularFileKey, .fileSizeKey],
+            options: [.skipsHiddenFiles]
+        ) else {
+            return 0
+        }
 
-            var total: Int64 = 0
-            for case let fileURL as URL in enumerator {
-                guard let resourceValues = try? fileURL.resourceValues(forKeys: [.isRegularFileKey, .fileSizeKey]),
-                      resourceValues.isRegularFile == true,
-                      let fileSize = resourceValues.fileSize else {
-                    continue
-                }
-                total += Int64(fileSize)
+        var total: Int64 = 0
+        for case let fileURL as URL in enumerator {
+            guard let resourceValues = try? fileURL.resourceValues(forKeys: [.isRegularFileKey, .fileSizeKey]),
+                  resourceValues.isRegularFile == true,
+                  let fileSize = resourceValues.fileSize else {
+                continue
             }
-            return total
-        } catch {
-            return 0
+            total += Int64(fileSize)
         }
+        return total
     }
 
-    func clearDirectory() throws {
-        let imageDirectoryURL = try self.imageDirectoryURL(create: false)
+    static func clearDirectory() throws {
+        let fileManager = FileManager.default
+        let imageDirectoryURL = try imageDirectoryURL(create: false, fileManager: fileManager)
         guard fileManager.fileExists(atPath: imageDirectoryURL.path) else { return }
         let contentURLs = try fileManager.contentsOfDirectory(
             at: imageDirectoryURL,
@@ -70,21 +104,15 @@ actor WebPageImageStore {
         }
     }
 
-    func removeImage(for url: URL) throws -> Bool {
+    static func removeImage(for url: URL) throws -> Bool {
+        let fileManager = FileManager.default
         let fileURL = try cachedImageURL(for: url)
         guard fileManager.fileExists(atPath: fileURL.path) else { return false }
         try fileManager.removeItem(at: fileURL)
         return true
     }
-}
-
-private extension WebPageImageStore {
-    func hashedFileName(for url: URL) -> String {
-        let hashValue = SHA256.hash(data: Data(url.absoluteString.utf8))
-        return hashValue.map { String(format: "%02x", $0) }.joined()
-    }
 
-    func imageDirectoryURL(create: Bool) throws -> URL {
+    static func imageDirectoryURL(create: Bool, fileManager: FileManager) throws -> URL {
         let directory = try fileManager.url(
             for: .applicationSupportDirectory,
             in: .userDomainMask,