Feature Branch 25.7

Modules/Package.swift

@@ -8,18 +8,18 @@ let package = Package(
         .iOS(.v16),
     ],
     products: XcodeSupport.products + [
-        .library(name: "JetpackStatsWidgetsCore", targets: ["JetpackStatsWidgetsCore"]),
+        .library(name: "AsyncImageKit", targets: ["AsyncImageKit"]),
         .library(name: "DesignSystem", targets: ["DesignSystem"]),
+        .library(name: "JetpackStatsWidgetsCore", targets: ["JetpackStatsWidgetsCore"]),
         .library(name: "WordPressFlux", targets: ["WordPressFlux"]),
-        .library(name: "WordPressMedia", targets: ["WordPressMedia"]),
         .library(name: "WordPressShared", targets: ["WordPressShared"]),
         .library(name: "WordPressUI", targets: ["WordPressUI"]),
     ],
     dependencies: [
         .package(url: "https://github.com/airbnb/lottie-ios", from: "4.4.0"),
         .package(url: "https://github.com/Alamofire/Alamofire", from: "5.9.1"),
-        .package(url: "https://github.com/Alamofire/AlamofireImage", from: "4.3.0"),
         .package(url: "https://github.com/AliSoftware/OHHTTPStubs", from: "9.1.0"),
+        .package(url: "https://github.com/apple/swift-collections", from: "1.0.0"),
         .package(url: "https://github.com/Automattic/Automattic-Tracks-iOS", from: "3.4.2"),
         .package(url: "https://github.com/Automattic/AutomatticAbout-swift", from: "1.1.4"),
         .package(url: "https://github.com/Automattic/Gravatar-SDK-iOS", from: "3.1.0"),
@@ -52,23 +52,26 @@ let package = Package(
         .package(url: "https://github.com/Automattic/color-studio", branch: "trunk"),
     ],
     targets: XcodeSupport.targets + [
-        .target(name: "JetpackStatsWidgetsCore", swiftSettings: [.swiftLanguageMode(.v5)]),
+        .target(name: "AsyncImageKit", dependencies: [
+            .product(name: "Collections", package: "swift-collections"),
+            .product(name: "Gifu", package: "Gifu"),
+        ]),
         .target(name: "DesignSystem", swiftSettings: [.swiftLanguageMode(.v5)]),
+        .target(name: "JetpackStatsWidgetsCore", swiftSettings: [.swiftLanguageMode(.v5)]),
         .target(name: "UITestsFoundation", dependencies: [
             .product(name: "ScreenObject", package: "ScreenObject"),
             .product(name: "XCUITestHelpers", package: "XCUITestHelpers"),
         ], swiftSettings: [.swiftLanguageMode(.v5)]),
         .target(name: "WordPressFlux", swiftSettings: [.swiftLanguageMode(.v5)]),
-        .target(name: "WordPressMedia"),
         .target(name: "WordPressSharedObjC", resources: [.process("Resources")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .target(name: "WordPressShared", dependencies: [.target(name: "WordPressSharedObjC")], resources: [.process("Resources")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .target(name: "WordPressTesting", resources: [.process("Resources")]),
         .target(name: "WordPressUI", dependencies: [.target(name: "WordPressShared")], resources: [.process("Resources")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .testTarget(name: "JetpackStatsWidgetsCoreTests", dependencies: [.target(name: "JetpackStatsWidgetsCore")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .testTarget(name: "DesignSystemTests", dependencies: [.target(name: "DesignSystem")], swiftSettings: [.swiftLanguageMode(.v5)]),
         .testTarget(name: "WordPressFluxTests", dependencies: ["WordPressFlux"], swiftSettings: [.swiftLanguageMode(.v5)]),
-        .testTarget(name: "WordPressMediaTests", dependencies: [
-            .target(name: "WordPressMedia"),
+        .testTarget(name: "AsyncImageKitTests", dependencies: [
+            .target(name: "AsyncImageKit"),
             .target(name: "WordPressTesting"),
             .product(name: "OHHTTPStubsSwift", package: "OHHTTPStubs")
         ]),
@@ -143,10 +146,9 @@ enum XcodeSupport {
                 "JetpackStatsWidgetsCore",
                 "WordPressFlux",
                 "WordPressShared",
-                "WordPressMedia",
+                "AsyncImageKit",
                 "WordPressUI",
                 .product(name: "Alamofire", package: "Alamofire"),
-                .product(name: "AlamofireImage", package: "AlamofireImage"),
                 .product(name: "AutomatticAbout", package: "AutomatticAbout-swift"),
                 .product(name: "AutomatticTracks", package: "Automattic-Tracks-iOS"),
                 .product(name: "CocoaLumberjack", package: "CocoaLumberjack"),

Modules/Sources/WordPressMedia/ImageDecoder.swift → Modules/Sources/AsyncImageKit/Helpers/ImageDecoder.swift

@@ -70,7 +70,7 @@ private extension Data {
     }
 }
 
-private extension CGSize {
+extension CGSize {
     func scaled(by scale: CGFloat) -> CGSize {
         CGSize(width: width * scale, height: height * scale)
     }

Modules/Sources/WordPressMedia/ImageDownloader.swift → Modules/Sources/AsyncImageKit/ImageDownloader.swift

@@ -3,8 +3,9 @@ import UIKit
 /// The system that downloads and caches images, and prepares them for display.
 @ImageDownloaderActor
 public final class ImageDownloader {
+    public nonisolated static let shared = ImageDownloader()
+
     private nonisolated let cache: MemoryCacheProtocol
-    private let authenticator: MediaRequestAuthenticatorProtocol?
 
     private let urlSession = URLSession {
         $0.urlCache = nil
@@ -21,14 +22,12 @@ public final class ImageDownloader {
     private var tasks: [String: ImageDataTask] = [:]
 
     public nonisolated init(
-        cache: MemoryCacheProtocol = MemoryCache.shared,
-        authenticator: MediaRequestAuthenticatorProtocol?
+        cache: MemoryCacheProtocol = MemoryCache.shared
     ) {
         self.cache = cache
-        self.authenticator = authenticator
     }
 
-    public func image(from url: URL, host: MediaHost? = nil, options: ImageRequestOptions = .init()) async throws -> UIImage {
+    public func image(from url: URL, host: MediaHostProtocol? = nil, options: ImageRequestOptions = .init()) async throws -> UIImage {
         try await image(for: ImageRequest(url: url, host: host, options: options))
     }
 
@@ -39,7 +38,7 @@ public final class ImageDownloader {
             return image
         }
         let data = try await data(for: request)
-        let image = try await ImageDecoder.makeImage(from: data, size: options.size)
+        let image = try await ImageDecoder.makeImage(from: data, size: options.size.map(CGSize.init))
         if options.isMemoryCacheEnabled {
             cache[key] = image
         }
@@ -55,8 +54,8 @@ public final class ImageDownloader {
         switch request.source {
         case .url(let url, let host):
             var request: URLRequest
-            if let host, let authenticator {
-                request = try await authenticator.authenticatedRequest(for: url, host: host)
+            if let host {
+                request = try await host.authenticatedRequest(for: url)
             } else {
                 request = URLRequest(url: url)
             }
@@ -69,24 +68,30 @@ public final class ImageDownloader {
 
     // MARK: - Caching
 
+    /// Returns an image from the memory cache.
+    nonisolated public func cachedImage(for request: ImageRequest) -> UIImage? {
+        guard let imageURL = request.source.url else { return nil }
+        return cachedImage(for: imageURL, size: request.options.size)
+    }
+
     /// Returns an image from the memory cache.
     ///
     /// - note: Use it to retrieve the image synchronously, which is no not possible
     /// with the async functions.
-    nonisolated public func cachedImage(for imageURL: URL, size: CGSize? = nil) -> UIImage? {
+    nonisolated public func cachedImage(for imageURL: URL, size: ImageSize? = nil) -> UIImage? {
         cache[makeKey(for: imageURL, size: size)]
     }
 
-    nonisolated public func setCachedImage(_ image: UIImage?, for imageURL: URL, size: CGSize? = nil) {
+    nonisolated public func setCachedImage(_ image: UIImage?, for imageURL: URL, size: ImageSize? = nil) {
         cache[makeKey(for: imageURL, size: size)] = image
     }
 
-    private nonisolated func makeKey(for imageURL: URL?, size: CGSize?) -> String {
+    private nonisolated func makeKey(for imageURL: URL?, size: ImageSize?) -> String {
         guard let imageURL else {
             assertionFailure("The request.url was nil") // This should never happen
             return ""
         }
-        return imageURL.absoluteString + (size.map { "?size=\($0)" } ?? "")
+        return imageURL.absoluteString + (size.map { "?w=\($0.width),h=\($0.height)" } ?? "")
     }
 
     public func clearURLSessionCache() {
@@ -189,6 +194,6 @@ private extension URLSession {
     }
 }
 
-public protocol MediaRequestAuthenticatorProtocol: Sendable {
-    @MainActor func authenticatedRequest(for url: URL, host: MediaHost) async throws -> URLRequest
+public protocol MediaHostProtocol: Sendable {
+    @MainActor func authenticatedRequest(for url: URL) async throws -> URLRequest
 }

Modules/Sources/AsyncImageKit/ImagePrefetcher.swift

@@ -0,0 +1,111 @@
+import UIKit
+import Collections
+
+@ImageDownloaderActor
+public final class ImagePrefetcher {
+    private let downloader: ImageDownloader
+    private let maxConcurrentTasks: Int
+    private var queue = OrderedDictionary<PrefetchKey, PrefetchTask>()
+    private var numberOfActiveTasks = 0
+
+    deinit {
+        let tasks = queue.values.compactMap(\.task)
+        for task in tasks {
+            task.cancel()
+        }
+    }
+
+    public nonisolated init(
+        downloader: ImageDownloader = .shared,
+        maxConcurrentTasks: Int = 2
+    ) {
+        self.downloader = downloader
+        self.maxConcurrentTasks = maxConcurrentTasks
+    }
+
+    public nonisolated func startPrefetching(for requests: [ImageRequest]) {
+        Task { @ImageDownloaderActor in
+            for request in requests {
+                startPrefetching(for: request)
+            }
+            performPendingTasks()
+        }
+    }
+
+    private func startPrefetching(for request: ImageRequest) {
+        let key = PrefetchKey(request: request)
+        guard queue[key] == nil else {
+            return
+        }
+        queue[key] = PrefetchTask()
+    }
+
+    private func performPendingTasks() {
+        var index = 0
+        func nextPendingTask() -> (PrefetchKey, PrefetchTask)? {
+            while index < queue.count {
+                if queue.elements[index].value.task == nil {
+                    return queue.elements[index]
+                }
+                index += 1
+            }
+            return nil
+        }
+        while numberOfActiveTasks < maxConcurrentTasks, let (key, task) = nextPendingTask() {
+            task.task = Task {
+                await self.actuallyPrefetchImage(for: key.request)
+            }
+            numberOfActiveTasks += 1
+        }
+    }
+
+    private func actuallyPrefetchImage(for request: ImageRequest) async {
+        _ = try? await downloader.image(for: request)
+
+        numberOfActiveTasks -= 1
+        queue[PrefetchKey(request: request)] = nil
+        performPendingTasks()
+    }
+
+    public nonisolated func stopPrefetching(for requests: [ImageRequest]) {
+        Task { @ImageDownloaderActor in
+            for request in requests {
+                stopPrefetching(for: request)
+            }
+            performPendingTasks()
+        }
+    }
+
+    private func stopPrefetching(for request: ImageRequest) {
+        let key = PrefetchKey(request: request)
+        if let task = queue.removeValue(forKey: key) {
+            task.task?.cancel()
+        }
+    }
+
+    public nonisolated func stopAll() {
+        Task { @ImageDownloaderActor in
+            for (_, value) in queue {
+                value.task?.cancel()
+            }
+            queue.removeAll()
+        }
+    }
+
+    private struct PrefetchKey: Hashable, Sendable {
+        let request: ImageRequest
+
+        func hash(into hasher: inout Hasher) {
+            request.source.url?.hash(into: &hasher)
+        }
+
+        static func == (lhs: PrefetchKey, rhs: PrefetchKey) -> Bool {
+            let (lhs, rhs) = (lhs.request, rhs.request)
+            return (lhs.source.url, lhs.options) == (rhs.source.url, rhs.options)
+        }
+    }
+
+    private final class PrefetchTask: @unchecked Sendable {
+        var task: Task<Void, Error>?
+    }
+}

Modules/Sources/AsyncImageKit/ImageRequest.swift

@@ -0,0 +1,84 @@
+import UIKit
+
+public final class ImageRequest: Sendable {
+    public enum Source: Sendable {
+        case url(URL, MediaHostProtocol?)
+        case urlRequest(URLRequest)
+
+        var url: URL? {
+            switch self {
+            case .url(let url, _): url
+            case .urlRequest(let request): request.url
+            }
+        }
+    }
+
+    let source: Source
+    let options: ImageRequestOptions
+
+    public init(url: URL, host: MediaHostProtocol? = nil, options: ImageRequestOptions = .init()) {
+        self.source = .url(url, host)
+        self.options = options
+    }
+
+    public init(urlRequest: URLRequest, options: ImageRequestOptions = .init()) {
+        self.source = .urlRequest(urlRequest)
+        self.options = options
+    }
+}
+
+public struct ImageRequestOptions: Hashable, Sendable {
+    /// Resize the thumbnail to the given size. By default, `nil`.
+    public var size: ImageSize?
+
+    /// If enabled, uses ``MemoryCache`` for caching decompressed images.
+    public var isMemoryCacheEnabled = true
+
+    /// If enabled, uses `URLSession` preconfigured with a custom `URLCache`
+    /// with a relatively high disk capacity. By default, `true`.
+    public var isDiskCacheEnabled = true
+
+    public init(
+        size: ImageSize? = nil,
+        isMemoryCacheEnabled: Bool = true,
+        isDiskCacheEnabled: Bool = true
+    ) {
+        self.size = size
+        self.isMemoryCacheEnabled = isMemoryCacheEnabled
+        self.isDiskCacheEnabled = isDiskCacheEnabled
+    }
+}
+
+/// Image size in **pixels**.
+public struct ImageSize: Hashable, Sendable {
+    public let width: CGFloat
+    public let height: CGFloat
+
+    public init(width: CGFloat, height: CGFloat) {
+        self.width = width
+        self.height = height
+    }
+
+    public init(_ size: CGSize) {
+        self.width = size.width
+        self.height = size.height
+    }
+
+    /// Initializes `ImageSize` with the given size scaled for the given view.
+    @MainActor
+    public init(scaling size: CGSize, in view: UIView) {
+        self.init(size.scaled(by: view.traitCollection.displayScale))
+    }
+
+    /// Initializes `ImageSize` with the given size scaled for the current trait
+    /// collection display scale.
+    public init(scaling size: CGSize) {
+        self.init(size.scaled(by: UITraitCollection.current.displayScale))
+    }
+}
+
+extension CGSize {
+    init(_ size: ImageSize) {
+        self.init(width: size.width, height: size.height)
+    }
+}