FetchImage 0.6.0

Author: Sam-Spencer

CHANGELOG.md

@@ -1,22 +1,33 @@
 # FetchImage 0.x
 
+## FetchImage 0.6.0
+
+*April 17, 2021*
+
+- Added `ScrollViewPrefetcher` which can be accessed via a `PrefetchImageModel` object. This helps prefetch images when using SwiftUI collections.
+- Updated to Nuke 9.5
+- Updated to Firebase 7.10
+- Added background loading for Firebase URLs
+- `@Publishable` updates are now all on the main thread
+
+
 ## FetchImage 0.5.0
 
-*Mar 16, 2021*
+*March 16, 2021*
 
 - The Firebase `load` call now provides a URL once cached.
 
 ## FetchImage 0.4.0
 
-*Mar 03, 2021*
+*March 03, 2021*
 
 - **Internal Change** `ImageRequest` objects are now optional and may not be immediately fulfilled when initializing a `FetchImage` instance. This allows expansion of the API for additional changes and improvements.
 - Google Firebase support. Using the new convenience initializer to create a `FetchImage` instance with a Firestore `StorageReference` instead of directly from a URL. Optionally, supply any cached URL content when using this initializer to decrease Firestore roundtrips.
 - Fixed and expanded in-line documentation.
 
 ## FetchImage 0.3.0
 
-*Dec 26, 2020*
+*December 26, 2020*
 
 - **Breaking Change** `FetchImage` no longer starts the request in the initializer, you must call `fetch()`.
 - Add `reset()` method which clears the entire `FetchImage` state including the downloaded image. This is crucial for long lists where you don't want `FetchImage` instances to retain images which are off screen.
@@ -35,6 +46,6 @@
 
 ## FetchImage 0.1.0
 
-*Mar 19, 2020*
+*March 19, 2020*
 
 - Initial release. See an [introductory post](https://kean.github.io/post/introducing-fetch-image) for more information.

Package.resolved

@@ -14,8 +14,8 @@ let package = Package(
         .library(name: "FetchImage", targets: ["FetchImage"])
     ],
     dependencies: [
-        .package(url: "https://github.com/kean/Nuke.git", from: "9.2.0"),
-        .package(name: "Firebase", url: "https://github.com/firebase/firebase-ios-sdk.git", from: "7.3.0")
+        .package(url: "https://github.com/kean/Nuke.git", from: "9.5.0"),
+        .package(name: "Firebase", url: "https://github.com/firebase/firebase-ios-sdk.git", from: "7.10.0")
     ],
     targets: [
         .target(name: "FetchImage",

Package.swift

@@ -1,6 +1,8 @@
+//
 // The MIT License (MIT)
 //
 // Copyright (c) 2020 Alexander Grebenyuk (github.com/kean).
+//
 
 import SwiftUI
 import Nuke
@@ -83,15 +85,17 @@ public final class FetchImage: ObservableObject, Identifiable {
         }
 
         func getRegularURL() {
-            regularStorageRef.downloadURL { (discoveredURL, error) in
-                if let given = discoveredURL {
-                    let newRequest = ImageRequest(url: given)
-                    self.request = newRequest
-                    self.priority = newRequest.priority
-                    
-                    finishOrLoad(newRequest, discoveredURL: given)
-                } else {
-                    finished?(discoveredURL)
+            DispatchQueue.global(qos: .userInteractive).async {
+                regularStorageRef.downloadURL { (discoveredURL, error) in
+                    if let given = discoveredURL {
+                        let newRequest = ImageRequest(url: given)
+                        self.request = newRequest
+                        self.priority = newRequest.priority
+                        
+                        finishOrLoad(newRequest, discoveredURL: given)
+                    } else {
+                        finished?(discoveredURL)
+                    }
                 }
             }
         }
@@ -117,12 +121,6 @@ public final class FetchImage: ObservableObject, Identifiable {
     /// Starts loading the image if not already loaded and the download is not already
     /// in progress.
     ///
-    /// - note: Low Data Mode. If the `lowDataRequest` is provided and the regular
-    /// request fails because of the constrained network access, the fetcher tries to
-    /// download the low-quality image. The fetcher always tries to get the high quality
-    /// image. If the first attempt fails, the next time you call `fetch`, it is going
-    /// to attempt to fetch the regular quality image again.
-    ///
     public func load(_ request: ImageRequest) {
         _reset()
 
@@ -136,31 +134,38 @@ public final class FetchImage: ObservableObject, Identifiable {
 
         // Try to display the regular image if it is available in memory cache
         if let container = pipeline.cachedImage(for: request) {
-            image = container.image
+            Thread.executeOnMain {
+                self.image = container.image
+            }
             return // Nothing to do
         }
 
-        isLoading = true
+        Thread.executeOnMain {
+            self.isLoading = true
+        }
         _load(request: request)
     }
 
     private func _load(request: ImageRequest) {
-        progress = Progress(completed: 0, total: 0)
-        currentlyLoadingImageQuality = quality
+        Thread.executeOnMain {
+            self.progress = Progress(completed: 0, total: 0)
+        }
 
         task = pipeline.loadImage(
             with: request,
-            progress: { [weak self] response, completed, total in
-                guard let self = self else { return }
-                
-                self.progress = Progress(completed: completed, total: total)
+            progress: { response, completed, total in
+                Thread.executeOnMain {
+                    self.progress = Progress(completed: completed, total: total)
+                }
 
                 if let image = response?.image {
-                    self.image = image // Display progressively decoded image
+                    Thread.executeOnMain {
+                        self.image = image // Display progressively decoded image
+                    }
                 }
             },
-            completion: { [weak self] in
-                self?.didFinishRequest(result: $0)
+            completion: { result in
+                self.didFinishRequest(result: result)
             }
         )
 
@@ -170,15 +175,22 @@ public final class FetchImage: ObservableObject, Identifiable {
     }
 
     private func didFinishRequest(result: Result<ImageResponse, ImagePipeline.Error>) {
-        task = nil
-        isLoading = false
+        defer {
+            task = nil
+            Thread.executeOnMain {
+                self.isLoading = false
+            }
+        }
 
         switch result {
         case let .success(response):
-            self.image = response.image
+            Thread.executeOnMain {
+                self.image = response.image
+            }
         case let .failure(error):
-            self.error = error
-            isLoading = false
+            Thread.executeOnMain {
+                self.error = error
+            }
         }
     }
 
@@ -190,7 +202,9 @@ public final class FetchImage: ObservableObject, Identifiable {
     public func cancel() {
         task?.cancel() // Guarantees that no more callbacks are will be delivered
         task = nil
-        isLoading = false
+        Thread.executeOnMain {
+            self.isLoading = false
+        }
     }
 
     /// Resets the `FetchImage` instance by cancelling the request and removing all of
@@ -202,11 +216,12 @@ public final class FetchImage: ObservableObject, Identifiable {
     }
 
     private func _reset() {
-        isLoading = false
-        image = nil
-        error = nil
-        progress = Progress(completed: 0, total: 0)
-        loadedImageQuality = nil
+        Thread.executeOnMain {
+            self.isLoading = false
+            self.image = nil
+            self.error = nil
+            self.progress = Progress(completed: 0, total: 0)
+        }
         request = nil
     }
 
@@ -223,3 +238,17 @@ public extension FetchImage {
     }
 
 }
+
+fileprivate extension Thread {
+    
+    class func executeOnMain(_ mainBlock: @escaping () -> Void) {
+        if Thread.isMainThread == true {
+            mainBlock()
+        } else {
+            DispatchQueue.main.async {
+                mainBlock()
+            }
+        }
+    }
+    
+}